diff --git a/CMakeLists.txt b/CMakeLists.txt
index 41b59b0f1c..4618349e36 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,3 +19,17 @@ if (LUA_VERSION MATCHES "luajit")
 else()
   add_subdirectory(src/lualib/lua)
 endif()
+
+# sol (C++ <-> Lua binding library, header-only) is bundled in src/lualib/sol.
+# Attaching it to lualib as INTERFACE propagates <sol/sol.hpp> and its compile
+# definitions to every consumer of lualib, whichever Lua backend is selected.
+# SYSTEM keeps the vendored header out of our warning surface: sol carries
+# GCC-only pragmas that clang would otherwise reject under -Werror.
+target_include_directories(lualib SYSTEM INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/src/lualib")
+
+# Keep sol runtime safety checks enabled in every build type: script errors must
+# surface as catchable Lua errors, never as undefined behaviour in the server.
+# SOL_EXCEPTIONS_SAFE_PROPAGATION=0 makes sol catch C++ exceptions at the
+# binding boundary and convert them into regular Lua errors carrying their
+# message; without it LuaJIT swallows them into a generic "C++ exception".
+target_compile_definitions(lualib INTERFACE SOL_ALL_SAFETIES_ON=1 SOL_EXCEPTIONS_SAFE_PROPAGATION=0)
diff --git a/src/LuaEngine/ALEBind.cpp b/src/LuaEngine/ALEBind.cpp
new file mode 100644
index 0000000000..34287840e3
--- /dev/null
+++ b/src/LuaEngine/ALEBind.cpp
@@ -0,0 +1,61 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#include "ALEBind.h"
+
+#include "Corpse.h"
+#include "GameObject.h"
+#include "Item.h"
+#include "Object.h"
+#include "Pet.h"
+#include "Player.h"
+#include "Transport.h"
+
+namespace ALEBind
+{
+    sol::object ToLuaDynamic(sol::state_view lua, Object const* obj)
+    {
+        if (!obj)
+            return sol::make_object(lua, sol::nil);
+
+        if (Player const* player = obj->ToPlayer())
+            return sol::make_object(lua, PlayerRef(player));
+
+        if (Creature* creature = const_cast<Object*>(obj)->ToCreature())
+        {
+            if (Pet const* pet = creature->ToPet())
+                return sol::make_object(lua, PetRef(pet));
+
+            return sol::make_object(lua, CreatureRef(creature));
+        }
+
+        if (GameObject* go = const_cast<Object*>(obj)->ToGameObject())
+        {
+            if (Transport const* transport = go->ToTransport())
+                return sol::make_object(lua, TransportRef(transport));
+
+            return sol::make_object(lua, GameObjectRef(go));
+        }
+
+        if (Corpse const* corpse = obj->ToCorpse())
+            return sol::make_object(lua, CorpseRef(corpse));
+
+        if (obj->IsItem())
+            return sol::make_object(lua, ItemRef(static_cast<Item const*>(obj)));
+
+        return sol::make_object(lua, sol::nil);
+    }
+
+    sol::object ToLuaDynamic(sol::state_view lua, WorldObject const* obj)
+    {
+        return ToLuaDynamic(lua, static_cast<Object const*>(obj));
+    }
+
+    sol::object ToLuaDynamic(sol::state_view lua, Unit const* unit)
+    {
+        return ToLuaDynamic(lua, static_cast<Object const*>(unit));
+    }
+}
diff --git a/src/LuaEngine/ALEBind.h b/src/LuaEngine/ALEBind.h
new file mode 100644
index 0000000000..bee88b35db
--- /dev/null
+++ b/src/LuaEngine/ALEBind.h
@@ -0,0 +1,368 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#ifndef _ALE_BIND_H
+#define _ALE_BIND_H
+
+#include "ALEHandles.h"
+
+#include <sol/sol.hpp>
+
+#include <type_traits>
+#include <utility>
+
+struct AuctionEntry;
+class AuctionHouseObject;
+class Aura;
+class Battleground;
+class ChatHandler;
+class GmTicket;
+struct Loot;
+class Roll;
+class Spell;
+class Vehicle;
+class Weather;
+
+/*
+ * Adapters that turn plain C++ functions into Lua-callable methods.
+ *
+ * Binding files should never touch the Lua stack or the handle machinery: they
+ * declare methods and this layer does the rest. The two entry points are:
+ *
+ *   ALEBind::Method   - binds a method on a game object usertype:
+ *
+ *       player["GetName"] = ALEBind::Method(&Player::GetName);
+ *       player["Emote"]   = ALEBind::Method([](Player* self, uint32 emoteId)
+ *       {
+ *           self->HandleEmoteCommand(emoteId);
+ *       });
+ *
+ *   ALEBind::Function - same conversions for free functions (no self):
+ *
+ *       lua["GetPlayerByName"] = ALEBind::Function([](std::string const& name)
+ *       {
+ *           return ObjectAccessor::FindPlayerByName(name);
+ *       });
+ *
+ * What the adapters do for you:
+ *
+ *   - `self` arrives as a safe handle (see ALEHandles.h) and is resolved before
+ *     your code runs; if the object is gone, the script gets a Lua error
+ *     instead of the server dereferencing freed memory.
+ *   - every parameter typed as a game object pointer (Player*, Unit*, ...) is
+ *     received as a handle from Lua and resolved the same way;
+ *   - every game object pointer you return is wrapped back into a handle, and
+ *     nullptr becomes nil. Pointers to Unit, WorldObject or Object are wrapped
+ *     into the most-derived handle, so Lua always sees the concrete type;
+ *   - all other types (numbers, strings, bools, enums, ...) pass through with
+ *     sol's usual conversions.
+ *
+ * Patterns for less common signatures:
+ *
+ *   - optional parameter: take sol::optional<T> and use value_or:
+ *       [](Player* self, sol::optional<uint8> locale) { uint8 l = locale.value_or(DEFAULT_LOCALE); ... }
+ *   - nullable object parameter: take sol::optional<UnitRef>;
+ *   - multiple return values: return std::tuple<...>;
+ *   - C++ out-parameters (uint32&) have no Lua equivalent: wrap the call in a
+ *     lambda and return the new value instead.
+ */
+namespace ALEBind
+{
+    // ---------------------------------------------------------------------
+    // Native type -> handle type mapping
+    // ---------------------------------------------------------------------
+
+    template<typename T>
+    struct HandleFor
+    {
+    };
+
+    // Object hierarchy: guid-resolved handles
+    template<> struct HandleFor<Object>      { using type = ObjectRef; };
+    template<> struct HandleFor<WorldObject> { using type = WorldObjectRef; };
+    template<> struct HandleFor<Unit>        { using type = UnitRef; };
+    template<> struct HandleFor<Player>      { using type = PlayerRef; };
+    template<> struct HandleFor<Creature>    { using type = CreatureRef; };
+    template<> struct HandleFor<Pet>         { using type = PetRef; };
+    template<> struct HandleFor<GameObject>  { using type = GameObjectRef; };
+    template<> struct HandleFor<Transport>   { using type = TransportRef; };
+    template<> struct HandleFor<Corpse>      { using type = CorpseRef; };
+    template<> struct HandleFor<Item>        { using type = ItemRef; };
+
+    // Manager-resolved handles
+    template<> struct HandleFor<Map>         { using type = MapRef; };
+    template<> struct HandleFor<Group>       { using type = GroupRef; };
+    template<> struct HandleFor<Guild>       { using type = GuildRef; };
+
+    // Transient objects: only valid during the event that provided them
+    template<> struct HandleFor<Aura>               { using type = ScopedRef<Aura>; };
+    template<> struct HandleFor<Spell>              { using type = ScopedRef<Spell>; };
+    template<> struct HandleFor<Vehicle>            { using type = ScopedRef<Vehicle>; };
+    template<> struct HandleFor<GmTicket>           { using type = ScopedRef<GmTicket>; };
+    template<> struct HandleFor<Battleground>       { using type = ScopedRef<Battleground>; };
+    template<> struct HandleFor<Weather>            { using type = ScopedRef<Weather>; };
+    template<> struct HandleFor<AuctionHouseObject> { using type = ScopedRef<AuctionHouseObject>; };
+    template<> struct HandleFor<AuctionEntry>       { using type = ScopedRef<AuctionEntry>; };
+    template<> struct HandleFor<Roll>               { using type = ScopedRef<Roll>; };
+    template<> struct HandleFor<Loot>               { using type = ScopedRef<Loot>; };
+    template<> struct HandleFor<ChatHandler>        { using type = ScopedRef<ChatHandler>; };
+
+    template<typename T>
+    using HandleForT = typename HandleFor<std::remove_const_t<T>>::type;
+
+    // Whether T is a game class that Lua sees through a handle.
+    template<typename T>
+    concept Handled = requires { typename HandleFor<std::remove_const_t<T>>::type; };
+
+    // Whether P is a (possibly const) pointer to a handled game class.
+    template<typename P>
+    concept HandledPtr = std::is_pointer_v<P> && Handled<std::remove_pointer_t<P>>;
+
+    // Whether P points to a polymorphic base (Object, WorldObject, Unit):
+    // those are wrapped into the most-derived handle at runtime.
+    template<typename P>
+    concept PolymorphicBasePtr = std::is_pointer_v<P>
+        && (std::is_same_v<std::remove_const_t<std::remove_pointer_t<P>>, Object>
+            || std::is_same_v<std::remove_const_t<std::remove_pointer_t<P>>, WorldObject>
+            || std::is_same_v<std::remove_const_t<std::remove_pointer_t<P>>, Unit>);
+
+    // ---------------------------------------------------------------------
+    // Parameter and return value conversions
+    // ---------------------------------------------------------------------
+
+    // Lua-side type of a native parameter: handles for game object pointers,
+    // the native type unchanged for everything else.
+    template<typename P>
+    struct LuaParam
+    {
+        using type = P;
+    };
+
+    template<HandledPtr P>
+    struct LuaParam<P>
+    {
+        using type = HandleForT<std::remove_pointer_t<P>>;
+    };
+
+    template<typename P>
+    using LuaParamT = typename LuaParam<P>::type;
+
+    // Converts a Lua-side argument to what the native function expects.
+    // Handles resolve to live pointers or raise a Lua error if stale.
+    template<typename P>
+    decltype(auto) FromLua(LuaParamT<P>& value)
+    {
+        if constexpr (HandledPtr<P>)
+            return value.Require();
+        else
+            return static_cast<P>(value);
+    }
+
+    // Wraps a pointer to a polymorphic base into the most-derived handle, so
+    // a Unit that is really a Player arrives in Lua as a Player.
+    // One exact overload per base class: binding files usually only see
+    // forward declarations, so no pointer conversion can happen there.
+    sol::object ToLuaDynamic(sol::state_view lua, Object const* obj);
+    sol::object ToLuaDynamic(sol::state_view lua, WorldObject const* obj);
+    sol::object ToLuaDynamic(sol::state_view lua, Unit const* unit);
+
+    // Converts a native return value to what Lua receives.
+    // Game object pointers become handles, nullptr becomes nil.
+    // Always returns by value: the native value is a temporary that dies
+    // before sol converts the result, so a reference here would dangle.
+    template<typename R>
+    auto ToLua(sol::state_view lua, R&& value)
+    {
+        using Bare = std::remove_cvref_t<R>;
+
+        if constexpr (PolymorphicBasePtr<Bare>)
+            return ToLuaDynamic(lua, value);
+        else if constexpr (HandledPtr<Bare>)
+        {
+            using Ref = HandleForT<std::remove_pointer_t<Bare>>;
+            return value ? sol::optional<Ref>(Ref(value)) : sol::optional<Ref>(sol::nullopt);
+        }
+        else
+            return Bare(std::forward<R>(value));
+    }
+
+    // ---------------------------------------------------------------------
+    // Binding factories
+    // ---------------------------------------------------------------------
+
+    // Builds the Lua-facing lambda for a callable invocable as R(T*, Args...).
+    template<typename R, typename T, typename... Args, typename F>
+    auto MakeMethod(F&& fn)
+    {
+        return [fn = std::forward<F>(fn)](sol::this_state state, HandleForT<T> const& self, LuaParamT<Args>... args)
+        {
+            T* obj = self.Require();
+
+            if constexpr (std::is_void_v<R>)
+                fn(obj, FromLua<Args>(args)...);
+            else
+                return ToLua(sol::state_view(state), fn(obj, FromLua<Args>(args)...));
+        };
+    }
+
+    // Builds the Lua-facing lambda for a callable invocable as R(Args...).
+    template<typename R, typename... Args, typename F>
+    auto MakeFunction(F&& fn)
+    {
+        return [fn = std::forward<F>(fn)](sol::this_state state, LuaParamT<Args>... args)
+        {
+            if constexpr (std::is_void_v<R>)
+                fn(FromLua<Args>(args)...);
+            else
+                return ToLua(sol::state_view(state), fn(FromLua<Args>(args)...));
+        };
+    }
+
+    // Signature extraction for lambdas and other callables, via operator().
+    template<typename F>
+    struct CallableTraits : CallableTraits<decltype(&F::operator())>
+    {
+    };
+
+    template<typename C, typename R, typename... Args>
+    struct CallableTraits<R (C::*)(Args...) const>
+    {
+        template<typename F>
+        static auto Method(F&& fn)
+        {
+            // The first parameter of the callable is `self`.
+            return MethodImpl<R, Args...>(std::forward<F>(fn));
+        }
+
+        template<typename F>
+        static auto Function(F&& fn)
+        {
+            return MakeFunction<R, Args...>(std::forward<F>(fn));
+        }
+
+    private:
+        template<typename R2, typename Self, typename... Rest, typename F>
+        static auto MethodImpl(F&& fn)
+        {
+            static_assert(std::is_pointer_v<Self> && Handled<std::remove_pointer_t<Self>>,
+                "the first parameter of a method callable must be a pointer to a game class (Player*, Unit*, ...)");
+            return MakeMethod<R2, std::remove_const_t<std::remove_pointer_t<Self>>, Rest...>(std::forward<F>(fn));
+        }
+    };
+
+    // Binds a non-const member function: Method(&Player::HasSpell)
+    template<typename R, typename T, typename... Args>
+    auto Method(R (T::*f)(Args...))
+    {
+        return MakeMethod<R, T, Args...>([f](T* self, Args... args) -> R
+        {
+            return (self->*f)(std::forward<Args>(args)...);
+        });
+    }
+
+    // Binds a const member function: Method(&Player::GetName)
+    template<typename R, typename T, typename... Args>
+    auto Method(R (T::*f)(Args...) const)
+    {
+        return MakeMethod<R, T, Args...>([f](T* self, Args... args) -> R
+        {
+            return (self->*f)(std::forward<Args>(args)...);
+        });
+    }
+
+    // Binds a free function whose first parameter is the self pointer:
+    // Method(&LuaCorpse::GetOwnerGUID) with ObjectGuid GetOwnerGUID(Corpse* corpse)
+    template<typename R, typename T, typename... Args>
+        requires Handled<std::remove_const_t<T>>
+    auto Method(R (*f)(T*, Args...))
+    {
+        return MakeMethod<R, std::remove_const_t<T>, Args...>([f](std::remove_const_t<T>* self, Args... args) -> R
+        {
+            return f(self, std::forward<Args>(args)...);
+        });
+    }
+
+    // Binds a lambda whose first parameter is the self pointer:
+    // Method([](Player* self, uint32 id) { ... })
+    template<typename F>
+        requires (!std::is_member_function_pointer_v<std::remove_reference_t<F>>
+            && !std::is_pointer_v<std::remove_reference_t<F>>)
+    auto Method(F&& fn)
+    {
+        return CallableTraits<std::remove_reference_t<F>>::Method(std::forward<F>(fn));
+    }
+
+    // Binds a free function or lambda with no self parameter:
+    // Function([](std::string const& name) { ... })
+    template<typename F>
+        requires (!std::is_member_function_pointer_v<std::remove_reference_t<F>>
+            && !std::is_pointer_v<std::remove_reference_t<F>>)
+    auto Function(F&& fn)
+    {
+        return CallableTraits<std::remove_reference_t<F>>::Function(std::forward<F>(fn));
+    }
+
+    template<typename R, typename... Args>
+    auto Function(R (*f)(Args...))
+    {
+        return MakeFunction<R, Args...>([f](Args... args) -> R
+        {
+            return f(std::forward<Args>(args)...);
+        });
+    }
+
+    // ---------------------------------------------------------------------
+    // Usertype creation
+    // ---------------------------------------------------------------------
+
+    /*
+     * Creates the Lua usertype for a handle class:
+     *
+     *     sol::usertype<PlayerRef> type =
+     *         ALEBind::NewHandleType<PlayerRef, UnitRef, WorldObjectRef, ObjectRef>(lua, "Player");
+     *
+     * `Bases` lists the handle's base classes so Lua can call, for example,
+     * Unit methods on a Player. Every handle type also receives:
+     *
+     *   - IsValid()       - whether the object is currently reachable;
+     *   - GetObjectType() - the type name as a string ("Player", ...);
+     *   - tostring()      - "TypeName (guid)" for guid-based handles.
+     */
+    template<typename Ref, typename... Bases>
+    sol::usertype<Ref> NewHandleType(sol::state& lua, char const* name)
+    {
+        sol::usertype<Ref> type = lua.new_usertype<Ref>(name,
+            sol::no_constructor,
+            sol::base_classes, sol::bases<Bases...>());
+
+        type["IsValid"] = &Ref::IsValid;
+        type["GetObjectType"] = [name](Ref const&) { return name; };
+        type[sol::meta_function::to_string] = [name](Ref const& ref)
+        {
+            if constexpr (requires { ref.GetGuid(); })
+                return std::string(name) + " (" + ref.GetGuid().ToString() + ")";
+            else
+                return std::string(name);
+        };
+
+        return type;
+    }
+}
+
+// Lua-visible names of transient types, used in stale-handle error messages.
+template<> struct ALETypeName<Aura>               { static constexpr char const* value = "Aura"; };
+template<> struct ALETypeName<Spell>              { static constexpr char const* value = "Spell"; };
+template<> struct ALETypeName<Vehicle>            { static constexpr char const* value = "Vehicle"; };
+template<> struct ALETypeName<GmTicket>           { static constexpr char const* value = "Ticket"; };
+template<> struct ALETypeName<Battleground>       { static constexpr char const* value = "BattleGround"; };
+template<> struct ALETypeName<Weather>            { static constexpr char const* value = "Weather"; };
+template<> struct ALETypeName<AuctionHouseObject> { static constexpr char const* value = "AuctionHouseObject"; };
+template<> struct ALETypeName<AuctionEntry>       { static constexpr char const* value = "AuctionEntry"; };
+template<> struct ALETypeName<Roll>               { static constexpr char const* value = "Roll"; };
+template<> struct ALETypeName<Loot>               { static constexpr char const* value = "Loot"; };
+template<> struct ALETypeName<ChatHandler>        { static constexpr char const* value = "ChatHandler"; };
+
+#endif // _ALE_BIND_H
diff --git a/src/LuaEngine/ALECompat.cpp b/src/LuaEngine/ALECompat.cpp
deleted file mode 100644
index 18535df499..0000000000
--- a/src/LuaEngine/ALECompat.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
- * This program is free software licensed under GPL version 3
- * Please see the included DOCS/LICENSE.md for more information
- */
-
-#include "ALECompat.h"
-
-#if LUA_VERSION_NUM == 501
-const char* luaL_tolstring(lua_State* L, int idx, size_t* len) {
-    if (!luaL_callmeta(L, idx, "__tostring")) {
-        int t = lua_type(L, idx), tt = 0;
-        char const* name = NULL;
-        switch (t) {
-        case LUA_TNIL:
-            lua_pushliteral(L, "nil");
-            break;
-        case LUA_TSTRING:
-        case LUA_TNUMBER:
-            lua_pushvalue(L, idx);
-            break;
-        case LUA_TBOOLEAN:
-            if (lua_toboolean(L, idx))
-                lua_pushliteral(L, "true");
-            else
-                lua_pushliteral(L, "false");
-            break;
-        default:
-            tt = luaL_getmetafield(L, idx, "__name");
-            name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
-            lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
-            if (tt != LUA_TNIL)
-                lua_replace(L, -2);
-            break;
-        }
-    }
-    else {
-        if (!lua_isstring(L, -1))
-            luaL_error(L, "'__tostring' must return a string");
-    }
-    return lua_tolstring(L, -1, len);
-}
-
-int luaL_getsubtable(lua_State* L, int i, const char* name) {
-    int abs_i = lua_absindex(L, i);
-    luaL_checkstack(L, 3, "not enough stack slots");
-    lua_pushstring(L, name);
-    lua_gettable(L, abs_i);
-    if (lua_istable(L, -1))
-        return 1;
-    lua_pop(L, 1);
-    lua_newtable(L);
-    lua_pushstring(L, name);
-    lua_pushvalue(L, -2);
-    lua_settable(L, abs_i);
-    return 0;
-}
-
-int lua_absindex(lua_State* L, int i) {
-    if (i < 0 && i > LUA_REGISTRYINDEX)
-        i += lua_gettop(L) + 1;
-    return i;
-}
-
-#if !defined LUAJIT_VERSION
-void* luaL_testudata(lua_State* L, int index, const char* tname) {
-    void* ud = lua_touserdata(L, index);
-    if (ud)
-    {
-        if (lua_getmetatable(L, index))
-        {
-            luaL_getmetatable(L, tname);
-            if (!lua_rawequal(L, -1, -2))
-                ud = NULL;
-            lua_pop(L, 2);
-            return ud;
-        }
-    }
-    return NULL;
-}
-
-void luaL_setmetatable(lua_State* L, const char* tname) {
-    lua_pushstring(L, tname);
-    lua_rawget(L, LUA_REGISTRYINDEX);
-    lua_setmetatable(L, -2);
-}
-#endif
-#endif
diff --git a/src/LuaEngine/ALECompat.h b/src/LuaEngine/ALECompat.h
deleted file mode 100644
index 42d783d7e5..0000000000
--- a/src/LuaEngine/ALECompat.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
- * This program is free software licensed under GPL version 3
- * Please see the included DOCS/LICENSE.md for more information
- */
-
-#ifndef ALECOMPAT_H
-#define ALECOMPAT_H
-
-extern "C"
-{
-#include "lua.h"
-#include "lauxlib.h"
-};
-
-/* Compatibility layer for compiling with Lua 5.1 or LuaJIT */
-#if LUA_VERSION_NUM == 501
-    int luaL_getsubtable(lua_State* L, int i, const char* name);
-    const char* luaL_tolstring(lua_State* L, int idx, size_t* len);
-    int lua_absindex(lua_State* L, int i);
-    #define lua_pushglobaltable(L) \
-        lua_pushvalue((L), LUA_GLOBALSINDEX)
-    #define lua_rawlen(L, idx) \
-        lua_objlen(L, idx)
-    #define lua_pushunsigned(L, u) \
-        lua_pushinteger(L, u)
-    #define lua_load(L, buf_read, dec_buf, str, NULL) \
-        lua_load(L, buf_read, dec_buf, str)
-
-    #ifndef LUA_OK
-        #define LUA_OK 0
-    #endif
-
-#if !defined LUAJIT_VERSION
-    void* luaL_testudata(lua_State* L, int index, const char* tname);
-    void luaL_setmetatable(lua_State* L, const char* tname);
-    #define luaL_setfuncs(L, l, n) luaL_register(L, NULL, l)
-#endif
-#endif
-
-#if LUA_VERSION_NUM > 502
-    #define lua_dump(L, writer, data) \
-        lua_dump(L, writer, data, 0)
-    #define lua_pushunsigned(L, u) \
-        lua_pushinteger(L, u)
-#endif
-#endif
diff --git a/src/LuaEngine/ALECreatureAI.h b/src/LuaEngine/ALECreatureAI.h
index cb9ccdae7c..1361783b3e 100644
--- a/src/LuaEngine/ALECreatureAI.h
+++ b/src/LuaEngine/ALECreatureAI.h
@@ -8,8 +8,7 @@
 #define _ALE_CREATURE_AI_H
 
 #include "LuaEngine.h"
-
-struct ScriptedAI;
+#include "ScriptedCreature.h"
 
 struct ALECreatureAI : ScriptedAI
 {
@@ -45,7 +44,7 @@ struct ALECreatureAI : ScriptedAI
 
         if (!sALE->UpdateAI(me, diff))
         {
-            if (!me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC))
+            if (!me->HasUnitFlag(UNIT_FLAG_IMMUNE_TO_NPC))
                 ScriptedAI::UpdateAI(diff);
         }
     }
diff --git a/src/LuaEngine/ALEDBCRegistry.h b/src/LuaEngine/ALEDBCRegistry.h
index b525ce8e49..6026279312 100644
--- a/src/LuaEngine/ALEDBCRegistry.h
+++ b/src/LuaEngine/ALEDBCRegistry.h
@@ -1,38 +1,42 @@
 #ifndef ALEDBCREGISTRY_H
 #define ALEDBCREGISTRY_H
 
+#include "ALEBind.h"
+#include "DBCStores.h"
+
+#include <functional>
 #include <string>
 #include <vector>
-#include <functional>
-#include <typeinfo>
-
-#include "DBCStores.h"
-#include "LuaEngine.h"
 
+/*
+ * Registry of DBC stores exposed to Lua through the global LookupEntry(name, id).
+ *
+ * Each entry knows how to look an id up in its store and how to wrap the found
+ * record into a Lua value of the matching usertype. DBC records live for the
+ * whole server uptime, so handing their address to Lua is safe.
+ */
 struct DBCDefinition
 {
     std::string name;
-    void* storage;
-    const std::type_info& type;
-    std::function<const void*(uint32)> lookupFunction;
-    std::function<void(lua_State*, const void*)> pushFunction;
+    std::function<void const* (uint32)> lookupFunction;
+    std::function<sol::object(sol::state_view, void const*)> makeObject;
 };
 
 extern std::vector<DBCDefinition> dbcRegistry;
 
-#define REGISTER_DBC(dbcName, entryType, store) \
-    {                                           \
-        #dbcName,                               \
-        reinterpret_cast<void*>(&store),        \
-        typeid(DBCStorage<entryType>),          \
-        [](uint32 id) -> const void* {          \
-            return store.LookupEntry(id);       \
-        },                                      \
-        [](lua_State* L, const void* entry) {   \
-            auto cast_entry = static_cast<const entryType*>(entry); \
-            ALE::Push(L, *cast_entry);        \
-        }                                       \
+#define REGISTER_DBC(dbcName, entryType, store)                             \
+    {                                                                       \
+        #dbcName,                                                           \
+        [](uint32 id) -> void const*                                        \
+        {                                                                   \
+            return store.LookupEntry(id);                                   \
+        },                                                                  \
+        [](sol::state_view lua, void const* entry) -> sol::object          \
+        {                                                                   \
+            /* Setters exist on some DBC usertypes, so expose non-const. */ \
+            return sol::make_object(lua,                                    \
+                const_cast<entryType*>(static_cast<entryType const*>(entry))); \
+        }                                                                   \
     }
 
 #endif // ALEDBCREGISTRY_H
-
diff --git a/src/LuaEngine/ALEEventMgr.cpp b/src/LuaEngine/ALEEventMgr.cpp
index f90cee3167..8f123cd49f 100644
--- a/src/LuaEngine/ALEEventMgr.cpp
+++ b/src/LuaEngine/ALEEventMgr.cpp
@@ -8,13 +8,7 @@
 #include "LuaEngine.h"
 #include "Object.h"
 
-extern "C"
-{
-#include "lua.h"
-#include "lauxlib.h"
-};
-
-ALEEventProcessor::ALEEventProcessor(ALE** _E, WorldObject* _obj) : m_time(0), obj(_obj), E(_E)
+ALEEventProcessor::ALEEventProcessor(ALE** _E, WorldObject* _obj) : obj(_obj), E(_E)
 {
     // can be called from multiple threads
     if (obj)
@@ -48,7 +42,7 @@ void ALEEventProcessor::Update(uint32 diff)
         eventList.erase(it);
 
         if (luaEvent->state != LUAEVENT_STATE_ERASE)
-            eventMap.erase(luaEvent->funcRef);
+            eventMap.erase(luaEvent->id);
 
         if (luaEvent->state == LUAEVENT_STATE_RUN)
         {
@@ -58,45 +52,41 @@ void ALEEventProcessor::Update(uint32 diff)
                 AddEvent(luaEvent); // Reschedule before calling incase RemoveEvents used
 
             // Call the timed event
-            (*E)->OnTimedEvent(luaEvent->funcRef, delay, luaEvent->repeats ? luaEvent->repeats-- : luaEvent->repeats, obj);
+            (*E)->OnTimedEvent(luaEvent->callback, luaEvent->id, delay, luaEvent->repeats ? luaEvent->repeats-- : luaEvent->repeats, obj);
 
             if (!remove)
                 continue;
         }
 
         // Event should be deleted (executed last time or set to be aborted)
-        RemoveEvent(luaEvent);
+        delete luaEvent;
     }
 }
 
 void ALEEventProcessor::SetStates(LuaEventState state)
 {
-    for (EventList::iterator it = eventList.begin(); it != eventList.end(); ++it)
-        it->second->SetState(state);
+    for (auto& [time, luaEvent] : eventList)
+        luaEvent->SetState(state);
+
     if (state == LUAEVENT_STATE_ERASE)
         eventMap.clear();
 }
 
 void ALEEventProcessor::RemoveEvents_internal()
 {
-    //if (!final)
-    //{
-    //    for (EventList::iterator it = eventList.begin(); it != eventList.end(); ++it)
-    //        it->second->to_Abort = true;
-    //    return;
-    //}
-
-    for (EventList::iterator it = eventList.begin(); it != eventList.end(); ++it)
-        RemoveEvent(it->second);
+    for (auto& [time, luaEvent] : eventList)
+        delete luaEvent;
 
     eventList.clear();
     eventMap.clear();
 }
 
-void ALEEventProcessor::SetState(int eventId, LuaEventState state)
+void ALEEventProcessor::SetState(uint64 eventId, LuaEventState state)
 {
-    if (eventMap.find(eventId) != eventMap.end())
-        eventMap[eventId]->SetState(state);
+    auto iter = eventMap.find(eventId);
+    if (iter != eventMap.end())
+        iter->second->SetState(state);
+
     if (state == LUAEVENT_STATE_ERASE)
         eventMap.erase(eventId);
 }
@@ -104,27 +94,18 @@ void ALEEventProcessor::SetState(int eventId, LuaEventState state)
 void ALEEventProcessor::AddEvent(LuaEvent* luaEvent)
 {
     luaEvent->GenerateDelay();
-    eventList.insert(std::pair<uint64, LuaEvent*>(m_time + luaEvent->delay, luaEvent));
-    eventMap[luaEvent->funcRef] = luaEvent;
+    eventList.insert({ m_time + luaEvent->delay, luaEvent });
+    eventMap[luaEvent->id] = luaEvent;
 }
 
-void ALEEventProcessor::AddEvent(int funcRef, uint32 min, uint32 max, uint32 repeats)
+uint64 ALEEventProcessor::AddEvent(sol::protected_function callback, uint32 min, uint32 max, uint32 repeats)
 {
-    AddEvent(new LuaEvent(funcRef, min, max, repeats));
-}
-
-void ALEEventProcessor::RemoveEvent(LuaEvent* luaEvent)
-{
-    // Unreference if should and if ALE was not yet uninitialized and if the lua state still exists
-    if (luaEvent->state != LUAEVENT_STATE_ERASE && ALE::IsInitialized() && (*E)->HasLuaState())
-    {
-        // Free lua function ref
-        luaL_unref((*E)->L, LUA_REGISTRYINDEX, luaEvent->funcRef);
-    }
-    delete luaEvent;
+    uint64 id = (*E)->eventMgr->NextEventId();
+    AddEvent(new LuaEvent(id, std::move(callback), min, max, repeats));
+    return id;
 }
 
-EventMgr::EventMgr(ALE** _E) : globalProcessor(new ALEEventProcessor(_E, NULL)), E(_E)
+EventMgr::EventMgr(ALE** _E) : globalProcessor(new ALEEventProcessor(_E, nullptr)), E(_E)
 {
 }
 
@@ -132,29 +113,26 @@ EventMgr::~EventMgr()
 {
     {
         Guard guard(GetLock());
-        if (!processors.empty())
-            for (ProcessorSet::const_iterator it = processors.begin(); it != processors.end(); ++it) // loop processors
-                (*it)->RemoveEvents_internal();
+        for (ALEEventProcessor* processor : processors)
+            processor->RemoveEvents_internal();
         globalProcessor->RemoveEvents_internal();
     }
     delete globalProcessor;
-    globalProcessor = NULL;
+    globalProcessor = nullptr;
 }
 
 void EventMgr::SetStates(LuaEventState state)
 {
     Guard guard(GetLock());
-    if (!processors.empty())
-        for (ProcessorSet::const_iterator it = processors.begin(); it != processors.end(); ++it) // loop processors
-            (*it)->SetStates(state);
+    for (ALEEventProcessor* processor : processors)
+        processor->SetStates(state);
     globalProcessor->SetStates(state);
 }
 
-void EventMgr::SetState(int eventId, LuaEventState state)
+void EventMgr::SetState(uint64 eventId, LuaEventState state)
 {
     Guard guard(GetLock());
-    if (!processors.empty())
-        for (ProcessorSet::const_iterator it = processors.begin(); it != processors.end(); ++it) // loop processors
-            (*it)->SetState(eventId, state);
+    for (ALEEventProcessor* processor : processors)
+        processor->SetState(eventId, state);
     globalProcessor->SetState(eventId, state);
 }
diff --git a/src/LuaEngine/ALEEventMgr.h b/src/LuaEngine/ALEEventMgr.h
index 5302ecead2..05a1505f24 100644
--- a/src/LuaEngine/ALEEventMgr.h
+++ b/src/LuaEngine/ALEEventMgr.h
@@ -10,9 +10,12 @@
 #include "ALEUtility.h"
 #include "Common.h"
 #include "Util.h"
-#include <map>
 
-#include "Define.h"
+#include <sol/sol.hpp>
+
+#include <map>
+#include <unordered_map>
+#include <unordered_set>
 
 class ALE;
 class EventMgr;
@@ -22,14 +25,19 @@ class WorldObject;
 enum LuaEventState
 {
     LUAEVENT_STATE_RUN,    // On next call run the function normally
-    LUAEVENT_STATE_ABORT,  // On next call unregisters reffed function and erases the data
+    LUAEVENT_STATE_ABORT,  // On next call unregisters the callback and erases the data
     LUAEVENT_STATE_ERASE,  // On next call just erases the data
 };
 
+/*
+ * A timed Lua callback registered with CreateLuaEvent or object:RegisterEvent.
+ * The callback keeps itself alive in the Lua registry for as long as the
+ * event exists.
+ */
 struct LuaEvent
 {
-    LuaEvent(int _funcRef, uint32 _min, uint32 _max, uint32 _repeats) :
-        min(_min), max(_max), delay(0), repeats(_repeats), funcRef(_funcRef), state(LUAEVENT_STATE_RUN)
+    LuaEvent(uint64 _id, sol::protected_function _callback, uint32 _min, uint32 _max, uint32 _repeats) :
+        min(_min), max(_max), delay(0), repeats(_repeats), id(_id), callback(std::move(_callback)), state(LUAEVENT_STATE_RUN)
     {
     }
 
@@ -48,7 +56,8 @@ struct LuaEvent
     uint32 max;   // Maximum delay between event calls
     uint32 delay; // The currently used waiting time
     uint32 repeats; // Amount of repeats to make, 0 for infinite
-    int funcRef;    // Lua function reference ID, also used as event ID
+    uint64 id;      // Event ID, used to remove the event from Lua
+    sol::protected_function callback;
     LuaEventState state;    // State for next call
 };
 
@@ -58,7 +67,7 @@ class ALEEventProcessor
 
 public:
     typedef std::multimap<uint64, LuaEvent*> EventList;
-    typedef std::unordered_map<int, LuaEvent*> EventMap;
+    typedef std::unordered_map<uint64, LuaEvent*> EventMap;
 
     ALEEventProcessor(ALE** _E, WorldObject* _obj);
     ~ALEEventProcessor();
@@ -67,16 +76,16 @@ class ALEEventProcessor
     // removes all timed events on next tick or at tick end
     void SetStates(LuaEventState state);
     // set the event to be removed when executing
-    void SetState(int eventId, LuaEventState state);
-    void AddEvent(int funcRef, uint32 min, uint32 max, uint32 repeats);
+    void SetState(uint64 eventId, LuaEventState state);
+    // registers the callback and returns its event ID
+    uint64 AddEvent(sol::protected_function callback, uint32 min, uint32 max, uint32 repeats);
     EventMap eventMap;
 
 private:
     void RemoveEvents_internal();
     void AddEvent(LuaEvent* luaEvent);
-    void RemoveEvent(LuaEvent* luaEvent);
     EventList eventList;
-    uint64 m_time;
+    uint64 m_time = 0;
     WorldObject* obj;
     ALE** E;
 };
@@ -92,13 +101,19 @@ class EventMgr : public ALEUtil::Lockable
     EventMgr(ALE** _E);
     ~EventMgr();
 
+    // Returns a new unique id for a timed event.
+    uint64 NextEventId() { return ++maxEventId; }
+
     // Set the state of all timed events
     // Execute only in safe env
     void SetStates(LuaEventState state);
 
     // Sets the eventId's state in all processors
     // Execute only in safe env
-    void SetState(int eventId, LuaEventState state);
+    void SetState(uint64 eventId, LuaEventState state);
+
+private:
+    uint64 maxEventId = 0;
 };
 
-#endif
+#endif // _ALE_EVENT_MGR_H
diff --git a/src/LuaEngine/ALEHandles.cpp b/src/LuaEngine/ALEHandles.cpp
new file mode 100644
index 0000000000..7c1b1382db
--- /dev/null
+++ b/src/LuaEngine/ALEHandles.cpp
@@ -0,0 +1,357 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#include "ALEHandles.h"
+
+#include "Corpse.h"
+#include "GameObject.h"
+#include "Group.h"
+#include "GroupMgr.h"
+#include "Guild.h"
+#include "GuildMgr.h"
+#include "Item.h"
+#include "Map.h"
+#include "MapMgr.h"
+#include "ObjectAccessor.h"
+#include "Pet.h"
+#include "Player.h"
+#include "Transport.h"
+
+namespace ALEHandleEpoch
+{
+    namespace
+    {
+        // Starts above the default handle epoch (0) so a fresh handle never
+        // accidentally matches the current call stack before its first resolve.
+        uint64 currentEpoch = 1;
+    }
+
+    uint64 GetEpoch()
+    {
+        return currentEpoch;
+    }
+
+    void Bump()
+    {
+        ++currentEpoch;
+    }
+}
+
+namespace
+{
+    // Captures where a world object lives so its handle can find the map again.
+    void CaptureMap(WorldObject const* obj, uint32& mapId, uint32& instanceId)
+    {
+        if (Map const* map = obj->FindMap())
+        {
+            mapId = map->GetId();
+            instanceId = map->GetInstanceId();
+        }
+    }
+}
+
+Object* ObjectRef::ResolveRaw() const
+{
+    if (!_guid)
+        return nullptr;
+
+    // Reuse the pointer resolved earlier in this same Lua call stack.
+    if (_cached && _epoch == ALEHandleEpoch::GetEpoch())
+        return _cached;
+
+    Object* resolved = nullptr;
+
+    // Players are reachable globally; items live in their owner's inventory;
+    // everything else is looked up on the map it was captured on.
+    if (_guid.IsPlayer())
+        resolved = ObjectAccessor::FindPlayer(_guid);
+    else if (_guid.IsItem())
+    {
+        if (Player* owner = ObjectAccessor::FindPlayer(_ownerGuid))
+            resolved = owner->GetItemByGuid(_guid);
+    }
+    else if (Map* map = sMapMgr->FindMap(_mapId, _instanceId))
+    {
+        if (_guid.IsCreatureOrVehicle())
+            resolved = map->GetCreature(_guid);
+        else if (_guid.IsPet())
+            resolved = map->GetPet(_guid);
+        else if (_guid.IsGameObject() || _guid.IsTransport())
+            resolved = map->GetGameObject(_guid);
+        else if (_guid.IsMOTransport())
+            resolved = map->GetTransport(_guid);
+        else if (_guid.IsCorpse())
+            resolved = map->GetCorpse(_guid);
+    }
+
+    if (resolved)
+    {
+        _cached = resolved;
+        _epoch = ALEHandleEpoch::GetEpoch();
+    }
+
+    return resolved;
+}
+
+Object* ObjectRef::Resolve() const
+{
+    return ResolveRaw();
+}
+
+Object* ObjectRef::Require() const
+{
+    if (Object* obj = ResolveRaw())
+        return obj;
+
+    throw ALEStaleObjectError("Object");
+}
+
+WorldObjectRef::WorldObjectRef(WorldObject const* obj) :
+    ObjectRef(obj->GetGUID(), 0, 0)
+{
+    CaptureMap(obj, _mapId, _instanceId);
+}
+
+WorldObject* WorldObjectRef::Resolve() const
+{
+    // Every guid type handled by ResolveRaw except items is a WorldObject.
+    if (_guid.IsItem())
+        return nullptr;
+
+    return static_cast<WorldObject*>(ResolveRaw());
+}
+
+WorldObject* WorldObjectRef::Require() const
+{
+    if (WorldObject* obj = Resolve())
+        return obj;
+
+    throw ALEStaleObjectError("WorldObject");
+}
+
+UnitRef::UnitRef(Unit const* unit) :
+    WorldObjectRef(unit)
+{
+}
+
+Unit* UnitRef::Resolve() const
+{
+    if (Object* obj = ResolveRaw())
+        return obj->ToUnit();
+
+    return nullptr;
+}
+
+Unit* UnitRef::Require() const
+{
+    if (Unit* unit = Resolve())
+        return unit;
+
+    throw ALEStaleObjectError("Unit");
+}
+
+PlayerRef::PlayerRef(Player const* player) :
+    UnitRef(player)
+{
+}
+
+Player* PlayerRef::Resolve() const
+{
+    if (Object* obj = ResolveRaw())
+        return obj->ToPlayer();
+
+    return nullptr;
+}
+
+Player* PlayerRef::Require() const
+{
+    if (Player* player = Resolve())
+        return player;
+
+    throw ALEStaleObjectError("Player");
+}
+
+CreatureRef::CreatureRef(Creature const* creature) :
+    UnitRef(creature)
+{
+}
+
+Creature* CreatureRef::Resolve() const
+{
+    if (Object* obj = ResolveRaw())
+        return obj->ToCreature();
+
+    return nullptr;
+}
+
+Creature* CreatureRef::Require() const
+{
+    if (Creature* creature = Resolve())
+        return creature;
+
+    throw ALEStaleObjectError("Creature");
+}
+
+PetRef::PetRef(Pet const* pet) :
+    CreatureRef(pet)
+{
+}
+
+Pet* PetRef::Resolve() const
+{
+    if (Object* obj = ResolveRaw())
+        if (Unit* unit = obj->ToUnit())
+            return unit->ToPet();
+
+    return nullptr;
+}
+
+Pet* PetRef::Require() const
+{
+    if (Pet* pet = Resolve())
+        return pet;
+
+    throw ALEStaleObjectError("Pet");
+}
+
+GameObjectRef::GameObjectRef(GameObject const* go) :
+    WorldObjectRef(go)
+{
+}
+
+GameObject* GameObjectRef::Resolve() const
+{
+    if (Object* obj = ResolveRaw())
+        return obj->ToGameObject();
+
+    return nullptr;
+}
+
+GameObject* GameObjectRef::Require() const
+{
+    if (GameObject* go = Resolve())
+        return go;
+
+    throw ALEStaleObjectError("GameObject");
+}
+
+TransportRef::TransportRef(Transport const* transport) :
+    GameObjectRef(transport)
+{
+}
+
+Transport* TransportRef::Resolve() const
+{
+    if (GameObject* go = GameObjectRef::Resolve())
+        return go->ToTransport();
+
+    return nullptr;
+}
+
+Transport* TransportRef::Require() const
+{
+    if (Transport* transport = Resolve())
+        return transport;
+
+    throw ALEStaleObjectError("Transport");
+}
+
+CorpseRef::CorpseRef(Corpse const* corpse) :
+    WorldObjectRef(corpse)
+{
+}
+
+Corpse* CorpseRef::Resolve() const
+{
+    if (Object* obj = ResolveRaw())
+        return obj->ToCorpse();
+
+    return nullptr;
+}
+
+Corpse* CorpseRef::Require() const
+{
+    if (Corpse* corpse = Resolve())
+        return corpse;
+
+    throw ALEStaleObjectError("Corpse");
+}
+
+ItemRef::ItemRef(Item const* item) :
+    ObjectRef(item->GetGUID(), 0, 0, item->GetOwnerGUID())
+{
+}
+
+Item* ItemRef::Resolve() const
+{
+    if (!_guid.IsItem())
+        return nullptr;
+
+    // The item resolution path in ResolveRaw only ever returns Item pointers.
+    return static_cast<Item*>(ResolveRaw());
+}
+
+Item* ItemRef::Require() const
+{
+    if (Item* item = Resolve())
+        return item;
+
+    throw ALEStaleObjectError("Item");
+}
+
+MapRef::MapRef(Map const* map) :
+    _mapId(map->GetId()), _instanceId(map->GetInstanceId())
+{
+}
+
+Map* MapRef::Resolve() const
+{
+    return sMapMgr->FindMap(_mapId, _instanceId);
+}
+
+Map* MapRef::Require() const
+{
+    if (Map* map = Resolve())
+        return map;
+
+    throw ALEStaleObjectError("Map");
+}
+
+GroupRef::GroupRef(Group const* group) :
+    _guid(group->GetGUID())
+{
+}
+
+Group* GroupRef::Resolve() const
+{
+    return sGroupMgr->GetGroupByGUID(_guid.GetCounter());
+}
+
+Group* GroupRef::Require() const
+{
+    if (Group* group = Resolve())
+        return group;
+
+    throw ALEStaleObjectError("Group");
+}
+
+GuildRef::GuildRef(Guild const* guild) :
+    _guildId(guild->GetId())
+{
+}
+
+Guild* GuildRef::Resolve() const
+{
+    return sGuildMgr->GetGuildById(_guildId);
+}
+
+Guild* GuildRef::Require() const
+{
+    if (Guild* guild = Resolve())
+        return guild;
+
+    throw ALEStaleObjectError("Guild");
+}
diff --git a/src/LuaEngine/ALEHandles.h b/src/LuaEngine/ALEHandles.h
new file mode 100644
index 0000000000..a1133f9975
--- /dev/null
+++ b/src/LuaEngine/ALEHandles.h
@@ -0,0 +1,319 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#ifndef _ALE_HANDLES_H
+#define _ALE_HANDLES_H
+
+#include "ObjectGuid.h"
+
+#include <stdexcept>
+#include <string>
+
+class Corpse;
+class GameObject;
+class Group;
+class Guild;
+class Item;
+class Map;
+class Object;
+class Pet;
+class Player;
+class Transport;
+class Unit;
+class WorldObject;
+class Creature;
+
+/*
+ * Safe references ("handles") to game objects exposed to Lua.
+ *
+ * Lua scripts can keep a value alive for as long as they want, but the game
+ * object behind it can despawn, log out or be unloaded at any moment. Handing
+ * raw pointers to Lua would therefore be a use-after-free waiting to happen.
+ *
+ * Instead, every world object crossing the C++/Lua boundary is wrapped in a
+ * handle that stores its ObjectGuid (plus enough context to find it again) and
+ * is re-resolved through the core accessors on every use:
+ *
+ *   - resolving is cheap: the resolved pointer is cached for the duration of
+ *     the current Lua call stack (see ALEHandleEpoch below), so repeated method
+ *     calls inside one event handler cost a single lookup;
+ *   - a handle kept across calls stays *safe*: if the object is gone, methods
+ *     raise a regular Lua error ("object no longer exists") instead of
+ *     dereferencing freed memory.
+ *
+ * The handle classes mirror the game class hierarchy (PlayerRef is a UnitRef
+ * is a WorldObjectRef is an ObjectRef) so that sol can pass a Player value to
+ * any function expecting a Unit or WorldObject.
+ */
+
+namespace ALEHandleEpoch
+{
+    /*
+     * Identifier of the current Lua call stack.
+     *
+     * The engine bumps it whenever the outermost event handler returns to C++.
+     * Handles use it to know whether their cached pointer belongs to the
+     * current call stack (safe to reuse) or to a previous one (must re-resolve).
+     */
+    uint64 GetEpoch();
+    void Bump();
+}
+
+/*
+ * Error thrown by Require() when a handle no longer resolves to a live object.
+ * sol converts it into a regular Lua error, catchable with pcall.
+ */
+class ALEStaleObjectError : public std::runtime_error
+{
+public:
+    explicit ALEStaleObjectError(char const* typeName) :
+        std::runtime_error(std::string(typeName) + " no longer exists (despawned, logged out or unloaded)")
+    {
+    }
+};
+
+/*
+ * Base handle: identity and resolution logic shared by every handle type.
+ *
+ * Resolution dispatches on the guid's HighGuid, so a UnitRef holding a player
+ * guid correctly resolves through ObjectAccessor while a creature guid goes
+ * through its owning map.
+ */
+class ObjectRef
+{
+public:
+    ObjectRef() = default;
+
+    ObjectGuid GetGuid() const { return _guid; }
+
+    // Returns whether the referenced object is currently reachable.
+    bool IsValid() const { return ResolveRaw() != nullptr; }
+
+    // Handles compare by identity: same guid means same game object.
+    bool operator==(ObjectRef const& other) const { return _guid == other._guid; }
+
+    Object* Resolve() const;
+    Object* Require() const;
+
+protected:
+    ObjectRef(ObjectGuid guid, uint32 mapId, uint32 instanceId, ObjectGuid ownerGuid = ObjectGuid::Empty) :
+        _guid(guid), _ownerGuid(ownerGuid), _mapId(mapId), _instanceId(instanceId)
+    {
+    }
+
+    // Looks the object up through the appropriate core accessor,
+    // reusing the pointer cached for the current Lua call stack when possible.
+    Object* ResolveRaw() const;
+
+    ObjectGuid _guid;
+    // Owning player's guid, only used to resolve items (an item lives in its owner's inventory).
+    ObjectGuid _ownerGuid;
+    uint32 _mapId = 0;
+    uint32 _instanceId = 0;
+
+private:
+    // Pointer cache, only trusted while _epoch matches the current call stack.
+    mutable Object* _cached = nullptr;
+    mutable uint64 _epoch = 0;
+};
+
+class WorldObjectRef : public ObjectRef
+{
+public:
+    WorldObjectRef() = default;
+    explicit WorldObjectRef(WorldObject const* obj);
+
+    WorldObject* Resolve() const;
+    WorldObject* Require() const;
+
+protected:
+    using ObjectRef::ObjectRef;
+};
+
+class UnitRef : public WorldObjectRef
+{
+public:
+    UnitRef() = default;
+    explicit UnitRef(Unit const* unit);
+
+    Unit* Resolve() const;
+    Unit* Require() const;
+
+protected:
+    using WorldObjectRef::WorldObjectRef;
+};
+
+class PlayerRef : public UnitRef
+{
+public:
+    PlayerRef() = default;
+    explicit PlayerRef(Player const* player);
+
+    Player* Resolve() const;
+    Player* Require() const;
+};
+
+class CreatureRef : public UnitRef
+{
+public:
+    CreatureRef() = default;
+    explicit CreatureRef(Creature const* creature);
+
+    Creature* Resolve() const;
+    Creature* Require() const;
+};
+
+class PetRef : public CreatureRef
+{
+public:
+    PetRef() = default;
+    explicit PetRef(Pet const* pet);
+
+    Pet* Resolve() const;
+    Pet* Require() const;
+};
+
+class GameObjectRef : public WorldObjectRef
+{
+public:
+    GameObjectRef() = default;
+    explicit GameObjectRef(GameObject const* go);
+
+    GameObject* Resolve() const;
+    GameObject* Require() const;
+};
+
+class TransportRef : public GameObjectRef
+{
+public:
+    TransportRef() = default;
+    explicit TransportRef(Transport const* transport);
+
+    Transport* Resolve() const;
+    Transport* Require() const;
+};
+
+class CorpseRef : public WorldObjectRef
+{
+public:
+    CorpseRef() = default;
+    explicit CorpseRef(Corpse const* corpse);
+
+    Corpse* Resolve() const;
+    Corpse* Require() const;
+};
+
+class ItemRef : public ObjectRef
+{
+public:
+    ItemRef() = default;
+    explicit ItemRef(Item const* item);
+
+    Item* Resolve() const;
+    Item* Require() const;
+};
+
+/*
+ * Handles for game objects outside the Object hierarchy that still have a
+ * stable identity: they resolve through their manager on every use, with the
+ * same guarantees as the handles above.
+ */
+
+class MapRef
+{
+public:
+    MapRef() = default;
+    explicit MapRef(Map const* map);
+
+    bool IsValid() const { return Resolve() != nullptr; }
+    bool operator==(MapRef const& other) const { return _mapId == other._mapId && _instanceId == other._instanceId; }
+
+    Map* Resolve() const;
+    Map* Require() const;
+
+private:
+    uint32 _mapId = 0;
+    uint32 _instanceId = 0;
+};
+
+class GroupRef
+{
+public:
+    GroupRef() = default;
+    explicit GroupRef(Group const* group);
+
+    bool IsValid() const { return Resolve() != nullptr; }
+    bool operator==(GroupRef const& other) const { return _guid == other._guid; }
+
+    Group* Resolve() const;
+    Group* Require() const;
+
+private:
+    ObjectGuid _guid;
+};
+
+class GuildRef
+{
+public:
+    GuildRef() = default;
+    explicit GuildRef(Guild const* guild);
+
+    bool IsValid() const { return Resolve() != nullptr; }
+    bool operator==(GuildRef const& other) const { return _guildId == other._guildId; }
+
+    Guild* Resolve() const;
+    Guild* Require() const;
+
+private:
+    uint32 _guildId = 0;
+};
+
+// Lua-visible type name of a scoped type, used in error messages.
+template<typename T>
+struct ALETypeName;
+
+/*
+ * Handle for transient game objects with no way to look them up again
+ * (Aura, Spell, Vehicle, ...).
+ *
+ * The wrapped pointer is only trusted during the Lua call stack that created
+ * it: exactly the window the core guarantees the object stays alive for.
+ * Using it later raises a Lua error instead of touching freed memory.
+ */
+template<typename T>
+class ScopedRef
+{
+public:
+    ScopedRef() = default;
+
+    explicit ScopedRef(T const* ptr) :
+        _ptr(const_cast<T*>(ptr)), _epoch(ALEHandleEpoch::GetEpoch())
+    {
+    }
+
+    bool IsValid() const { return Resolve() != nullptr; }
+    bool operator==(ScopedRef const& other) const { return Resolve() == other.Resolve(); }
+
+    T* Resolve() const
+    {
+        return _epoch == ALEHandleEpoch::GetEpoch() ? _ptr : nullptr;
+    }
+
+    T* Require() const
+    {
+        if (T* ptr = Resolve())
+            return ptr;
+
+        throw std::runtime_error(std::string(ALETypeName<T>::value)
+            + " is only valid during the event that provided it; it cannot be stored and used later");
+    }
+
+private:
+    T* _ptr = nullptr;
+    uint64 _epoch = 0;
+};
+
+#endif // _ALE_HANDLES_H
diff --git a/src/LuaEngine/ALEIncludes.h b/src/LuaEngine/ALEIncludes.h
deleted file mode 100644
index bc38f08200..0000000000
--- a/src/LuaEngine/ALEIncludes.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
-* This program is free software licensed under GPL version 3
-* Please see the included DOCS/LICENSE.md for more information
-*/
-
-#ifndef _ALE_INCLUDES_H
-#define _ALE_INCLUDES_H
-
-// Required
-#include "AccountMgr.h"
-#include "AuctionHouseMgr.h"
-#include "Cell.h"
-#include "CellImpl.h"
-#include "Chat.h"
-#include "Channel.h"
-#include "DBCStores.h"
-#include "GameEventMgr.h"
-#include "GossipDef.h"
-#include "GridNotifiers.h"
-#include "GridNotifiersImpl.h"
-#include "Group.h"
-#include "Guild.h"
-#include "GuildMgr.h"
-#include "Language.h"
-#include "Mail.h"
-#include "ObjectAccessor.h"
-#include "ObjectMgr.h"
-#include "Opcodes.h"
-#include "Player.h"
-#include "Pet.h"
-#include "ReputationMgr.h"
-#include "ScriptMgr.h"
-#include "Spell.h"
-#include "SpellAuras.h"
-#include "SpellInfo.h"
-#include "SpellMgr.h"
-#include "TemporarySummon.h"
-#include "Transport.h"
-#include "WorldPacket.h"
-#include "WorldSession.h"
-#include "MapMgr.h"
-#include "Config.h"
-#include "GameEventMgr.h"
-#include "GitRevision.h"
-#include "GroupMgr.h"
-#include "ScriptedCreature.h"
-#include "WeatherMgr.h"
-#include "Battleground.h"
-#include "MotionMaster.h"
-#include "DatabaseEnv.h"
-#include "Bag.h"
-#include "Vehicle.h"
-#include "ArenaTeam.h"
-#include "WorldSessionMgr.h"
-
-typedef Opcodes                 OpcodesList;
-
-/*
- * Note: if you add or change a CORE_NAME or CORE_VERSION #define,
- *   please update LuaGlobalFunctions::GetCoreName or LuaGlobalFunctions::GetCoreVersion documentation example string.
- */
-#define CORE_NAME               "AzerothCore"
-
-#define CORE_VERSION            (GitRevision::GetFullVersion())
-#define eWorldSessionMgr        (sWorldSessionMgr)
-#define eWorld                  (sWorld)
-#define eMapMgr                 (sMapMgr)
-#define eConfigMgr              (sConfigMgr)
-#define eGuildMgr               (sGuildMgr)
-#define eObjectMgr              (sObjectMgr)
-#define eAccountMgr             (sAccountMgr)
-#define eAuctionMgr             (sAuctionMgr)
-#define eGameEventMgr           (sGameEventMgr)
-#define eObjectAccessor()       ObjectAccessor::
-
-#endif // _ALE_INCLUDES_H
diff --git a/src/LuaEngine/ALEInstanceAI.cpp b/src/LuaEngine/ALEInstanceAI.cpp
index ea32f2feaa..1c59f0a8c7 100644
--- a/src/LuaEngine/ALEInstanceAI.cpp
+++ b/src/LuaEngine/ALEInstanceAI.cpp
@@ -6,8 +6,198 @@
 
 #include "ALEInstanceAI.h"
 #include "ALEUtility.h"
-#include "lmarshal.h"
 
+#include <cstring>
+#include <memory>
+#include <unordered_set>
+
+namespace
+{
+    /*
+     * Minimal binary serializer for the instance data table.
+     *
+     * Instance data only ever holds plain data (booleans, numbers, strings and
+     * nested tables), so a small tagged format is enough: one tag byte per
+     * value, numbers as doubles, strings length-prefixed, tables as a pair
+     * count followed by the key/value pairs. Entries of any other type
+     * (function, userdata, ...) cannot survive a server restart anyway and are
+     * skipped with a warning instead of failing the whole save.
+     */
+    enum class DataTag : uint8
+    {
+        False  = 0,
+        True   = 1,
+        Number = 2,
+        String = 3,
+        Table  = 4
+    };
+
+    bool IsSerializable(sol::object const& value)
+    {
+        switch (value.get_type())
+        {
+            case sol::type::boolean:
+            case sol::type::number:
+            case sol::type::string:
+            case sol::type::table:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    void EncodeValue(sol::object const& value, std::string& out, std::unordered_set<void const*>& openTables);
+
+    void EncodeTable(sol::table const& table, std::string& out, std::unordered_set<void const*>& openTables)
+    {
+        // A table reachable from itself would recurse forever; fail the save
+        // cleanly instead.
+        if (!openTables.insert(table.pointer()).second)
+            throw std::runtime_error("instance data contains a table that references itself (cycle)");
+
+        uint32 count = 0;
+        for (auto const& [key, value] : table.pairs())
+            if (IsSerializable(key) && IsSerializable(value))
+                ++count;
+
+        out.push_back(static_cast<char>(DataTag::Table));
+        out.append(reinterpret_cast<char const*>(&count), sizeof(count));
+
+        for (auto const& [key, value] : table.pairs())
+        {
+            if (!IsSerializable(key) || !IsSerializable(value))
+            {
+                ALE_LOG_ERROR("Instance data entry skipped while saving: keys and values must be booleans, numbers, strings or tables");
+                continue;
+            }
+
+            EncodeValue(key, out, openTables);
+            EncodeValue(value, out, openTables);
+        }
+
+        openTables.erase(table.pointer());
+    }
+
+    void EncodeValue(sol::object const& value, std::string& out, std::unordered_set<void const*>& openTables)
+    {
+        switch (value.get_type())
+        {
+            case sol::type::boolean:
+                out.push_back(static_cast<char>(value.as<bool>() ? DataTag::True : DataTag::False));
+                break;
+            case sol::type::number:
+            {
+                double number = value.as<double>();
+                out.push_back(static_cast<char>(DataTag::Number));
+                out.append(reinterpret_cast<char const*>(&number), sizeof(number));
+                break;
+            }
+            case sol::type::string:
+            {
+                std::string str = value.as<std::string>();
+                uint32 length = static_cast<uint32>(str.size());
+                out.push_back(static_cast<char>(DataTag::String));
+                out.append(reinterpret_cast<char const*>(&length), sizeof(length));
+                out.append(str);
+                break;
+            }
+            case sol::type::table:
+                EncodeTable(value.as<sol::table>(), out, openTables);
+                break;
+            default:
+                // Filtered out by IsSerializable before we get here.
+                break;
+        }
+    }
+
+    // Cursor over the decoded save data; every read is bounds-checked so a
+    // truncated or corrupted blob fails cleanly instead of reading past the end.
+    struct DataReader
+    {
+        unsigned char const* pos;
+        unsigned char const* end;
+
+        size_t Remaining() const { return static_cast<size_t>(end - pos); }
+
+        bool Read(void* dest, size_t size)
+        {
+            if (Remaining() < size)
+                return false;
+
+            std::memcpy(dest, pos, size);
+            pos += size;
+            return true;
+        }
+    };
+
+    // Reads one value; returns sol::lua_nil and clears `ok` on malformed data.
+    sol::object DecodeValue(sol::state& lua, DataReader& reader, bool& ok)
+    {
+        uint8 tag;
+        if (!reader.Read(&tag, sizeof(tag)))
+        {
+            ok = false;
+            return sol::make_object(lua, sol::lua_nil);
+        }
+
+        switch (static_cast<DataTag>(tag))
+        {
+            case DataTag::False:
+                return sol::make_object(lua, false);
+            case DataTag::True:
+                return sol::make_object(lua, true);
+            case DataTag::Number:
+            {
+                double number;
+                if (!reader.Read(&number, sizeof(number)))
+                    break;
+
+                return sol::make_object(lua, number);
+            }
+            case DataTag::String:
+            {
+                uint32 length;
+                if (!reader.Read(&length, sizeof(length)))
+                    break;
+
+                // The length comes from persisted data: validate it against the
+                // remaining bytes before allocating anything.
+                if (length > reader.Remaining())
+                    break;
+
+                std::string str(length, '\0');
+                if (!reader.Read(str.data(), length))
+                    break;
+
+                return sol::make_object(lua, str);
+            }
+            case DataTag::Table:
+            {
+                uint32 count;
+                if (!reader.Read(&count, sizeof(count)))
+                    break;
+
+                sol::table table = lua.create_table();
+                for (uint32 i = 0; i < count; ++i)
+                {
+                    sol::object key = DecodeValue(lua, reader, ok);
+                    sol::object value = DecodeValue(lua, reader, ok);
+                    if (!ok)
+                        return sol::make_object(lua, sol::lua_nil);
+
+                    table[key] = value;
+                }
+
+                return table;
+            }
+            default:
+                break;
+        }
+
+        ok = false;
+        return sol::make_object(lua, sol::lua_nil);
+    }
+}
 
 void ALEInstanceAI::Initialize()
 {
@@ -16,9 +206,7 @@ void ALEInstanceAI::Initialize()
     ASSERT(!sALE->HasInstanceData(instance));
 
     // Create a new table for instance data.
-    lua_State* L = sALE->L;
-    lua_newtable(L);
-    sALE->CreateInstanceData(instance);
+    sALE->CreateInstanceData(instance, sALE->lua.create_table());
 
     sALE->OnInitialize(this);
 }
@@ -30,115 +218,72 @@ void ALEInstanceAI::Load(const char* data)
     // If we get passed NULL (i.e. `Reload` was called) then use
     //   the last known save data (or maybe just an empty string).
     if (!data)
-    {
         data = lastSaveData.c_str();
-    }
     else // Otherwise, copy the new data into our buffer.
-    {
         lastSaveData.assign(data);
-    }
 
     if (data[0] == '\0')
     {
         ASSERT(!sALE->HasInstanceData(instance));
 
         // Create a new table for instance data.
-        lua_State* L = sALE->L;
-        lua_newtable(L);
-        sALE->CreateInstanceData(instance);
+        sALE->CreateInstanceData(instance, sALE->lua.create_table());
 
         sALE->OnLoad(this);
-        // Stack: (empty)
         return;
     }
 
     size_t decodedLength;
-    const unsigned char* decodedData = ALEUtil::DecodeData(data, &decodedLength);
-    lua_State* L = sALE->L;
+    std::unique_ptr<unsigned char const[]> decodedData(ALEUtil::DecodeData(data, &decodedLength));
 
-    if (decodedData)
+    if (!decodedData)
     {
-        // Stack: (empty)
-
-        lua_pushcfunction(L, mar_decode);
-        lua_pushlstring(L, (const char*)decodedData, decodedLength);
-        // Stack: mar_decode, decoded_data
-
-        // Call `mar_decode` and check for success.
-        if (lua_pcall(L, 1, 1, 0) == 0)
-        {
-            // Stack: data
-            // Only use the data if it's a table.
-            if (lua_istable(L, -1))
-            {
-                sALE->CreateInstanceData(instance);
-                // Stack: (empty)
-                sALE->OnLoad(this);
-                // WARNING! lastSaveData might be different after `OnLoad` if the Lua code saved data.
-            }
-            else
-            {
-                ALE_LOG_ERROR("Error while loading instance data: Expected data to be a table (type 5), got type {} instead", lua_type(L, -1));
-                lua_pop(L, 1);
-                // Stack: (empty)
-
-                Initialize();
-            }
-        }
-        else
-        {
-            // Stack: error_message
-            ALE_LOG_ERROR("Error while parsing instance data with lua-marshal: {}", lua_tostring(L, -1));
-            lua_pop(L, 1);
-            // Stack: (empty)
+        ALE_LOG_ERROR("Error while decoding instance data: Data is not valid base-64");
+        Initialize();
+        return;
+    }
 
-            Initialize();
-        }
+    DataReader reader{ decodedData.get(), decodedData.get() + decodedLength };
+    bool ok = true;
+    sol::object decoded = DecodeValue(sALE->lua, reader, ok);
 
-        delete[] decodedData;
-    }
-    else
+    if (!ok || !decoded.is<sol::table>())
     {
-        ALE_LOG_ERROR("Error while decoding instance data: Data is not valid base-64");
-
+        ALE_LOG_ERROR("Error while loading instance data: save data is malformed");
         Initialize();
+        return;
     }
+
+    sALE->CreateInstanceData(instance, decoded.as<sol::table>());
+    // WARNING! lastSaveData might be different after `OnLoad` if the Lua code saved data.
+    sALE->OnLoad(this);
 }
 
 const char* ALEInstanceAI::Save() const
 {
     LOCK_ALE;
-    lua_State* L = sALE->L;
-    // Stack: (empty)
 
     /*
      * Need to cheat because this method actually does modify this instance,
      *   even though it's declared as `const`.
-     *
-     * Declaring virtual methods as `const` is BAD!
-     * Don't dictate to children that their methods must be pure.
      */
     ALEInstanceAI* self = const_cast<ALEInstanceAI*>(this);
 
-    lua_pushcfunction(L, mar_encode);
-    sALE->PushInstanceData(L, self, false);
-    // Stack: mar_encode, instance_data
+    std::string encoded;
+    std::unordered_set<void const*> openTables;
 
-    if (lua_pcall(L, 1, 1, 0) != 0)
+    try
     {
-        // Stack: error_message
-        ALE_LOG_ERROR("Error while saving: {}", lua_tostring(L, -1));
-        lua_pop(L, 1);
-        return NULL;
+        EncodeTable(sALE->GetInstanceData(self), encoded, openTables);
+    }
+    catch (std::exception const& error)
+    {
+        ALE_LOG_ERROR("Error while saving instance data: {}", error.what());
+        return nullptr;
     }
 
-    // Stack: data
-    size_t dataLength;
-    const unsigned char* data = (const unsigned char*)lua_tolstring(L, -1, &dataLength);
-    ALEUtil::EncodeData(data, dataLength, self->lastSaveData);
-
-    lua_pop(L, 1);
-    // Stack: (empty)
+    // The serialized table is binary; store it base-64 encoded.
+    ALEUtil::EncodeData(reinterpret_cast<unsigned char const*>(encoded.data()), encoded.size(), self->lastSaveData);
 
     return lastSaveData.c_str();
 }
@@ -146,83 +291,31 @@ const char* ALEInstanceAI::Save() const
 uint32 ALEInstanceAI::GetData(uint32 key) const
 {
     LOCK_ALE;
-    lua_State* L = sALE->L;
-    // Stack: (empty)
-
-    sALE->PushInstanceData(L, const_cast<ALEInstanceAI*>(this), false);
-    // Stack: instance_data
-
-    ALE::Push(L, key);
-    // Stack: instance_data, key
 
-    lua_gettable(L, -2);
-    // Stack: instance_data, value
-
-    uint32 value = ALE::CHECKVAL<uint32>(L, -1, 0);
-    lua_pop(L, 2);
-    // Stack: (empty)
-
-    return value;
+    sol::table data = sALE->GetInstanceData(const_cast<ALEInstanceAI*>(this));
+    return data.get_or(key, 0u);
 }
 
 void ALEInstanceAI::SetData(uint32 key, uint32 value)
 {
     LOCK_ALE;
-    lua_State* L = sALE->L;
-    // Stack: (empty)
-
-    sALE->PushInstanceData(L, this, false);
-    // Stack: instance_data
 
-    ALE::Push(L, key);
-    ALE::Push(L, value);
-    // Stack: instance_data, key, value
-
-    lua_settable(L, -3);
-    // Stack: instance_data
-
-    lua_pop(L, 1);
-    // Stack: (empty)
+    sol::table data = sALE->GetInstanceData(this);
+    data[key] = value;
 }
 
 uint64 ALEInstanceAI::GetData64(uint32 key) const
 {
     LOCK_ALE;
-    lua_State* L = sALE->L;
-    // Stack: (empty)
-
-    sALE->PushInstanceData(L, const_cast<ALEInstanceAI*>(this), false);
-    // Stack: instance_data
 
-    ALE::Push(L, key);
-    // Stack: instance_data, key
-
-    lua_gettable(L, -2);
-    // Stack: instance_data, value
-
-    uint64 value = ALE::CHECKVAL<uint64>(L, -1, 0);
-    lua_pop(L, 2);
-    // Stack: (empty)
-
-    return value;
+    sol::table data = sALE->GetInstanceData(const_cast<ALEInstanceAI*>(this));
+    return data.get_or(key, uint64(0));
 }
 
 void ALEInstanceAI::SetData64(uint32 key, uint64 value)
 {
     LOCK_ALE;
-    lua_State* L = sALE->L;
-    // Stack: (empty)
-
-    sALE->PushInstanceData(L, this, false);
-    // Stack: instance_data
-
-    ALE::Push(L, key);
-    ALE::Push(L, value);
-    // Stack: instance_data, key, value
-
-    lua_settable(L, -3);
-    // Stack: instance_data
 
-    lua_pop(L, 1);
-    // Stack: (empty)
+    sol::table data = sALE->GetInstanceData(this);
+    data[key] = value;
 }
diff --git a/src/LuaEngine/ALEInstanceAI.h b/src/LuaEngine/ALEInstanceAI.h
index ebc5037db0..900f0f1192 100644
--- a/src/LuaEngine/ALEInstanceAI.h
+++ b/src/LuaEngine/ALEInstanceAI.h
@@ -70,7 +70,8 @@ class ALEInstanceAI : public InstanceData
     // Simply calls Save, since the functions are a bit different in name and data types on different cores
     std::string GetSaveData() override
     {
-        return Save();
+        char const* data = Save();
+        return data ? data : "";
     }
     const char* Save() const;
 
diff --git a/src/LuaEngine/ALEScriptCache.cpp b/src/LuaEngine/ALEScriptCache.cpp
new file mode 100644
index 0000000000..238395272a
--- /dev/null
+++ b/src/LuaEngine/ALEScriptCache.cpp
@@ -0,0 +1,209 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#include "ALEScriptCache.h"
+#include "ALEConfig.h"
+#include "ALEUtility.h"
+
+#include <filesystem>
+#include <fstream>
+#include <mutex>
+#include <unordered_map>
+#include <vector>
+
+namespace
+{
+    /*
+     * Identity of a script file's content: sub-second modification time plus
+     * size. Second-level mtime alone would let a script edited twice within
+     * the same second serve stale bytecode.
+     */
+    struct FileStamp
+    {
+        std::filesystem::file_time_type mtime{};
+        uintmax_t size = 0;
+
+        bool operator==(FileStamp const&) const = default;
+        bool IsValid() const { return *this != FileStamp{}; }
+    };
+
+    struct CacheEntry
+    {
+        std::vector<char> bytecode;
+        FileStamp stamp;
+    };
+
+    std::unordered_map<std::string, CacheEntry> bytecodeCache;
+    std::unordered_map<std::string, FileStamp> stampCache;
+    std::mutex cacheMutex;
+
+    FileStamp GetFileStamp(std::string const& filepath)
+    {
+        std::error_code ec;
+        FileStamp stamp;
+
+        stamp.mtime = std::filesystem::last_write_time(filepath, ec);
+        if (ec)
+            return {};
+
+        stamp.size = std::filesystem::file_size(filepath, ec);
+        if (ec)
+            return {};
+
+        return stamp;
+    }
+
+    // Same, but remembers the answer until the next reload so a directory of
+    // scripts doesn't stat the same files twice.
+    FileStamp GetFileStampCached(std::string const& filepath)
+    {
+        auto iter = stampCache.find(filepath);
+        if (iter != stampCache.end())
+            return iter->second;
+
+        FileStamp stamp = GetFileStamp(filepath);
+        stampCache[filepath] = stamp;
+        return stamp;
+    }
+
+    // Loads `filepath` as a chunk in `lua` without caching:
+    // plain compilation for Lua, the `moonscript` module for MoonScript.
+    sol::protected_function LoadUncached(sol::state& lua, std::string const& filepath, bool isMoonScript)
+    {
+        if (isMoonScript)
+        {
+            std::string loader = "return require('moonscript').loadfile([[" + filepath + "]])";
+            sol::protected_function_result result = lua.safe_script(loader, sol::script_pass_on_error);
+            if (!result.valid())
+            {
+                sol::error error = result;
+                ALE_LOG_ERROR("[ALE]: Error compiling MoonScript `{}`: {}", filepath, error.what());
+                return sol::protected_function();
+            }
+
+            return result.get<sol::protected_function>();
+        }
+
+        sol::load_result loaded = lua.load_file(filepath);
+        if (!loaded.valid())
+        {
+            sol::error error = loaded;
+            ALE_LOG_ERROR("[ALE]: Error loading `{}`: {}", filepath, error.what());
+            return sol::protected_function();
+        }
+
+        return loaded.get<sol::protected_function>();
+    }
+
+    // Compiles `filepath` in a throwaway state and stores its bytecode.
+    // Returns false (leaving no cache entry) if compilation fails.
+    bool CompileToCache(std::string const& filepath, bool isMoonScript)
+    {
+        sol::state compiler;
+        compiler.open_libraries();
+
+        sol::protected_function chunk = LoadUncached(compiler, filepath, isMoonScript);
+        if (!chunk.valid())
+            return false;
+
+        sol::bytecode dumped = chunk.dump();
+        if (dumped.as_string_view().empty())
+            return false;
+
+        std::lock_guard<std::mutex> guard(cacheMutex);
+        CacheEntry& entry = bytecodeCache[filepath];
+        entry.stamp = GetFileStamp(filepath);
+        entry.bytecode.assign(dumped.as_string_view().begin(), dumped.as_string_view().end());
+        return true;
+    }
+
+    // Loads the cached bytecode of `filepath` if it is still up to date.
+    sol::protected_function LoadFromCache(sol::state& lua, std::string const& filepath)
+    {
+        std::lock_guard<std::mutex> guard(cacheMutex);
+
+        auto iter = bytecodeCache.find(filepath);
+        if (iter == bytecodeCache.end() || iter->second.bytecode.empty())
+            return sol::protected_function();
+
+        FileStamp stamp = GetFileStampCached(filepath);
+        if (!stamp.IsValid() || iter->second.stamp != stamp)
+            return sol::protected_function();
+
+        sol::load_result loaded = lua.load(
+            std::string_view(iter->second.bytecode.data(), iter->second.bytecode.size()),
+            filepath, sol::load_mode::binary);
+        if (!loaded.valid())
+            return sol::protected_function();
+
+        return loaded.get<sol::protected_function>();
+    }
+}
+
+namespace ALEScriptCache
+{
+    sol::protected_function Load(sol::state& lua, std::string const& filepath, bool isMoonScript,
+        uint32& compiledCount, uint32& cachedCount)
+    {
+        if (!ALEConfig::GetInstance().IsByteCodeCacheEnabled())
+            return LoadUncached(lua, filepath, isMoonScript);
+
+        if (sol::protected_function cached = LoadFromCache(lua, filepath); cached.valid())
+        {
+            ++cachedCount;
+            return cached;
+        }
+
+        if (CompileToCache(filepath, isMoonScript))
+        {
+            if (sol::protected_function compiled = LoadFromCache(lua, filepath); compiled.valid())
+            {
+                ++compiledCount;
+                return compiled;
+            }
+        }
+
+        // The cache could not serve this file; fall back to a direct load.
+        return LoadUncached(lua, filepath, isMoonScript);
+    }
+
+    sol::protected_function LoadCompiled(sol::state& lua, std::string const& filepath)
+    {
+        std::ifstream file(filepath, std::ios::binary);
+        if (!file.is_open())
+        {
+            ALE_LOG_ERROR("[ALE]: Could not open compiled script `{}`", filepath);
+            return sol::protected_function();
+        }
+
+        std::vector<char> buffer(std::istreambuf_iterator<char>(file), {});
+
+        sol::load_result loaded = lua.load(
+            std::string_view(buffer.data(), buffer.size()), filepath, sol::load_mode::binary);
+        if (!loaded.valid())
+        {
+            sol::error error = loaded;
+            ALE_LOG_ERROR("[ALE]: Error loading compiled script `{}`: {}", filepath, error.what());
+            return sol::protected_function();
+        }
+
+        return loaded.get<sol::protected_function>();
+    }
+
+    void ClearCache()
+    {
+        std::lock_guard<std::mutex> guard(cacheMutex);
+        bytecodeCache.clear();
+        stampCache.clear();
+        ALE_LOG_INFO("[ALE]: Global bytecode cache cleared");
+    }
+
+    void ClearTimestamps()
+    {
+        std::lock_guard<std::mutex> guard(cacheMutex);
+        stampCache.clear();
+    }
+}
diff --git a/src/LuaEngine/ALEScriptCache.h b/src/LuaEngine/ALEScriptCache.h
new file mode 100644
index 0000000000..c29df0057b
--- /dev/null
+++ b/src/LuaEngine/ALEScriptCache.h
@@ -0,0 +1,52 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#ifndef _ALE_SCRIPT_CACHE_H
+#define _ALE_SCRIPT_CACHE_H
+
+#include "Common.h"
+
+#include <sol/sol.hpp>
+
+#include <ctime>
+#include <string>
+
+/*
+ * Script loading with an optional global bytecode cache.
+ *
+ * Compiling a large script collection on every reload is slow, so when
+ * `ALE.BytecodeCache` is enabled, compiled bytecode is kept in a cache that
+ * survives Lua state reloads and is only invalidated when the file on disk
+ * changes. MoonScript sources are compiled through the `moonscript` Lua module
+ * and cached the same way.
+ */
+namespace ALEScriptCache
+{
+    /*
+     * Loads a Lua or MoonScript file as a callable chunk, going through the
+     * bytecode cache when it is enabled.
+     *
+     * Increments `compiledCount` / `cachedCount` for the reload statistics.
+     * Returns an invalid function on failure (the error is logged).
+     */
+    sol::protected_function Load(sol::state& lua, std::string const& filepath, bool isMoonScript,
+        uint32& compiledCount, uint32& cachedCount);
+
+    /*
+     * Loads a precompiled (.out, luac output) script file as a callable chunk.
+     * Returns an invalid function on failure (the error is logged).
+     */
+    sol::protected_function LoadCompiled(sol::state& lua, std::string const& filepath);
+
+    // Drops all cached bytecode (called on shutdown).
+    void ClearCache();
+
+    // Drops the cached file timestamps so the next load re-checks the disk
+    // (called at the start of every reload).
+    void ClearTimestamps();
+}
+
+#endif // _ALE_SCRIPT_CACHE_H
diff --git a/src/LuaEngine/ALETemplate.h b/src/LuaEngine/ALETemplate.h
deleted file mode 100644
index a8d6fc497a..0000000000
--- a/src/LuaEngine/ALETemplate.h
+++ /dev/null
@@ -1,389 +0,0 @@
-/*
-* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
-* This program is free software licensed under GPL version 3
-* Please see the included DOCS/LICENSE.md for more information
-*/
-
-#ifndef _ALE_TEMPLATE_H
-#define _ALE_TEMPLATE_H
-
-extern "C"
-{
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
-};
-#include "LuaEngine.h"
-#include "ALECompat.h"
-#include "ALEUtility.h"
-#include "SharedDefines.h"
-
-class ALEGlobal
-{
-public:
-    static int thunk(lua_State* L)
-    {
-        luaL_Reg* l = static_cast<luaL_Reg*>(lua_touserdata(L, lua_upvalueindex(1)));
-        int top = lua_gettop(L);
-        int expected = l->func(L);
-        int args = lua_gettop(L) - top;
-        if (args < 0 || args > expected)
-        {
-            ALE_LOG_ERROR("[ALE]: {} returned unexpected amount of arguments {} out of {}. Report to devs", l->name, args, expected);
-            ASSERT(false);
-        }
-        lua_settop(L, top + expected);
-        return expected;
-    }
-
-    static void SetMethods(ALE* E, luaL_Reg* methodTable)
-    {
-        ASSERT(E);
-        ASSERT(methodTable);
-
-        lua_pushglobaltable(E->L);
-
-        for (; methodTable && methodTable->name && methodTable->func; ++methodTable)
-        {
-            lua_pushstring(E->L, methodTable->name);
-            lua_pushlightuserdata(E->L, (void*)methodTable);
-            lua_pushcclosure(E->L, thunk, 1);
-            lua_rawset(E->L, -3);
-        }
-
-        lua_remove(E->L, -1);
-    }
-};
-
-class ALEObject
-{
-public:
-    template<typename T>
-    ALEObject(T * obj, bool manageMemory);
-
-    ~ALEObject()
-    {
-    }
-
-    // Get wrapped object pointer
-    void* GetObj() const { return object; }
-    // Returns whether the object is valid or not
-    bool IsValid() const { return !callstackid || callstackid == sALE->GetCallstackId(); }
-    // Returns whether the object can be invalidated or not
-    bool CanInvalidate() const { return _invalidate; }
-    // Returns pointer to the wrapped object's type name
-    const char* GetTypeName() const { return type_name; }
-
-    // Sets the object pointer that is wrapped
-    void SetObj(void* obj)
-    {
-        ASSERT(obj);
-        object = obj;
-        SetValid(true);
-    }
-    // Sets the object pointer to valid or invalid
-    void SetValid(bool valid)
-    {
-        ASSERT(!valid || (valid && object));
-        if (valid)
-            if (CanInvalidate())
-                callstackid = sALE->GetCallstackId();
-            else
-                callstackid = 0;
-        else
-            callstackid = 1;
-    }
-    // Sets whether the pointer will be invalidated at end of calls
-    void SetValidation(bool invalidate)
-    {
-        _invalidate = invalidate;
-    }
-    // Invalidates the pointer if it should be invalidated
-    void Invalidate()
-    {
-        if (CanInvalidate())
-            callstackid = 1;
-    }
-
-private:
-    uint64 callstackid;
-    bool _invalidate;
-    void* object;
-    const char* type_name;
-};
-
-template<typename T>
-struct ALERegister
-{
-    const char* name;
-    int(*mfunc)(lua_State*, T*);
-};
-
-template<typename T>
-class ALETemplate
-{
-public:
-    static const char* tname;
-    static bool manageMemory;
-
-    // name will be used as type name
-    // If gc is true, lua will handle the memory management for object pushed
-    // gc should be used if pushing for example WorldPacket,
-    // that will only be needed on lua side and will not be managed by TC/mangos/<core>
-    static void Register(ALE* E, const char* name, bool gc = false)
-    {
-        ASSERT(E);
-        ASSERT(name);
-
-        // check that metatable isn't already there
-        lua_getglobal(E->L, name);
-        ASSERT(lua_isnoneornil(E->L, -1));
-
-        // pop nil
-        lua_pop(E->L, 1);
-
-        tname = name;
-        manageMemory = gc;
-
-        // create metatable for userdata of this type
-        luaL_newmetatable(E->L, tname);
-        int metatable  = lua_gettop(E->L);
-
-        // push methodtable to stack to be accessed and modified by users
-        lua_pushvalue(E->L, metatable);
-        lua_setglobal(E->L, tname);
-
-        // tostring
-        lua_pushcfunction(E->L, ToString);
-        lua_setfield(E->L, metatable, "__tostring");
-
-        // garbage collecting
-        lua_pushcfunction(E->L, CollectGarbage);
-        lua_setfield(E->L, metatable, "__gc");
-
-        // make methods accessible through metatable
-        lua_pushvalue(E->L, metatable);
-        lua_setfield(E->L, metatable, "__index");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Add);
-        lua_setfield(E->L, metatable, "__add");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Substract);
-        lua_setfield(E->L, metatable, "__sub");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Multiply);
-        lua_setfield(E->L, metatable, "__mul");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Divide);
-        lua_setfield(E->L, metatable, "__div");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Mod);
-        lua_setfield(E->L, metatable, "__mod");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Pow);
-        lua_setfield(E->L, metatable, "__pow");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, UnaryMinus);
-        lua_setfield(E->L, metatable, "__unm");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Concat);
-        lua_setfield(E->L, metatable, "__concat");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Length);
-        lua_setfield(E->L, metatable, "__len");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Equal);
-        lua_setfield(E->L, metatable, "__eq");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Less);
-        lua_setfield(E->L, metatable, "__lt");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, LessOrEqual);
-        lua_setfield(E->L, metatable, "__le");
-
-        // make new indexes saved to methods
-        lua_pushcfunction(E->L, Call);
-        lua_setfield(E->L, metatable, "__call");
-
-        // special method to get the object type
-        lua_pushcfunction(E->L, GetType);
-        lua_setfield(E->L, metatable, "GetObjectType");
-
-        // special method to decide object invalidation at end of call
-        lua_pushcfunction(E->L, SetInvalidation);
-        lua_setfield(E->L, metatable, "SetInvalidation");
-
-        // pop metatable
-        lua_pop(E->L, 1);
-    }
-
-    template<typename C>
-    static void SetMethods(ALE* E, ALERegister<C>* methodTable)
-    {
-        ASSERT(E);
-        ASSERT(tname);
-        ASSERT(methodTable);
-
-        // get metatable
-        lua_pushstring(E->L, tname);
-        lua_rawget(E->L, LUA_REGISTRYINDEX);
-        ASSERT(lua_istable(E->L, -1));
-
-        for (; methodTable && methodTable->name && methodTable->mfunc; ++methodTable)
-        {
-            lua_pushstring(E->L, methodTable->name);
-            lua_pushlightuserdata(E->L, (void*)methodTable);
-            lua_pushcclosure(E->L, CallMethod, 1);
-            lua_rawset(E->L, -3);
-        }
-
-        lua_pop(E->L, 1);
-    }
-
-    static int Push(lua_State* L, T const* obj)
-    {
-        if (!obj)
-        {
-            lua_pushnil(L);
-            return 1;
-        }
-
-        // Create new userdata
-        ALEObject** ptrHold = static_cast<ALEObject**>(lua_newuserdata(L, sizeof(ALEObject*)));
-        if (!ptrHold)
-        {
-            ALE_LOG_ERROR("{} could not create new userdata", tname);
-            lua_pushnil(L);
-            return 1;
-        }
-        *ptrHold = new ALEObject(const_cast<T*>(obj), manageMemory);
-
-        // Set metatable for it
-        lua_pushstring(L, tname);
-        lua_rawget(L, LUA_REGISTRYINDEX);
-        if (!lua_istable(L, -1))
-        {
-            ALE_LOG_ERROR("{} missing metatable", tname);
-            lua_pop(L, 2);
-            lua_pushnil(L);
-            return 1;
-        }
-        lua_setmetatable(L, -2);
-        return 1;
-    }
-
-    static T* Check(lua_State* L, int narg, bool error = true)
-    {
-        ALEObject* ALEObj = ALE::CHECKTYPE(L, narg, tname, error);
-        if (!ALEObj)
-            return NULL;
-
-        if (!ALEObj->IsValid())
-        {
-            char buff[256];
-            snprintf(buff, 256, "%s expected, got pointer to nonexisting (invalidated) object (%s). Check your code.", tname, luaL_typename(L, narg));
-            if (error)
-            {
-                luaL_argerror(L, narg, buff);
-            }
-            else
-            {
-                ALE_LOG_ERROR("{}", buff);
-            }
-            return NULL;
-        }
-        return static_cast<T*>(ALEObj->GetObj());
-    }
-
-    static int GetType(lua_State* L)
-    {
-        lua_pushstring(L, tname);
-        return 1;
-    }
-
-    static int SetInvalidation(lua_State* L)
-    {
-        ALEObject* ALEObj = ALE::CHECKOBJ<ALEObject>(L, 1);
-        bool invalidate = ALE::CHECKVAL<bool>(L, 2);
-
-        ALEObj->SetValidation(invalidate);
-        return 0;
-    }
-
-    static int CallMethod(lua_State* L)
-    {
-        T* obj = ALE::CHECKOBJ<T>(L, 1); // get self
-        if (!obj)
-            return 0;
-        ALERegister<T>* l = static_cast<ALERegister<T>*>(lua_touserdata(L, lua_upvalueindex(1)));
-        int top = lua_gettop(L);
-        int expected = l->mfunc(L, obj);
-        int args = lua_gettop(L) - top;
-        if (args < 0 || args > expected)
-        {
-            ALE_LOG_ERROR("[ALE]: {} returned unexpected amount of arguments {} out of {}. Report to devs", l->name, args, expected);
-            ASSERT(false);
-        }
-        lua_settop(L, top + expected);
-        return expected;
-    }
-
-    // Metamethods ("virtual")
-
-    // Remember special cases like ALETemplate<Vehicle>::CollectGarbage
-    static int CollectGarbage(lua_State* L)
-    {
-        // Get object pointer (and check type, no error)
-        ALEObject* obj = ALE::CHECKOBJ<ALEObject>(L, 1, false);
-        if (obj && manageMemory)
-            delete static_cast<T*>(obj->GetObj());
-        delete obj;
-        return 0;
-    }
-
-    static int ToString(lua_State* L)
-    {
-        T* obj = ALE::CHECKOBJ<T>(L, 1, true); // get self
-        lua_pushfstring(L, "%s: %p", tname, obj);
-        return 1;
-    }
-
-    static int ArithmeticError(lua_State* L) { return luaL_error(L, "attempt to perform arithmetic on a %s value", tname); }
-    static int CompareError(lua_State* L) { return luaL_error(L, "attempt to compare %s", tname); }
-    static int Add(lua_State* L) { return ArithmeticError(L); }
-    static int Substract(lua_State* L) { return ArithmeticError(L); }
-    static int Multiply(lua_State* L) { return ArithmeticError(L); }
-    static int Divide(lua_State* L) { return ArithmeticError(L); }
-    static int Mod(lua_State* L) { return ArithmeticError(L); }
-    static int Pow(lua_State* L) { return ArithmeticError(L); }
-    static int UnaryMinus(lua_State* L) { return ArithmeticError(L); }
-    static int Concat(lua_State* L) { return luaL_error(L, "attempt to concatenate a %s value", tname); }
-    static int Length(lua_State* L) { return luaL_error(L, "attempt to get length of a %s value", tname); }
-    static int Equal(lua_State* L) { ALE::Push(L, ALE::CHECKOBJ<T>(L, 1) == ALE::CHECKOBJ<T>(L, 2)); return 1; }
-    static int Less(lua_State* L) { return CompareError(L); }
-    static int LessOrEqual(lua_State* L) { return CompareError(L); }
-    static int Call(lua_State* L) { return luaL_error(L, "attempt to call a %s value", tname); }
-};
-
-template<typename T>
-ALEObject::ALEObject(T * obj, bool manageMemory) : callstackid(1), _invalidate(!manageMemory), object(obj), type_name(ALETemplate<T>::tname)
-{
-    SetValid(true);
-}
-
-template<typename T> const char* ALETemplate<T>::tname = NULL;
-template<typename T> bool ALETemplate<T>::manageMemory = false;
-
-#endif
diff --git a/src/LuaEngine/ALEUtility.cpp b/src/LuaEngine/ALEUtility.cpp
index 9817465efa..d1d8bb92d0 100644
--- a/src/LuaEngine/ALEUtility.cpp
+++ b/src/LuaEngine/ALEUtility.cpp
@@ -27,7 +27,7 @@ ALEUtil::ObjectGUIDCheck::ObjectGUIDCheck(ObjectGuid guid) : _guid(guid)
 
 bool ALEUtil::ObjectGUIDCheck::operator()(WorldObject* object)
 {
-    return object->GET_GUID() == _guid;
+    return object->GetGUID() == _guid;
 }
 
 ALEUtil::ObjectDistanceOrderPred::ObjectDistanceOrderPred(WorldObject const* pRefObj, bool ascending) : m_refObj(pRefObj), m_ascending(ascending)
@@ -59,7 +59,7 @@ bool ALEUtil::WorldObjectInRangeCheck::operator()(WorldObject* u)
         return false;
     if (i_entry && u->GetEntry() != i_entry)
         return false;
-    if (i_obj->GET_GUID() == u->GET_GUID())
+    if (i_obj->GetGUID() == u->GetGUID())
         return false;
     if (!i_obj->IsWithinDistInMap(u, i_range))
         return false;
diff --git a/src/LuaEngine/ALEUtility.h b/src/LuaEngine/ALEUtility.h
index 5af4ad8519..07d65c3573 100644
--- a/src/LuaEngine/ALEUtility.h
+++ b/src/LuaEngine/ALEUtility.h
@@ -18,38 +18,11 @@
 #include "Log.h"
 
 typedef QueryResult ALEQuery;
-#define GET_GUID                GetGUID
-#define HIGHGUID_PLAYER         HighGuid::Player
-#define HIGHGUID_UNIT           HighGuid::Unit
-#define HIGHGUID_ITEM           HighGuid::Item
-#define HIGHGUID_GAMEOBJECT     HighGuid::GameObject
-#define HIGHGUID_PET            HighGuid::Pet
-#define HIGHGUID_TRANSPORT      HighGuid::Transport
-#define HIGHGUID_VEHICLE        HighGuid::Vehicle
-#define HIGHGUID_CONTAINER      HighGuid::Container
-#define HIGHGUID_DYNAMICOBJECT  HighGuid::DynamicObject
-#define HIGHGUID_CORPSE         HighGuid::Corpse
-#define HIGHGUID_MO_TRANSPORT   HighGuid::Mo_Transport
-#define HIGHGUID_INSTANCE       HighGuid::Instance
-#define HIGHGUID_GROUP          HighGuid::Group
 
 #define ALE_LOG_INFO(...)     LOG_INFO("ALE", __VA_ARGS__);
 #define ALE_LOG_ERROR(...)    LOG_ERROR("ALE", __VA_ARGS__);
 #define ALE_LOG_DEBUG(...)    LOG_DEBUG("ALE", __VA_ARGS__);
 
-#ifndef MAKE_NEW_GUID
-#define MAKE_NEW_GUID(l, e, h)  ObjectGuid(h, e, l)
-#endif
-#ifndef GUID_ENPART
-#define GUID_ENPART(guid)       ObjectGuid(guid).GetEntry()
-#endif
-#ifndef GUID_LOPART
-#define GUID_LOPART(guid)       ObjectGuid(guid).GetCounter()
-#endif
-#ifndef GUID_HIPART
-#define GUID_HIPART(guid)       ObjectGuid(guid).GetHigh()
-#endif
-
 class Unit;
 class WorldObject;
 struct FactionTemplateEntry;
diff --git a/src/LuaEngine/BindingMap.h b/src/LuaEngine/BindingMap.h
index 786de550fc..6bf19d1ce0 100644
--- a/src/LuaEngine/BindingMap.h
+++ b/src/LuaEngine/BindingMap.h
@@ -7,232 +7,179 @@
 #ifndef _BINDING_MAP_H
 #define _BINDING_MAP_H
 
-#include <memory>
 #include "Common.h"
-#include "ALEUtility.h"
-#include <type_traits>
+#include "ObjectGuid.h"
 
-extern "C"
-{
-#include "lua.h"
-#include "lauxlib.h"
-};
+#include <sol/sol.hpp>
 
+#include <mutex>
+#include <unordered_map>
+#include <vector>
 
 /*
- * A set of bindings from keys of type `K` to Lua references.
+ * A set of Lua event handlers registered against keys of type `K`.
+ *
+ * Scripts register handlers with RegisterPlayerEvent & co; hooks fetch them
+ * back by key when the matching game event fires. Handlers are stored as
+ * sol::protected_function, so their lifetime in the Lua registry is managed
+ * automatically.
  */
 template<typename K>
-class BindingMap : public ALEUtil::Lockable
+class BindingMap
 {
 private:
-    lua_State* L;
-    uint64 maxBindingID;
-
     struct Binding
     {
         uint64 id;
-        lua_State* L;
+        // Number of times the handler still fires before expiring; 0 means never expires.
         uint32 remainingShots;
-        int functionReference;
-
-        Binding(lua_State* L, uint64 id, int functionReference, uint32 remainingShots) :
-            id(id),
-            L(L),
-            remainingShots(remainingShots),
-            functionReference(functionReference)
-        { }
-
-        ~Binding()
-        {
-            luaL_unref(L, LUA_REGISTRYINDEX, functionReference);
-        }
+        sol::protected_function callback;
     };
 
-    typedef std::vector< std::unique_ptr<Binding> > BindingList;
-
-    std::unordered_map<K, BindingList> bindings;
-    /*
-     * This table is for fast removal of bindings by ID.
-     *
-     * Instead of having to look through (potentially) every BindingList to find
-     *   the Binding with the right ID, this allows you to go directly to the
-     *   BindingList that might have the Binding with that ID.
-     *
-     * However, you must be careful not to store pointers to BindingLists
-     *   that no longer exist (see `void Clear(const K& key)` implementation).
-     */
-    std::unordered_map<uint64, BindingList*> id_lookup_table;
+    std::unordered_map<K, std::vector<Binding>> bindings;
+    // Maps a binding id back to its key, so Remove doesn't have to scan every list.
+    std::unordered_map<uint64, K> keysById;
+    uint64 maxBindingID = 0;
+    std::mutex mutex;
 
 public:
-    BindingMap(lua_State* L) :
-        L(L),
-        maxBindingID(0)
-    { }
-
     /*
-     * Insert a new binding from `key` to `ref`, which lasts for `shots`-many pushes.
+     * Inserts a new handler for `key` that fires `shots` times.
      *
-     * If `shots` is 0, it will never automatically expire, but can still be
-     *   removed with `Clear` or `Remove`.
+     * If `shots` is 0 the handler never expires on its own, but can still be
+     * removed with `Clear` or `Remove`. Returns an id usable with `Remove`.
      */
-    uint64 Insert(const K& key, int ref, uint32 shots)
+    uint64 Insert(K const& key, sol::protected_function callback, uint32 shots)
     {
-        Guard guard(GetLock());
+        std::lock_guard<std::mutex> guard(mutex);
 
-        uint64 id = (++maxBindingID);
-        BindingList& list = bindings[key];
-        list.push_back(std::unique_ptr<Binding>(new Binding(L, id, ref, shots)));
-        id_lookup_table[id] = &list;
+        uint64 id = ++maxBindingID;
+        bindings[key].push_back({ id, shots, std::move(callback) });
+        keysById.emplace(id, key);
         return id;
     }
 
-    /*
-     * Clear all bindings for `key`.
-     */
-    void Clear(const K& key)
+    // Removes all handlers for `key`.
+    void Clear(K const& key)
     {
-        Guard guard(GetLock());
-
-        if (bindings.empty())
-            return;
+        std::lock_guard<std::mutex> guard(mutex);
 
         auto iter = bindings.find(key);
         if (iter == bindings.end())
             return;
 
-        BindingList& list = iter->second;
+        for (Binding const& binding : iter->second)
+            keysById.erase(binding.id);
 
-        // Remove all pointers to `list` from `id_lookup_table`.
-        for (auto i = list.begin(); i != list.end(); ++i)
-        {
-            std::unique_ptr<Binding>& binding = *i;
-            id_lookup_table.erase(binding->id);
-        }
-
-        bindings.erase(key);
+        bindings.erase(iter);
     }
 
-    /*
-     * Clear all bindings for all keys.
-     */
+    // Removes all handlers for all keys.
     void Clear()
     {
-        Guard guard(GetLock());
+        std::lock_guard<std::mutex> guard(mutex);
 
-        if (bindings.empty())
-            return;
-
-        id_lookup_table.clear();
+        keysById.clear();
         bindings.clear();
     }
 
-    /*
-     * Remove a specific binding identified by `id`.
-     *
-     * If `id` in invalid, nothing is removed.
-     */
+    // Removes the single handler identified by `id`, if it still exists.
     void Remove(uint64 id)
     {
-        Guard guard(GetLock());
+        std::lock_guard<std::mutex> guard(mutex);
 
-        auto iter = id_lookup_table.find(id);
-        if (iter == id_lookup_table.end())
+        auto keyIter = keysById.find(id);
+        if (keyIter == keysById.end())
             return;
 
-        BindingList* list = iter->second;
-        auto i = list->begin();
-
-        for (; i != list->end(); ++i)
+        auto listIter = bindings.find(keyIter->second);
+        if (listIter != bindings.end())
         {
-            std::unique_ptr<Binding>& binding = *i;
-            if (binding->id == id)
-                break;
+            std::vector<Binding>& list = listIter->second;
+            std::erase_if(list, [id](Binding const& binding) { return binding.id == id; });
+            if (list.empty())
+                bindings.erase(listIter);
         }
 
-        if (i != list->end())
-            list->erase(i);
-
-        // Unconditionally erase the ID in the lookup table because
-        //   it was either already invalid, or it's no longer valid.
-        id_lookup_table.erase(id);
+        keysById.erase(keyIter);
     }
 
-    /*
-     * Check whether `key` has any bindings.
-     */
-    bool HasBindingsFor(const K& key)
+    // Returns whether `key` has any handlers.
+    bool HasBindingsFor(K const& key)
     {
-        Guard guard(GetLock());
-
-        if (bindings.empty())
-            return false;
-
-        auto result = bindings.find(key);
-        if (result == bindings.end())
-            return false;
+        std::lock_guard<std::mutex> guard(mutex);
 
-        BindingList& list = result->second;
-        return !list.empty();
+        auto iter = bindings.find(key);
+        return iter != bindings.end() && !iter->second.empty();
     }
 
     /*
-     * Push all Lua references for `key` onto the stack.
+     * Returns a snapshot of the handlers registered for `key`, consuming one
+     * shot from each.
+     *
+     * Dispatch iterates the snapshot, so a handler that registers or removes
+     * handlers while running cannot corrupt the iteration.
      */
-    void PushRefsFor(const K& key)
+    std::vector<sol::protected_function> GetCallbacksFor(K const& key)
     {
-        Guard guard(GetLock());
+        std::lock_guard<std::mutex> guard(mutex);
 
-        if (bindings.empty())
-            return;
+        std::vector<sol::protected_function> callbacks;
 
-        auto result = bindings.find(key);
-        if (result == bindings.end())
-            return;
+        auto iter = bindings.find(key);
+        if (iter == bindings.end())
+            return callbacks;
 
-        BindingList& list = result->second;
-        luaL_checkstack(L, static_cast<int>(list.size()), "not enough stack space to push function bindings");
-        for (auto i = list.begin(); i != list.end();)
+        std::vector<Binding>& list = iter->second;
+        callbacks.reserve(list.size());
+
+        for (Binding& binding : list)
+            callbacks.push_back(binding.callback);
+
+        // Expire handlers that just used up their last shot.
+        std::erase_if(list, [this](Binding& binding)
         {
-            std::unique_ptr<Binding>& binding = (*i);
-            auto i_prev = (i++);
+            if (binding.remainingShots == 0)
+                return false;
 
-            lua_rawgeti(L, LUA_REGISTRYINDEX, binding->functionReference);
+            --binding.remainingShots;
+            if (binding.remainingShots > 0)
+                return false;
 
-            if (binding->remainingShots > 0)
-            {
-                binding->remainingShots -= 1;
+            keysById.erase(binding.id);
+            return true;
+        });
 
-                if (binding->remainingShots == 0)
-                {
-                    id_lookup_table.erase(binding->id);
-                    list.erase(i_prev);
-                }
-            }
-        }
+        if (list.empty())
+            bindings.erase(iter);
+
+        return callbacks;
     }
 };
 
-
 /*
- * A `BindingMap` key type for simple event ID bindings
- *   (ServerEvents, GuildEvents, etc.).
+ * A `BindingMap` key for global event bindings (ServerEvents, GuildEvents, ...).
  */
-template <typename T>
+template<typename T>
 struct EventKey
 {
     T event_id;
 
     EventKey(T event_id) :
         event_id(event_id)
-    { }
+    {
+    }
+
+    bool operator==(EventKey const& other) const
+    {
+        return event_id == other.event_id;
+    }
 };
 
 /*
- * A `BindingMap` key type for event ID/Object entry ID bindings
- *   (CreatureEvents, GameObjectEvents, etc.).
+ * A `BindingMap` key for event ID + entry bindings (CreatureEvents, GameObjectEvents, ...).
  */
-template <typename T>
+template<typename T>
 struct EntryKey
 {
     T event_id;
@@ -241,14 +188,20 @@ struct EntryKey
     EntryKey(T event_id, uint32 entry) :
         event_id(event_id),
         entry(entry)
-    { }
+    {
+    }
+
+    bool operator==(EntryKey const& other) const
+    {
+        return event_id == other.event_id && entry == other.entry;
+    }
 };
 
 /*
- * A `BindingMap` key type for event ID/unique Object bindings
- *   (currently just CreatureEvents).
+ * A `BindingMap` key for event ID + specific object bindings
+ * (currently just CreatureEvents on one spawned creature).
  */
-template <typename T>
+template<typename T>
 struct UniqueObjectKey
 {
     T event_id;
@@ -259,116 +212,64 @@ struct UniqueObjectKey
         event_id(event_id),
         guid(guid),
         instance_id(instance_id)
-    { }
-};
-
-class hash_helper
-{
-public:
-    typedef std::size_t result_type;
-
-    template <typename T1, typename T2, typename... T>
-    static inline result_type hash(T1 const & t1, T2 const & t2, T const &... t)
     {
-        result_type seed = 0;
-        _hash_combine(seed, t1, t2, t...);
-        return seed;
     }
 
-    template <typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
-    static inline result_type hash(T const & t)
-    {
-        return std::hash<typename std::underlying_type<T>::type>()(t);
-    }
-    
-    template <typename T, typename std::enable_if<!std::is_enum<T>::value>::type* = nullptr>
-    static inline result_type hash(T const & t)
+    bool operator==(UniqueObjectKey const& other) const
     {
-        return std::hash<T>()(t);
+        return event_id == other.event_id && guid == other.guid && instance_id == other.instance_id;
     }
+};
 
-private:
-    template <typename T>
-    static inline void _hash_combine(result_type& seed, T const & v)
+namespace ALEKeyHash
+{
+    inline void Combine(std::size_t& seed, std::size_t value)
     {
-        // from http://www.boost.org/doc/libs/1_40_0/boost/functional/hash/hash.hpp
-        seed ^= hash(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+        // from boost::hash_combine
+        seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
     }
 
-    template <typename H, typename T1, typename... T>
-    static inline void _hash_combine(result_type& seed, H const & h, T1 const & t1, T const &... t)
+    template<typename T>
+    std::size_t HashEnum(T value)
     {
-        _hash_combine(seed, h);
-        _hash_combine(seed, t1, t...);
+        return std::hash<std::underlying_type_t<T>>()(static_cast<std::underlying_type_t<T>>(value));
     }
-};
+}
 
 /*
- * Implementations of various std functions on the above key types,
- *   so that they can be used within an unordered_map.
+ * std::hash implementations so the key types can be used in unordered_map.
  */
 namespace std
 {
     template<typename T>
-    struct equal_to < EventKey<T> >
-    {
-        bool operator()(EventKey<T> const& lhs, EventKey<T> const& rhs) const
-        {
-            return lhs.event_id == rhs.event_id;
-        }
-    };
-
-    template<typename T>
-    struct equal_to < EntryKey<T> >
-    {
-        bool operator()(EntryKey<T> const& lhs, EntryKey<T> const& rhs) const
-        {
-            return lhs.event_id == rhs.event_id
-                && lhs.entry == rhs.entry;
-        }
-    };
-
-    template<typename T>
-    struct equal_to < UniqueObjectKey<T> >
+    struct hash<EventKey<T>>
     {
-        bool operator()(UniqueObjectKey<T> const& lhs, UniqueObjectKey<T> const& rhs) const
+        std::size_t operator()(EventKey<T> const& key) const
         {
-            return lhs.event_id == rhs.event_id
-                && lhs.guid == rhs.guid
-                && lhs.instance_id == rhs.instance_id;
+            return ALEKeyHash::HashEnum(key.event_id);
         }
     };
 
     template<typename T>
-    struct hash < EventKey<T> >
+    struct hash<EntryKey<T>>
     {
-        typedef EventKey<T> argument_type;
-
-        hash_helper::result_type operator()(argument_type const& k) const
+        std::size_t operator()(EntryKey<T> const& key) const
         {
-            return hash_helper::hash(k.event_id);
+            std::size_t seed = ALEKeyHash::HashEnum(key.event_id);
+            ALEKeyHash::Combine(seed, std::hash<uint32>()(key.entry));
+            return seed;
         }
     };
 
     template<typename T>
-    struct hash < EntryKey<T> >
+    struct hash<UniqueObjectKey<T>>
     {
-        typedef EntryKey<T> argument_type;
-
-        hash_helper::result_type operator()(argument_type const& k) const
-        {
-            return hash_helper::hash(k.event_id, k.entry);
-        }
-    };
-
-    template<typename T>
-    struct hash < UniqueObjectKey<T> >
-    {
-        typedef UniqueObjectKey<T> argument_type;
-
-        hash_helper::result_type operator()(argument_type const& k) const
+        std::size_t operator()(UniqueObjectKey<T> const& key) const
         {
-            return hash_helper::hash(k.event_id, k.instance_id, k.guid.GetRawValue());
+            std::size_t seed = ALEKeyHash::HashEnum(key.event_id);
+            ALEKeyHash::Combine(seed, std::hash<uint32>()(key.instance_id));
+            ALEKeyHash::Combine(seed, std::hash<uint64>()(key.guid.GetRawValue()));
+            return seed;
         }
     };
 }
diff --git a/src/LuaEngine/HookHelpers.h b/src/LuaEngine/HookHelpers.h
deleted file mode 100644
index 557f7531b9..0000000000
--- a/src/LuaEngine/HookHelpers.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
- * This program is free software licensed under GPL version 3
- * Please see the included DOCS/LICENSE.md for more information
- */
-
-#ifndef _HOOK_HELPERS_H
-#define _HOOK_HELPERS_H
-
-#include "LuaEngine.h"
-#include "ALEUtility.h"
-
-/*
- * Sets up the stack so that event handlers can be called.
- *
- * Returns the number of functions that were pushed onto the stack.
- */
-template<typename K1, typename K2>
-int ALE::SetupStack(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, int number_of_arguments)
-{
-    ASSERT(number_of_arguments == this->push_counter);
-    ASSERT(key1.event_id == key2.event_id);
-    // Stack: [arguments]
-
-    Push(key1.event_id);
-    this->push_counter = 0;
-    ++number_of_arguments;
-    // Stack: [arguments], event_id
-
-    int arguments_top = lua_gettop(L);
-    int first_argument_index = arguments_top - number_of_arguments + 1;
-    ASSERT(arguments_top >= number_of_arguments);
-
-    lua_insert(L, first_argument_index);
-    // Stack: event_id, [arguments]
-
-    bindings1->PushRefsFor(key1);
-    if (bindings2)
-        bindings2->PushRefsFor(key2);
-    // Stack: event_id, [arguments], [functions]
-
-    int number_of_functions = lua_gettop(L) - arguments_top;
-    return number_of_functions;
-}
-
-/*
- * Replace one of the arguments pushed before `SetupStack` with a new value.
- */
-template<typename T>
-void ALE::ReplaceArgument(T value, uint8 index)
-{
-    ASSERT(index < lua_gettop(L) && index > 0);
-    // Stack: event_id, [arguments], [functions], [results]
-
-    ALE::Push(L, value);
-    // Stack: event_id, [arguments], [functions], [results], value
-
-    lua_replace(L, index + 1);
-    // Stack: event_id, [arguments and value], [functions], [results]
-}
-
-/*
- * Call all event handlers registered to the event ID/entry combination and ignore any results.
- */
-template<typename K1, typename K2>
-void ALE::CallAllFunctions(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2)
-{
-    int number_of_arguments = this->push_counter;
-    // Stack: [arguments]
-
-    int number_of_functions = SetupStack(bindings1, bindings2, key1, key2, number_of_arguments);
-    // Stack: event_id, [arguments], [functions]
-
-    while (number_of_functions > 0)
-    {
-        CallOneFunction(number_of_functions, number_of_arguments, 0);
-        --number_of_functions;
-        // Stack: event_id, [arguments], [functions - 1]
-    }
-    // Stack: event_id, [arguments]
-
-    CleanUpStack(number_of_arguments);
-    // Stack: (empty)
-}
-
-/*
- * Call all event handlers registered to the event ID/entry combination,
- *   and returns `default_value` if ALL event handlers returned `default_value`,
- *   otherwise returns the opposite of `default_value`.
- */
-template<typename K1, typename K2>
-bool ALE::CallAllFunctionsBool(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, bool default_value/* = false*/)
-{
-    bool result = default_value;
-    // Note: number_of_arguments here does not count in eventID, which is pushed in SetupStack
-    int number_of_arguments = this->push_counter;
-    // Stack: [arguments]
-
-    int number_of_functions = SetupStack(bindings1, bindings2, key1, key2, number_of_arguments);
-    // Stack: event_id, [arguments], [functions]
-
-    while (number_of_functions > 0)
-    {
-        int r = CallOneFunction(number_of_functions, number_of_arguments, 1);
-        --number_of_functions;
-        // Stack: event_id, [arguments], [functions - 1], result
-
-        if (lua_isboolean(L, r) && (lua_toboolean(L, r) == 1) != default_value)
-            result = !default_value;
-
-        lua_pop(L, 1);
-        // Stack: event_id, [arguments], [functions - 1]
-    }
-    // Stack: event_id, [arguments]
-
-    CleanUpStack(number_of_arguments);
-    // Stack: (empty)
-    return result;
-}
-
-#endif // _HOOK_HELPERS_H
diff --git a/src/LuaEngine/HttpManager.cpp b/src/LuaEngine/HttpManager.cpp
index f7079cf3c9..0955ce2439 100644
--- a/src/LuaEngine/HttpManager.cpp
+++ b/src/LuaEngine/HttpManager.cpp
@@ -1,9 +1,10 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
 #include <thread>
-extern "C"
-{
-#include "lua.h"
-#include "lauxlib.h"
-};
 
 #define CPPHTTPLIB_OPENSSL_SUPPORT
 
@@ -11,8 +12,9 @@ extern "C"
 #include "HttpManager.h"
 #include "LuaEngine.h"
 
-HttpWorkItem::HttpWorkItem(int funcRef, const std::string& httpVerb, const std::string& url, const std::string& body, const std::string& contentType, const httplib::Headers& headers)
-    : funcRef(funcRef),
+HttpWorkItem::HttpWorkItem(sol::protected_function callback, const std::string& httpVerb, const std::string& url,
+    const std::string& body, const std::string& contentType, const httplib::Headers& headers)
+    : callback(std::move(callback)),
     httpVerb(httpVerb),
     url(url),
     body(body),
@@ -20,8 +22,8 @@ HttpWorkItem::HttpWorkItem(int funcRef, const std::string& httpVerb, const std::
     headers(headers)
 { }
 
-HttpResponse::HttpResponse(int funcRef, int statusCode, const std::string& body, const httplib::Headers& headers)
-    : funcRef(funcRef),
+HttpResponse::HttpResponse(sol::protected_function callback, int statusCode, const std::string& body, const httplib::Headers& headers)
+    : callback(std::move(callback)),
     statusCode(statusCode),
     body(body),
     headers(headers)
@@ -68,20 +70,14 @@ void HttpManager::ClearQueues()
     while (workQueue.front())
     {
         HttpWorkItem* item = *workQueue.front();
-        if (item != nullptr)
-        {
-            delete item;
-        }
+        delete item;
         workQueue.pop();
     }
 
     while (responseQueue.front())
     {
         HttpResponse* item = *responseQueue.front();
-        if (item != nullptr)
-        {
-            delete item;
-        }
+        delete item;
         responseQueue.pop();
     }
 }
@@ -89,9 +85,7 @@ void HttpManager::ClearQueues()
 void HttpManager::StopHttpWorker()
 {
     if (!startedWorkerThread)
-    {
         return;
-    }
 
     cancelationToken.store(true);
     condVar.notify_one();
@@ -100,6 +94,13 @@ void HttpManager::StopHttpWorker()
     startedWorkerThread = false;
 }
 
+void HttpManager::FinishRequest(HttpWorkItem* req, int statusCode, std::string body, httplib::Headers headers)
+{
+    // The callback must always come back to the world thread, even on
+    // failure, so its Lua reference is released there and never here.
+    responseQueue.push(new HttpResponse(std::move(req->callback), statusCode, std::move(body), std::move(headers)));
+}
+
 void HttpManager::HttpWorkerThread()
 {
     while (true)
@@ -110,28 +111,26 @@ void HttpManager::HttpWorkerThread()
         }
 
         if (cancelationToken.load())
-        {
             break;
-        }
+
         if (!workQueue.front())
-        {
             continue;
-        }
 
         HttpWorkItem* req = *workQueue.front();
         workQueue.pop();
         if (!req)
-        {
             continue;
-        }
 
         try
         {
             std::string host;
             std::string path;
 
-            if (!ParseUrl(req->url, host, path)) {
+            if (!ParseUrl(req->url, host, path))
+            {
                 ALE_LOG_ERROR("[ALE]: Could not parse URL {}", req->url);
+                FinishRequest(req, -1, "", {});
+                delete req;
                 continue;
             }
 
@@ -145,32 +144,45 @@ void HttpManager::HttpWorkerThread()
             if (err != httplib::Error::Success)
             {
                 ALE_LOG_ERROR("[ALE]: HTTP request error: {}", httplib::to_string(err));
+                FinishRequest(req, -1, "", {});
+                delete req;
                 continue;
             }
 
             if (res->status == 301)
             {
                 std::string location = res->get_header_value("Location");
-                std::string host;
-                std::string path;
+                std::string redirectHost;
+                std::string redirectPath;
 
-                if (!ParseUrl(location, host, path))
+                if (!ParseUrl(location, redirectHost, redirectPath))
                 {
                     ALE_LOG_ERROR("[ALE]: Could not parse URL after redirect: {}", location);
+                    FinishRequest(req, -1, "", {});
+                    delete req;
                     continue;
                 }
-                httplib::Client cli2(host);
+                httplib::Client cli2(redirectHost);
                 cli2.set_connection_timeout(0, 3000000); // 3 seconds
                 cli2.set_read_timeout(5, 0); // 5 seconds
                 cli2.set_write_timeout(5, 0); // 5 seconds
-                res = DoRequest(cli2, req, path);
+                res = DoRequest(cli2, req, redirectPath);
+
+                if (res.error() != httplib::Error::Success)
+                {
+                    ALE_LOG_ERROR("[ALE]: HTTP request error after redirect: {}", httplib::to_string(res.error()));
+                    FinishRequest(req, -1, "", {});
+                    delete req;
+                    continue;
+                }
             }
 
-            responseQueue.push(new HttpResponse(req->funcRef, res->status, res->body, res->headers));
+            FinishRequest(req, res->status, res->body, res->headers);
         }
         catch (const std::exception& ex)
         {
             ALE_LOG_ERROR("[ALE]: HTTP request error: {}", ex.what());
+            FinishRequest(req, -1, "", {});
         }
 
         delete req;
@@ -181,33 +193,19 @@ httplib::Result HttpManager::DoRequest(httplib::Client& client, HttpWorkItem* re
 {
     const char* path = urlPath.c_str();
     if (req->httpVerb == "GET")
-    {
         return client.Get(path, req->headers);
-    }
     if (req->httpVerb == "HEAD")
-    {
         return client.Head(path, req->headers);
-    }
     if (req->httpVerb == "POST")
-    {
         return client.Post(path, req->headers, req->body, req->contentType.c_str());
-    }
     if (req->httpVerb == "PUT")
-    {
         return client.Put(path, req->headers, req->body, req->contentType.c_str());
-    }
     if (req->httpVerb == "PATCH")
-    {
         return client.Patch(path, req->headers, req->body, req->contentType.c_str());
-    }
     if (req->httpVerb == "DELETE")
-    {
         return client.Delete(path, req->headers);
-    }
     if (req->httpVerb == "OPTIONS")
-    {
         return client.Options(path, req->headers);
-    }
 
     ALE_LOG_ERROR("[ALE]: HTTP request error: invalid HTTP verb {}", req->httpVerb);
     return client.Get(path, req->headers);
@@ -218,9 +216,7 @@ bool HttpManager::ParseUrl(const std::string& url, std::string& host, std::strin
     std::smatch matches;
 
     if (!std::regex_search(url, matches, parseUrlRegex))
-    {
         return false;
-    }
 
     std::string scheme = matches[2];
     std::string authority = matches[4];
@@ -228,9 +224,8 @@ bool HttpManager::ParseUrl(const std::string& url, std::string& host, std::strin
     host = scheme + "://" + authority;
     path = matches[5];
     if (path.empty())
-    {
         path = "/";
-    }
+
     path += (query.empty() ? "" : "?") + query;
 
     return true;
@@ -243,33 +238,23 @@ void HttpManager::HandleHttpResponses()
         HttpResponse* res = *responseQueue.front();
         responseQueue.pop();
 
-        if (res == nullptr)
-        {
+        if (!res)
             continue;
-        }
 
         LOCK_ALE;
 
-        lua_State* L = ALE::GALE->L;
-
-        // Get function
-        lua_rawgeti(L, LUA_REGISTRYINDEX, res->funcRef);
+        // Failures are delivered too (statusCode -1, empty body), so Lua
+        // callers can tell their request never completed.
+        if (sALE->HasLuaState())
+        {
+            // The handler receives the headers as a table.
+            sol::table headerTable = sALE->lua.create_table();
+            for (auto const& [name, value] : res->headers)
+                headerTable[name] = value;
 
-        // Push parameters
-        ALE::Push(L, res->statusCode);
-        ALE::Push(L, res->body);
-        lua_newtable(L);
-        for (const auto& item : res->headers) {
-            ALE::Push(L, item.first);
-            ALE::Push(L, item.second);
-            lua_settable(L, -3);
+            sALE->CallFunction(res->callback, res->statusCode, res->body, headerTable);
         }
 
-        // Call function
-        ALE::GALE->ExecuteCall(3, 0);
-
-        luaL_unref(L, LUA_REGISTRYINDEX, res->funcRef);
-
         delete res;
     }
 }
diff --git a/src/LuaEngine/HttpManager.h b/src/LuaEngine/HttpManager.h
index cab17a4466..d089b4c8de 100644
--- a/src/LuaEngine/HttpManager.h
+++ b/src/LuaEngine/HttpManager.h
@@ -1,17 +1,31 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
 #ifndef ALE_HTTP_MANAGER_H
 #define ALE_HTTP_MANAGER_H
 
+#include <sol/sol.hpp>
+
 #include <regex>
 
 #include "libs/httplib.h"
 #include "libs/rigtorp/SPSCQueue.h"
 
+/*
+ * Threading note: the Lua callback travels through the worker thread as a
+ * moved sol reference. Moving never touches the Lua state, so the worker
+ * stays Lua-free; the callback is only invoked - and released - from the
+ * world thread in HandleHttpResponses().
+ */
 struct HttpWorkItem
 {
-public:
-    HttpWorkItem(int funcRef, const std::string& httpVerb, const std::string& url, const std::string& body, const std::string &contentType, const httplib::Headers& headers);
+    HttpWorkItem(sol::protected_function callback, const std::string& httpVerb, const std::string& url,
+        const std::string& body, const std::string& contentType, const httplib::Headers& headers);
 
-    int funcRef;
+    sol::protected_function callback;
     std::string httpVerb;
     std::string url;
     std::string body;
@@ -21,16 +35,15 @@ struct HttpWorkItem
 
 struct HttpResponse
 {
-public:
-    HttpResponse(int funcRef, int statusCode, const std::string& body, const httplib::Headers& headers);
+    HttpResponse(sol::protected_function callback, int statusCode, const std::string& body, const httplib::Headers& headers);
 
-    int funcRef;
+    sol::protected_function callback;
+    // -1 when the request failed: the callback is not invoked, only released.
     int statusCode;
     std::string body;
     httplib::Headers headers;
 };
 
-
 class HttpManager
 {
 public:
@@ -45,6 +58,8 @@ class HttpManager
 private:
     void ClearQueues();
     void HttpWorkerThread();
+    // Hands the callback back to the world thread, with the request's result.
+    void FinishRequest(HttpWorkItem* req, int statusCode, std::string body, httplib::Headers headers);
     bool ParseUrl(const std::string& url, std::string& host, std::string& path);
     httplib::Result DoRequest(httplib::Client& client, HttpWorkItem* req, const std::string& path);
 
@@ -58,4 +73,4 @@ class HttpManager
     std::regex parseUrlRegex;
 };
 
-#endif // #ifndef ALE_HTTP_MANAGER_H
+#endif // ALE_HTTP_MANAGER_H
diff --git a/src/LuaEngine/LuaEngine.cpp b/src/LuaEngine/LuaEngine.cpp
index c647d689a5..eeec89fff9 100644
--- a/src/LuaEngine/LuaEngine.cpp
+++ b/src/LuaEngine/LuaEngine.cpp
@@ -4,61 +4,41 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#include "Hooks.h"
 #include "LuaEngine.h"
-#include "BindingMap.h"
-#include "Chat.h"
-#include "ALECompat.h"
-#include "ALEEventMgr.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
-#include "ALEUtility.h"
 #include "ALECreatureAI.h"
+#include "ALEEventMgr.h"
 #include "ALEInstanceAI.h"
-
-#if AC_PLATFORM == AC_PLATFORM_WINDOWS
-#define ALE_WINDOWS
-#endif
-
-// Some dummy includes containing BOOST_VERSION:
-// ObjectAccessor.h Config.h Log.h
-#define USING_BOOST
+#include "ALEScriptCache.h"
+#include "Chat.h"
+#include "GameEventMgr.h"
+#include "GuildMgr.h"
+#include "Log.h"
+#include "MapMgr.h"
+#include "ObjectAccessor.h"
+#include "ObjectMgr.h"
+#include "Opcodes.h"
+#include "Player.h"
+#include "SpellMgr.h"
+#include "StringFormat.h"
+#include "WorldSessionMgr.h"
 
 #include <boost/filesystem.hpp>
-#include <fstream>
-#include <vector>
-#include <ctime>
-#include <sys/stat.h>
-#include <unordered_map>
 
-extern "C"
-{
-// Base lua libraries
-#include "lua.h"
-#include "lualib.h"
-#include "lauxlib.h"
+// Registers all usertypes and global functions into the state (LuaFunctions.cpp).
+extern void RegisterFunctions(ALE* E);
 
-// Additional lua libraries
-};
+ALE* ALE::GALE = nullptr;
 
 ALE::ScriptList ALE::lua_scripts;
 ALE::ScriptList ALE::lua_extensions;
 std::string ALE::lua_folderpath;
 std::string ALE::lua_requirepath;
 std::string ALE::lua_requirecpath;
-ALE* ALE::GALE = NULL;
 bool ALE::reload = false;
 bool ALE::initialized = false;
 ALE::LockType ALE::lock;
 std::unique_ptr<ALEFileWatcher> ALE::fileWatcher;
 
-// Global bytecode cache that survives ALE reloads
-static std::unordered_map<std::string, GlobalCacheEntry> globalBytecodeCache;
-static std::unordered_map<std::string, std::time_t> timestampCache;
-static std::mutex globalCacheMutex;
-
-extern void RegisterFunctions(ALE* E);
-
 void ALE::Initialize()
 {
     LOCK_ALE;
@@ -80,7 +60,7 @@ void ALE::Initialize()
     // Start file watcher if enabled
     if (ALEConfig::GetInstance().IsAutoReloadEnabled())
     {
-        uint32 watchInterval = eConfigMgr->GetOption<uint32>("ALE.AutoReloadInterval", 1);
+        uint32 watchInterval = sConfigMgr->GetOption<uint32>("ALE.AutoReloadInterval", 1);
         fileWatcher = std::make_unique<ALEFileWatcher>();
         fileWatcher->StartWatching(lua_folderpath, watchInterval);
     }
@@ -99,13 +79,12 @@ void ALE::Uninitialize()
     }
 
     delete GALE;
-    GALE = NULL;
+    GALE = nullptr;
 
     lua_scripts.clear();
     lua_extensions.clear();
 
-    // Clear global cache on shutdown
-    ClearGlobalCache();
+    ALEScriptCache::ClearCache();
 
     initialized = false;
 }
@@ -118,23 +97,22 @@ void ALE::LoadScriptPaths()
     lua_extensions.clear();
 
     lua_folderpath = ALEConfig::GetInstance().GetScriptPath();
-    const std::string& lua_path_extra = static_cast<std::string>(ALEConfig::GetInstance().GetRequirePath());
-    const std::string& lua_cpath_extra = static_cast<std::string>(ALEConfig::GetInstance().GetRequireCPath());
+    std::string lua_path_extra(ALEConfig::GetInstance().GetRequirePath());
+    std::string lua_cpath_extra(ALEConfig::GetInstance().GetRequireCPath());
 
 #ifndef ALE_WINDOWS
-    if (lua_folderpath[0] == '~')
-        if (const char* home = getenv("HOME"))
+    if (!lua_folderpath.empty() && lua_folderpath[0] == '~')
+        if (char const* home = getenv("HOME"))
             lua_folderpath.replace(0, 1, home);
 #endif
     ALE_LOG_INFO("[ALE]: Searching scripts from `{}`", lua_folderpath);
 
-    // clear all cache variables
     lua_requirepath.clear();
     lua_requirecpath.clear();
 
     GetScripts(lua_folderpath);
 
-    // append our custom require paths and cpaths if the config variables are not empty
+    // append custom require paths and cpaths if the config variables are not empty
     if (!lua_path_extra.empty())
         lua_requirepath += lua_path_extra;
 
@@ -156,69 +134,32 @@ void ALE::_ReloadALE()
     LOCK_ALE;
     ASSERT(IsInitialized());
 
-    if (eConfigMgr->GetOption<bool>("ALE.PlayerAnnounceReload", false))
-        eWorldSessionMgr->SendServerMessage(SERVER_MSG_STRING, "Reloading ALE...");
+    if (sConfigMgr->GetOption<bool>("ALE.PlayerAnnounceReload", false))
+        sWorldSessionMgr->SendServerMessage(SERVER_MSG_STRING, "Reloading ALE...");
     else
         ChatHandler(nullptr).SendGMText(SERVER_MSG_STRING, "Reloading ALE...");
 
     // Remove all timed events
     sALE->eventMgr->SetStates(LUAEVENT_STATE_ERASE);
 
-    // Close lua
     sALE->CloseLua();
 
-    // Reload script paths
     LoadScriptPaths();
 
-    // Open new lua and libaraies
     sALE->OpenLua();
-
-    // Run scripts from laoded paths
     sALE->RunScripts();
 
     reload = false;
 }
 
 ALE::ALE() :
-event_level(0),
-push_counter(0),
-
-L(NULL),
-eventMgr(NULL),
-httpManager(),
-queryProcessor(),
-
-ServerEventBindings(NULL),
-PlayerEventBindings(NULL),
-GuildEventBindings(NULL),
-GroupEventBindings(NULL),
-VehicleEventBindings(NULL),
-BGEventBindings(NULL),
-AllCreatureEventBindings(NULL),
-
-PacketEventBindings(NULL),
-CreatureEventBindings(NULL),
-CreatureGossipBindings(NULL),
-GameObjectEventBindings(NULL),
-GameObjectGossipBindings(NULL),
-ItemEventBindings(NULL),
-ItemGossipBindings(NULL),
-PlayerGossipBindings(NULL),
-MapEventBindings(NULL),
-InstanceEventBindings(NULL),
-TicketEventBindings(NULL),
-SpellEventBindings(NULL),
-
-CreatureUniqueBindings(NULL)
+    eventMgr(nullptr)
 {
     ASSERT(IsInitialized());
 
     OpenLua();
 
-    // Replace this with map insert if making multithread version
-
-    // Set event manager. Must be after setting sALE
-    // on multithread have a map of state pointers and here insert this pointer to the map and then save a pointer of that pointer to the EventMgr
+    // Must be after OpenLua()
     eventMgr = new EventMgr(&ALE::GALE);
 }
 
@@ -229,22 +170,24 @@ ALE::~ALE()
     CloseLua();
 
     delete eventMgr;
-    eventMgr = NULL;
+    eventMgr = nullptr;
 }
 
 void ALE::CloseLua()
 {
+    if (!stateOpened)
+        return;
+
     OnLuaStateClose();
 
+    // Everything referencing the Lua state must be released before it is
+    // replaced: handlers, instance data tables, ...
     DestroyBindStores();
-
-    // Must close lua state after deleting stores and mgr
-    if (L)
-        lua_close(L);
-    L = NULL;
-
     instanceDataRefs.clear();
     continentDataRefs.clear();
+
+    lua = sol::state();
+    stateOpened = false;
 }
 
 void ALE::OpenLua()
@@ -255,112 +198,76 @@ void ALE::OpenLua()
         return;
     }
 
-    L = luaL_newstate();
+    lua = sol::state();
+    lua.open_libraries();
+    stateOpened = true;
 
-    lua_pushlightuserdata(L, this);
-    lua_setfield(L, LUA_REGISTRYINDEX, ALE_STATE_PTR);
+    // Append a Lua stack trace to every handler error when enabled
+    if (ALEConfig::GetInstance().IsTraceBackEnabled())
+        sol::protected_function::set_default_handler(lua["debug"]["traceback"]);
 
     CreateBindStores();
 
-    // open base lua libraries
-    luaL_openlibs(L);
-
-    // open additional lua libraries
-
-    // Register methods and functions
+    // Register usertypes and global functions
     RegisterFunctions(this);
 
     // Set lua require folder paths (scripts folder structure)
-    lua_getglobal(L, "package");
-    lua_pushstring(L, GetRequirePath().c_str());
-    lua_setfield(L, -2, "path");
-    lua_pushstring(L, GetRequireCPath().c_str());
-    lua_setfield(L, -2, "cpath");
-
-    // Set package.loaders loader for precompiled scripts
-    lua_getfield(L, -1, "loaders");
-    if (lua_isnil(L, -1)) {
-        // Lua 5.2+ uses searchers instead of loaders
-        lua_pop(L, 1);
-        lua_getfield(L, -1, "searchers");
-    }
-
-    lua_pop(L, 1);
+    lua["package"]["path"] = GetRequirePath();
+    lua["package"]["cpath"] = GetRequireCPath();
 }
 
 void ALE::CreateBindStores()
 {
     DestroyBindStores();
 
-    ServerEventBindings      = new BindingMap< EventKey<Hooks::ServerEvents> >(L);
-    PlayerEventBindings      = new BindingMap< EventKey<Hooks::PlayerEvents> >(L);
-    GuildEventBindings       = new BindingMap< EventKey<Hooks::GuildEvents> >(L);
-    GroupEventBindings       = new BindingMap< EventKey<Hooks::GroupEvents> >(L);
-    VehicleEventBindings     = new BindingMap< EventKey<Hooks::VehicleEvents> >(L);
-    BGEventBindings          = new BindingMap< EventKey<Hooks::BGEvents> >(L);
-    TicketEventBindings      = new BindingMap< EventKey<Hooks::TicketEvents> >(L);
-    AllCreatureEventBindings = new BindingMap< EventKey<Hooks::AllCreatureEvents> >(L);
-
-    PacketEventBindings      = new BindingMap< EntryKey<Hooks::PacketEvents> >(L);
-    CreatureEventBindings    = new BindingMap< EntryKey<Hooks::CreatureEvents> >(L);
-    CreatureGossipBindings   = new BindingMap< EntryKey<Hooks::GossipEvents> >(L);
-    GameObjectEventBindings  = new BindingMap< EntryKey<Hooks::GameObjectEvents> >(L);
-    GameObjectGossipBindings = new BindingMap< EntryKey<Hooks::GossipEvents> >(L);
-    ItemEventBindings        = new BindingMap< EntryKey<Hooks::ItemEvents> >(L);
-    ItemGossipBindings       = new BindingMap< EntryKey<Hooks::GossipEvents> >(L);
-    PlayerGossipBindings     = new BindingMap< EntryKey<Hooks::GossipEvents> >(L);
-    MapEventBindings         = new BindingMap< EntryKey<Hooks::InstanceEvents> >(L);
-    InstanceEventBindings    = new BindingMap< EntryKey<Hooks::InstanceEvents> >(L);
-    SpellEventBindings       = new BindingMap< EntryKey<Hooks::SpellEvents> >(L);
-
-    CreatureUniqueBindings   = new BindingMap< UniqueObjectKey<Hooks::CreatureEvents> >(L);
+    ServerEventBindings      = std::make_unique<BindingMap<EventKey<Hooks::ServerEvents>>>();
+    PlayerEventBindings      = std::make_unique<BindingMap<EventKey<Hooks::PlayerEvents>>>();
+    GuildEventBindings       = std::make_unique<BindingMap<EventKey<Hooks::GuildEvents>>>();
+    GroupEventBindings       = std::make_unique<BindingMap<EventKey<Hooks::GroupEvents>>>();
+    VehicleEventBindings     = std::make_unique<BindingMap<EventKey<Hooks::VehicleEvents>>>();
+    BGEventBindings          = std::make_unique<BindingMap<EventKey<Hooks::BGEvents>>>();
+    TicketEventBindings      = std::make_unique<BindingMap<EventKey<Hooks::TicketEvents>>>();
+    AllCreatureEventBindings = std::make_unique<BindingMap<EventKey<Hooks::AllCreatureEvents>>>();
+
+    PacketEventBindings      = std::make_unique<BindingMap<EntryKey<Hooks::PacketEvents>>>();
+    CreatureEventBindings    = std::make_unique<BindingMap<EntryKey<Hooks::CreatureEvents>>>();
+    CreatureGossipBindings   = std::make_unique<BindingMap<EntryKey<Hooks::GossipEvents>>>();
+    GameObjectEventBindings  = std::make_unique<BindingMap<EntryKey<Hooks::GameObjectEvents>>>();
+    GameObjectGossipBindings = std::make_unique<BindingMap<EntryKey<Hooks::GossipEvents>>>();
+    ItemEventBindings        = std::make_unique<BindingMap<EntryKey<Hooks::ItemEvents>>>();
+    ItemGossipBindings       = std::make_unique<BindingMap<EntryKey<Hooks::GossipEvents>>>();
+    PlayerGossipBindings     = std::make_unique<BindingMap<EntryKey<Hooks::GossipEvents>>>();
+    MapEventBindings         = std::make_unique<BindingMap<EntryKey<Hooks::InstanceEvents>>>();
+    InstanceEventBindings    = std::make_unique<BindingMap<EntryKey<Hooks::InstanceEvents>>>();
+    SpellEventBindings       = std::make_unique<BindingMap<EntryKey<Hooks::SpellEvents>>>();
+
+    CreatureUniqueBindings   = std::make_unique<BindingMap<UniqueObjectKey<Hooks::CreatureEvents>>>();
 }
 
 void ALE::DestroyBindStores()
 {
-    delete ServerEventBindings;
-    delete PlayerEventBindings;
-    delete GuildEventBindings;
-    delete GroupEventBindings;
-    delete VehicleEventBindings;
-    delete AllCreatureEventBindings;
-
-    delete PacketEventBindings;
-    delete CreatureEventBindings;
-    delete CreatureGossipBindings;
-    delete GameObjectEventBindings;
-    delete GameObjectGossipBindings;
-    delete ItemEventBindings;
-    delete ItemGossipBindings;
-    delete PlayerGossipBindings;
-    delete BGEventBindings;
-    delete MapEventBindings;
-    delete InstanceEventBindings;
-    delete SpellEventBindings;
-
-    delete CreatureUniqueBindings;
-
-    ServerEventBindings = NULL;
-    PlayerEventBindings = NULL;
-    GuildEventBindings = NULL;
-    GroupEventBindings = NULL;
-    VehicleEventBindings = NULL;
-    AllCreatureEventBindings = NULL;
-
-    PacketEventBindings = NULL;
-    CreatureEventBindings = NULL;
-    CreatureGossipBindings = NULL;
-    GameObjectEventBindings = NULL;
-    GameObjectGossipBindings = NULL;
-    ItemEventBindings = NULL;
-    ItemGossipBindings = NULL;
-    PlayerGossipBindings = NULL;
-    BGEventBindings = NULL;
-    MapEventBindings = NULL;
-    InstanceEventBindings = NULL;
-    SpellEventBindings = NULL;
-
-    CreatureUniqueBindings = NULL;
+    ServerEventBindings.reset();
+    PlayerEventBindings.reset();
+    GuildEventBindings.reset();
+    GroupEventBindings.reset();
+    VehicleEventBindings.reset();
+    BGEventBindings.reset();
+    TicketEventBindings.reset();
+    AllCreatureEventBindings.reset();
+
+    PacketEventBindings.reset();
+    CreatureEventBindings.reset();
+    CreatureGossipBindings.reset();
+    GameObjectEventBindings.reset();
+    GameObjectGossipBindings.reset();
+    ItemEventBindings.reset();
+    ItemGossipBindings.reset();
+    PlayerGossipBindings.reset();
+    MapEventBindings.reset();
+    InstanceEventBindings.reset();
+    SpellEventBindings.reset();
+
+    CreatureUniqueBindings.reset();
 }
 
 void ALE::AddScriptPath(std::string filename, const std::string& fullpath)
@@ -375,7 +282,7 @@ void ALE::AddScriptPath(std::string filename, const std::string& fullpath)
     filename = filename.substr(0, extDot);
 
     // check extension and add path to scripts to load
-    if (ext != ".lua" && ext != ".dll" && ext != ".so" && ext != ".ext" && ext !=".moon" && ext != ".out")
+    if (ext != ".lua" && ext != ".dll" && ext != ".so" && ext != ".ext" && ext != ".moon" && ext != ".out")
         return;
     bool extension = ext == ".ext";
 
@@ -391,228 +298,6 @@ void ALE::AddScriptPath(std::string filename, const std::string& fullpath)
     ALE_LOG_DEBUG("[ALE]: AddScriptPath add path `{}`", fullpath);
 }
 
-std::time_t ALE::GetFileModTime(const std::string& filepath)
-{
-    struct stat fileInfo;
-    if (stat(filepath.c_str(), &fileInfo) == 0)
-        return fileInfo.st_mtime;
-    return 0;
-}
-
-std::time_t ALE::GetFileModTimeWithCache(const std::string& filepath)
-{
-    auto it = timestampCache.find(filepath);
-    if (it != timestampCache.end())
-        return it->second;
-    
-    std::time_t modTime = GetFileModTime(filepath);
-    timestampCache[filepath] = modTime;
-    return modTime;
-}
-
-bool ALE::CompileScriptToGlobalCache(const std::string& filepath)
-{
-    std::lock_guard<std::mutex> lock(globalCacheMutex);
-    
-    lua_State* tempL = luaL_newstate();
-    if (!tempL)
-        return false;
-
-    int result = luaL_loadfile(tempL, filepath.c_str());
-    if (result != LUA_OK)
-    {
-        lua_close(tempL);
-        return false;
-    }
-
-    std::time_t modTime = GetFileModTime(filepath);
-    
-    auto& cacheEntry = globalBytecodeCache[filepath];
-    cacheEntry.last_modified = modTime;
-    cacheEntry.filepath = filepath;
-    cacheEntry.bytecode.clear();
-    cacheEntry.bytecode.reserve(1024);
-
-    struct BytecodeWriter {
-        BytecodeBuffer* buffer;
-        static int writer(lua_State*, const void* p, size_t sz, void* ud) {
-            BytecodeWriter* w = static_cast<BytecodeWriter*>(ud);
-            const uint8* bytes = static_cast<const uint8*>(p);
-            w->buffer->insert(w->buffer->end(), bytes, bytes + sz);
-            return 0;
-        }
-    };
-
-    BytecodeWriter writer;
-    writer.buffer = &cacheEntry.bytecode;
-
-    int dumpResult = lua_dump(tempL, BytecodeWriter::writer, &writer);
-    if (dumpResult != LUA_OK || cacheEntry.bytecode.empty())
-    {
-        globalBytecodeCache.erase(filepath);
-        lua_close(tempL);
-        return false;
-    }
-
-    lua_close(tempL);
-    return true;
-}
-
-bool ALE::CompileMoonScriptToGlobalCache(const std::string& filepath)
-{
-    std::lock_guard<std::mutex> lock(globalCacheMutex);
-    
-    lua_State* tempL = luaL_newstate();
-    if (!tempL)
-        return false;
-
-    luaL_openlibs(tempL);
-
-    std::string moonscriptLoader = "return require('moonscript').loadfile([[" + filepath + "]])";
-    int result = luaL_loadstring(tempL, moonscriptLoader.c_str());
-    if (result != LUA_OK)
-    {
-        lua_close(tempL);
-        return false;
-    }
-
-    result = lua_pcall(tempL, 0, 1, 0);
-    if (result != LUA_OK)
-    {
-        lua_close(tempL);
-        return false;
-    }
-
-    std::time_t modTime = GetFileModTime(filepath);
-    
-    auto& cacheEntry = globalBytecodeCache[filepath];
-    cacheEntry.last_modified = modTime;
-    cacheEntry.filepath = filepath;
-    cacheEntry.bytecode.clear();
-    cacheEntry.bytecode.reserve(2048);
-
-    struct BytecodeWriter {
-        BytecodeBuffer* buffer;
-        static int writer(lua_State*, const void* p, size_t sz, void* ud) {
-            BytecodeWriter* w = static_cast<BytecodeWriter*>(ud);
-            const uint8* bytes = static_cast<const uint8*>(p);
-            w->buffer->insert(w->buffer->end(), bytes, bytes + sz);
-            return 0;
-        }
-    };
-
-    BytecodeWriter writer;
-    writer.buffer = &cacheEntry.bytecode;
-
-    int dumpResult = lua_dump(tempL, BytecodeWriter::writer, &writer);
-    if (dumpResult != LUA_OK || cacheEntry.bytecode.empty())
-    {
-        globalBytecodeCache.erase(filepath);
-        lua_close(tempL);
-        return false;
-    }
-
-    lua_close(tempL);
-    return true;
-}
-
-int ALE::TryLoadFromGlobalCache(lua_State* L, const std::string& filepath)
-{
-    std::lock_guard<std::mutex> lock(globalCacheMutex);
-    
-    auto it = globalBytecodeCache.find(filepath);
-    if (it == globalBytecodeCache.end() || it->second.bytecode.empty())
-        return LUA_ERRFILE;
-    
-    std::time_t currentModTime = GetFileModTimeWithCache(filepath);
-    if (it->second.last_modified != currentModTime || currentModTime == 0)
-        return LUA_ERRFILE;
-    
-    return luaL_loadbuffer(L, reinterpret_cast<const char*>(it->second.bytecode.data()), it->second.bytecode.size(), filepath.c_str());
-}
-
-int ALE::LoadScriptWithCache(lua_State* L, const std::string& filepath, bool isMoonScript, uint32* compiledCount, uint32* cachedCount)
-{
-    bool cacheEnabled = ALEConfig::GetInstance().IsByteCodeCacheEnabled();
-    
-    if (cacheEnabled)
-    {
-        int result = TryLoadFromGlobalCache(L, filepath);
-        if (result == LUA_OK)
-        {
-            if (cachedCount) (*cachedCount)++;
-            return LUA_OK;
-        }
-        
-        bool compileSuccess = isMoonScript ? 
-            CompileMoonScriptToGlobalCache(filepath) : 
-            CompileScriptToGlobalCache(filepath);
-            
-        if (compileSuccess)
-        {
-            if (compiledCount) (*compiledCount)++;
-            std::lock_guard<std::mutex> lock(globalCacheMutex);
-            auto it = globalBytecodeCache.find(filepath);
-            if (it != globalBytecodeCache.end() && !it->second.bytecode.empty())
-            {
-                result = luaL_loadbuffer(L, reinterpret_cast<const char*>(it->second.bytecode.data()), it->second.bytecode.size(), filepath.c_str());
-                if (result == LUA_OK)
-                    return LUA_OK;
-            }
-        }
-    }
-    
-    if (isMoonScript)
-    {
-        std::string str = "return require('moonscript').loadfile([[" + filepath + "]])";
-        int result = luaL_loadstring(L, str.c_str());
-        if (result != LUA_OK)
-            return result;
-        return lua_pcall(L, 0, LUA_MULTRET, 0);
-    }
-    else
-    {
-        return luaL_loadfile(L, filepath.c_str());
-    }
-}
-
-void ALE::ClearGlobalCache()
-{
-    std::lock_guard<std::mutex> lock(globalCacheMutex);
-    globalBytecodeCache.clear();
-    timestampCache.clear();
-    ALE_LOG_INFO("[ALE]: Global bytecode cache cleared");
-}
-
-void ALE::ClearTimestampCache()
-{
-    std::lock_guard<std::mutex> lock(globalCacheMutex);
-    timestampCache.clear();
-}
-
-size_t ALE::GetGlobalCacheSize()
-{
-    std::lock_guard<std::mutex> lock(globalCacheMutex);
-    return globalBytecodeCache.size();
-}
-
-int ALE::LoadCompiledScript(lua_State* L, const std::string& filepath)
-{
-    std::ifstream file(filepath, std::ios::binary);
-    if (!file.is_open())
-        return LUA_ERRFILE;
-
-    file.seekg(0, std::ios::end);
-    size_t fileSize = file.tellg();
-    file.seekg(0, std::ios::beg);
-
-    std::vector<char> buffer(fileSize);
-    file.read(buffer.data(), fileSize);
-    file.close();
-
-    return luaL_loadbuffer(L, buffer.data(), fileSize, filepath.c_str());
-}
-
 // Finds lua script files from given path (including subdirectories) and pushes them to scripts
 void ALE::GetScripts(std::string path)
 {
@@ -621,45 +306,45 @@ void ALE::GetScripts(std::string path)
     boost::filesystem::path someDir(path);
     boost::filesystem::directory_iterator end_iter;
 
-    if (boost::filesystem::exists(someDir) && boost::filesystem::is_directory(someDir))
+    if (!boost::filesystem::exists(someDir) || !boost::filesystem::is_directory(someDir))
+        return;
+
+    lua_requirepath +=
+        path + "/?.lua;" +
+        path + "/?.moon;" +
+        path + "/?.ext;";
+
+    lua_requirecpath +=
+        path + "/?.dll;" +
+        path + "/?.so;";
+
+    for (boost::filesystem::directory_iterator dir_iter(someDir); dir_iter != end_iter; ++dir_iter)
     {
-        lua_requirepath +=
-            path + "/?.lua;" +
-            path + "/?.moon;" +
-            path + "/?.ext;";
-        
-        lua_requirecpath +=
-            path + "/?.dll;" +
-            path + "/?.so;";
-
-        for (boost::filesystem::directory_iterator dir_iter(someDir); dir_iter != end_iter; ++dir_iter)
-        {
-            std::string fullpath = dir_iter->path().generic_string();
+        std::string fullpath = dir_iter->path().generic_string();
 
-            // Check if file is hidden
+        // Check if file is hidden
 #ifdef ALE_WINDOWS
-            DWORD dwAttrib = GetFileAttributes(fullpath.c_str());
-            if (dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_HIDDEN))
-                continue;
+        DWORD dwAttrib = GetFileAttributes(fullpath.c_str());
+        if (dwAttrib != INVALID_FILE_ATTRIBUTES && (dwAttrib & FILE_ATTRIBUTE_HIDDEN))
+            continue;
 #else
-            std::string name = dir_iter->path().filename().generic_string().c_str();
-            if (name[0] == '.')
-                continue;
+        std::string name = dir_iter->path().filename().generic_string();
+        if (name[0] == '.')
+            continue;
 #endif
 
-            // load subfolder
-            if (boost::filesystem::is_directory(dir_iter->status()))
-            {
-                GetScripts(fullpath);
-                continue;
-            }
+        // load subfolder
+        if (boost::filesystem::is_directory(dir_iter->status()))
+        {
+            GetScripts(fullpath);
+            continue;
+        }
 
-            if (boost::filesystem::is_regular_file(dir_iter->status()))
-            {
-                // was file, try add
-                std::string filename = dir_iter->path().filename().generic_string();
-                AddScriptPath(filename, fullpath);
-            }
+        if (boost::filesystem::is_regular_file(dir_iter->status()))
+        {
+            // was file, try add
+            std::string filename = dir_iter->path().filename().generic_string();
+            AddScriptPath(filename, fullpath);
         }
     }
 }
@@ -672,7 +357,7 @@ static bool ScriptPathComparator(const LuaScript& first, const LuaScript& second
 void ALE::RunScripts()
 {
     LOCK_ALE;
-    if (!ALEConfig::GetInstance().IsALEEnabled())
+    if (!stateOpened)
         return;
 
     uint32 oldMSTime = ALEUtil::GetCurrTime();
@@ -680,10 +365,10 @@ void ALE::RunScripts()
     uint32 compiledCount = 0;
     uint32 cachedCount = 0;
     uint32 precompiledCount = 0;
-    bool cacheEnabled = eConfigMgr->GetOption<bool>("ALE.BytecodeCache", true);
-    
+    bool cacheEnabled = ALEConfig::GetInstance().IsByteCodeCacheEnabled();
+
     if (cacheEnabled)
-        ClearTimestampCache();
+        ALEScriptCache::ClearTimestamps();
 
     ScriptList scripts;
     lua_extensions.sort(ScriptPathComparator);
@@ -693,668 +378,128 @@ void ALE::RunScripts()
 
     std::unordered_map<std::string, std::string> loaded; // filename, path
 
-    lua_getglobal(L, "package");
-    // Stack: package
-    luaL_getsubtable(L, -1, "loaded");
-    // Stack: package, modules
-    int modules = lua_gettop(L);
-    for (ScriptList::iterator it = scripts.begin(); it != scripts.end(); ++it)
+    sol::table packageLoaded = lua["package"]["loaded"];
+
+    for (LuaScript const& script : scripts)
     {
         // Check that no duplicate names exist
-        if (loaded.find(it->filename) != loaded.end())
+        if (loaded.find(script.filename) != loaded.end())
         {
-            ALE_LOG_ERROR("[ALE]: Error loading `{}`. File with same name already loaded from `{}`, rename either file", it->filepath, loaded[it->filename]);
+            ALE_LOG_ERROR("[ALE]: Error loading `{}`. File with same name already loaded from `{}`, rename either file", script.filepath, loaded[script.filename]);
             continue;
         }
-        loaded[it->filename] = it->filepath;
+        loaded[script.filename] = script.filepath;
 
-        lua_getfield(L, modules, it->filename.c_str());
-        // Stack: package, modules, module
-        if (!lua_isnoneornil(L, -1))
+        // Skip anything require() already pulled in
+        if (packageLoaded[script.filename].valid() && packageLoaded[script.filename] != sol::nil)
         {
-            lua_pop(L, 1);
-            ALE_LOG_DEBUG("[ALE]: `{}` was already loaded or required", it->filepath);
+            ALE_LOG_DEBUG("[ALE]: `{}` was already loaded or required", script.filepath);
             continue;
         }
-        lua_pop(L, 1);
-        // Stack: package, modules
 
-        if (it->fileext == ".moon")
+        // Load the file as a callable chunk
+        sol::protected_function chunk;
+        if (script.fileext == ".out")
         {
-            if (LoadScriptWithCache(L, it->filepath, true, &compiledCount, &cachedCount))
-            {
-                // Stack: package, modules, errmsg
-                ALE_LOG_ERROR("[ALE]: Error loading MoonScript `{}`", it->filepath);
-                Report(L);
-                // Stack: package, modules
-                continue;
-            }
-        }
-        else if (it->fileext == ".out")
-        {
-            if (LoadCompiledScript(L, it->filepath))
-            {
-                // Stack: package, modules, errmsg
-                ALE_LOG_ERROR("[ALE]: Error loading compiled script `{}`", it->filepath);
-                Report(L);
-                // Stack: package, modules
-                continue;
-            }
-            precompiledCount++;
-        }
-        else if (it->fileext == ".lua" || it->fileext == ".ext")
-        {
-            if (LoadScriptWithCache(L, it->filepath, false, &compiledCount, &cachedCount))
-            {
-                // Stack: package, modules, errmsg
-                ALE_LOG_ERROR("[ALE]: Error loading `{}`", it->filepath);
-                Report(L);
-                // Stack: package, modules
-                continue;
-            }
+            chunk = ALEScriptCache::LoadCompiled(lua, script.filepath);
+            if (chunk.valid())
+                ++precompiledCount;
         }
         else
-        {
-           if (luaL_loadfile(L, it->filepath.c_str()))
-           {
-               // Stack: package, modules, errmsg
-               ALE_LOG_ERROR("[ALE]: Error loading `{}`", it->filepath);
-               Report(L);
-               // Stack: package, modules
-               continue;
-           }
-        }
+            chunk = ALEScriptCache::Load(lua, script.filepath, script.fileext == ".moon", compiledCount, cachedCount);
 
-        // Stack: package, modules, filefunc
-        if (ExecuteCall(0, 1))
-        {
-            // Stack: package, modules, result
-            if (lua_isnoneornil(L, -1) || (lua_isboolean(L, -1) && !lua_toboolean(L, -1)))
-            {
-                // if result evaluates to false, change it to true
-                lua_pop(L, 1);
-                Push(L, true);
-            }
-            lua_setfield(L, modules, it->filename.c_str());
-            // Stack: package, modules
-
-            // successfully loaded and ran file
-            ALE_LOG_DEBUG("[ALE]: Successfully loaded `{}`", it->filepath);
-            ++count;
+        if (!chunk.valid())
             continue;
-        }
-    }
-    // Stack: package, modules
-    lua_pop(L, 2);
-    
-    std::string details = "";
-    if (cacheEnabled && (compiledCount > 0 || cachedCount > 0 || precompiledCount > 0))
-    {
-        details = fmt::format("({} compiled, {} cached, {} pre-compiled)", compiledCount, cachedCount, precompiledCount);
-    }
-    ALE_LOG_INFO("[ALE]: Executed {} Lua scripts in {} ms {}", count, ALEUtil::GetTimeDiff(oldMSTime), details);
-
-    OnLuaStateOpen();
-}
-
-void ALE::InvalidateObjects()
-{
-    ++callstackid;
-    ASSERT(callstackid && "Callstackid overflow");
-}
 
-void ALE::Report(lua_State* _L)
-{
-    const char* msg = lua_tostring(_L, -1);
-    ALE_LOG_ERROR("{}", msg);
-    lua_pop(_L, 1);
-}
-
-// Borrowed from http://stackoverflow.com/questions/12256455/print-stacktrace-from-c-code-with-embedded-lua
-int ALE::StackTrace(lua_State *_L)
-{
-    // Stack: errmsg
-    if (!lua_isstring(_L, -1))  /* 'message' not a string? */
-        return 1;  /* keep it intact */
-    // Stack: errmsg, debug
-    lua_getglobal(_L, "debug");
-    if (!lua_istable(_L, -1))
-    {
-        lua_pop(_L, 1);
-        return 1;
-    }
-    // Stack: errmsg, debug, traceback
-    lua_getfield(_L, -1, "traceback");
-    if (!lua_isfunction(_L, -1))
-    {
-        lua_pop(_L, 2);
-        return 1;
-    }
-    lua_pushvalue(_L, -3);  /* pass error message */
-    lua_pushinteger(_L, 1);  /* skip this function and traceback */
-    // Stack: errmsg, debug, traceback, errmsg, 2
-    lua_call(_L, 2, 1);  /* call debug.traceback */
-
-    // dirty stack?
-    // Stack: errmsg, debug, tracemsg
-    sALE->OnError(std::string(lua_tostring(_L, -1)));
-    return 1;
-}
-
-bool ALE::ExecuteCall(int params, int res)
-{
-    int top = lua_gettop(L);
-    int base = top - params;
-
-    // Expected: function, [parameters]
-    ASSERT(base > 0);
-
-    // Check function type
-    if (!lua_isfunction(L, base))
-    {
-        ALE_LOG_ERROR("[ALE]: Cannot execute call: registered value is {}, not a function.", luaL_tolstring(L, base, NULL));
-        ASSERT(false); // stack probably corrupt
-    }
-
-    bool usetrace = ALEConfig::GetInstance().IsTraceBackEnabled();
-    if (usetrace)
-    {
-        lua_pushcfunction(L, &StackTrace);
-        // Stack: function, [parameters], traceback
-        lua_insert(L, base);
-        // Stack: traceback, function, [parameters]
-    }
+        // Run it and remember its result the way require() would
+        // (the guard covers the rest of the iteration, which is harmless).
+        DispatchGuard guard(this);
+        sol::protected_function_result result = chunk();
 
-    // Objects are invalidated when event_level hits 0
-    ++event_level;
-    int result = lua_pcall(L, params, res, usetrace ? base : 0);
-    --event_level;
-
-    if (usetrace)
-    {
-        // Stack: traceback, [results or errmsg]
-        lua_remove(L, base);
-    }
-    // Stack: [results or errmsg]
-
-    // lua_pcall returns 0 on success.
-    // On error print the error and push nils for expected amount of returned values
-    if (result)
-    {
-        // Stack: errmsg
-        Report(L);
-
-        // Force garbage collect
-        lua_gc(L, LUA_GCCOLLECT, 0);
-
-        // Push nils for expected amount of results
-        for (int i = 0; i < res; ++i)
-            lua_pushnil(L);
-        // Stack: [nils]
-        return false;
-    }
-
-    // Stack: [results]
-    return true;
-}
-
-void ALE::Push(lua_State* luastate)
-{
-    lua_pushnil(luastate);
-}
-void ALE::Push(lua_State* luastate, const long long l)
-{
-    ALETemplate<long long>::Push(luastate, new long long(l));
-}
-void ALE::Push(lua_State* luastate, const unsigned long long l)
-{
-    ALETemplate<unsigned long long>::Push(luastate, new unsigned long long(l));
-}
-void ALE::Push(lua_State* luastate, const long l)
-{
-    Push(luastate, static_cast<long long>(l));
-}
-void ALE::Push(lua_State* luastate, const unsigned long l)
-{
-    Push(luastate, static_cast<unsigned long long>(l));
-}
-void ALE::Push(lua_State* luastate, const int i)
-{
-    lua_pushinteger(luastate, i);
-}
-void ALE::Push(lua_State* luastate, const unsigned int u)
-{
-    lua_pushunsigned(luastate, u);
-}
-void ALE::Push(lua_State* luastate, const double d)
-{
-    lua_pushnumber(luastate, d);
-}
-void ALE::Push(lua_State* luastate, const float f)
-{
-    lua_pushnumber(luastate, f);
-}
-void ALE::Push(lua_State* luastate, const bool b)
-{
-    lua_pushboolean(luastate, b);
-}
-void ALE::Push(lua_State* luastate, const std::string& str)
-{
-    lua_pushstring(luastate, str.c_str());
-}
-void ALE::Push(lua_State* luastate, const char* str)
-{
-    lua_pushstring(luastate, str);
-}
-void ALE::Push(lua_State* luastate, Pet const* pet)
-{
-    Push<Creature>(luastate, pet);
-}
-void ALE::Push(lua_State* luastate, TempSummon const* summon)
-{
-    Push<Creature>(luastate, summon);
-}
-void ALE::Push(lua_State* luastate, Unit const* unit)
-{
-    if (!unit)
-    {
-        Push(luastate);
-        return;
-    }
-    switch (unit->GetTypeId())
-    {
-        case TYPEID_UNIT:
-            Push(luastate, unit->ToCreature());
-            break;
-        case TYPEID_PLAYER:
-            Push(luastate, unit->ToPlayer());
-            break;
-        default:
-            ALETemplate<Unit>::Push(luastate, unit);
-    }
-}
-void ALE::Push(lua_State* luastate, WorldObject const* obj)
-{
-    if (!obj)
-    {
-        Push(luastate);
-        return;
-    }
-    switch (obj->GetTypeId())
-    {
-        case TYPEID_UNIT:
-            Push(luastate, obj->ToCreature());
-            break;
-        case TYPEID_PLAYER:
-            Push(luastate, obj->ToPlayer());
-            break;
-        case TYPEID_GAMEOBJECT:
-            Push(luastate, obj->ToGameObject());
-            break;
-        case TYPEID_CORPSE:
-            Push(luastate, obj->ToCorpse());
-            break;
-        default:
-            ALETemplate<WorldObject>::Push(luastate, obj);
-    }
-}
-void ALE::Push(lua_State* luastate, Object const* obj)
-{
-    if (!obj)
-    {
-        Push(luastate);
-        return;
-    }
-    switch (obj->GetTypeId())
-    {
-        case TYPEID_UNIT:
-            Push(luastate, obj->ToCreature());
-            break;
-        case TYPEID_PLAYER:
-            Push(luastate, obj->ToPlayer());
-            break;
-        case TYPEID_GAMEOBJECT:
-            Push(luastate, obj->ToGameObject());
-            break;
-        case TYPEID_CORPSE:
-            Push(luastate, obj->ToCorpse());
-            break;
-        default:
-            ALETemplate<Object>::Push(luastate, obj);
-    }
-}
-void ALE::Push(lua_State* luastate, ObjectGuid const guid)
-{
-    ALETemplate<unsigned long long>::Push(luastate, new unsigned long long(guid.GetRawValue()));
-}
-
-void ALE::Push(lua_State* luastate, GemPropertiesEntry const& gemProperties)
-{
-    Push(luastate, &gemProperties);
-}
-
-void ALE::Push(lua_State* luastate, SpellEntry const& spell)
-{
-    Push(luastate, &spell);
-}
-
-void ALE::Push(lua_State* luastate, CreatureTemplate const* creatureTemplate)
-{
-    Push<CreatureTemplate>(luastate, creatureTemplate);
-}
-
-std::string ALE::FormatQuery(lua_State* L, const char* query)
-{
-    int numArgs = lua_gettop(L);
-    std::string formattedQuery = query;
-
-    size_t position = 0;
-    for (int i = 2; i <= numArgs; ++i) 
-    {
-        std::string arg;
-
-        if (lua_isnumber(L, i)) 
-        {
-            arg = std::to_string(lua_tonumber(L, i));
-        } 
-        else if (lua_isstring(L, i)) 
+        if (!result.valid())
         {
-            std::string value = lua_tostring(L, i);
-            for (size_t pos = 0; (pos = value.find('\'', pos)) != std::string::npos; pos += 2)
-            {
-                value.insert(pos, "'");
-            }
-            arg = "'" + value + "'";
-        } 
-        else 
-        {
-            luaL_error(L, "Unsupported argument type. Only numbers and strings are supported.");
-            return "";
+            Report(sol::error(result));
+            continue;
         }
 
-        position = formattedQuery.find("?", position);
-        if (position == std::string::npos) 
-        {
-            luaL_error(L, "Mismatch between placeholders and arguments.");
-            return "";
-        }
-        formattedQuery.replace(position, 1, arg);
-        position += arg.length();
-    }
+        sol::object value = result.get<sol::object>(0);
+        if (!value.valid() || value == sol::nil || (value.is<bool>() && !value.as<bool>()))
+            value = sol::make_object(lua, true);
+        packageLoaded[script.filename] = value;
 
-    return formattedQuery;
-}
-
-static int CheckIntegerRange(lua_State* luastate, int narg, int min, int max)
-{
-    double value = luaL_checknumber(luastate, narg);
-    char error_buffer[64];
-
-    if (value > max)
-    {
-        snprintf(error_buffer, 64, "value must be less than or equal to %i", max);
-        return luaL_argerror(luastate, narg, error_buffer);
+        ALE_LOG_DEBUG("[ALE]: Successfully loaded `{}`", script.filepath);
+        ++count;
     }
 
-    if (value < min)
-    {
-        snprintf(error_buffer, 64, "value must be greater than or equal to %i", min);
-        return luaL_argerror(luastate, narg, error_buffer);
-    }
-
-    return static_cast<int>(value);
-}
-
-static unsigned int CheckUnsignedRange(lua_State* luastate, int narg, unsigned int max)
-{
-    double value = luaL_checknumber(luastate, narg);
-
-    if (value < 0)
-        return luaL_argerror(luastate, narg, "value must be greater than or equal to 0");
-
-    if (value > max)
-    {
-        char error_buffer[64];
-        snprintf(error_buffer, 64, "value must be less than or equal to %u", max);
-        return luaL_argerror(luastate, narg, error_buffer);
-    }
-
-    return static_cast<unsigned int>(value);
-}
+    std::string details;
+    if (cacheEnabled && (compiledCount > 0 || cachedCount > 0 || precompiledCount > 0))
+        details = fmt::format("({} compiled, {} cached, {} pre-compiled)", compiledCount, cachedCount, precompiledCount);
 
-template<> bool ALE::CHECKVAL<bool>(lua_State* luastate, int narg)
-{
-    return lua_toboolean(luastate, narg) != 0;
-}
-template<> float ALE::CHECKVAL<float>(lua_State* luastate, int narg)
-{
-    return static_cast<float>(luaL_checknumber(luastate, narg));
-}
-template<> double ALE::CHECKVAL<double>(lua_State* luastate, int narg)
-{
-    return luaL_checknumber(luastate, narg);
-}
-template<> signed char ALE::CHECKVAL<signed char>(lua_State* luastate, int narg)
-{
-    return CheckIntegerRange(luastate, narg, SCHAR_MIN, SCHAR_MAX);
-}
-template<> unsigned char ALE::CHECKVAL<unsigned char>(lua_State* luastate, int narg)
-{
-    return CheckUnsignedRange(luastate, narg, UCHAR_MAX);
-}
-template<> short ALE::CHECKVAL<short>(lua_State* luastate, int narg)
-{
-    return CheckIntegerRange(luastate, narg, SHRT_MIN, SHRT_MAX);
-}
-template<> unsigned short ALE::CHECKVAL<unsigned short>(lua_State* luastate, int narg)
-{
-    return CheckUnsignedRange(luastate, narg, USHRT_MAX);
-}
-template<> int ALE::CHECKVAL<int>(lua_State* luastate, int narg)
-{
-    return CheckIntegerRange(luastate, narg, INT_MIN, INT_MAX);
-}
-template<> unsigned int ALE::CHECKVAL<unsigned int>(lua_State* luastate, int narg)
-{
-    return CheckUnsignedRange(luastate, narg, UINT_MAX);
-}
-template<> const char* ALE::CHECKVAL<const char*>(lua_State* luastate, int narg)
-{
-    return luaL_checkstring(luastate, narg);
-}
-template<> std::string ALE::CHECKVAL<std::string>(lua_State* luastate, int narg)
-{
-    return luaL_checkstring(luastate, narg);
-}
-template<> long long ALE::CHECKVAL<long long>(lua_State* luastate, int narg)
-{
-    if (lua_isnumber(luastate, narg))
-        return static_cast<long long>(CHECKVAL<double>(luastate, narg));
-    return *(ALE::CHECKOBJ<long long>(luastate, narg, true));
-}
-template<> unsigned long long ALE::CHECKVAL<unsigned long long>(lua_State* luastate, int narg)
-{
-    if (lua_isnumber(luastate, narg))
-        return static_cast<unsigned long long>(CHECKVAL<uint32>(luastate, narg));
-    return *(ALE::CHECKOBJ<unsigned long long>(luastate, narg, true));
-}
-template<> long ALE::CHECKVAL<long>(lua_State* luastate, int narg)
-{
-    return static_cast<long>(CHECKVAL<long long>(luastate, narg));
-}
-template<> unsigned long ALE::CHECKVAL<unsigned long>(lua_State* luastate, int narg)
-{
-    return static_cast<unsigned long>(CHECKVAL<unsigned long long>(luastate, narg));
-}
-template<> ObjectGuid ALE::CHECKVAL<ObjectGuid>(lua_State* luastate, int narg)
-{
-    return ObjectGuid(uint64((CHECKVAL<unsigned long long>(luastate, narg))));
-}
+    ALE_LOG_INFO("[ALE]: Executed {} Lua scripts in {} ms {}", count, ALEUtil::GetTimeDiff(oldMSTime), details);
 
-template<> Object* ALE::CHECKOBJ<Object>(lua_State* luastate, int narg, bool error)
-{
-    Object* obj = CHECKOBJ<WorldObject>(luastate, narg, false);
-    if (!obj)
-        obj = CHECKOBJ<Item>(luastate, narg, false);
-    if (!obj)
-        obj = ALETemplate<Object>::Check(luastate, narg, error);
-    return obj;
-}
-template<> WorldObject* ALE::CHECKOBJ<WorldObject>(lua_State* luastate, int narg, bool error)
-{
-    WorldObject* obj = CHECKOBJ<Unit>(luastate, narg, false);
-    if (!obj)
-        obj = CHECKOBJ<GameObject>(luastate, narg, false);
-    if (!obj)
-        obj = CHECKOBJ<Corpse>(luastate, narg, false);
-    if (!obj)
-        obj = ALETemplate<WorldObject>::Check(luastate, narg, error);
-    return obj;
-}
-template<> Unit* ALE::CHECKOBJ<Unit>(lua_State* luastate, int narg, bool error)
-{
-    Unit* obj = CHECKOBJ<Player>(luastate, narg, false);
-    if (!obj)
-        obj = CHECKOBJ<Creature>(luastate, narg, false);
-    if (!obj)
-        obj = ALETemplate<Unit>::Check(luastate, narg, error);
-    return obj;
+    OnLuaStateOpen();
 }
 
-template<> ALEObject* ALE::CHECKOBJ<ALEObject>(lua_State* luastate, int narg, bool error)
+void ALE::Report(sol::error const& error)
 {
-    return CHECKTYPE(luastate, narg, NULL, error);
+    ALE_LOG_ERROR("{}", error.what());
+    OnError(std::string(error.what()));
 }
 
-ALEObject* ALE::CHECKTYPE(lua_State* luastate, int narg, const char* tname, bool error)
+/*
+ * Saves the handler to the register type's store for the given entry/guid
+ * under the given event. Returns a callable that cancels the registration.
+ */
+sol::object ALE::Register(uint8 regtype, uint32 entry, ObjectGuid guid, uint32 instanceId,
+    uint32 event_id, sol::protected_function callback, uint32 shots)
 {
-    if (lua_islightuserdata(luastate, narg))
+    // Inserts the handler and builds the Lua-side cancel callable.
+    auto bind = [&](auto& bindings, auto key) -> sol::object
     {
-        if (error)
-            luaL_argerror(luastate, narg, "bad argument : userdata expected, got lightuserdata");
-        return NULL;
-    }
-
-    ALEObject** ptrHold = static_cast<ALEObject**>(lua_touserdata(luastate, narg));
-
-    if (!ptrHold || (tname && (*ptrHold)->GetTypeName() != tname))
-    {
-        if (error)
-        {
-            char buff[256];
-            snprintf(buff, 256, "bad argument : %s expected, got %s", tname ? tname : "ALEObject", ptrHold ? (*ptrHold)->GetTypeName() : luaL_typename(luastate, narg));
-            luaL_argerror(luastate, narg, buff);
-        }
-        return NULL;
-    }
-    return *ptrHold;
-}
-
-template<typename K>
-static int cancelBinding(lua_State *L)
-{
-    uint64 bindingID = ALE::CHECKVAL<uint64>(L, lua_upvalueindex(1));
-
-    BindingMap<K>* bindings = (BindingMap<K>*)lua_touserdata(L, lua_upvalueindex(2));
-    ASSERT(bindings != NULL);
-
-    bindings->Remove(bindingID);
-
-    return 0;
-}
-
-template<typename K>
-static void createCancelCallback(lua_State* L, uint64 bindingID, BindingMap<K>* bindings)
-{
-    ALE::Push(L, bindingID);
-    lua_pushlightuserdata(L, bindings);
-    // Stack: bindingID, bindings
-
-    lua_pushcclosure(L, &cancelBinding<K>, 2);
-    // Stack: cancel_callback
-}
-
-// Saves the function reference ID given to the register type's store for given entry under the given event
-int ALE::Register(lua_State* L, uint8 regtype, uint32 entry, ObjectGuid guid, uint32 instanceId, uint32 event_id, int functionRef, uint32 shots)
-{
-    uint64 bindingID;
+        uint64 bindingID = bindings->Insert(key, std::move(callback), shots);
+        auto* store = bindings.get();
+        return sol::make_object(lua, [store, bindingID]() { store->Remove(bindingID); });
+    };
 
     switch (regtype)
     {
         case Hooks::REGTYPE_SERVER:
             if (event_id < Hooks::SERVER_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::ServerEvents>((Hooks::ServerEvents)event_id);
-                bindingID = ServerEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, ServerEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(ServerEventBindings, EventKey<Hooks::ServerEvents>((Hooks::ServerEvents)event_id));
             break;
 
         case Hooks::REGTYPE_PLAYER:
             if (event_id < Hooks::PLAYER_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::PlayerEvents>((Hooks::PlayerEvents)event_id);
-                bindingID = PlayerEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, PlayerEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(PlayerEventBindings, EventKey<Hooks::PlayerEvents>((Hooks::PlayerEvents)event_id));
             break;
 
         case Hooks::REGTYPE_GUILD:
             if (event_id < Hooks::GUILD_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::GuildEvents>((Hooks::GuildEvents)event_id);
-                bindingID = GuildEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, GuildEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(GuildEventBindings, EventKey<Hooks::GuildEvents>((Hooks::GuildEvents)event_id));
             break;
 
         case Hooks::REGTYPE_GROUP:
             if (event_id < Hooks::GROUP_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::GroupEvents>((Hooks::GroupEvents)event_id);
-                bindingID = GroupEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, GroupEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(GroupEventBindings, EventKey<Hooks::GroupEvents>((Hooks::GroupEvents)event_id));
             break;
 
         case Hooks::REGTYPE_VEHICLE:
             if (event_id < Hooks::VEHICLE_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::VehicleEvents>((Hooks::VehicleEvents)event_id);
-                bindingID = VehicleEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, VehicleEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(VehicleEventBindings, EventKey<Hooks::VehicleEvents>((Hooks::VehicleEvents)event_id));
             break;
 
         case Hooks::REGTYPE_BG:
             if (event_id < Hooks::BG_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::BGEvents>((Hooks::BGEvents)event_id);
-                bindingID = BGEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, BGEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(BGEventBindings, EventKey<Hooks::BGEvents>((Hooks::BGEvents)event_id));
             break;
 
         case Hooks::REGTYPE_PACKET:
             if (event_id < Hooks::PACKET_EVENT_COUNT)
             {
                 if (entry >= NUM_MSG_TYPES)
-                {
-                    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                    luaL_error(L, "Couldn't find a creature with (ID: %d)!", entry);
-                    return 0; // Stack: (empty)
-                }
+                    throw std::invalid_argument(Acore::StringFormat("Couldn't find an opcode with (ID: {})!", entry));
 
-                auto key = EntryKey<Hooks::PacketEvents>((Hooks::PacketEvents)event_id, entry);
-                bindingID = PacketEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, PacketEventBindings);
-                return 1; // Stack: callback
+                return bind(PacketEventBindings, EntryKey<Hooks::PacketEvents>((Hooks::PacketEvents)event_id, entry));
             }
             break;
 
@@ -1363,261 +508,134 @@ int ALE::Register(lua_State* L, uint8 regtype, uint32 entry, ObjectGuid guid, ui
             {
                 if (entry != 0)
                 {
-                    if (!eObjectMgr->GetCreatureTemplate(entry))
-                    {
-                        luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                        luaL_error(L, "Couldn't find a creature with (ID: %d)!", entry);
-                        return 0; // Stack: (empty)
-                    }
-
-                    auto key = EntryKey<Hooks::CreatureEvents>((Hooks::CreatureEvents)event_id, entry);
-                    bindingID = CreatureEventBindings->Insert(key, functionRef, shots);
-                    createCancelCallback(L, bindingID, CreatureEventBindings);
-                }
-                else
-                {
-                    if (guid.IsEmpty())
-                    {
-                        luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                        luaL_error(L, "guid was 0!");
-                        return 0; // Stack: (empty)
-                    }
-
-                    auto key = UniqueObjectKey<Hooks::CreatureEvents>((Hooks::CreatureEvents)event_id, guid, instanceId);
-                    bindingID = CreatureUniqueBindings->Insert(key, functionRef, shots);
-                    createCancelCallback(L, bindingID, CreatureUniqueBindings);
+                    if (!sObjectMgr->GetCreatureTemplate(entry))
+                        throw std::invalid_argument(Acore::StringFormat("Couldn't find a creature with (ID: {})!", entry));
+
+                    return bind(CreatureEventBindings, EntryKey<Hooks::CreatureEvents>((Hooks::CreatureEvents)event_id, entry));
                 }
-                return 1; // Stack: callback
+
+                if (guid.IsEmpty())
+                    throw std::invalid_argument("guid was 0!");
+
+                return bind(CreatureUniqueBindings, UniqueObjectKey<Hooks::CreatureEvents>((Hooks::CreatureEvents)event_id, guid, instanceId));
             }
             break;
 
         case Hooks::REGTYPE_CREATURE_GOSSIP:
             if (event_id < Hooks::GOSSIP_EVENT_COUNT)
             {
-                if (!eObjectMgr->GetCreatureTemplate(entry))
-                {
-                    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                    luaL_error(L, "Couldn't find a creature with (ID: %d)!", entry);
-                    return 0; // Stack: (empty)
-                }
+                if (!sObjectMgr->GetCreatureTemplate(entry))
+                    throw std::invalid_argument(Acore::StringFormat("Couldn't find a creature with (ID: {})!", entry));
 
-                auto key = EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry);
-                bindingID = CreatureGossipBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, CreatureGossipBindings);
-                return 1; // Stack: callback
+                return bind(CreatureGossipBindings, EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry));
             }
             break;
 
         case Hooks::REGTYPE_GAMEOBJECT:
             if (event_id < Hooks::GAMEOBJECT_EVENT_COUNT)
             {
-                if (!eObjectMgr->GetGameObjectTemplate(entry))
-                {
-                    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                    luaL_error(L, "Couldn't find a gameobject with (ID: %d)!", entry);
-                    return 0; // Stack: (empty)
-                }
+                if (!sObjectMgr->GetGameObjectTemplate(entry))
+                    throw std::invalid_argument(Acore::StringFormat("Couldn't find a gameobject with (ID: {})!", entry));
 
-                auto key = EntryKey<Hooks::GameObjectEvents>((Hooks::GameObjectEvents)event_id, entry);
-                bindingID = GameObjectEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, GameObjectEventBindings);
-                return 1; // Stack: callback
+                return bind(GameObjectEventBindings, EntryKey<Hooks::GameObjectEvents>((Hooks::GameObjectEvents)event_id, entry));
             }
             break;
 
         case Hooks::REGTYPE_GAMEOBJECT_GOSSIP:
             if (event_id < Hooks::GOSSIP_EVENT_COUNT)
             {
-                if (!eObjectMgr->GetGameObjectTemplate(entry))
-                {
-                    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                    luaL_error(L, "Couldn't find a gameobject with (ID: %d)!", entry);
-                    return 0; // Stack: (empty)
-                }
+                if (!sObjectMgr->GetGameObjectTemplate(entry))
+                    throw std::invalid_argument(Acore::StringFormat("Couldn't find a gameobject with (ID: {})!", entry));
 
-                auto key = EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry);
-                bindingID = GameObjectGossipBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, GameObjectGossipBindings);
-                return 1; // Stack: callback
+                return bind(GameObjectGossipBindings, EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry));
             }
             break;
 
         case Hooks::REGTYPE_ITEM:
             if (event_id < Hooks::ITEM_EVENT_COUNT)
             {
-                if (!eObjectMgr->GetItemTemplate(entry))
-                {
-                    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                    luaL_error(L, "Couldn't find a item with (ID: %d)!", entry);
-                    return 0; // Stack: (empty)
-                }
+                if (!sObjectMgr->GetItemTemplate(entry))
+                    throw std::invalid_argument(Acore::StringFormat("Couldn't find an item with (ID: {})!", entry));
 
-                auto key = EntryKey<Hooks::ItemEvents>((Hooks::ItemEvents)event_id, entry);
-                bindingID = ItemEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, ItemEventBindings);
-                return 1; // Stack: callback
+                return bind(ItemEventBindings, EntryKey<Hooks::ItemEvents>((Hooks::ItemEvents)event_id, entry));
             }
             break;
 
         case Hooks::REGTYPE_ITEM_GOSSIP:
             if (event_id < Hooks::GOSSIP_EVENT_COUNT)
             {
-                if (!eObjectMgr->GetItemTemplate(entry))
-                {
-                    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                    luaL_error(L, "Couldn't find a item with (ID: %d)!", entry);
-                    return 0; // Stack: (empty)
-                }
+                if (!sObjectMgr->GetItemTemplate(entry))
+                    throw std::invalid_argument(Acore::StringFormat("Couldn't find an item with (ID: {})!", entry));
 
-                auto key = EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry);
-                bindingID = ItemGossipBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, ItemGossipBindings);
-                return 1; // Stack: callback
+                return bind(ItemGossipBindings, EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry));
             }
             break;
 
         case Hooks::REGTYPE_PLAYER_GOSSIP:
             if (event_id < Hooks::GOSSIP_EVENT_COUNT)
-            {
-                auto key = EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry);
-                bindingID = PlayerGossipBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, PlayerGossipBindings);
-                return 1; // Stack: callback
-            }
+                return bind(PlayerGossipBindings, EntryKey<Hooks::GossipEvents>((Hooks::GossipEvents)event_id, entry));
             break;
 
         case Hooks::REGTYPE_MAP:
             if (event_id < Hooks::INSTANCE_EVENT_COUNT)
-            {
-                auto key = EntryKey<Hooks::InstanceEvents>((Hooks::InstanceEvents)event_id, entry);
-                bindingID = MapEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, MapEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(MapEventBindings, EntryKey<Hooks::InstanceEvents>((Hooks::InstanceEvents)event_id, entry));
             break;
 
         case Hooks::REGTYPE_INSTANCE:
             if (event_id < Hooks::INSTANCE_EVENT_COUNT)
-            {
-                auto key = EntryKey<Hooks::InstanceEvents>((Hooks::InstanceEvents)event_id, entry);
-                bindingID = InstanceEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, InstanceEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(InstanceEventBindings, EntryKey<Hooks::InstanceEvents>((Hooks::InstanceEvents)event_id, entry));
             break;
 
-      case Hooks::REGTYPE_TICKET:
+        case Hooks::REGTYPE_TICKET:
             if (event_id < Hooks::TICKET_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::TicketEvents>((Hooks::TicketEvents)event_id);
-                bindingID = TicketEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, TicketEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(TicketEventBindings, EventKey<Hooks::TicketEvents>((Hooks::TicketEvents)event_id));
             break;
 
         case Hooks::REGTYPE_SPELL:
             if (event_id < Hooks::SPELL_EVENT_COUNT)
             {
                 if (!sSpellMgr->GetSpellInfo(entry))
-                {
-                    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-                    luaL_error(L, "Couldn't find a spell with (ID: %d)!", entry);
-                    return 0; // Stack: (empty)
-                }
+                    throw std::invalid_argument(Acore::StringFormat("Couldn't find a spell with (ID: {})!", entry));
 
-                auto key = EntryKey<Hooks::SpellEvents>((Hooks::SpellEvents)event_id, entry);
-                bindingID = SpellEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, SpellEventBindings);
-                return 1; // Stack: callback
+                return bind(SpellEventBindings, EntryKey<Hooks::SpellEvents>((Hooks::SpellEvents)event_id, entry));
             }
             break;
 
         case Hooks::REGTYPE_ALL_CREATURE:
             if (event_id < Hooks::ALL_CREATURE_EVENT_COUNT)
-            {
-                auto key = EventKey<Hooks::AllCreatureEvents>((Hooks::AllCreatureEvents)event_id);
-                bindingID = AllCreatureEventBindings->Insert(key, functionRef, shots);
-                createCancelCallback(L, bindingID, AllCreatureEventBindings);
-                return 1; // Stack: callback
-            }
+                return bind(AllCreatureEventBindings, EventKey<Hooks::AllCreatureEvents>((Hooks::AllCreatureEvents)event_id));
             break;
     }
-    luaL_unref(L, LUA_REGISTRYINDEX, functionRef);
-    std::ostringstream oss;
-    oss << "regtype " << static_cast<uint32>(regtype) << ", event " << event_id << ", entry " << entry << ", guid " << guid.GetRawValue() << ", instance " << instanceId;
-    luaL_error(L, "Unknown event type (%s)", oss.str().c_str());
-    return 0;
-}
-
-/*
- * Cleans up the stack, effectively undoing all Push calls and the Setup call.
- */
-void ALE::CleanUpStack(int number_of_arguments)
-{
-    // Stack: event_id, [arguments]
 
-    lua_pop(L, number_of_arguments + 1); // Add 1 because the caller doesn't know about `event_id`.
-    // Stack: (empty)
-
-    if (event_level == 0)
-        InvalidateObjects();
-}
-
-/*
- * Call a single event handler that was put on the stack with `Setup` and removes it from the stack.
- *
- * The caller is responsible for keeping track of how many times this should be called.
- */
-int ALE::CallOneFunction(int number_of_functions, int number_of_arguments, int number_of_results)
-{
-    ++number_of_arguments; // Caller doesn't know about `event_id`.
-    ASSERT(number_of_functions > 0 && number_of_arguments > 0 && number_of_results >= 0);
-    // Stack: event_id, [arguments], [functions]
-
-    int functions_top        = lua_gettop(L);
-    int first_function_index = functions_top - number_of_functions + 1;
-    int arguments_top        = first_function_index - 1;
-    int first_argument_index = arguments_top - number_of_arguments + 1;
-
-    // Copy the arguments from the bottom of the stack to the top.
-    for (int argument_index = first_argument_index; argument_index <= arguments_top; ++argument_index)
-    {
-        lua_pushvalue(L, argument_index);
-    }
-    // Stack: event_id, [arguments], [functions], event_id, [arguments]
-
-    ExecuteCall(number_of_arguments, number_of_results);
-    --functions_top;
-    // Stack: event_id, [arguments], [functions - 1], [results]
-
-    return functions_top + 1; // Return the location of the first result (if any exist).
+    throw std::invalid_argument(Acore::StringFormat(
+        "Unknown event type (regtype {}, event {}, entry {}, guid {}, instance {})",
+        regtype, event_id, entry, guid.GetRawValue(), instanceId));
 }
 
 CreatureAI* ALE::GetAI(Creature* creature)
 {
     if (!ALEConfig::GetInstance().IsALEEnabled())
-        return NULL;
+        return nullptr;
 
     for (int i = 1; i < Hooks::CREATURE_EVENT_COUNT; ++i)
     {
         Hooks::CreatureEvents event_id = (Hooks::CreatureEvents)i;
 
         auto entryKey = EntryKey<Hooks::CreatureEvents>(event_id, creature->GetEntry());
-        auto uniqueKey = UniqueObjectKey<Hooks::CreatureEvents>(event_id, creature->GET_GUID(), creature->GetInstanceId());
+        auto uniqueKey = UniqueObjectKey<Hooks::CreatureEvents>(event_id, creature->GetGUID(), creature->GetInstanceId());
 
         if (CreatureEventBindings->HasBindingsFor(entryKey) ||
             CreatureUniqueBindings->HasBindingsFor(uniqueKey))
             return new ALECreatureAI(creature);
     }
 
-    return NULL;
+    return nullptr;
 }
 
 InstanceData* ALE::GetInstanceData(Map* map)
 {
     if (!ALEConfig::GetInstance().IsALEEnabled())
-        return NULL;
+        return nullptr;
 
     for (int i = 1; i < Hooks::INSTANCE_EVENT_COUNT; ++i)
     {
@@ -1630,52 +648,40 @@ InstanceData* ALE::GetInstanceData(Map* map)
             return new ALEInstanceAI(map);
     }
 
-    return NULL;
+    return nullptr;
 }
 
 bool ALE::HasInstanceData(Map const* map)
 {
     if (!map->Instanceable())
         return continentDataRefs.find(map->GetId()) != continentDataRefs.end();
-    else
-        return instanceDataRefs.find(map->GetInstanceId()) != instanceDataRefs.end();
+
+    return instanceDataRefs.find(map->GetInstanceId()) != instanceDataRefs.end();
 }
 
-void ALE::CreateInstanceData(Map const* map)
+void ALE::CreateInstanceData(Map const* map, sol::table data)
 {
-    ASSERT(lua_istable(L, -1));
-    int ref = luaL_ref(L, LUA_REGISTRYINDEX);
-
+    // Overwriting an existing entry releases the previous table automatically.
     if (!map->Instanceable())
-    {
-        uint32 mapId = map->GetId();
-
-        // If there's another table that was already stored for the map, unref it.
-        auto mapRef = continentDataRefs.find(mapId);
-        if (mapRef != continentDataRefs.end())
-        {
-            luaL_unref(L, LUA_REGISTRYINDEX, mapRef->second);
-        }
-
-        continentDataRefs[mapId] = ref;
-    }
+        continentDataRefs[map->GetId()] = std::move(data);
     else
-    {
-        uint32 instanceId = map->GetInstanceId();
+        instanceDataRefs[map->GetInstanceId()] = std::move(data);
+}
 
-        // If there's another table that was already stored for the instance, unref it.
-        auto instRef = instanceDataRefs.find(instanceId);
-        if (instRef != instanceDataRefs.end())
-        {
-            luaL_unref(L, LUA_REGISTRYINDEX, instRef->second);
-        }
+sol::table ALE::GetInstanceData(ALEInstanceAI* ai)
+{
+    // Check if the instance data is missing (i.e. someone reloaded ALE).
+    if (!HasInstanceData(ai->instance))
+        ai->Reload();
 
-        instanceDataRefs[instanceId] = ref;
-    }
+    if (!ai->instance->Instanceable())
+        return continentDataRefs[ai->instance->GetId()];
+
+    return instanceDataRefs[ai->instance->GetInstanceId()];
 }
 
 /*
- * Unrefs the instanceId related events and data
+ * Releases the instanceId related events and data.
  * Does all required actions for when an instance is freed.
  */
 void ALE::FreeInstanceId(uint32 instanceId)
@@ -1689,34 +695,9 @@ void ALE::FreeInstanceId(uint32 instanceId)
     {
         auto key = EntryKey<Hooks::InstanceEvents>((Hooks::InstanceEvents)i, instanceId);
 
-        if (MapEventBindings->HasBindingsFor(key))
-            MapEventBindings->Clear(key);
-
-        if (InstanceEventBindings->HasBindingsFor(key))
-            InstanceEventBindings->Clear(key);
-
-        if (instanceDataRefs.find(instanceId) != instanceDataRefs.end())
-        {
-            luaL_unref(L, LUA_REGISTRYINDEX, instanceDataRefs[instanceId]);
-            instanceDataRefs.erase(instanceId);
-        }
+        MapEventBindings->Clear(key);
+        InstanceEventBindings->Clear(key);
     }
-}
-
-void ALE::PushInstanceData(lua_State* L, ALEInstanceAI* ai, bool incrementCounter)
-{
-    // Check if the instance data is missing (i.e. someone reloaded ALE).
-    if (!HasInstanceData(ai->instance))
-        ai->Reload();
-
-    // Get the instance data table from the registry.
-    if (!ai->instance->Instanceable())
-        lua_rawgeti(L, LUA_REGISTRYINDEX, continentDataRefs[ai->instance->GetId()]);
-    else
-        lua_rawgeti(L, LUA_REGISTRYINDEX, instanceDataRefs[ai->instance->GetInstanceId()]);
-
-    ASSERT(lua_istable(L, -1));
 
-    if (incrementCounter)
-        ++push_counter;
+    instanceDataRefs.erase(instanceId);
 }
diff --git a/src/LuaEngine/LuaEngine.h b/src/LuaEngine/LuaEngine.h
index a21640d0e4..74c6fef4a5 100644
--- a/src/LuaEngine/LuaEngine.h
+++ b/src/LuaEngine/LuaEngine.h
@@ -18,24 +18,24 @@
 #include "Weather.h"
 #include "World.h"
 #include "Hooks.h"
-#include "LFG.h"
+#include "ALEBind.h"
+#include "ALEConfig.h"
+#include "ALEFileWatcher.h"
+#include "ALEHandles.h"
 #include "ALEUtility.h"
-#include "HttpManager.h"
+#include "BindingMap.h"
 #include "EventEmitter.h"
-#include "TicketMgr.h"
+#include "HttpManager.h"
+#include "LFG.h"
 #include "LootMgr.h"
-#include "ALEFileWatcher.h"
-#include "ALEConfig.h"
-#include <mutex>
+#include "TicketMgr.h"
+
+#include <sol/sol.hpp>
+
 #include <memory>
-#include <vector>
-#include <ctime>
+#include <mutex>
 #include <unordered_map>
-
-extern "C"
-{
-#include <lua.h>
-};
+#include <vector>
 
 struct ItemTemplate;
 typedef BattlegroundTypeId BattleGroundTypeId;
@@ -49,7 +49,6 @@ class Corpse;
 class Creature;
 class CreatureAI;
 class GameObject;
-class GameObjectAI;
 class Guild;
 class Group;
 class InstanceScript;
@@ -62,36 +61,12 @@ class Quest;
 class Spell;
 class SpellCastTargets;
 class TempSummon;
-// class Transport;
 class Unit;
 class Weather;
 class WorldPacket;
 class Vehicle;
 
-struct lua_State;
 class EventMgr;
-class ALEObject;
-template<typename T> class ALETemplate;
-
-template<typename K> class BindingMap;
-template<typename T> struct EventKey;
-template<typename T> struct EntryKey;
-template<typename T> struct UniqueObjectKey;
-
-// Type definition for bytecode buffer
-typedef std::vector<uint8> BytecodeBuffer;
-
-// Global bytecode cache entry
-struct GlobalCacheEntry
-{
-    BytecodeBuffer bytecode;
-    std::time_t last_modified;
-    std::string filepath;
-    
-    GlobalCacheEntry() : last_modified(0) {}
-    GlobalCacheEntry(const BytecodeBuffer& code, std::time_t modTime, const std::string& path)
-        : bytecode(code), last_modified(modTime), filepath(path) {}
-};
 
 struct LuaScript
 {
@@ -99,12 +74,9 @@ struct LuaScript
     std::string filename;
     std::string filepath;
     std::string modulepath;
-    LuaScript() {}
 };
 
-#define ALE_STATE_PTR "ALE State Ptr"
 #define LOCK_ALE ALE::Guard __guard(ALE::GetLock())
-
 #define ALE_GAME_API AC_GAME_API
 
 class ALE_GAME_API ALE
@@ -130,27 +102,23 @@ class ALE_GAME_API ALE
 
     // Lua script folder path
     static std::string lua_folderpath;
-    // lua path variable for require() function
+    // lua path variables for the require() function
     static std::string lua_requirepath;
     static std::string lua_requirecpath;
 
-    // A counter for lua event stacks that occur (see event_level).
-    // This is used to determine whether an object belongs to the current call stack or not.
-    // 0 is reserved for always belonging to the call stack
-    // 1 is reserved for a non valid callstackid
-    uint64 callstackid = 2;
-    // A counter for the amount of nested events. When the event_level
-    // reaches 0 we are about to return back to C++. At this point the
-    // objects used during the event stack are invalidated.
-    uint32 event_level;
-    // When a hook pushes arguments to be passed to event handlers,
-    //  this is used to keep track of how many arguments were pushed.
-    uint8 push_counter;
-
-    // Map from instance ID -> Lua table ref
-    std::unordered_map<uint32, int> instanceDataRefs;
-    // Map from map ID -> Lua table ref
-    std::unordered_map<uint32, int> continentDataRefs;
+    // Depth of nested event dispatches. When it drops back to 0 the engine
+    // returns to C++ and the handle pointer caches are retired
+    // (see ALEHandleEpoch in ALEHandles.h).
+    uint32 event_level = 0;
+
+    // Whether OpenLua() ran: a sol::state member always exists, but scripts
+    // and bindings are only loaded into it while the engine is enabled.
+    bool stateOpened = false;
+
+    // Per-map instance data tables, kept alive by sol references.
+    std::unordered_map<uint32, sol::table> instanceDataRefs;
+    // Per-continent data tables (map id -> table).
+    std::unordered_map<uint32, sol::table> continentDataRefs;
 
     ALE();
     ~ALE();
@@ -163,7 +131,6 @@ class ALE_GAME_API ALE
     void CloseLua();
     void DestroyBindStores();
     void CreateBindStores();
-    void InvalidateObjects();
 
     // Use ReloadALE() to make ALE reload
     // This is called on world update to reload ALE
@@ -171,96 +138,61 @@ class ALE_GAME_API ALE
     static void LoadScriptPaths();
     static void GetScripts(std::string path);
     static void AddScriptPath(std::string filename, const std::string& fullpath);
-    static int LoadCompiledScript(lua_State* L, const std::string& filepath);
-    static std::time_t GetFileModTime(const std::string& filepath);
-    static std::time_t GetFileModTimeWithCache(const std::string& filepath);
-    
-    // Global cache management
-    static bool CompileScriptToGlobalCache(const std::string& filepath);
-    static bool CompileMoonScriptToGlobalCache(const std::string& filepath);
-    static int TryLoadFromGlobalCache(lua_State* L, const std::string& filepath);
-    static int LoadScriptWithCache(lua_State* L, const std::string& filepath, bool isMoonScript, uint32* compiledCount = nullptr, uint32* cachedCount = nullptr);
-    static void ClearGlobalCache();
-    static void ClearTimestampCache();
-    static size_t GetGlobalCacheSize();
-
-    static int StackTrace(lua_State *_L);
-    static void Report(lua_State* _L);
-
-    // Some helpers for hooks to call event handlers.
-    // The bodies of the templates are in HookHelpers.h, so if you want to use them you need to #include "HookHelpers.h".
-    template<typename K1, typename K2> int SetupStack(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, int number_of_arguments);
-                                       int CallOneFunction(int number_of_functions, int number_of_arguments, int number_of_results);
-                                       void CleanUpStack(int number_of_arguments);
-    template<typename T>               void ReplaceArgument(T value, uint8 index);
-    template<typename K1, typename K2> void CallAllFunctions(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2);
-    template<typename K1, typename K2> bool CallAllFunctionsBool(BindingMap<K1>* bindings1, BindingMap<K2>* bindings2, const K1& key1, const K2& key2, bool default_value = false);
-
-    // Same as above but for only one binding instead of two.
-    // `key` is passed twice because there's no NULL for references, but it's not actually used if `bindings2` is NULL.
-    template<typename K> int SetupStack(BindingMap<K>* bindings, const K& key, int number_of_arguments)
-    {
-        return SetupStack<K, K>(bindings, NULL, key, key, number_of_arguments);
-    }
-    template<typename K> void CallAllFunctions(BindingMap<K>* bindings, const K& key)
-    {
-        CallAllFunctions<K, K>(bindings, NULL, key, key);
-    }
-    template<typename K> bool CallAllFunctionsBool(BindingMap<K>* bindings, const K& key, bool default_value = false)
+
+    // RAII marker of one nested dispatch level; retires handle caches when the
+    // outermost handler returns, even if argument conversion or the call throws.
+    struct DispatchGuard
     {
-        return CallAllFunctionsBool<K, K>(bindings, NULL, key, key, default_value);
-    }
+        explicit DispatchGuard(ALE* engine) : _engine(engine) { ++_engine->event_level; }
+        ~DispatchGuard()
+        {
+            if (--_engine->event_level == 0)
+                ALEHandleEpoch::Bump();
+        }
+
+        DispatchGuard(DispatchGuard const&) = delete;
+        DispatchGuard& operator=(DispatchGuard const&) = delete;
+
+    private:
+        ALE* _engine;
+    };
 
-    // Non-static pushes, to be used in hooks.
-    // These just call the correct static version with the main thread's Lua state.
-    void Push()                                 { Push(L); ++push_counter; }
-    void Push(const long long value)            { Push(L, value); ++push_counter; }
-    void Push(const unsigned long long value)   { Push(L, value); ++push_counter; }
-    void Push(const long value)                 { Push(L, value); ++push_counter; }
-    void Push(const unsigned long value)        { Push(L, value); ++push_counter; }
-    void Push(const int value)                  { Push(L, value); ++push_counter; }
-    void Push(const unsigned int value)         { Push(L, value); ++push_counter; }
-    void Push(const bool value)                 { Push(L, value); ++push_counter; }
-    void Push(const float value)                { Push(L, value); ++push_counter; }
-    void Push(const double value)               { Push(L, value); ++push_counter; }
-    void Push(const std::string& value)         { Push(L, value); ++push_counter; }
-    void Push(const char* value)                { Push(L, value); ++push_counter; }
-    void Push(ObjectGuid const value)           { Push(L, value); ++push_counter; }
-    void Push(const CreatureTemplate* value)    { Push(L, value); ++push_counter; }
-    template<typename T>
-    void Push(T const* ptr)                     { Push(L, ptr); ++push_counter; }
+    // Reports a failed handler call to the log and the OnError emitter.
+    void Report(sol::error const& error);
 
 public:
     static ALE* GALE;
 
-    lua_State* L;
+    // The Lua state. Bindings and hooks go through sol, never the raw C API.
+    sol::state lua;
+
     EventMgr* eventMgr;
     HttpManager httpManager;
     QueryCallbackProcessor queryProcessor;
     EventEmitter<void(std::string)> OnError;
 
-    BindingMap< EventKey<Hooks::ServerEvents> >*        ServerEventBindings;
-    BindingMap< EventKey<Hooks::PlayerEvents> >*        PlayerEventBindings;
-    BindingMap< EventKey<Hooks::GuildEvents> >*         GuildEventBindings;
-    BindingMap< EventKey<Hooks::GroupEvents> >*         GroupEventBindings;
-    BindingMap< EventKey<Hooks::VehicleEvents> >*       VehicleEventBindings;
-    BindingMap< EventKey<Hooks::BGEvents> >*            BGEventBindings;
-    BindingMap< EventKey<Hooks::AllCreatureEvents> >*   AllCreatureEventBindings;
-
-    BindingMap< EntryKey<Hooks::PacketEvents> >*        PacketEventBindings;
-    BindingMap< EntryKey<Hooks::CreatureEvents> >*      CreatureEventBindings;
-    BindingMap< EntryKey<Hooks::GossipEvents> >*        CreatureGossipBindings;
-    BindingMap< EntryKey<Hooks::GameObjectEvents> >*    GameObjectEventBindings;
-    BindingMap< EntryKey<Hooks::GossipEvents> >*        GameObjectGossipBindings;
-    BindingMap< EntryKey<Hooks::ItemEvents> >*          ItemEventBindings;
-    BindingMap< EntryKey<Hooks::GossipEvents> >*        ItemGossipBindings;
-    BindingMap< EntryKey<Hooks::GossipEvents> >*        PlayerGossipBindings;
-    BindingMap< EntryKey<Hooks::InstanceEvents> >*      MapEventBindings;
-    BindingMap< EntryKey<Hooks::InstanceEvents> >*      InstanceEventBindings;
-    BindingMap< EventKey<Hooks::TicketEvents> >*        TicketEventBindings;
-    BindingMap< EntryKey<Hooks::SpellEvents> >*         SpellEventBindings;
-
-    BindingMap< UniqueObjectKey<Hooks::CreatureEvents> >*  CreatureUniqueBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::ServerEvents>>>      ServerEventBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::PlayerEvents>>>      PlayerEventBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::GuildEvents>>>       GuildEventBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::GroupEvents>>>       GroupEventBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::VehicleEvents>>>     VehicleEventBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::BGEvents>>>          BGEventBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::TicketEvents>>>      TicketEventBindings;
+    std::unique_ptr<BindingMap<EventKey<Hooks::AllCreatureEvents>>> AllCreatureEventBindings;
+
+    std::unique_ptr<BindingMap<EntryKey<Hooks::PacketEvents>>>      PacketEventBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::CreatureEvents>>>    CreatureEventBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::GossipEvents>>>      CreatureGossipBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::GameObjectEvents>>>  GameObjectEventBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::GossipEvents>>>      GameObjectGossipBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::ItemEvents>>>        ItemEventBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::GossipEvents>>>      ItemGossipBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::GossipEvents>>>      PlayerGossipBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::InstanceEvents>>>    MapEventBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::InstanceEvents>>>    InstanceEventBindings;
+    std::unique_ptr<BindingMap<EntryKey<Hooks::SpellEvents>>>       SpellEventBindings;
+
+    std::unique_ptr<BindingMap<UniqueObjectKey<Hooks::CreatureEvents>>> CreatureUniqueBindings;
 
     static void Initialize();
     static void Uninitialize();
@@ -268,98 +200,184 @@ class ALE_GAME_API ALE
     static void ReloadALE() { LOCK_ALE; reload = true; }
     static LockType& GetLock() { return lock; };
     static bool IsInitialized() { return initialized; }
-    // Never returns nullptr
-    static ALE* GetALE(lua_State* L)
+
+    void RunScripts();
+    bool ShouldReload() const { return reload; }
+    bool HasLuaState() const { return stateOpened; }
+
+    /*
+     * Registers a Lua handler for an event. Called from the Register* global
+     * functions exposed to scripts. Returns a callable that cancels the
+     * registration, or raises a Lua error on invalid arguments.
+     */
+    sol::object Register(uint8 regtype, uint32 entry, ObjectGuid guid, uint32 instanceId,
+        uint32 event_id, sol::protected_function callback, uint32 shots);
+
+    // -----------------------------------------------------------------
+    // Event dispatch
+    //
+    // Every game object argument is automatically wrapped into its safe
+    // handle (see ALEBind.h); plain values pass through unchanged.
+    // -----------------------------------------------------------------
+
+    // Calls one handler with (event_id, args...); reports errors.
+    // Returns an invalid result when the handler raised an error.
+    template<typename E, typename... Args>
+    sol::protected_function_result Call(sol::protected_function const& callback, E event_id, Args&&... args)
     {
-        lua_pushstring(L, ALE_STATE_PTR);
-        lua_rawget(L, LUA_REGISTRYINDEX);
-        ASSERT(lua_islightuserdata(L, -1));
-        ALE* E = static_cast<ALE*>(lua_touserdata(L, -1));
-        lua_pop(L, 1);
-        ASSERT(E);
-        return E;
+        DispatchGuard guard(this);
+        sol::protected_function_result result = callback(event_id, ALEBind::ToLua(lua, std::forward<Args>(args))...);
+
+        if (!result.valid())
+            Report(sol::error(result));
+
+        return result;
     }
 
-    // Static pushes, can be used by anything, including methods.
-    static void Push(lua_State* luastate); // nil
-    static void Push(lua_State* luastate, const long long);
-    static void Push(lua_State* luastate, const unsigned long long);
-    static void Push(lua_State* luastate, const long);
-    static void Push(lua_State* luastate, const unsigned long);
-    static void Push(lua_State* luastate, const int);
-    static void Push(lua_State* luastate, const unsigned int);
-    static void Push(lua_State* luastate, const bool);
-    static void Push(lua_State* luastate, const float);
-    static void Push(lua_State* luastate, const double);
-    static void Push(lua_State* luastate, const std::string&);
-    static void Push(lua_State* luastate, const char*);
-    static void Push(lua_State* luastate, Object const* obj);
-    static void Push(lua_State* luastate, WorldObject const* obj);
-    static void Push(lua_State* luastate, Unit const* unit);
-    static void Push(lua_State* luastate, Pet const* pet);
-    static void Push(lua_State* luastate, TempSummon const* summon);
-    static void Push(lua_State* luastate, ObjectGuid const guid);
-    static void Push(lua_State* luastate, GemPropertiesEntry const& gemProperties);
-    static void Push(lua_State* luastate, SpellEntry const& spell);
-    static void Push(lua_State* luastate, CreatureTemplate const* creatureTemplate);
-    template<typename T>
-    static void Push(lua_State* luastate, T const* ptr)
+    // Calls a plain Lua callback (no event id prepended); reports errors.
+    // Used for timed events, HTTP responses, async query results, ...
+    template<typename... Args>
+    sol::protected_function_result CallFunction(sol::protected_function const& callback, Args&&... args)
     {
-        ALETemplate<T>::Push(luastate, ptr);
+        DispatchGuard guard(this);
+        sol::protected_function_result result = callback(ALEBind::ToLua(lua, std::forward<Args>(args))...);
+
+        if (!result.valid())
+            Report(sol::error(result));
+
+        return result;
     }
 
-    static std::string FormatQuery(lua_State* L, const char* query);
+    // Calls every handler bound to `key`, ignoring their results.
+    template<typename K, typename... Args>
+    void CallAll(BindingMap<K>& bindings, K const& key, Args&&... args)
+    {
+        for (sol::protected_function const& callback : bindings.GetCallbacksFor(key))
+            Call(callback, key.event_id, args...);
+    }
 
-    bool ExecuteCall(int params, int res);
+    // Same, for events bound in two maps (creature entry + unique creature).
+    template<typename K1, typename K2, typename... Args>
+    void CallAll(BindingMap<K1>& bindings1, BindingMap<K2>& bindings2, K1 const& key1, K2 const& key2, Args&&... args)
+    {
+        CallAll(bindings1, key1, args...);
+        CallAll(bindings2, key2, args...);
+    }
 
     /*
-     * Returns `true` if ALE has instance data for `map`.
+     * Calls every handler bound to `key` and folds their first return value:
+     * returns `default_value` if every handler returned it (or nothing),
+     * the opposite as soon as one handler disagrees.
+     *
+     * With default_value = false this implements the usual "return true to
+     * override default behaviour" hook contract.
      */
-    bool HasInstanceData(Map const* map);
+    template<typename K, typename... Args>
+    bool CallAllBool(BindingMap<K>& bindings, K const& key, bool default_value, Args&&... args)
+    {
+        bool result = default_value;
 
-    /*
-     * Use the top element of the stack as the instance data table for `map`,
-     *   then pops it off the stack.
-     */
-    void CreateInstanceData(Map const* map);
+        for (sol::protected_function const& callback : bindings.GetCallbacksFor(key))
+        {
+            sol::protected_function_result callResult = Call(callback, key.event_id, args...);
+            if (!callResult.valid())
+                continue;
+
+            if (sol::optional<bool> value = callResult.get<sol::optional<bool>>(0))
+                if (*value != default_value)
+                    result = !default_value;
+        }
+
+        return result;
+    }
+
+    // Same, for events bound in two maps (creature entry + unique creature).
+    template<typename K1, typename K2, typename... Args>
+    bool CallAllBool(BindingMap<K1>& bindings1, BindingMap<K2>& bindings2, K1 const& key1, K2 const& key2,
+        bool default_value, Args&&... args)
+    {
+        bool result1 = CallAllBool(bindings1, key1, default_value, args...);
+        bool result2 = CallAllBool(bindings2, key2, default_value, args...);
+        return (result1 != default_value || result2 != default_value) ? !default_value : default_value;
+    }
 
     /*
-     * Retrieve the instance data for the `Map` scripted by `ai` and push it
-     *   onto the stack.
+     * Calls every handler bound to `key` and threads `value` through them:
+     * a handler that returns a value of type V replaces it for the handlers
+     * after it. Returns the final value.
      *
-     * An `ALEInstanceAI` is needed because the instance data might
-     *   not exist (i.e. ALE has been reloaded).
+     * `invoke` receives (handler, current value) and performs the call, so
+     * the caller decides where the value sits among the arguments:
      *
-     * In that case, the AI is "reloaded" (new instance data table is created
-     *   and loaded with the last known save state, and `Load`/`Initialize`
-     *   hooks are called).
+     *     damage = CallAllFold(*bindings, key, damage, [&](auto const& callback, uint32 current)
+     *     {
+     *         return Call(callback, key.event_id, me, target, current, spellInfo);
+     *     });
      */
-    void PushInstanceData(lua_State* L, ALEInstanceAI* ai, bool incrementCounter = true);
-
-    void RunScripts();
-    bool ShouldReload() const { return reload; }
-    bool HasLuaState() const { return L != NULL; }
-    uint64 GetCallstackId() const { return callstackid; }
-    int Register(lua_State* L, uint8 reg, uint32 entry, ObjectGuid guid, uint32 instanceId, uint32 event_id, int functionRef, uint32 shots);
+    template<typename K, typename V, typename Invoker>
+    V CallAllFold(BindingMap<K>& bindings, K const& key, V value, Invoker&& invoke)
+    {
+        return FoldCallbacks(bindings.GetCallbacksFor(key), value, std::forward<Invoker>(invoke));
+    }
 
-    // Checks
-    template<typename T> static T CHECKVAL(lua_State* luastate, int narg);
-    template<typename T> static T CHECKVAL(lua_State* luastate, int narg, T def)
+    // Same fold over an explicit handler snapshot, for events bound in two
+    // maps (see GetCreatureCallbacks).
+    template<typename V, typename Invoker>
+    V FoldCallbacks(std::vector<sol::protected_function> const& callbacks, V value, Invoker&& invoke)
     {
-        return lua_isnoneornil(luastate, narg) ? def : CHECKVAL<T>(luastate, narg);
+        for (sol::protected_function const& callback : callbacks)
+        {
+            sol::protected_function_result result = invoke(callback, value);
+            if (!result.valid())
+                continue;
+
+            if (sol::optional<V> newValue = result.get<sol::optional<V>>(0))
+                value = *newValue;
+        }
+
+        return value;
     }
-    template<typename T> static T* CHECKOBJ(lua_State* luastate, int narg, bool error = true)
+
+    /*
+     * Returns the merged handler snapshot for a creature event bound by entry
+     * and/or by unique spawn, for hooks that need to inspect each handler's
+     * results themselves (modified damage, multiple return values, ...).
+     */
+    std::vector<sol::protected_function> GetCreatureCallbacks(
+        EntryKey<Hooks::CreatureEvents> const& entryKey, UniqueObjectKey<Hooks::CreatureEvents> const& uniqueKey)
     {
-        return ALETemplate<T>::Check(luastate, narg, error);
+        std::vector<sol::protected_function> callbacks = CreatureEventBindings->GetCallbacksFor(entryKey);
+        std::vector<sol::protected_function> unique = CreatureUniqueBindings->GetCallbacksFor(uniqueKey);
+        callbacks.insert(callbacks.end(), unique.begin(), unique.end());
+        return callbacks;
     }
-    static ALEObject* CHECKTYPE(lua_State* luastate, int narg, const char *tname, bool error = true);
+
+    /*
+     * Returns `true` if ALE has instance data for `map`.
+     */
+    bool HasInstanceData(Map const* map);
+
+    /*
+     * Stores `data` as the instance data table for `map`.
+     */
+    void CreateInstanceData(Map const* map, sol::table data);
+
+    /*
+     * Retrieves the instance data table for the `Map` scripted by `ai`.
+     *
+     * An `ALEInstanceAI` is needed because the instance data might not exist
+     * (i.e. ALE has been reloaded). In that case the AI is "reloaded" (a new
+     * instance data table is created and loaded with the last known save
+     * state, and `Load`/`Initialize` hooks are called).
+     */
+    sol::table GetInstanceData(ALEInstanceAI* ai);
 
     CreatureAI* GetAI(Creature* creature);
     InstanceData* GetInstanceData(Map* map);
     void FreeInstanceId(uint32 instanceId);
 
     /* Custom */
-    void OnTimedEvent(int funcRef, uint32 delay, uint32 calls, WorldObject* obj);
+    void OnTimedEvent(sol::protected_function const& callback, uint64 eventId, uint32 delay, uint32 calls, WorldObject* obj);
     bool OnCommand(ChatHandler& handler, const char* text);
     void OnWorldUpdate(uint32 diff);
     void OnLootItem(Player* pPlayer, Item* pItem, uint32 count, ObjectGuid guid);
@@ -475,6 +493,8 @@ class ALE_GAME_API ALE
     bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Guild* pGuild);
     bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Channel* pChannel);
     bool OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Player* pReceiver);
+    bool DispatchChatEvent(EventKey<Hooks::PlayerEvents> const& key, Player* pPlayer, std::string& msg,
+        uint32 type, uint32 lang, sol::optional<sol::object> extra);
     void OnEmote(Player* pPlayer, uint32 emote);
     void OnTextEmote(Player* pPlayer, uint32 textEmote, uint32 emoteNum, ObjectGuid guid);
     void OnPlayerSpellCast(Player* pPlayer, Spell* pSpell, bool skipCheck);
@@ -597,7 +617,7 @@ class ALE_GAME_API ALE
     void OnTicketClose(GmTicket* ticket);
     void OnTicketUpdateLastChange(GmTicket* ticket);
     void OnTicketResolve(GmTicket* ticket);
-  
+
     /* Spell */
     void OnSpellPrepare(Unit* caster, Spell* spell, SpellInfo const* spellInfo);
     void OnSpellCast(Unit* caster, Spell* spell, SpellInfo const* spellInfo, bool skipCheck);
@@ -618,10 +638,7 @@ class ALE_GAME_API ALE
     void OnAllCreatureModifyHealReceived(Creature* me, Unit* target, uint32& heal, SpellInfo const* spellInfo);
     uint32 OnAllCreatureDealDamage(Creature* me, Unit* pVictim, uint32 damage, DamageEffectType damagetype);
 };
-template<> Unit* ALE::CHECKOBJ<Unit>(lua_State* L, int narg, bool error);
-template<> Object* ALE::CHECKOBJ<Object>(lua_State* L, int narg, bool error);
-template<> WorldObject* ALE::CHECKOBJ<WorldObject>(lua_State* L, int narg, bool error);
-template<> ALEObject* ALE::CHECKOBJ<ALEObject>(lua_State* L, int narg, bool error);
 
 #define sALE ALE::GALE
-#endif
+
+#endif // _LUA_ENGINE_H
diff --git a/src/LuaEngine/LuaFunctions.cpp b/src/LuaEngine/LuaFunctions.cpp
index c0acc013a4..49eff2fa58 100644
--- a/src/LuaEngine/LuaFunctions.cpp
+++ b/src/LuaEngine/LuaFunctions.cpp
@@ -4,1994 +4,173 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-extern "C"
-{
-#include "lua.h"
-};
-
-// ALE
 #include "LuaEngine.h"
-#include "ALEEventMgr.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
-#include "ALEUtility.h"
-
-// Method includes
-#include "GlobalMethods.h"
-#include "ObjectMethods.h"
-#include "WorldObjectMethods.h"
-#include "UnitMethods.h"
-#include "PlayerMethods.h"
-#include "CreatureMethods.h"
-#include "GroupMethods.h"
-#include "GuildMethods.h"
-#include "GameObjectMethods.h"
-#include "ALEQueryMethods.h"
-#include "AuraMethods.h"
-#include "ItemMethods.h"
-#include "WorldPacketMethods.h"
-#include "SpellMethods.h"
-#include "QuestMethods.h"
-#include "MapMethods.h"
-#include "CorpseMethods.h"
-#include "VehicleMethods.h"
-#include "BattleGroundMethods.h"
-#include "ChatHandlerMethods.h"
-#include "AchievementMethods.h"
-#include "ItemTemplateMethods.h"
-#include "RollMethods.h"
-#include "TicketMethods.h"
-#include "SpellInfoMethods.h"
-#include "PetMethods.h"
-#include "LootMethods.h"
-#include "TransportMethods.h"
-
-// DBCStores includes
-#include "GemPropertiesEntryMethods.h"
-#include "SpellEntryMethods.h"
-
-luaL_Reg GlobalMethods[] =
-{
-    // Hooks
-    { "RegisterPacketEvent", &LuaGlobalFunctions::RegisterPacketEvent },
-    { "RegisterServerEvent", &LuaGlobalFunctions::RegisterServerEvent },
-    { "RegisterPlayerEvent", &LuaGlobalFunctions::RegisterPlayerEvent },
-    { "RegisterGuildEvent", &LuaGlobalFunctions::RegisterGuildEvent },
-    { "RegisterGroupEvent", &LuaGlobalFunctions::RegisterGroupEvent },
-    { "RegisterCreatureEvent", &LuaGlobalFunctions::RegisterCreatureEvent },
-    { "RegisterUniqueCreatureEvent", &LuaGlobalFunctions::RegisterUniqueCreatureEvent },
-    { "RegisterCreatureGossipEvent", &LuaGlobalFunctions::RegisterCreatureGossipEvent },
-    { "RegisterGameObjectEvent", &LuaGlobalFunctions::RegisterGameObjectEvent },
-    { "RegisterGameObjectGossipEvent", &LuaGlobalFunctions::RegisterGameObjectGossipEvent },
-    { "RegisterItemEvent", &LuaGlobalFunctions::RegisterItemEvent },
-    { "RegisterItemGossipEvent", &LuaGlobalFunctions::RegisterItemGossipEvent },
-    { "RegisterPlayerGossipEvent", &LuaGlobalFunctions::RegisterPlayerGossipEvent },
-    { "RegisterBGEvent", &LuaGlobalFunctions::RegisterBGEvent },
-    { "RegisterMapEvent", &LuaGlobalFunctions::RegisterMapEvent },
-    { "RegisterInstanceEvent", &LuaGlobalFunctions::RegisterInstanceEvent },
-    { "RegisterTicketEvent", &LuaGlobalFunctions::RegisterTicketEvent },
-    { "RegisterSpellEvent", &LuaGlobalFunctions::RegisterSpellEvent },
-    { "RegisterAllCreatureEvent", &LuaGlobalFunctions::RegisterAllCreatureEvent },
-
-
-    { "ClearBattleGroundEvents", &LuaGlobalFunctions::ClearBattleGroundEvents },
-    { "ClearCreatureEvents", &LuaGlobalFunctions::ClearCreatureEvents },
-    { "ClearUniqueCreatureEvents", &LuaGlobalFunctions::ClearUniqueCreatureEvents },
-    { "ClearCreatureGossipEvents", &LuaGlobalFunctions::ClearCreatureGossipEvents },
-    { "ClearGameObjectEvents", &LuaGlobalFunctions::ClearGameObjectEvents },
-    { "ClearGameObjectGossipEvents", &LuaGlobalFunctions::ClearGameObjectGossipEvents },
-    { "ClearGroupEvents", &LuaGlobalFunctions::ClearGroupEvents },
-    { "ClearGuildEvents", &LuaGlobalFunctions::ClearGuildEvents },
-    { "ClearItemEvents", &LuaGlobalFunctions::ClearItemEvents },
-    { "ClearItemGossipEvents", &LuaGlobalFunctions::ClearItemGossipEvents },
-    { "ClearPacketEvents", &LuaGlobalFunctions::ClearPacketEvents },
-    { "ClearPlayerEvents", &LuaGlobalFunctions::ClearPlayerEvents },
-    { "ClearPlayerGossipEvents", &LuaGlobalFunctions::ClearPlayerGossipEvents },
-    { "ClearServerEvents", &LuaGlobalFunctions::ClearServerEvents },
-    { "ClearMapEvents", &LuaGlobalFunctions::ClearMapEvents },
-    { "ClearInstanceEvents", &LuaGlobalFunctions::ClearInstanceEvents },
-    { "ClearTicketEvents", &LuaGlobalFunctions::ClearTicketEvents },
-    { "ClearSpellEvents", &LuaGlobalFunctions::ClearSpellEvents },
-    { "ClearAllCreatureEvents", &LuaGlobalFunctions::ClearAllCreatureEvents },
-
-    // Getters
-    { "GetLuaEngine", &LuaGlobalFunctions::GetLuaEngine },
-    { "GetCoreName", &LuaGlobalFunctions::GetCoreName },
-    { "GetConfigValue", &LuaGlobalFunctions::GetConfigValue },
-    { "GetRealmID", &LuaGlobalFunctions::GetRealmID },
-    { "GetCoreVersion", &LuaGlobalFunctions::GetCoreVersion },
-    { "GetCoreExpansion", &LuaGlobalFunctions::GetCoreExpansion },
-    { "GetStateMap", &LuaGlobalFunctions::GetStateMap },
-    { "GetStateMapId", &LuaGlobalFunctions::GetStateMapId },
-    { "GetStateInstanceId", &LuaGlobalFunctions::GetStateInstanceId },
-    { "GetQuest", &LuaGlobalFunctions::GetQuest },
-    { "GetPlayerByGUID", &LuaGlobalFunctions::GetPlayerByGUID },
-    { "GetPlayerByName", &LuaGlobalFunctions::GetPlayerByName },
-    { "GetGameTime", &LuaGlobalFunctions::GetGameTime },
-    { "GetPlayersInWorld", &LuaGlobalFunctions::GetPlayersInWorld },
-    { "GetGuildByName", &LuaGlobalFunctions::GetGuildByName },
-    { "GetGuildByLeaderGUID", &LuaGlobalFunctions::GetGuildByLeaderGUID },
-    { "GetPlayerCount", &LuaGlobalFunctions::GetPlayerCount },
-    { "GetPlayerGUID", &LuaGlobalFunctions::GetPlayerGUID },
-    { "GetItemGUID", &LuaGlobalFunctions::GetItemGUID },
-    { "GetItemTemplate", &LuaGlobalFunctions::GetItemTemplate },
-    { "GetObjectGUID", &LuaGlobalFunctions::GetObjectGUID },
-    { "GetUnitGUID", &LuaGlobalFunctions::GetUnitGUID },
-    { "GetGUIDLow", &LuaGlobalFunctions::GetGUIDLow },
-    { "GetGUIDType", &LuaGlobalFunctions::GetGUIDType },
-    { "GetGUIDEntry", &LuaGlobalFunctions::GetGUIDEntry },
-    { "GetPackedGUIDSize", &LuaGlobalFunctions::GetPackedGUIDSize },
-    { "GetAreaName", &LuaGlobalFunctions::GetAreaName },
-    { "GetOwnerHalaa", &LuaGlobalFunctions::GetOwnerHalaa },
-    { "bit_not", &LuaGlobalFunctions::bit_not },
-    { "bit_xor", &LuaGlobalFunctions::bit_xor },
-    { "bit_rshift", &LuaGlobalFunctions::bit_rshift },
-    { "bit_lshift", &LuaGlobalFunctions::bit_lshift },
-    { "bit_or", &LuaGlobalFunctions::bit_or },
-    { "bit_and", &LuaGlobalFunctions::bit_and },
-    { "GetItemLink", &LuaGlobalFunctions::GetItemLink },
-    { "GetMapById", &LuaGlobalFunctions::GetMapById },
-    { "GetCurrTime", &LuaGlobalFunctions::GetCurrTime },
-    { "GetTimeDiff", &LuaGlobalFunctions::GetTimeDiff },
-    { "PrintInfo", &LuaGlobalFunctions::PrintInfo },
-    { "PrintError", &LuaGlobalFunctions::PrintError },
-    { "PrintDebug", &LuaGlobalFunctions::PrintDebug },
-    { "GetActiveGameEvents", &LuaGlobalFunctions::GetActiveGameEvents },
-    { "GetGossipMenuOptionLocale", &LuaGlobalFunctions::GetGossipMenuOptionLocale },
-    { "GetMapEntrance", &LuaGlobalFunctions::GetMapEntrance },
-    { "GetSpellInfo", &LuaGlobalFunctions::GetSpellInfo },
-
-    // Boolean
-    { "IsCompatibilityMode", &LuaGlobalFunctions::IsCompatibilityMode },
-    { "IsInventoryPos", &LuaGlobalFunctions::IsInventoryPos },
-    { "IsEquipmentPos", &LuaGlobalFunctions::IsEquipmentPos },
-    { "IsBankPos", &LuaGlobalFunctions::IsBankPos },
-    { "IsBagPos", &LuaGlobalFunctions::IsBagPos },
-    { "IsGameEventActive", &LuaGlobalFunctions::IsGameEventActive },
-
-    // Other
-    { "ReloadALE", &LuaGlobalFunctions::ReloadALE },
-    { "RunCommand", &LuaGlobalFunctions::RunCommand },
-    { "SendWorldMessage", &LuaGlobalFunctions::SendWorldMessage },
-    { "WorldDBQuery", &LuaGlobalFunctions::WorldDBQuery },
-    { "WorldDBQueryAsync", &LuaGlobalFunctions::WorldDBQueryAsync },
-    { "WorldDBExecute", &LuaGlobalFunctions::WorldDBExecute },
-    { "CharDBQuery", &LuaGlobalFunctions::CharDBQuery },
-    { "CharDBQueryAsync", &LuaGlobalFunctions::CharDBQueryAsync },
-    { "CharDBExecute", &LuaGlobalFunctions::CharDBExecute },
-    { "AuthDBQuery", &LuaGlobalFunctions::AuthDBQuery },
-    { "AuthDBQueryAsync", &LuaGlobalFunctions::AuthDBQueryAsync },
-    { "AuthDBExecute", &LuaGlobalFunctions::AuthDBExecute },
-    { "CreateLuaEvent", &LuaGlobalFunctions::CreateLuaEvent },
-    { "RemoveEventById", &LuaGlobalFunctions::RemoveEventById },
-    { "RemoveEvents", &LuaGlobalFunctions::RemoveEvents },
-    { "PerformIngameSpawn", &LuaGlobalFunctions::PerformIngameSpawn },
-    { "CreatePacket", &LuaGlobalFunctions::CreatePacket },
-    { "AddVendorItem", &LuaGlobalFunctions::AddVendorItem },
-    { "VendorRemoveItem", &LuaGlobalFunctions::VendorRemoveItem },
-    { "VendorRemoveAllItems", &LuaGlobalFunctions::VendorRemoveAllItems },
-    { "Kick", &LuaGlobalFunctions::Kick },
-    { "Ban", &LuaGlobalFunctions::Ban },
-    { "SaveAllPlayers", &LuaGlobalFunctions::SaveAllPlayers },
-    { "SendMail", &LuaGlobalFunctions::SendMail },
-    { "AddTaxiPath", &LuaGlobalFunctions::AddTaxiPath },
-    { "CreateInt64", &LuaGlobalFunctions::CreateLongLong },
-    { "CreateUint64", &LuaGlobalFunctions::CreateULongLong },
-    { "StartGameEvent", &LuaGlobalFunctions::StartGameEvent },
-    { "StopGameEvent", &LuaGlobalFunctions::StopGameEvent },
-    { "HttpRequest", &LuaGlobalFunctions::HttpRequest },
-    { "SetOwnerHalaa", &LuaGlobalFunctions::SetOwnerHalaa },
-    { "LookupEntry", &LuaGlobalFunctions::LookupEntry },
-
-    { NULL, NULL }
-};
-
-ALERegister<Object> ObjectMethods[] =
-{
-    // Getters
-    { "GetEntry", &LuaObject::GetEntry },
-    { "GetGUID", &LuaObject::GetGUID },
-    { "GetGUIDLow", &LuaObject::GetGUIDLow },
-    { "GetInt32Value", &LuaObject::GetInt32Value },
-    { "GetUInt32Value", &LuaObject::GetUInt32Value },
-    { "GetFloatValue", &LuaObject::GetFloatValue },
-    { "GetByteValue", &LuaObject::GetByteValue },
-    { "GetUInt16Value", &LuaObject::GetUInt16Value },
-    { "GetUInt64Value", &LuaObject::GetUInt64Value },
-    { "GetScale", &LuaObject::GetScale },
-    { "GetTypeId", &LuaObject::GetTypeId },
-
-    // Setters
-    { "SetInt32Value", &LuaObject::SetInt32Value },
-    { "SetUInt32Value", &LuaObject::SetUInt32Value },
-    { "UpdateUInt32Value", &LuaObject::UpdateUInt32Value },
-    { "SetFloatValue", &LuaObject::SetFloatValue },
-    { "SetByteValue", &LuaObject::SetByteValue },
-    { "SetUInt16Value", &LuaObject::SetUInt16Value },
-    { "SetInt16Value", &LuaObject::SetInt16Value },
-    { "SetUInt64Value", &LuaObject::SetUInt64Value },
-    { "SetScale", &LuaObject::SetScale },
-    { "SetFlag", &LuaObject::SetFlag },
-
-    // Boolean
-    { "IsInWorld", &LuaObject::IsInWorld },
-    { "IsPlayer", &LuaObject::IsPlayer },
-    { "HasFlag", &LuaObject::HasFlag },
-
-    // Other
-    { "ToGameObject", &LuaObject::ToGameObject },
-    { "ToUnit", &LuaObject::ToUnit },
-    { "ToCreature", &LuaObject::ToCreature },
-    { "ToPlayer", &LuaObject::ToPlayer },
-    { "ToCorpse", &LuaObject::ToCorpse },
-    { "RemoveFlag", &LuaObject::RemoveFlag },
-
-    { NULL, NULL }
-};
-
-ALERegister<WorldObject> WorldObjectMethods[] =
-{
-    // Getters
-    { "GetName", &LuaWorldObject::GetName },
-    { "GetMap", &LuaWorldObject::GetMap },
-    { "GetPhaseMask", &LuaWorldObject::GetPhaseMask },
-    { "SetPhaseMask", &LuaWorldObject::SetPhaseMask },
-    { "GetInstanceId", &LuaWorldObject::GetInstanceId },
-    { "GetAreaId", &LuaWorldObject::GetAreaId },
-    { "GetZoneId", &LuaWorldObject::GetZoneId },
-    { "GetMapId", &LuaWorldObject::GetMapId },
-    { "GetX", &LuaWorldObject::GetX },
-    { "GetY", &LuaWorldObject::GetY },
-    { "GetZ", &LuaWorldObject::GetZ },
-    { "GetO", &LuaWorldObject::GetO },
-    { "GetLocation", &LuaWorldObject::GetLocation },
-    { "GetPlayersInRange", &LuaWorldObject::GetPlayersInRange },
-    { "GetCreaturesInRange", &LuaWorldObject::GetCreaturesInRange },
-    { "GetGameObjectsInRange", &LuaWorldObject::GetGameObjectsInRange },
-    { "GetNearestPlayer", &LuaWorldObject::GetNearestPlayer },
-    { "GetNearestGameObject", &LuaWorldObject::GetNearestGameObject },
-    { "GetNearestCreature", &LuaWorldObject::GetNearestCreature },
-    { "GetNearObject", &LuaWorldObject::GetNearObject },
-    { "GetNearObjects", &LuaWorldObject::GetNearObjects },
-    { "GetDistance", &LuaWorldObject::GetDistance },
-    { "GetExactDistance", &LuaWorldObject::GetExactDistance },
-    { "GetDistance2d", &LuaWorldObject::GetDistance2d },
-    { "GetExactDistance2d", &LuaWorldObject::GetExactDistance2d },
-    { "GetRelativePoint", &LuaWorldObject::GetRelativePoint },
-    { "GetAngle", &LuaWorldObject::GetAngle },
-    { "GetTransport", &LuaWorldObject::GetTransport },
-
-    // Boolean
-    { "IsWithinLoS", &LuaWorldObject::IsWithinLoS },
-    { "IsInMap", &LuaWorldObject::IsInMap },
-    { "IsWithinDist3d", &LuaWorldObject::IsWithinDist3d },
-    { "IsWithinDist2d", &LuaWorldObject::IsWithinDist2d },
-    { "IsWithinDist", &LuaWorldObject::IsWithinDist },
-    { "IsWithinDistInMap", &LuaWorldObject::IsWithinDistInMap },
-    { "IsInRange", &LuaWorldObject::IsInRange },
-    { "IsInRange2d", &LuaWorldObject::IsInRange2d },
-    { "IsInRange3d", &LuaWorldObject::IsInRange3d },
-    { "IsInFront", &LuaWorldObject::IsInFront },
-    { "IsInBack", &LuaWorldObject::IsInBack },
-
-    // Other
-    { "SummonGameObject", &LuaWorldObject::SummonGameObject },
-    { "SpawnCreature", &LuaWorldObject::SpawnCreature },
-    { "SendPacket", &LuaWorldObject::SendPacket },
-    { "RegisterEvent", &LuaWorldObject::RegisterEvent },
-    { "RemoveEventById", &LuaWorldObject::RemoveEventById },
-    { "RemoveEvents", &LuaWorldObject::RemoveEvents },
-    { "PlayMusic", &LuaWorldObject::PlayMusic },
-    { "PlayDirectSound", &LuaWorldObject::PlayDirectSound },
-    { "PlayDistanceSound", &LuaWorldObject::PlayDistanceSound },
-
-    { NULL, NULL }
-};
-
-ALERegister<Unit> UnitMethods[] =
-{
-    // Getters
-    { "GetLevel", &LuaUnit::GetLevel },
-    { "GetHealth", &LuaUnit::GetHealth },
-    { "GetDisplayId", &LuaUnit::GetDisplayId },
-    { "GetNativeDisplayId", &LuaUnit::GetNativeDisplayId },
-    { "GetPower", &LuaUnit::GetPower },
-    { "GetMaxPower", &LuaUnit::GetMaxPower },
-    { "GetPowerType", &LuaUnit::GetPowerType },
-    { "GetMaxHealth", &LuaUnit::GetMaxHealth },
-    { "GetHealthPct", &LuaUnit::GetHealthPct },
-    { "GetPowerPct", &LuaUnit::GetPowerPct },
-    { "GetGender", &LuaUnit::GetGender },
-    { "GetRace", &LuaUnit::GetRace },
-    { "GetClass", &LuaUnit::GetClass },
-    { "GetRaceMask", &LuaUnit::GetRaceMask },
-    { "GetClassMask", &LuaUnit::GetClassMask },
-    { "GetRaceAsString", &LuaUnit::GetRaceAsString },
-    { "GetClassAsString", &LuaUnit::GetClassAsString },
-    { "GetAura", &LuaUnit::GetAura },
-    { "GetFaction", &LuaUnit::GetFaction },
-    { "GetCurrentSpell", &LuaUnit::GetCurrentSpell },
-    { "GetCreatureType", &LuaUnit::GetCreatureType },
-    { "GetMountId", &LuaUnit::GetMountId },
-    { "GetOwner", &LuaUnit::GetOwner },
-    { "GetFriendlyUnitsInRange", &LuaUnit::GetFriendlyUnitsInRange },
-    { "GetUnfriendlyUnitsInRange", &LuaUnit::GetUnfriendlyUnitsInRange },
-    { "GetOwnerGUID", &LuaUnit::GetOwnerGUID },
-    { "GetCreatorGUID", &LuaUnit::GetCreatorGUID },
-    { "GetMinionGUID", &LuaUnit::GetPetGUID },
-    { "GetCharmerGUID", &LuaUnit::GetCharmerGUID },
-    { "GetCharmGUID", &LuaUnit::GetCharmGUID },
-    { "GetPetGUID", &LuaUnit::GetPetGUID },
-    { "GetCritterGUID", &LuaUnit::GetCritterGUID },
-    { "GetControllerGUID", &LuaUnit::GetControllerGUID },
-    { "GetControllerGUIDS", &LuaUnit::GetControllerGUIDS },
-    { "GetStandState", &LuaUnit::GetStandState },
-    { "GetVictim", &LuaUnit::GetVictim },
-    { "GetSpeed", &LuaUnit::GetSpeed },
-    { "GetSpeedRate", &LuaUnit::GetSpeedRate },
-    { "GetStat", &LuaUnit::GetStat },
-    { "GetBaseSpellPower", &LuaUnit::GetBaseSpellPower },
-    { "GetVehicleKit", &LuaUnit::GetVehicleKit },
-    // {"GetVehicle", &LuaUnit::GetVehicle},                           // :GetVehicle() - UNDOCUMENTED - Gets the Vehicle kit of the vehicle the unit is on
-    { "GetMovementType", &LuaUnit::GetMovementType },
-    { "GetAttackers", &LuaUnit::GetAttackers },
-    { "GetThreat", &LuaUnit::GetThreat },
-
-    // Setters
-    { "SetFaction", &LuaUnit::SetFaction },
-    { "SetLevel", &LuaUnit::SetLevel },
-    { "SetHealth", &LuaUnit::SetHealth },
-    { "SetMaxHealth", &LuaUnit::SetMaxHealth },
-    { "SetPower", &LuaUnit::SetPower },
-    { "SetMaxPower", &LuaUnit::SetMaxPower },
-    { "SetPowerType", &LuaUnit::SetPowerType },
-    { "SetDisplayId", &LuaUnit::SetDisplayId },
-    { "SetNativeDisplayId", &LuaUnit::SetNativeDisplayId },
-    { "SetFacing", &LuaUnit::SetFacing },
-    { "SetFacingToObject", &LuaUnit::SetFacingToObject },
-    { "SetSpeed", &LuaUnit::SetSpeed },
-    { "SetSpeedRate", &LuaUnit::SetSpeedRate },
-    // {"SetStunned", &LuaUnit::SetStunned},                           // :SetStunned([enable]) - UNDOCUMENTED - Stuns or removes stun
-    {"SetRooted", &LuaUnit::SetRooted},
-    {"SetConfused", &LuaUnit::SetConfused},
-    {"SetFeared", &LuaUnit::SetFeared},
-    { "SetPvP", &LuaUnit::SetPvP },
-    { "SetFFA", &LuaUnit::SetFFA },
-    { "SetSanctuary", &LuaUnit::SetSanctuary },
-    // {"SetCanFly", &LuaUnit::SetCanFly},                             // :SetCanFly(apply) - UNDOCUMENTED
-    // {"SetVisible", &LuaUnit::SetVisible},                           // :SetVisible(x) - UNDOCUMENTED
-    { "SetOwnerGUID", &LuaUnit::SetOwnerGUID },
-    { "SetName", &LuaUnit::SetName },
-    { "SetSheath", &LuaUnit::SetSheath },
-    { "SetCreatorGUID", &LuaUnit::SetCreatorGUID },
-    { "SetMinionGUID", &LuaUnit::SetPetGUID },
-    { "SetPetGUID", &LuaUnit::SetPetGUID },
-    { "SetCritterGUID", &LuaUnit::SetCritterGUID },
-    { "SetWaterWalk", &LuaUnit::SetWaterWalk },
-    { "SetStandState", &LuaUnit::SetStandState },
-    { "SetInCombatWith", &LuaUnit::SetInCombatWith },
-    { "ModifyPower", &LuaUnit::ModifyPower },
-    { "SetImmuneTo", &LuaUnit::SetImmuneTo },
-
-    // Boolean
-    { "IsAlive", &LuaUnit::IsAlive },
-    { "IsDead", &LuaUnit::IsDead },
-    { "IsDying", &LuaUnit::IsDying },
-    { "IsPvPFlagged", &LuaUnit::IsPvPFlagged },
-    { "IsInCombat", &LuaUnit::IsInCombat },
-    { "IsBanker", &LuaUnit::IsBanker },
-    { "IsBattleMaster", &LuaUnit::IsBattleMaster },
-    { "IsCharmed", &LuaUnit::IsCharmed },
-    { "IsArmorer", &LuaUnit::IsArmorer },
-    { "IsAttackingPlayer", &LuaUnit::IsAttackingPlayer },
-    { "IsInWater", &LuaUnit::IsInWater },
-    { "IsUnderWater", &LuaUnit::IsUnderWater },
-    { "IsAuctioneer", &LuaUnit::IsAuctioneer },
-    { "IsGuildMaster", &LuaUnit::IsGuildMaster },
-    { "IsInnkeeper", &LuaUnit::IsInnkeeper },
-    { "IsTrainer", &LuaUnit::IsTrainer },
-    { "IsGossip", &LuaUnit::IsGossip },
-    { "IsTaxi", &LuaUnit::IsTaxi },
-    { "IsSpiritHealer", &LuaUnit::IsSpiritHealer },
-    { "IsSpiritGuide", &LuaUnit::IsSpiritGuide },
-    { "IsTabardDesigner", &LuaUnit::IsTabardDesigner },
-    { "IsServiceProvider", &LuaUnit::IsServiceProvider },
-    { "IsSpiritService", &LuaUnit::IsSpiritService },
-    { "HealthBelowPct", &LuaUnit::HealthBelowPct },
-    { "HealthAbovePct", &LuaUnit::HealthAbovePct },
-    { "IsMounted", &LuaUnit::IsMounted },
-    { "AttackStop", &LuaUnit::AttackStop },
-    { "Attack", &LuaUnit::Attack },
-    // {"IsVisible", &LuaUnit::IsVisible},                              // :IsVisible() - UNDOCUMENTED
-    // {"IsMoving", &LuaUnit::IsMoving},                                // :IsMoving() - UNDOCUMENTED
-    // {"IsFlying", &LuaUnit::IsFlying},                                // :IsFlying() - UNDOCUMENTED
-    { "IsStopped", &LuaUnit::IsStopped },
-    { "HasUnitState", &LuaUnit::HasUnitState },
-    { "IsQuestGiver", &LuaUnit::IsQuestGiver },
-    { "IsInAccessiblePlaceFor", &LuaUnit::IsInAccessiblePlaceFor },
-    { "IsVendor", &LuaUnit::IsVendor },
-    { "IsRooted", &LuaUnit::IsRooted },
-    { "IsFullHealth", &LuaUnit::IsFullHealth },
-    { "HasAura", &LuaUnit::HasAura },
-    { "IsCasting", &LuaUnit::IsCasting },
-    { "IsStandState", &LuaUnit::IsStandState },
-    { "IsOnVehicle", &LuaUnit::IsOnVehicle },
-
-    // Other
-    { "HandleStatFlatModifier", &LuaUnit::HandleStatFlatModifier },
-    { "AddAura", &LuaUnit::AddAura },
-    { "RemoveAura", &LuaUnit::RemoveAura },
-    { "RemoveAllAuras", &LuaUnit::RemoveAllAuras },
-    { "RemoveArenaAuras", &LuaUnit::RemoveArenaAuras },
-    { "ClearInCombat", &LuaUnit::ClearInCombat },
-    { "DeMorph", &LuaUnit::DeMorph },
-    { "SendUnitWhisper", &LuaUnit::SendUnitWhisper },
-    { "SendUnitEmote", &LuaUnit::SendUnitEmote },
-    { "SendUnitSay", &LuaUnit::SendUnitSay },
-    { "SendUnitYell", &LuaUnit::SendUnitYell },
-    { "CastSpell", &LuaUnit::CastSpell },
-    { "CastCustomSpell", &LuaUnit::CastCustomSpell },
-    { "CastSpellAoF", &LuaUnit::CastSpellAoF },
-    { "Kill", &LuaUnit::Kill },
-    { "StopSpellCast", &LuaUnit::StopSpellCast },
-    { "InterruptSpell", &LuaUnit::InterruptSpell },
-    { "SendChatMessageToPlayer", &LuaUnit::SendChatMessageToPlayer },
-    { "PerformEmote", &LuaUnit::PerformEmote },
-    { "EmoteState", &LuaUnit::EmoteState },
-    { "CountPctFromCurHealth", &LuaUnit::CountPctFromCurHealth },
-    { "CountPctFromMaxHealth", &LuaUnit::CountPctFromMaxHealth },
-    { "Dismount", &LuaUnit::Dismount },
-    { "Mount", &LuaUnit::Mount },
-    // {"RestoreDisplayId", &LuaUnit::RestoreDisplayId},                // :RestoreDisplayId() - UNDOCUMENTED
-    // {"RestoreFaction", &LuaUnit::RestoreFaction},                    // :RestoreFaction() - UNDOCUMENTED
-    // {"RemoveBindSightAuras", &LuaUnit::RemoveBindSightAuras},        // :RemoveBindSightAuras() - UNDOCUMENTED
-    // {"RemoveCharmAuras", &LuaUnit::RemoveCharmAuras},                // :RemoveCharmAuras() - UNDOCUMENTED
-    { "ClearThreatList", &LuaUnit::ClearThreatList },
-    { "GetThreatList", &LuaUnit::GetThreatList },
-    { "ClearUnitState", &LuaUnit::ClearUnitState },
-    { "AddUnitState", &LuaUnit::AddUnitState },
-    // {"DisableMelee", &LuaUnit::DisableMelee},                        // :DisableMelee([disable]) - UNDOCUMENTED - if true, enables
-    // {"SummonGuardian", &LuaUnit::SummonGuardian},                    // :SummonGuardian(entry, x, y, z, o[, duration]) - UNDOCUMENTED - summons a guardian to location. Scales with summoner, is friendly to him and guards him.
-    { "NearTeleport", &LuaUnit::NearTeleport },
-    { "MoveIdle", &LuaUnit::MoveIdle },
-    { "MoveRandom", &LuaUnit::MoveRandom },
-    { "MoveHome", &LuaUnit::MoveHome },
-    { "MoveFollow", &LuaUnit::MoveFollow },
-    { "MoveChase", &LuaUnit::MoveChase },
-    { "MoveConfused", &LuaUnit::MoveConfused },
-    { "MoveFleeing", &LuaUnit::MoveFleeing },
-    { "MoveTo", &LuaUnit::MoveTo },
-    { "MoveJump", &LuaUnit::MoveJump },
-    { "MoveStop", &LuaUnit::MoveStop },
-    { "MoveExpire", &LuaUnit::MoveExpire },
-    { "MoveClear", &LuaUnit::MoveClear },
-    { "DealDamage", &LuaUnit::DealDamage },
-    { "DealHeal", &LuaUnit::DealHeal },
-    { "AddThreat", &LuaUnit::AddThreat },
-    { "ModifyThreatPct", &LuaUnit::ModifyThreatPct },
-    { "ClearThreat", &LuaUnit::ClearThreat },
-    { "ResetAllThreat", &LuaUnit::ResetAllThreat },
-
-    { NULL, NULL }
-};
-
-ALERegister<Player> PlayerMethods[] =
-{
-    // Getters
-    { "GetInventoryFreeSlots", &LuaPlayer::GetInventoryFreeSlots },
-    { "GetBankFreeSlots", &LuaPlayer::GetBankFreeSlots },
-    { "GetSelection", &LuaPlayer::GetSelection },
-    { "GetGMRank", &LuaPlayer::GetGMRank },
-    { "GetGuildId", &LuaPlayer::GetGuildId },
-    { "GetCoinage", &LuaPlayer::GetCoinage },
-    { "GetTeam", &LuaPlayer::GetTeam },
-    { "GetItemCount", &LuaPlayer::GetItemCount },
-    { "GetGroup", &LuaPlayer::GetGroup },
-    { "GetGuild", &LuaPlayer::GetGuild },
-    { "GetAccountId", &LuaPlayer::GetAccountId },
-    { "GetAccountName", &LuaPlayer::GetAccountName },
-    { "GetCompletedQuestsCount", &LuaPlayer::GetCompletedQuestsCount },
-    { "GetArenaPoints", &LuaPlayer::GetArenaPoints },
-    { "GetHonorPoints", &LuaPlayer::GetHonorPoints },
-    { "GetTodayHonorPoints", &LuaPlayer::GetTodayHonorPoints },
-    { "GetYesterdayHonorPoints", &LuaPlayer::GetYesterdayHonorPoints },
-    { "GetLifetimeKills", &LuaPlayer::GetLifetimeKills },
-    { "GetTodayKills", &LuaPlayer::GetTodayKills },
-    { "GetYesterdayKills", &LuaPlayer::GetYesterdayKills },
-    { "GetPlayerIP", &LuaPlayer::GetPlayerIP },
-    { "GetLevelPlayedTime", &LuaPlayer::GetLevelPlayedTime },
-    { "GetTotalPlayedTime", &LuaPlayer::GetTotalPlayedTime },
-    { "GetItemByPos", &LuaPlayer::GetItemByPos },
-    { "GetItemByEntry", &LuaPlayer::GetItemByEntry },
-    { "GetItemByGUID", &LuaPlayer::GetItemByGUID },
-    { "GetMailCount", &LuaPlayer::GetMailCount },
-    { "GetMailItem", &LuaPlayer::GetMailItem },
-    { "GetReputation", &LuaPlayer::GetReputation },
-    { "GetEquippedItemBySlot", &LuaPlayer::GetEquippedItemBySlot },
-    { "GetQuestLevel", &LuaPlayer::GetQuestLevel },
-    { "GetChatTag", &LuaPlayer::GetChatTag },
-    { "GetRestBonus", &LuaPlayer::GetRestBonus },
-    { "GetPhaseMaskForSpawn", &LuaPlayer::GetPhaseMaskForSpawn },
-    { "GetAchievementPoints", &LuaPlayer::GetAchievementPoints },
-    { "GetCompletedAchievementsCount", &LuaPlayer::GetCompletedAchievementsCount },
-    { "GetReqKillOrCastCurrentCount", &LuaPlayer::GetReqKillOrCastCurrentCount },
-    { "GetQuestStatus", &LuaPlayer::GetQuestStatus },
-    { "GetInGameTime", &LuaPlayer::GetInGameTime },
-    { "GetComboPoints", &LuaPlayer::GetComboPoints },
-    { "GetComboTarget", &LuaPlayer::GetComboTarget },
-    { "GetGuildName", &LuaPlayer::GetGuildName },
-    { "GetFreeTalentPoints", &LuaPlayer::GetFreeTalentPoints },
-    { "GetActiveSpec", &LuaPlayer::GetActiveSpec },
-    { "GetSpecsCount", &LuaPlayer::GetSpecsCount },
-    { "GetSpellCooldownDelay", &LuaPlayer::GetSpellCooldownDelay },
-    { "GetGuildRank", &LuaPlayer::GetGuildRank },
-    { "GetDifficulty", &LuaPlayer::GetDifficulty },
-    { "GetHealthBonusFromStamina", &LuaPlayer::GetHealthBonusFromStamina },
-    { "GetManaBonusFromIntellect", &LuaPlayer::GetManaBonusFromIntellect },
-    { "GetMaxSkillValue", &LuaPlayer::GetMaxSkillValue },
-    { "GetPureMaxSkillValue", &LuaPlayer::GetPureMaxSkillValue },
-    { "GetSkillValue", &LuaPlayer::GetSkillValue },
-    { "GetBaseSkillValue", &LuaPlayer::GetBaseSkillValue },
-    { "GetPureSkillValue", &LuaPlayer::GetPureSkillValue },
-    { "GetSkillPermBonusValue", &LuaPlayer::GetSkillPermBonusValue },
-    { "GetSkillTempBonusValue", &LuaPlayer::GetSkillTempBonusValue },
-    { "GetReputationRank", &LuaPlayer::GetReputationRank },
-    { "GetDrunkValue", &LuaPlayer::GetDrunkValue },
-    { "GetBattlegroundId", &LuaPlayer::GetBattlegroundId },
-    { "GetBattlegroundTypeId", &LuaPlayer::GetBattlegroundTypeId },
-    { "GetXP", &LuaPlayer::GetXP },
-    { "GetXPRestBonus", &LuaPlayer::GetXPRestBonus },
-    { "GetGroupInvite", &LuaPlayer::GetGroupInvite },
-    { "GetSubGroup", &LuaPlayer::GetSubGroup },
-    { "GetNextRandomRaidMember", &LuaPlayer::GetNextRandomRaidMember },
-    { "GetOriginalGroup", &LuaPlayer::GetOriginalGroup },
-    { "GetOriginalSubGroup", &LuaPlayer::GetOriginalSubGroup },
-    { "GetChampioningFaction", &LuaPlayer::GetChampioningFaction },
-    { "GetLatency", &LuaPlayer::GetLatency },
-    // {"GetRecruiterId", &LuaPlayer::GetRecruiterId},                            // :GetRecruiterId() - UNDOCUMENTED - Returns player's recruiter's ID
-    { "GetDbLocaleIndex", &LuaPlayer::GetDbLocaleIndex },
-    { "GetDbcLocale", &LuaPlayer::GetDbcLocale },
-    { "GetCorpse", &LuaPlayer::GetCorpse },
-    { "GetGossipTextId", &LuaPlayer::GetGossipTextId },
-    { "GetQuestRewardStatus", &LuaPlayer::GetQuestRewardStatus },
-    { "GetShieldBlockValue", &LuaPlayer::GetShieldBlockValue },
-    { "GetPlayerSettingValue", &LuaPlayer::GetPlayerSettingValue },
-    { "GetTrader", &LuaPlayer::GetTrader },
-    { "GetBonusTalentCount", &LuaPlayer::GetBonusTalentCount },
-    { "GetKnownTaxiNodes", &LuaPlayer::GetKnownTaxiNodes },
-    { "GetPet", &LuaPlayer::GetPet },
-    { "GetTemporaryUnsummonedPetNumber", &LuaPlayer::GetTemporaryUnsummonedPetNumber },
-    { "GetLastPetNumber", &LuaPlayer::GetLastPetNumber },
-    { "GetLastPetSpell", &LuaPlayer::GetLastPetSpell },
-    { "GetQuestSlotQuestId", &LuaPlayer::GetQuestSlotQuestId },
-    { "GetTalentTreePoints", &LuaPlayer::GetTalentTreePoints },
-    { "GetMostPointsTalentTree", &LuaPlayer::GetMostPointsTalentTree },
-
-    // Setters
-    { "SetTemporaryUnsummonedPetNumber", &LuaPlayer::SetTemporaryUnsummonedPetNumber },
-    { "SetLastPetNumber", &LuaPlayer::SetLastPetNumber },
-    { "SetLastPetSpell", &LuaPlayer::SetLastPetSpell },
-    { "SetShowDKPet", &LuaPlayer::SetShowDKPet },
-    { "AdvanceSkillsToMax", &LuaPlayer::AdvanceSkillsToMax },
-    { "AdvanceSkill", &LuaPlayer::AdvanceSkill },
-    { "AdvanceAllSkills", &LuaPlayer::AdvanceAllSkills },
-    { "AddLifetimeKills", &LuaPlayer::AddLifetimeKills },
-    { "SetCoinage", &LuaPlayer::SetCoinage },
-    { "SetKnownTitle", &LuaPlayer::SetKnownTitle },
-    { "UnsetKnownTitle", &LuaPlayer::UnsetKnownTitle },
-    { "SetBindPoint", &LuaPlayer::SetBindPoint },
-    { "SetArenaPoints", &LuaPlayer::SetArenaPoints },
-    { "SetHonorPoints", &LuaPlayer::SetHonorPoints },
-    { "SetSpellPower", &LuaPlayer::SetSpellPower },
-    { "SetLifetimeKills", &LuaPlayer::SetLifetimeKills },
-    { "SetGameMaster", &LuaPlayer::SetGameMaster },
-    { "SetGMChat", &LuaPlayer::SetGMChat },
-    { "SetKnownTaxiNodes", &LuaPlayer::SetKnownTaxiNodes },
-    { "SetTaxiCheat", &LuaPlayer::SetTaxiCheat },
-    { "SetGMVisible", &LuaPlayer::SetGMVisible },
-    { "SetPvPDeath", &LuaPlayer::SetPvPDeath },
-    { "SetAcceptWhispers", &LuaPlayer::SetAcceptWhispers },
-    { "SetRestBonus", &LuaPlayer::SetRestBonus },
-    { "SetQuestStatus", &LuaPlayer::SetQuestStatus },
-    { "SetReputation", &LuaPlayer::SetReputation },
-    { "SetFreeTalentPoints", &LuaPlayer::SetFreeTalentPoints },
-    { "SetGuildRank", &LuaPlayer::SetGuildRank },
-    // {"SetMovement", &LuaPlayer::SetMovement},                  // :SetMovement(type) - UNDOCUMENTED - Sets player's movement type
-    { "SetSkill", &LuaPlayer::SetSkill },
-    { "SetFactionForRace", &LuaPlayer::SetFactionForRace },
-    { "SetDrunkValue", &LuaPlayer::SetDrunkValue },
-    { "SetAtLoginFlag", &LuaPlayer::SetAtLoginFlag },
-    { "SetPlayerLock", &LuaPlayer::SetPlayerLock },
-    { "SetGender", &LuaPlayer::SetGender },
-    { "SetSheath", &LuaPlayer::SetSheath },
-    { "SetBonusTalentCount", &LuaPlayer::SetBonusTalentCount },
-    { "AddBonusTalent", &LuaPlayer::AddBonusTalent },
-    { "RemoveBonusTalent", &LuaPlayer::RemoveBonusTalent },
-    { "GetHomebind", &LuaPlayer::GetHomebind },
-    { "GetSpells", &LuaPlayer::GetSpells },
-    { "GetAverageItemLevel", &LuaPlayer::GetAverageItemLevel },
-    { "GetBarberShopCost", &LuaPlayer::GetBarberShopCost },
-    { "GetSightRange", &LuaPlayer::GetSightRange },
-    { "GetWeaponProficiency", &LuaPlayer::GetWeaponProficiency },
-    { "GetArmorProficiency", &LuaPlayer::GetArmorProficiency },
-    { "GetAmmoDPS", &LuaPlayer::GetAmmoDPS },
-    { "GetShield", &LuaPlayer::GetShield },
-    { "GetRunesState", &LuaPlayer::GetRunesState },
-    { "GetViewpoint", &LuaPlayer::GetViewpoint },
-    { "GetDodgeFromAgility", &LuaPlayer::GetDodgeFromAgility },
-    { "GetMeleeCritFromAgility", &LuaPlayer::GetMeleeCritFromAgility },
-    { "GetSpellCritFromIntellect", &LuaPlayer::GetSpellCritFromIntellect },
-    { "GetInventoryItem", &LuaPlayer::GetInventoryItem },
-    { "GetBankItem", &LuaPlayer::GetBankItem },
-    { "GetCreationTime", &LuaPlayer::GetCreationTime },
-    { "SetCanFly", &LuaPlayer::SetCanFly },
-
-    // Boolean
-    { "HasTankSpec", &LuaPlayer::HasTankSpec },
-    { "HasMeleeSpec", &LuaPlayer::HasMeleeSpec },
-    { "HasCasterSpec", &LuaPlayer::HasCasterSpec },
-    { "HasHealSpec", &LuaPlayer::HasHealSpec },
-    { "IsInGroup", &LuaPlayer::IsInGroup },
-    { "IsInGuild", &LuaPlayer::IsInGuild },
-    { "IsGM", &LuaPlayer::IsGM },
-    { "IsImmuneToDamage", &LuaPlayer::IsImmuneToDamage },
-    { "IsAlliance", &LuaPlayer::IsAlliance },
-    { "IsHorde", &LuaPlayer::IsHorde },
-    { "HasTitle", &LuaPlayer::HasTitle },
-    { "HasItem", &LuaPlayer::HasItem },
-    { "Teleport", &LuaPlayer::Teleport },
-    { "AddItem", &LuaPlayer::AddItem },
-    { "IsInArenaTeam", &LuaPlayer::IsInArenaTeam },
-    { "CanRewardQuest", &LuaPlayer::CanRewardQuest },
-    { "CanCompleteRepeatableQuest", &LuaPlayer::CanCompleteRepeatableQuest },
-    { "CanCompleteQuest", &LuaPlayer::CanCompleteQuest },
-    { "CanEquipItem", &LuaPlayer::CanEquipItem },
-    { "IsFalling", &LuaPlayer::IsFalling },
-    { "ToggleAFK", &LuaPlayer::ToggleAFK },
-    { "ToggleDND", &LuaPlayer::ToggleDND },
-    { "IsAFK", &LuaPlayer::IsAFK },
-    { "IsDND", &LuaPlayer::IsDND },
-    { "IsAcceptingWhispers", &LuaPlayer::IsAcceptingWhispers },
-    { "IsGMChat", &LuaPlayer::IsGMChat },
-    { "IsTaxiCheater", &LuaPlayer::IsTaxiCheater },
-    { "IsGMVisible", &LuaPlayer::IsGMVisible },
-    { "HasQuest", &LuaPlayer::HasQuest },
-    { "InBattlegroundQueue", &LuaPlayer::InBattlegroundQueue },
-    // {"IsImmuneToEnvironmentalDamage", &LuaPlayer::IsImmuneToEnvironmentalDamage},        // :IsImmuneToEnvironmentalDamage() - UNDOCUMENTED - Returns true if the player is immune to environmental damage
-    { "CanSpeak", &LuaPlayer::CanSpeak },
-    { "HasAtLoginFlag", &LuaPlayer::HasAtLoginFlag },
-    // {"InRandomLfgDungeon", &LuaPlayer::InRandomLfgDungeon},                              // :InRandomLfgDungeon() - UNDOCUMENTED - Returns true if the player is in a random LFG dungeon
-    // {"HasPendingBind", &LuaPlayer::HasPendingBind},                                      // :HasPendingBind() - UNDOCUMENTED - Returns true if the player has a pending instance bind
-    { "HasAchieved", &LuaPlayer::HasAchieved },
-    { "GetAchievementCriteriaProgress", &LuaPlayer::GetAchievementCriteriaProgress },
-    { "SetAchievement", &LuaPlayer::SetAchievement },
-    { "CanUninviteFromGroup", &LuaPlayer::CanUninviteFromGroup },
-    { "IsRested", &LuaPlayer::IsRested },
-    // {"CanFlyInZone", &LuaPlayer::CanFlyInZone},                                          // :CanFlyInZone(mapid, zone) - UNDOCUMENTED - Returns true if the player can fly in the area
-    // {"IsNeverVisible", &LuaPlayer::IsNeverVisible},                                      // :IsNeverVisible() - UNDOCUMENTED - Returns true if the player is never visible
-    { "IsVisibleForPlayer", &LuaPlayer::IsVisibleForPlayer },
-    // {"IsUsingLfg", &LuaPlayer::IsUsingLfg},                                              // :IsUsingLfg() - UNDOCUMENTED - Returns true if the player is using LFG
-    { "HasQuestForItem", &LuaPlayer::HasQuestForItem },
-    { "HasQuestForGO", &LuaPlayer::HasQuestForGO },
-    { "CanShareQuest", &LuaPlayer::CanShareQuest },
-    // {"HasReceivedQuestReward", &LuaPlayer::HasReceivedQuestReward},                      // :HasReceivedQuestReward(entry) - UNDOCUMENTED - Returns true if the player has recieved the quest's reward
-    { "HasTalent", &LuaPlayer::HasTalent },
-    { "IsInSameGroupWith", &LuaPlayer::IsInSameGroupWith },
-    { "IsInSameRaidWith", &LuaPlayer::IsInSameRaidWith },
-    { "IsGroupVisibleFor", &LuaPlayer::IsGroupVisibleFor },
-    { "HasSkill", &LuaPlayer::HasSkill },
-    { "IsHonorOrXPTarget", &LuaPlayer::IsHonorOrXPTarget },
-    { "CanParry", &LuaPlayer::CanParry },
-    { "CanBlock", &LuaPlayer::CanBlock },
-    { "CanTitanGrip", &LuaPlayer::CanTitanGrip },
-    { "InBattleground", &LuaPlayer::InBattleground },
-    { "InArena", &LuaPlayer::InArena },
-    // {"IsOutdoorPvPActive", &LuaPlayer::IsOutdoorPvPActive},                              // :IsOutdoorPvPActive() - UNDOCUMENTED - Returns true if the player is outdoor pvp active
-    // {"IsARecruiter", &LuaPlayer::IsARecruiter},                                          // :IsARecruiter() - UNDOCUMENTED - Returns true if the player is a recruiter
-    { "CanUseItem", &LuaPlayer::CanUseItem },
-    { "HasSpell", &LuaPlayer::HasSpell },
-    { "HasSpellCooldown", &LuaPlayer::HasSpellCooldown },
-    { "IsInWater", &LuaPlayer::IsInWater },
-    { "CanFly", &LuaPlayer::CanFly },
-    { "IsMoving", &LuaPlayer::IsMoving },
-    { "IsFlying", &LuaPlayer::IsFlying },
-    { "CanPetResurrect", &LuaPlayer::CanPetResurrect },
-    { "IsExistPet", &LuaPlayer::IsExistPet },
-    { "CanTameExoticPets", &LuaPlayer::CanTameExoticPets },
-    { "IsPetNeedBeTemporaryUnsummoned", &LuaPlayer::IsPetNeedBeTemporaryUnsummoned },
-    { "CanResummonPet", &LuaPlayer::CanResummonPet },
-    { "CanSeeDKPet", &LuaPlayer::CanSeeDKPet },
-    { "IsMaxLevel", &LuaPlayer::IsMaxLevel },
-    { "IsDailyQuestDone", &LuaPlayer::IsDailyQuestDone },
-    { "IsPvP", &LuaPlayer::IsPvP },
-    { "IsFFAPvP", &LuaPlayer::IsFFAPvP },
-    { "IsUsingLfg", &LuaPlayer::IsUsingLfg },
-    { "InRandomLfgDungeon", &LuaPlayer::InRandomLfgDungeon },
-    { "CanInteractWithQuestGiver", &LuaPlayer::CanInteractWithQuestGiver },
-    { "CanSeeStartQuest", &LuaPlayer::CanSeeStartQuest },
-    { "CanTakeQuest", &LuaPlayer::CanTakeQuest },
-    { "CanAddQuest", &LuaPlayer::CanAddQuest },
-    { "CalculateReputationGain", &LuaPlayer::CalculateReputationGain },
-    { "HasTitleByIndex", &LuaPlayer::HasTitleByIndex },
-    { "IsAtGroupRewardDistance", &LuaPlayer::IsAtGroupRewardDistance },
-    { "IsAtLootRewardDistance", &LuaPlayer::IsAtLootRewardDistance },
-    { "CanTeleport", &LuaPlayer::CanTeleport },
-    { "IsSpectator", &LuaPlayer::IsSpectator },
-    { "HasKnownTaxiNode", &LuaPlayer::HasKnownTaxiNode },
-    { "IsBot", &LuaPlayer::IsBot },
-    // { "HasSpellMod", &LuaPlayer::HasSpellMod },
-
-    // Gossip
-    { "GossipMenuAddItem", &LuaPlayer::GossipMenuAddItem },
-    { "GossipSendMenu", &LuaPlayer::GossipSendMenu },
-    { "GossipComplete", &LuaPlayer::GossipComplete },
-    { "GossipClearMenu", &LuaPlayer::GossipClearMenu },
-
-    // Other
-    { "SendBroadcastMessage", &LuaPlayer::SendBroadcastMessage },
-    { "SendAreaTriggerMessage", &LuaPlayer::SendAreaTriggerMessage },
-    { "SendNotification", &LuaPlayer::SendNotification },
-    { "SendPacket", &LuaPlayer::SendPacket },
-    { "SendAddonMessage", &LuaPlayer::SendAddonMessage },
-    { "ModifyMoney", &LuaPlayer::ModifyMoney },
-    { "LearnSpell", &LuaPlayer::LearnSpell },
-    { "LearnTalent", &LuaPlayer::LearnTalent },
-
-    { "RunCommand", &LuaPlayer::RunCommand },
-    { "SetGlyph", &LuaPlayer::SetGlyph },
-    { "GetGlyph", &LuaPlayer::GetGlyph },
-    { "RemoveArenaSpellCooldowns", &LuaPlayer::RemoveArenaSpellCooldowns },
-    { "RemoveItem", &LuaPlayer::RemoveItem },
-    { "RemoveLifetimeKills", &LuaPlayer::RemoveLifetimeKills },
-    { "ResurrectPlayer", &LuaPlayer::ResurrectPlayer },
-    { "EquipItem", &LuaPlayer::EquipItem },
-    { "ResetSpellCooldown", &LuaPlayer::ResetSpellCooldown },
-    { "ResetTypeCooldowns", &LuaPlayer::ResetTypeCooldowns },
-    { "ResetAllCooldowns", &LuaPlayer::ResetAllCooldowns },
-    { "GiveXP", &LuaPlayer::GiveXP },                                                       // :GiveXP(xp[, victim, pureXP, triggerHook]) - UNDOCUMENTED - Gives XP to the player. If pure is false, bonuses are count in. If triggerHook is false, GiveXp hook is not triggered.
-    // {"RemovePet", &LuaPlayer::RemovePet},                                                // :RemovePet([mode, returnreagent]) - UNDOCUMENTED - Removes the player's pet. Mode determines if the pet is saved and how
-    // {"SummonPet", &LuaPlayer::SummonPet},                                              // :SummonPet(entry, x, y, z, o, petType, despwtime) - Summons a pet for the player
-    { "Say", &LuaPlayer::Say },
-    { "Yell", &LuaPlayer::Yell },
-    { "TextEmote", &LuaPlayer::TextEmote },
-    { "Whisper", &LuaPlayer::Whisper },
-    { "CompleteQuest", &LuaPlayer::CompleteQuest },
-    { "IncompleteQuest", &LuaPlayer::IncompleteQuest },
-    { "FailQuest", &LuaPlayer::FailQuest },
-    { "AddQuest", &LuaPlayer::AddQuest },
-    { "RemoveQuest", &LuaPlayer::RemoveQuest },
-    // {"RemoveActiveQuest", &LuaPlayer::RemoveActiveQuest},                                // :RemoveActiveQuest(entry) - UNDOCUMENTED - Removes an active quest
-    // {"RemoveRewardedQuest", &LuaPlayer::RemoveRewardedQuest},                            // :RemoveRewardedQuest(entry) - UNDOCUMENTED - Removes a rewarded quest
-    { "AreaExploredOrEventHappens", &LuaPlayer::AreaExploredOrEventHappens },
-    { "GroupEventHappens", &LuaPlayer::GroupEventHappens },
-    { "KilledMonsterCredit", &LuaPlayer::KilledMonsterCredit },
-    // {"KilledPlayerCredit", &LuaPlayer::KilledPlayerCredit},                              // :KilledPlayerCredit() - UNDOCUMENTED - Satisfies a player kill for the player
-    // {"KillGOCredit", &LuaPlayer::KillGOCredit},                                          // :KillGOCredit(GOEntry[, GUID]) - UNDOCUMENTED - Credits the player for destroying a GO, guid is optional
-    { "TalkedToCreature", &LuaPlayer::TalkedToCreature },
-    { "ResetPetTalents", &LuaPlayer::ResetPetTalents },
-    { "AddComboPoints", &LuaPlayer::AddComboPoints },
-    // {"GainSpellComboPoints", &LuaPlayer::GainSpellComboPoints},                          // :GainSpellComboPoints(amount) - UNDOCUMENTED - Player gains spell combo points
-    { "ClearComboPoints", &LuaPlayer::ClearComboPoints },
-    { "RemoveSpell", &LuaPlayer::RemoveSpell },
-    { "ResetTalents", &LuaPlayer::ResetTalents },
-    { "ResetTalentsCost", &LuaPlayer::ResetTalentsCost },
-    // {"AddTalent", &LuaPlayer::AddTalent},                                                // :AddTalent(spellid, spec, learning) - UNDOCUMENTED - Adds a talent spell for the player to given spec
-    { "RemoveFromGroup", &LuaPlayer::RemoveFromGroup },
-    { "KillPlayer", &LuaPlayer::KillPlayer },
-    { "DurabilityLossAll", &LuaPlayer::DurabilityLossAll },
-    { "DurabilityLoss", &LuaPlayer::DurabilityLoss },
-    { "DurabilityPointsLoss", &LuaPlayer::DurabilityPointsLoss },
-    { "DurabilityPointsLossAll", &LuaPlayer::DurabilityPointsLossAll },
-    { "DurabilityPointLossForEquipSlot", &LuaPlayer::DurabilityPointLossForEquipSlot },
-    { "DurabilityRepairAll", &LuaPlayer::DurabilityRepairAll },
-    { "DurabilityRepair", &LuaPlayer::DurabilityRepair },
-    { "ModifyHonorPoints", &LuaPlayer::ModifyHonorPoints },
-    { "ModifyArenaPoints", &LuaPlayer::ModifyArenaPoints },
-    { "LeaveBattleground", &LuaPlayer::LeaveBattleground },
-    // {"BindToInstance", &LuaPlayer::BindToInstance},                                      // :BindToInstance() - UNDOCUMENTED - Binds the player to the current instance
-    { "UnbindInstance", &LuaPlayer::UnbindInstance },
-    { "UnbindAllInstances", &LuaPlayer::UnbindAllInstances },
-    { "RemoveFromBattlegroundRaid", &LuaPlayer::RemoveFromBattlegroundRaid },
-    { "ResetAchievements", &LuaPlayer::ResetAchievements },
-    { "KickPlayer", &LuaPlayer::KickPlayer },
-    { "LogoutPlayer", &LuaPlayer::LogoutPlayer },
-    { "SendTrainerList", &LuaPlayer::SendTrainerList },
-    { "SendListInventory", &LuaPlayer::SendListInventory },
-    { "SendShowBank", &LuaPlayer::SendShowBank },
-    { "SendTabardVendorActivate", &LuaPlayer::SendTabardVendorActivate },
-    { "SendSpiritResurrect", &LuaPlayer::SendSpiritResurrect },
-    { "SendTaxiMenu", &LuaPlayer::SendTaxiMenu },
-    { "SendUpdateWorldState", &LuaPlayer::SendUpdateWorldState },
-    { "RewardQuest", &LuaPlayer::RewardQuest },
-    { "SendAuctionMenu", &LuaPlayer::SendAuctionMenu },
-    { "SendShowMailBox", &LuaPlayer::SendShowMailBox },
-    { "StartTaxi", &LuaPlayer::StartTaxi },
-    { "GossipSendPOI", &LuaPlayer::GossipSendPOI },
-    { "GossipAddQuests", &LuaPlayer::GossipAddQuests },
-    { "SendQuestTemplate", &LuaPlayer::SendQuestTemplate },
-    { "SpawnBones", &LuaPlayer::SpawnBones },
-    { "RemovedInsignia", &LuaPlayer::RemovedInsignia },
-    { "SendGuildInvite", &LuaPlayer::SendGuildInvite },
-    { "Mute", &LuaPlayer::Mute },
-    { "SummonPlayer", &LuaPlayer::SummonPlayer },
-    { "SaveToDB", &LuaPlayer::SaveToDB },
-    { "GroupInvite", &LuaPlayer::GroupInvite },
-    { "GroupCreate", &LuaPlayer::GroupCreate },
-    { "SendCinematicStart", &LuaPlayer::SendCinematicStart },
-    { "SendMovieStart", &LuaPlayer::SendMovieStart },
-    { "UpdatePlayerSetting", &LuaPlayer::UpdatePlayerSetting },
-    { "TeleportTo", &LuaPlayer::TeleportTo },
-    { "SummonPet", &LuaPlayer::SummonPet },
-    { "CreatePet", &LuaPlayer::CreatePet },
-    { "UnsummonPetTemporarily", &LuaPlayer::UnsummonPetTemporarily },
-    { "RemovePet", &LuaPlayer::RemovePet },
-    { "ResetPetTalents", &LuaPlayer::ResetPetTalents },
-    { "LearnPetTalent", &LuaPlayer::LearnPetTalent },
-    { "ResummonPetTemporaryUnSummonedIfAny", &LuaPlayer::ResummonPetTemporaryUnSummonedIfAny },
-    { "SetPlayerFlag", &LuaPlayer::SetPlayerFlag },
-    { "RemovePlayerFlag", &LuaPlayer::RemovePlayerFlag },
-    { "DoRandomRoll", &LuaPlayer::DoRandomRoll },
-    { "EnvironmentalDamage", &LuaPlayer::EnvironmentalDamage },
-    { "InitTaxiNodesForLevel", &LuaPlayer::InitTaxiNodesForLevel },
-    { "AbandonQuest", &LuaPlayer::AbandonQuest },
-    { "AddWeaponProficiency", &LuaPlayer::AddWeaponProficiency },
-    { "AddArmorProficiency", &LuaPlayer::AddArmorProficiency },
-    { "SetAmmo", &LuaPlayer::SetAmmo },
-    { "RemoveAmmo", &LuaPlayer::RemoveAmmo },
-    { "SetCanTeleport", &LuaPlayer::SetCanTeleport },
-    { "SetIsSpectator", &LuaPlayer::SetIsSpectator },
-    { "SetViewpoint", &LuaPlayer::SetViewpoint },
-    { "ToggleInstantFlight", &LuaPlayer::ToggleInstantFlight },
-    { "SetCreationTime", &LuaPlayer::SetCreationTime },
-    { "ApplyRatingMod", &LuaPlayer::ApplyRatingMod },
-
-    { NULL, NULL }
-};
-
-ALERegister<Creature> CreatureMethods[] =
-{
-    // Getters
-    { "GetAITarget", &LuaCreature::GetAITarget },
-    { "GetAITargets", &LuaCreature::GetAITargets },
-    { "GetAITargetsCount", &LuaCreature::GetAITargetsCount },
-    { "GetHomePosition", &LuaCreature::GetHomePosition },
-    { "GetCorpseDelay", &LuaCreature::GetCorpseDelay },
-    { "GetCreatureSpellCooldownDelay", &LuaCreature::GetCreatureSpellCooldownDelay },
-    { "GetScriptId", &LuaCreature::GetScriptId },
-    { "GetAIName", &LuaCreature::GetAIName },
-    { "GetScriptName", &LuaCreature::GetScriptName },
-    { "GetAggroRange", &LuaCreature::GetAggroRange },
-    { "GetDefaultMovementType", &LuaCreature::GetDefaultMovementType },
-    { "GetRespawnDelay", &LuaCreature::GetRespawnDelay },
-    { "GetWanderRadius", &LuaCreature::GetWanderRadius },
-    { "GetCurrentWaypointId", &LuaCreature::GetCurrentWaypointId },
-    { "GetSpawnId", &LuaCreature::GetSpawnId },
-    { "GetWaypointPath", &LuaCreature::GetWaypointPath },
-    { "GetLootMode", &LuaCreature::GetLootMode },
-    { "GetLootRecipient", &LuaCreature::GetLootRecipient },
-    { "GetLootRecipientGroup", &LuaCreature::GetLootRecipientGroup },
-    { "GetNPCFlags", &LuaCreature::GetNPCFlags },
-    { "GetUnitFlags", &LuaCreature::GetUnitFlags },
-    { "GetUnitFlagsTwo", &LuaCreature::GetUnitFlagsTwo },
-    { "GetExtraFlags", &LuaCreature::GetExtraFlags },
-    { "GetRank", &LuaCreature::GetRank },
-    { "GetShieldBlockValue", &LuaCreature::GetShieldBlockValue },
-    { "GetDBTableGUIDLow", &LuaCreature::GetDBTableGUIDLow },
-    { "GetCreatureFamily", &LuaCreature::GetCreatureFamily },
-    { "GetReactState", &LuaCreature::GetReactState },
-    { "GetLoot", &LuaCreature::GetLoot },
-
-    // Setters
-    { "SetRegeneratingHealth", &LuaCreature::SetRegeneratingHealth },
-    { "SetHover", &LuaCreature::SetHover },
-    { "SetDisableGravity", &LuaCreature::SetDisableGravity },
-    { "SetAggroEnabled", &LuaCreature::SetAggroEnabled },
-    { "SetCorpseDelay", &LuaCreature::SetCorpseDelay },
-    { "SetNoCallAssistance", &LuaCreature::SetNoCallAssistance },
-    { "SetNoSearchAssistance", &LuaCreature::SetNoSearchAssistance },
-    { "SetDefaultMovementType", &LuaCreature::SetDefaultMovementType },
-    { "SetRespawnDelay", &LuaCreature::SetRespawnDelay },
-    { "SetWanderRadius", &LuaCreature::SetWanderRadius },
-    { "SetInCombatWithZone", &LuaCreature::SetInCombatWithZone },
-    { "SetDisableReputationGain", &LuaCreature::SetDisableReputationGain },
-    { "SetLootMode", &LuaCreature::SetLootMode },
-    { "SetNPCFlags", &LuaCreature::SetNPCFlags },
-    { "SetUnitFlags", &LuaCreature::SetUnitFlags },
-    { "SetUnitFlagsTwo", &LuaCreature::SetUnitFlagsTwo },
-    { "SetReactState", &LuaCreature::SetReactState },
-    { "SetDeathState", &LuaCreature::SetDeathState },
-    { "SetWalk", &LuaCreature::SetWalk },
-    { "SetHomePosition", &LuaCreature::SetHomePosition },
-    { "SetEquipmentSlots", &LuaCreature::SetEquipmentSlots },
-
-    // Boolean
-    { "IsRegeneratingHealth", &LuaCreature::IsRegeneratingHealth },
-    { "IsDungeonBoss", &LuaCreature::IsDungeonBoss },
-    { "IsWorldBoss", &LuaCreature::IsWorldBoss },
-    { "IsRacialLeader", &LuaCreature::IsRacialLeader },
-    { "IsCivilian", &LuaCreature::IsCivilian },
-    { "IsTrigger", &LuaCreature::IsTrigger },
-    { "IsGuard", &LuaCreature::IsGuard },
-    { "IsElite", &LuaCreature::IsElite },
-    { "IsInEvadeMode", &LuaCreature::IsInEvadeMode },
-    { "HasCategoryCooldown", &LuaCreature::HasCategoryCooldown },
-    { "CanWalk", &LuaCreature::CanWalk },
-    { "CanSwim", &LuaCreature::CanSwim },
-    { "CanAggro", &LuaCreature::CanAggro },
-    { "CanStartAttack", &LuaCreature::CanStartAttack },
-    { "HasSearchedAssistance", &LuaCreature::HasSearchedAssistance },
-    { "IsTappedBy", &LuaCreature::IsTappedBy },
-    { "HasLootRecipient", &LuaCreature::HasLootRecipient },
-    { "CanAssistTo", &LuaCreature::CanAssistTo },
-    { "IsTargetableForAttack", &LuaCreature::IsTargetableForAttack },
-    { "CanCompleteQuest", &LuaCreature::CanCompleteQuest },
-    { "IsReputationGainDisabled", &LuaCreature::IsReputationGainDisabled },
-    { "IsDamageEnoughForLootingAndReward", &LuaCreature::IsDamageEnoughForLootingAndReward },
-    { "HasLootMode", &LuaCreature::HasLootMode },
-    { "HasSpell", &LuaCreature::HasSpell },
-    { "HasQuest", &LuaCreature::HasQuest },
-    { "HasSpellCooldown", &LuaCreature::HasSpellCooldown },
-    { "CanFly", &LuaCreature::CanFly },
-
-    // Other
-    { "FleeToGetAssistance", &LuaCreature::FleeToGetAssistance },
-    { "CallForHelp", &LuaCreature::CallForHelp },
-    { "CallAssistance", &LuaCreature::CallAssistance },
-    { "RemoveCorpse", &LuaCreature::RemoveCorpse },
-    { "AllLootRemovedFromCorpse", &LuaCreature::AllLootRemovedFromCorpse },
-    { "DespawnOrUnsummon", &LuaCreature::DespawnOrUnsummon },
-    { "Respawn", &LuaCreature::Respawn },
-    { "AttackStart", &LuaCreature::AttackStart },
-    { "AddLootMode", &LuaCreature::AddLootMode },
-    { "ResetLootMode", &LuaCreature::ResetLootMode },
-    { "RemoveLootMode", &LuaCreature::RemoveLootMode },
-    { "SaveToDB", &LuaCreature::SaveToDB },
-    { "SelectVictim", &LuaCreature::SelectVictim },
-    { "MoveWaypoint", &LuaCreature::MoveWaypoint },
-    { "UpdateEntry", &LuaCreature::UpdateEntry },
-
-    { NULL, NULL }
-};
-
-ALERegister<GameObject> GameObjectMethods[] =
-{
-    // Getters
-    { "GetDisplayId", &LuaGameObject::GetDisplayId },
-    { "GetGoState", &LuaGameObject::GetGoState },
-    { "GetLootState", &LuaGameObject::GetLootState },
-    { "GetLootRecipient", &LuaGameObject::GetLootRecipient },
-    { "GetLootRecipientGroup", &LuaGameObject::GetLootRecipientGroup },
-    { "GetSpawnId", &LuaGameObject::GetSpawnId },
-
-    // Setters
-    { "SetGoState", &LuaGameObject::SetGoState },
-    { "SetLootState", &LuaGameObject::SetLootState },
-    { "SetRespawnTime", &LuaGameObject::SetRespawnTime },
-    { "SetRespawnDelay", &LuaGameObject::SetRespawnDelay },
-
-    // Boolean
-    { "IsTransport", &LuaGameObject::IsTransport },
-    // {"IsDestructible", &LuaGameObject::IsDestructible},    // :IsDestructible() - UNDOCUMENTED
-    { "IsActive", &LuaGameObject::IsActive },
-    { "HasQuest", &LuaGameObject::HasQuest },
-    { "IsSpawned", &LuaGameObject::IsSpawned },
-
-    // Other
-    { "RemoveFromWorld", &LuaGameObject::RemoveFromWorld },
-    { "UseDoorOrButton", &LuaGameObject::UseDoorOrButton },
-    { "Despawn", &LuaGameObject::Despawn },
-    { "Respawn", &LuaGameObject::Respawn },
-    { "SaveToDB", &LuaGameObject::SaveToDB },
-    { "AddLoot", &LuaGameObject::AddLoot },
-
-    { NULL, NULL }
-};
-
-ALERegister<Item> ItemMethods[] =
-{
-    // Getters
-    { "GetOwnerGUID", &LuaItem::GetOwnerGUID },
-    { "GetOwner", &LuaItem::GetOwner },
-    { "GetCount", &LuaItem::GetCount },
-    { "GetMaxStackCount", &LuaItem::GetMaxStackCount },
-    { "GetSlot", &LuaItem::GetSlot },
-    { "GetBagSlot", &LuaItem::GetBagSlot },
-    { "GetEnchantmentId", &LuaItem::GetEnchantmentId },
-    { "GetSpellId", &LuaItem::GetSpellId },
-    { "GetSpellTrigger", &LuaItem::GetSpellTrigger },
-    { "GetItemLink", &LuaItem::GetItemLink },
-    { "GetClass", &LuaItem::GetClass },
-    { "GetSubClass", &LuaItem::GetSubClass },
-    { "GetName", &LuaItem::GetName },
-    { "GetDisplayId", &LuaItem::GetDisplayId },
-    { "GetQuality", &LuaItem::GetQuality },
-    { "GetBuyCount", &LuaItem::GetBuyCount },
-    { "GetBuyPrice", &LuaItem::GetBuyPrice },
-    { "GetSellPrice", &LuaItem::GetSellPrice },
-    { "GetInventoryType", &LuaItem::GetInventoryType },
-    { "GetAllowableClass", &LuaItem::GetAllowableClass },
-    { "GetAllowableRace", &LuaItem::GetAllowableRace },
-    { "GetItemLevel", &LuaItem::GetItemLevel },
-    { "GetRequiredLevel", &LuaItem::GetRequiredLevel },
-    { "GetStatsCount", &LuaItem::GetStatsCount },
-    { "GetRandomProperty", &LuaItem::GetRandomProperty },
-    { "GetRandomSuffix", &LuaItem::GetRandomSuffix },
-    { "GetItemSet", &LuaItem::GetItemSet },
-    { "GetBagSize", &LuaItem::GetBagSize },
-    { "GetItemTemplate", &LuaItem::GetItemTemplate },
-
-    // Setters
-    { "SetOwner", &LuaItem::SetOwner },
-    { "SetBinding", &LuaItem::SetBinding },
-    { "SetCount", &LuaItem::SetCount },
-    { "SetRandomProperty", &LuaItem::SetRandomProperty },
-    { "SetRandomSuffix", &LuaItem::SetRandomSuffix },
-
-    // Boolean
-    { "IsSoulBound", &LuaItem::IsSoulBound },
-    { "IsBoundAccountWide", &LuaItem::IsBoundAccountWide },
-    { "IsBoundByEnchant", &LuaItem::IsBoundByEnchant },
-    { "IsNotBoundToPlayer", &LuaItem::IsNotBoundToPlayer },
-    { "IsLocked", &LuaItem::IsLocked },
-    { "IsBag", &LuaItem::IsBag },
-    { "IsCurrencyToken", &LuaItem::IsCurrencyToken },
-    { "IsNotEmptyBag", &LuaItem::IsNotEmptyBag },
-    { "IsBroken", &LuaItem::IsBroken },
-    { "CanBeTraded", &LuaItem::CanBeTraded },
-    { "IsInTrade", &LuaItem::IsInTrade },
-    { "IsInBag", &LuaItem::IsInBag },
-    { "IsEquipped", &LuaItem::IsEquipped },
-    { "HasQuest", &LuaItem::HasQuest },
-    { "IsPotion", &LuaItem::IsPotion },
-    { "IsWeaponVellum", &LuaItem::IsWeaponVellum },
-    { "IsArmorVellum", &LuaItem::IsArmorVellum },
-    { "IsConjuredConsumable", &LuaItem::IsConjuredConsumable },
-    //{"IsRefundExpired", &LuaItem::IsRefundExpired},               // :IsRefundExpired() - UNDOCUMENTED - Returns true if the item's refund time has expired
-    { "SetEnchantment", &LuaItem::SetEnchantment },
-    { "ClearEnchantment", &LuaItem::ClearEnchantment },
-
-    // Other
-    { "SaveToDB", &LuaItem::SaveToDB },
-
-    { NULL, NULL }
-};
-
-ALERegister<ItemTemplate> ItemTemplateMethods[] =
-{
-    { "GetItemId", &LuaItemTemplate::GetItemId },
-    { "GetClass", &LuaItemTemplate::GetClass },
-    { "GetSubClass", &LuaItemTemplate::GetSubClass },
-    { "GetName", &LuaItemTemplate::GetName },
-    { "GetDisplayId", &LuaItemTemplate::GetDisplayId },
-    { "GetQuality", &LuaItemTemplate::GetQuality },
-    { "GetFlags", &LuaItemTemplate::GetFlags },
-    { "GetExtraFlags", &LuaItemTemplate::GetExtraFlags },
-    { "GetBuyCount", &LuaItemTemplate::GetBuyCount },
-    { "GetBuyPrice", &LuaItemTemplate::GetBuyPrice },
-    { "GetSellPrice", &LuaItemTemplate::GetSellPrice },
-    { "GetInventoryType", &LuaItemTemplate::GetInventoryType },
-    { "GetAllowableClass", &LuaItemTemplate::GetAllowableClass },
-    { "GetAllowableRace", &LuaItemTemplate::GetAllowableRace },
-    { "GetItemLevel", &LuaItemTemplate::GetItemLevel },
-    { "GetRequiredLevel", &LuaItemTemplate::GetRequiredLevel },
-    { "GetIcon", &LuaItemTemplate::GetIcon },
-    { NULL, NULL }
-};
-
-ALERegister<Aura> AuraMethods[] =
-{
-    // Getters
-    { "GetCaster", &LuaAura::GetCaster },
-    { "GetCasterGUID", &LuaAura::GetCasterGUID },
-    { "GetCasterLevel", &LuaAura::GetCasterLevel },
-    { "GetDuration", &LuaAura::GetDuration },
-    { "GetMaxDuration", &LuaAura::GetMaxDuration },
-    { "GetAuraId", &LuaAura::GetAuraId },
-    { "GetStackAmount", &LuaAura::GetStackAmount },
-    { "GetOwner", &LuaAura::GetOwner },
-
-    // Setters
-    { "SetDuration", &LuaAura::SetDuration },
-    { "SetMaxDuration", &LuaAura::SetMaxDuration },
-    { "SetStackAmount", &LuaAura::SetStackAmount },
-
-    // Other
-    { "Remove", &LuaAura::Remove },
-
-    { NULL, NULL }
-};
-
-ALERegister<Spell> SpellMethods[] =
-{
-    // Getters
-    { "GetCaster", &LuaSpell::GetCaster },
-    { "GetCastTime", &LuaSpell::GetCastTime },
-    { "GetEntry", &LuaSpell::GetEntry },
-    { "GetDuration", &LuaSpell::GetDuration },
-    { "GetPowerCost", &LuaSpell::GetPowerCost },
-    { "GetReagentCost", &LuaSpell::GetReagentCost },
-    { "GetTargetDest", &LuaSpell::GetTargetDest },
-    { "GetTarget", &LuaSpell::GetTarget },
-
-    // Setters
-    { "SetAutoRepeat", &LuaSpell::SetAutoRepeat },
-
-    // Boolean
-    { "IsAutoRepeat", &LuaSpell::IsAutoRepeat },
-
-    // Other
-    { "Cancel", &LuaSpell::Cancel },
-    { "Cast", &LuaSpell::Cast },
-    { "Finish", &LuaSpell::Finish },
-
-    { NULL, NULL }
-};
-
-ALERegister<Quest> QuestMethods[] =
-{
-    // Getters
-    { "GetId", &LuaQuest::GetId },
-    { "GetLevel", &LuaQuest::GetLevel },
-    // {"GetMaxLevel", &LuaQuest::GetMaxLevel},                   // :GetMaxLevel() - UNDOCUMENTED - Returns the quest's max level
-    { "GetMinLevel", &LuaQuest::GetMinLevel },
-    { "GetNextQuestId", &LuaQuest::GetNextQuestId },
-    { "GetPrevQuestId", &LuaQuest::GetPrevQuestId },
-    { "GetNextQuestInChain", &LuaQuest::GetNextQuestInChain },
-    { "GetFlags", &LuaQuest::GetFlags },
-    { "GetType", &LuaQuest::GetType },
-
-    // Boolean
-    { "HasFlag", &LuaQuest::HasFlag },
-    { "IsDaily", &LuaQuest::IsDaily },
-    { "IsRepeatable", &LuaQuest::IsRepeatable },
-
-    { NULL, NULL }
-};
-
-ALERegister<Group> GroupMethods[] =
-{
-    // Getters
-    { "GetMembers", &LuaGroup::GetMembers },
-    { "GetLeaderGUID", &LuaGroup::GetLeaderGUID },
-    { "GetGUID", &LuaGroup::GetGUID },
-    { "GetMemberGroup", &LuaGroup::GetMemberGroup },
-    { "GetMemberGUID", &LuaGroup::GetMemberGUID },
-    { "GetMembersCount", &LuaGroup::GetMembersCount },
-    { "GetGroupType", &LuaGroup::GetGroupType },
-
-    // Setters
-    { "SetLeader", &LuaGroup::SetLeader },
-    { "SetMembersGroup", &LuaGroup::SetMembersGroup },
-    { "SetTargetIcon", &LuaGroup::SetTargetIcon },
-    { "SetMemberFlag", &LuaGroup::SetMemberFlag },
-
-    // Boolean
-    { "IsLeader", &LuaGroup::IsLeader },
-    { "AddMember", &LuaGroup::AddMember },
-    { "RemoveMember", &LuaGroup::RemoveMember },
-    { "Disband", &LuaGroup::Disband },
-    { "IsFull", &LuaGroup::IsFull },
-    { "IsLFGGroup", &LuaGroup::IsLFGGroup },
-    { "IsRaidGroup", &LuaGroup::IsRaidGroup },
-    { "IsBGGroup", &LuaGroup::IsBGGroup },
-    // {"IsBFGroup", &LuaGroup::IsBFGroup},                       // :IsBFGroup() - UNDOCUMENTED - Returns true if the group is a battlefield group
-    { "IsMember", &LuaGroup::IsMember },
-    { "IsAssistant", &LuaGroup::IsAssistant },
-    { "SameSubGroup", &LuaGroup::SameSubGroup },
-    { "HasFreeSlotSubGroup", &LuaGroup::HasFreeSlotSubGroup },
-
-    // Other
-    { "SendPacket", &LuaGroup::SendPacket },
-    // {"ConvertToLFG", &LuaGroup::ConvertToLFG},                 // :ConvertToLFG() - UNDOCUMENTED - Converts the group to an LFG group
-    { "ConvertToRaid", &LuaGroup::ConvertToRaid },
-
-    { NULL, NULL }
-};
-
-ALERegister<Guild> GuildMethods[] =
-{
-    // Getters
-    { "GetMembers", &LuaGuild::GetMembers },
-    { "GetLeader", &LuaGuild::GetLeader },
-    { "GetLeaderGUID", &LuaGuild::GetLeaderGUID },
-    { "GetId", &LuaGuild::GetId },
-    { "GetName", &LuaGuild::GetName },
-    { "GetMOTD", &LuaGuild::GetMOTD },
-    { "GetInfo", &LuaGuild::GetInfo },
-    { "GetMemberCount", &LuaGuild::GetMemberCount },
-    { "GetCreatedDate", &LuaGuild::GetCreatedDate },
-    { "GetTotalBankMoney", &LuaGuild::GetTotalBankMoney },
-
-    // Setters
-    { "SetBankTabText", &LuaGuild::SetBankTabText },
-    { "SetMemberRank", &LuaGuild::SetMemberRank },
-    { "SetLeader", &LuaGuild::SetLeader },
-    { "SetName", &LuaGuild::SetName },
-
-    // Other
-    { "SendPacket", &LuaGuild::SendPacket },
-    { "SendPacketToRanked", &LuaGuild::SendPacketToRanked },
-    { "Disband", &LuaGuild::Disband },
-    { "AddMember", &LuaGuild::AddMember },
-    { "DeleteMember", &LuaGuild::DeleteMember },
-    { "SendMessage", &LuaGuild::SendMessage },
-    { "UpdateMemberData", &LuaGuild::UpdateMemberData },
-    { "MassInviteToEvent", &LuaGuild::MassInviteToEvent },
-    { "SwapItems", &LuaGuild::SwapItems },
-    { "SwapItemsWithInventory", &LuaGuild::SwapItemsWithInventory },
-    { "ResetTimes", &LuaGuild::ResetTimes },
-    { "ModifyBankMoney", &LuaGuild::ModifyBankMoney },
-
-    { NULL, NULL }
-};
-
-ALERegister<Vehicle> VehicleMethods[] =
-{
-    // Getters
-    { "GetOwner", &LuaVehicle::GetOwner },
-    { "GetEntry", &LuaVehicle::GetEntry },
-    { "GetPassenger", &LuaVehicle::GetPassenger },
-
-    // Boolean
-    { "IsOnBoard", &LuaVehicle::IsOnBoard },
-
-    // Other
-    { "AddPassenger", &LuaVehicle::AddPassenger },
-    { "RemovePassenger", &LuaVehicle::RemovePassenger },
-
-    { NULL, NULL }
-};
-
-ALERegister<ALEQuery> QueryMethods[] =
-{
-    // Getters
-    { "GetColumnCount", &LuaQuery::GetColumnCount },
-    { "GetRowCount", &LuaQuery::GetRowCount },
-    { "GetRow", &LuaQuery::GetRow },
-    { "GetBool", &LuaQuery::GetBool },
-    { "GetUInt8", &LuaQuery::GetUInt8 },
-    { "GetUInt16", &LuaQuery::GetUInt16 },
-    { "GetUInt32", &LuaQuery::GetUInt32 },
-    { "GetUInt64", &LuaQuery::GetUInt64 },
-    { "GetInt8", &LuaQuery::GetInt8 },
-    { "GetInt16", &LuaQuery::GetInt16 },
-    { "GetInt32", &LuaQuery::GetInt32 },
-    { "GetInt64", &LuaQuery::GetInt64 },
-    { "GetFloat", &LuaQuery::GetFloat },
-    { "GetDouble", &LuaQuery::GetDouble },
-    { "GetString", &LuaQuery::GetString },
-
-    // Boolean
-    { "NextRow", &LuaQuery::NextRow },
-    { "IsNull", &LuaQuery::IsNull },
-
-    { NULL, NULL }
-};
-
-ALERegister<WorldPacket> PacketMethods[] =
-{
-    // Getters
-    { "GetOpcode", &LuaPacket::GetOpcode },
-    { "GetSize", &LuaPacket::GetSize },
-
-    // Setters
-    { "SetOpcode", &LuaPacket::SetOpcode },
-
-    // Readers
-    { "ReadByte", &LuaPacket::ReadByte },
-    { "ReadUByte", &LuaPacket::ReadUByte },
-    { "ReadShort", &LuaPacket::ReadShort },
-    { "ReadUShort", &LuaPacket::ReadUShort },
-    { "ReadLong", &LuaPacket::ReadLong },
-    { "ReadULong", &LuaPacket::ReadULong },
-    { "ReadGUID", &LuaPacket::ReadGUID },
-    { "ReadPackedGUID", &LuaPacket::ReadPackedGUID },
-    { "ReadString", &LuaPacket::ReadString },
-    { "ReadFloat", &LuaPacket::ReadFloat },
-    { "ReadDouble", &LuaPacket::ReadDouble },
-
-    // Writers
-    { "WriteByte", &LuaPacket::WriteByte },
-    { "WriteUByte", &LuaPacket::WriteUByte },
-    { "WriteShort", &LuaPacket::WriteShort },
-    { "WriteUShort", &LuaPacket::WriteUShort },
-    { "WriteLong", &LuaPacket::WriteLong },
-    { "WriteULong", &LuaPacket::WriteULong },
-    { "WriteGUID", &LuaPacket::WriteGUID },
-    { "WritePackedGUID", &LuaPacket::WritePackedGUID },
-    { "WriteString", &LuaPacket::WriteString },
-    { "WriteFloat", &LuaPacket::WriteFloat },
-    { "WriteDouble", &LuaPacket::WriteDouble },
-
-    { NULL, NULL }
-};
-
-ALERegister<Map> MapMethods[] =
-{
-    // Getters
-    { "GetName", &LuaMap::GetName },
-    { "GetDifficulty", &LuaMap::GetDifficulty },
-    { "GetInstanceId", &LuaMap::GetInstanceId },
-    { "GetInstanceData", &LuaMap::GetInstanceData },
-    { "GetPlayerCount", &LuaMap::GetPlayerCount },
-    { "GetPlayers", &LuaMap::GetPlayers },
-    { "GetMapId", &LuaMap::GetMapId },
-    { "GetAreaId", &LuaMap::GetAreaId },
-    { "GetHeight", &LuaMap::GetHeight },
-    { "GetWorldObject", &LuaMap::GetWorldObject },
-    { "GetCreatures", &LuaMap::GetCreatures },
-    { "GetCreaturesByAreaId", &LuaMap::GetCreaturesByAreaId },
-    { "GetTransports", &LuaMap::GetTransports },
-
-
-    // Setters
-    { "SetWeather", &LuaMap::SetWeather },
-
-    // Boolean
-    { "IsArena", &LuaMap::IsArena },
-    { "IsBattleground", &LuaMap::IsBattleground },
-    { "IsDungeon", &LuaMap::IsDungeon },
-    { "IsEmpty", &LuaMap::IsEmpty },
-    { "IsHeroic", &LuaMap::IsHeroic },
-    { "IsRaid", &LuaMap::IsRaid },
-
-    // Other
-    { "SaveInstanceData", &LuaMap::SaveInstanceData },
-
-    { NULL, NULL }
-};
-
-ALERegister<Corpse> CorpseMethods[] =
-{
-    // Getters
-    { "GetOwnerGUID", &LuaCorpse::GetOwnerGUID },
-    { "GetGhostTime", &LuaCorpse::GetGhostTime },
-    { "GetType", &LuaCorpse::GetType },
-
-    // Other
-    { "ResetGhostTime", &LuaCorpse::ResetGhostTime },
-    { "SaveToDB", &LuaCorpse::SaveToDB },
-
-    { NULL, NULL }
-};
-
-ALERegister<AuctionHouseEntry> AuctionMethods[] =
-{
-    { NULL, NULL }
-};
-
-ALERegister<BattleGround> BattleGroundMethods[] =
-{
-    // Getters
-    { "GetName", &LuaBattleGround::GetName },
-    { "GetAlivePlayersCountByTeam", &LuaBattleGround::GetAlivePlayersCountByTeam },
-    { "GetMap", &LuaBattleGround::GetMap },
-    { "GetBonusHonorFromKillCount", &LuaBattleGround::GetBonusHonorFromKillCount },
-    { "GetEndTime", &LuaBattleGround::GetEndTime },
-    { "GetFreeSlotsForTeam", &LuaBattleGround::GetFreeSlotsForTeam },
-    { "GetInstanceId", &LuaBattleGround::GetInstanceId },
-    { "GetMapId", &LuaBattleGround::GetMapId },
-    { "GetTypeId", &LuaBattleGround::GetTypeId },
-    { "GetMaxLevel", &LuaBattleGround::GetMaxLevel },
-    { "GetMinLevel", &LuaBattleGround::GetMinLevel },
-    { "GetMaxPlayers", &LuaBattleGround::GetMaxPlayers },
-    { "GetMinPlayers", &LuaBattleGround::GetMinPlayers },
-    { "GetMaxPlayersPerTeam", &LuaBattleGround::GetMaxPlayersPerTeam },
-    { "GetMinPlayersPerTeam", &LuaBattleGround::GetMinPlayersPerTeam },
-    { "GetWinner", &LuaBattleGround::GetWinner },
-    { "GetStatus", &LuaBattleGround::GetStatus },
-
-    { NULL, NULL }
-};
-
-ALERegister<ChatHandler> ChatHandlerMethods[] =
-{
-    { "SendSysMessage", &LuaChatHandler::SendSysMessage },
-    { "IsConsole", &LuaChatHandler::IsConsole },
-    { "GetPlayer", &LuaChatHandler::GetPlayer },
-    { "SendGlobalSysMessage", &LuaChatHandler::SendGlobalSysMessage },
-    { "SendGlobalGMSysMessage", &LuaChatHandler::SendGlobalGMSysMessage },
-    { "HasLowerSecurity", &LuaChatHandler::HasLowerSecurity },
-    { "HasLowerSecurityAccount", &LuaChatHandler::HasLowerSecurityAccount },
-    { "GetSelectedPlayer", &LuaChatHandler::GetSelectedPlayer },
-    { "GetSelectedCreature", &LuaChatHandler::GetSelectedCreature },
-    { "GetSelectedUnit", &LuaChatHandler::GetSelectedUnit },
-    { "GetSelectedObject", &LuaChatHandler::GetSelectedObject },
-    { "GetSelectedPlayerOrSelf", &LuaChatHandler::GetSelectedPlayerOrSelf },
-    { "IsAvailable", &LuaChatHandler::IsAvailable },
-    { "HasSentErrorMessage", &LuaChatHandler::HasSentErrorMessage },
-
-    { NULL, NULL }
-};
-
-ALERegister<AchievementEntry> AchievementMethods[] =
-{
-    { "GetId", &LuaAchievement::GetId },
-    { "GetName", &LuaAchievement::GetName },
-
-    { NULL, NULL }
-};
-
-ALERegister<Roll> RollMethods[] =
-{
-    { "GetItemGUID", &LuaRoll::GetItemGUID },
-    { "GetItemId", &LuaRoll::GetItemId },
-    { "GetItemRandomPropId", &LuaRoll::GetItemRandomPropId },
-    { "GetItemRandomSuffix", &LuaRoll::GetItemRandomSuffix },
-    { "GetItemCount", &LuaRoll::GetItemCount },
-    { "GetPlayerVote", &LuaRoll::GetPlayerVote },
-    { "GetPlayerVoteGUIDs", &LuaRoll::GetPlayerVoteGUIDs },
-    { "GetTotalPlayersRolling", &LuaRoll::GetTotalPlayersRolling },
-    { "GetTotalNeed", &LuaRoll::GetTotalNeed },
-    { "GetTotalGreed", &LuaRoll::GetTotalGreed },
-    { "GetTotalPass", &LuaRoll::GetTotalPass },
-    { "GetItemSlot", &LuaRoll::GetItemSlot },
-    { "GetRollVoteMask", &LuaRoll::GetRollVoteMask },
-
-    { NULL, NULL }
-};
-
-ALERegister<GmTicket> TicketMethods[] =
-{
-    { "IsClosed", &LuaTicket::IsClosed },
-    { "IsCompleted", &LuaTicket::IsCompleted },
-    { "IsFromPlayer", &LuaTicket::IsFromPlayer },
-    { "IsAssigned", &LuaTicket::IsAssigned },
-    { "IsAssignedTo", &LuaTicket::IsAssignedTo },
-    { "IsAssignedNotTo", &LuaTicket::IsAssignedNotTo },
-
-    { "GetId", &LuaTicket::GetId },
-    { "GetPlayer", &LuaTicket::GetPlayer },
-    { "GetPlayerName", &LuaTicket::GetPlayerName },
-    { "GetMessage", &LuaTicket::GetMessage },
-    { "GetAssignedPlayer", &LuaTicket::GetAssignedPlayer },
-    { "GetAssignedToGUID", &LuaTicket::GetAssignedToGUID },
-    { "GetLastModifiedTime", &LuaTicket::GetLastModifiedTime },
-    { "GetResponse", &LuaTicket::GetResponse },
-    { "GetChatLog", &LuaTicket::GetChatLog },
-
-    { "SetAssignedTo", &LuaTicket::SetAssignedTo },
-    { "SetResolvedBy", &LuaTicket::SetResolvedBy },
-    { "SetCompleted", &LuaTicket::SetCompleted },
-    { "SetMessage", &LuaTicket::SetMessage },
-    { "SetComment", &LuaTicket::SetComment },
-    { "SetViewed", &LuaTicket::SetViewed },
-    { "SetUnassigned", &LuaTicket::SetUnassigned },
-    { "SetPosition", &LuaTicket::SetPosition },
-    { "AppendResponse", &LuaTicket::AppendResponse },
-    { "DeleteResponse", &LuaTicket::DeleteResponse },
-  
-    { NULL, NULL }
-};
-
-ALERegister<SpellInfo> SpellInfoMethods[] =
-{
-    // Getters
-    { "GetAttributes", &LuaSpellInfo::GetAttributes },
-    { "GetCategory", &LuaSpellInfo::GetCategory },
-    { "GetName", &LuaSpellInfo::GetName },
-    { "CheckShapeshift", &LuaSpellInfo::CheckShapeshift },
-    { "CheckLocation", &LuaSpellInfo::CheckLocation },
-    { "CheckTarget", &LuaSpellInfo::CheckTarget },
-    { "CheckExplicitTarget", &LuaSpellInfo::CheckExplicitTarget },
-    { "CheckTargetCreatureType", &LuaSpellInfo::CheckTargetCreatureType },
-    { "CheckTargetCreatureType", &LuaSpellInfo::CheckTargetCreatureType },
-    { "GetSchoolMask", &LuaSpellInfo::GetSchoolMask },
-    { "GetAllEffectsMechanicMask", &LuaSpellInfo::GetAllEffectsMechanicMask },
-    { "GetEffectMechanicMask", &LuaSpellInfo::GetEffectMechanicMask },
-    { "GetSpellMechanicMaskByEffectMask", &LuaSpellInfo::GetSpellMechanicMaskByEffectMask },
-    { "GetEffectMechanic", &LuaSpellInfo::GetEffectMechanic },
-    { "GetDispelMask", &LuaSpellInfo::GetDispelMask },
-    { "GetExplicitTargetMask", &LuaSpellInfo::GetExplicitTargetMask },
-    { "GetAuraState", &LuaSpellInfo::GetAuraState },
-    { "GetSpellSpecific", &LuaSpellInfo::GetSpellSpecific },
-    { "GetEffectMiscValueA", &LuaSpellInfo::GetEffectMiscValueA },
-    { "GetEffectMiscValueB", &LuaSpellInfo::GetEffectMiscValueB },
-
-    // Setters
-
-    // Boolean
-    { "HasAreaAuraEffect", &LuaSpellInfo::HasAreaAuraEffect },
-    { "HasAttribute", &LuaSpellInfo::HasAttribute },
-    { "HasAura", &LuaSpellInfo::HasAura },
-    { "HasEffect", &LuaSpellInfo::HasEffect },
-
-    { "IsAbilityLearnedWithProfession", &LuaSpellInfo::IsAbilityLearnedWithProfession },
-    { "IsAbilityOfSkillType", &LuaSpellInfo::IsAbilityOfSkillType },
-    { "IsAffectingArea", &LuaSpellInfo::IsAffectingArea },
-    { "IsAllowingDeadTarget", &LuaSpellInfo::IsAllowingDeadTarget },
-    { "IsAutocastable", &LuaSpellInfo::IsAutocastable },
-    { "IsAutoRepeatRangedSpell", &LuaSpellInfo::IsAutoRepeatRangedSpell },
-    { "IsBreakingStealth", &LuaSpellInfo::IsBreakingStealth },
-    { "IsChanneled", &LuaSpellInfo::IsChanneled },
-    { "IsCooldownStartedOnEvent", &LuaSpellInfo::IsCooldownStartedOnEvent },
-    { "IsDeathPersistent", &LuaSpellInfo::IsDeathPersistent },
-    { "IsExplicitDiscovery", &LuaSpellInfo::IsExplicitDiscovery },
-    { "IsLootCrafting", &LuaSpellInfo::IsLootCrafting },
-    { "IsMultiSlotAura", &LuaSpellInfo::IsMultiSlotAura },
-    { "IsPassive", &LuaSpellInfo::IsPassive },
-    { "IsPassiveStackableWithRanks", &LuaSpellInfo::IsPassiveStackableWithRanks },
-    { "IsPositive", &LuaSpellInfo::IsPositive },
-    { "IsPositiveEffect", &LuaSpellInfo::IsPositiveEffect },
-    { "IsPrimaryProfession", &LuaSpellInfo::IsPrimaryProfession },
-    { "IsPrimaryProfessionFirstRank", &LuaSpellInfo::IsPrimaryProfessionFirstRank },
-    { "IsProfession", &LuaSpellInfo::IsProfession },
-    { "IsProfessionOrRiding", &LuaSpellInfo::IsProfessionOrRiding },
-    { "IsRangedWeaponSpell", &LuaSpellInfo::IsRangedWeaponSpell },
-    { "IsRequiringDeadTarget", &LuaSpellInfo::IsRequiringDeadTarget },
-    { "IsStackableWithRanks", &LuaSpellInfo::IsStackableWithRanks },
-    { "IsTargetingArea", &LuaSpellInfo::IsTargetingArea },
-    { "IsAffectedBySpellMods", &LuaSpellInfo::IsAffectedBySpellMods },
-    /* { "IsAffectedBySpellMod", &LuaSpellInfo::IsAffectedBySpellMod }, */
-    { "CanPierceImmuneAura", &LuaSpellInfo::CanPierceImmuneAura },
-    { "CanDispelAura", &LuaSpellInfo::CanDispelAura },
-    { "IsSingleTarget", &LuaSpellInfo::IsSingleTarget },
-    { "IsAuraExclusiveBySpecificWith", &LuaSpellInfo::IsAuraExclusiveBySpecificWith },
-    { "IsAuraExclusiveBySpecificPerCasterWith", &LuaSpellInfo::IsAuraExclusiveBySpecificPerCasterWith },
-    { "CanBeUsedInCombat", &LuaSpellInfo::CanBeUsedInCombat },
-
-    { "NeedsComboPoints", &LuaSpellInfo::NeedsComboPoints },
-    { "NeedsExplicitUnitTarget", &LuaSpellInfo::NeedsExplicitUnitTarget },
-    { "NeedsToBeTriggeredByCaster", &LuaSpellInfo::NeedsToBeTriggeredByCaster },
-
-    { NULL, NULL }
-};
-
-ALERegister<GemPropertiesEntry> GemPropertiesEntryMethods[] =
-{
-    // Getters
-    { "GetId", &LuaGemPropertiesEntry::GetId },
-    { "GetSpellItemEnchantement", &LuaGemPropertiesEntry::GetSpellItemEnchantement },
-
-    { NULL, NULL }
-};
-
-ALERegister<SpellEntry> SpellEntryMethods[] =
-{
-    // Getters
-    { "GetId", &LuaSpellEntry::GetId },
-    { "GetCategory", &LuaSpellEntry::GetCategory },
-    { "GetDispel", &LuaSpellEntry::GetDispel },
-    { "GetMechanic", &LuaSpellEntry::GetMechanic },
-    { "GetAttributes", &LuaSpellEntry::GetAttributes },
-    { "GetAttributesEx", &LuaSpellEntry::GetAttributesEx },
-    { "GetAttributesEx2", &LuaSpellEntry::GetAttributesEx2 },
-    { "GetAttributesEx3", &LuaSpellEntry::GetAttributesEx3 },
-    { "GetAttributesEx4", &LuaSpellEntry::GetAttributesEx4 },
-    { "GetAttributesEx5", &LuaSpellEntry::GetAttributesEx5 },
-    { "GetAttributesEx6", &LuaSpellEntry::GetAttributesEx6 },
-    { "GetAttributesEx7", &LuaSpellEntry::GetAttributesEx7 },
-    { "GetStances", &LuaSpellEntry::GetStances },
-    { "GetStancesNot", &LuaSpellEntry::GetStancesNot },
-    { "GetTargets", &LuaSpellEntry::GetTargets },
-    { "GetTargetCreatureType", &LuaSpellEntry::GetTargetCreatureType },
-    { "GetRequiresSpellFocus", &LuaSpellEntry::GetRequiresSpellFocus },
-    { "GetFacingCasterFlags", &LuaSpellEntry::GetFacingCasterFlags },
-    { "GetCasterAuraState", &LuaSpellEntry::GetCasterAuraState },
-    { "GetTargetAuraState", &LuaSpellEntry::GetTargetAuraState },
-    { "GetCasterAuraStateNot", &LuaSpellEntry::GetCasterAuraStateNot },
-    { "GetTargetAuraStateNot", &LuaSpellEntry::GetTargetAuraStateNot },
-    { "GetCasterAuraSpell", &LuaSpellEntry::GetCasterAuraSpell },
-    { "GetTargetAuraSpell", &LuaSpellEntry::GetTargetAuraSpell },
-    { "GetExcludeCasterAuraSpell", &LuaSpellEntry::GetExcludeCasterAuraSpell },
-    { "GetExcludeTargetAuraSpell", &LuaSpellEntry::GetExcludeTargetAuraSpell },
-    { "GetCastingTimeIndex", &LuaSpellEntry::GetCastingTimeIndex },
-    { "GetRecoveryTime", &LuaSpellEntry::GetRecoveryTime },
-    { "GetCategoryRecoveryTime", &LuaSpellEntry::GetCategoryRecoveryTime },
-    { "GetInterruptFlags", &LuaSpellEntry::GetInterruptFlags },
-    { "GetAuraInterruptFlags", &LuaSpellEntry::GetAuraInterruptFlags },
-    { "GetChannelInterruptFlags", &LuaSpellEntry::GetChannelInterruptFlags },
-    { "GetProcFlags", &LuaSpellEntry::GetProcFlags },
-    { "GetProcChance", &LuaSpellEntry::GetProcChance },
-    { "GetProcCharges", &LuaSpellEntry::GetProcCharges },
-    { "GetMaxLevel", &LuaSpellEntry::GetMaxLevel },
-    { "GetBaseLevel", &LuaSpellEntry::GetBaseLevel },
-    { "GetSpellLevel", &LuaSpellEntry::GetSpellLevel },
-    { "GetDurationIndex", &LuaSpellEntry::GetDurationIndex },
-    { "GetPowerType", &LuaSpellEntry::GetPowerType },
-    { "GetManaCost", &LuaSpellEntry::GetManaCost },
-    { "GetManaCostPerlevel", &LuaSpellEntry::GetManaCostPerlevel },
-    { "GetManaPerSecond", &LuaSpellEntry::GetManaPerSecond },
-    { "GetManaPerSecondPerLevel", &LuaSpellEntry::GetManaPerSecondPerLevel },
-    { "GetRangeIndex", &LuaSpellEntry::GetRangeIndex },
-    { "GetSpeed", &LuaSpellEntry::GetSpeed },
-    { "GetStackAmount", &LuaSpellEntry::GetStackAmount },
-    { "GetTotem", &LuaSpellEntry::GetTotem },
-    { "GetReagent", &LuaSpellEntry::GetReagent },
-    { "GetReagentCount", &LuaSpellEntry::GetReagentCount },
-    { "GetEquippedItemClass", &LuaSpellEntry::GetEquippedItemClass },
-    { "GetEquippedItemSubClassMask", &LuaSpellEntry::GetEquippedItemSubClassMask },
-    { "GetEquippedItemInventoryTypeMask", &LuaSpellEntry::GetEquippedItemInventoryTypeMask },
-    { "GetEffect", &LuaSpellEntry::GetEffect },
-    { "GetEffectDieSides", &LuaSpellEntry::GetEffectDieSides },
-    { "GetEffectRealPointsPerLevel", &LuaSpellEntry::GetEffectRealPointsPerLevel },
-    { "GetEffectBasePoints", &LuaSpellEntry::GetEffectBasePoints },
-    { "GetEffectMechanic", &LuaSpellEntry::GetEffectMechanic },
-    { "GetEffectImplicitTargetA", &LuaSpellEntry::GetEffectImplicitTargetA },
-    { "GetEffectImplicitTargetB", &LuaSpellEntry::GetEffectImplicitTargetB },
-    { "GetEffectRadiusIndex", &LuaSpellEntry::GetEffectRadiusIndex },
-    { "GetEffectApplyAuraName", &LuaSpellEntry::GetEffectApplyAuraName },
-    { "GetEffectAmplitude", &LuaSpellEntry::GetEffectAmplitude },
-    { "GetEffectValueMultiplier", &LuaSpellEntry::GetEffectValueMultiplier },
-    { "GetEffectChainTarget", &LuaSpellEntry::GetEffectChainTarget },
-    { "GetEffectItemType", &LuaSpellEntry::GetEffectItemType },
-    { "GetEffectMiscValue", &LuaSpellEntry::GetEffectMiscValue },
-    { "GetEffectMiscValueB", &LuaSpellEntry::GetEffectMiscValueB },
-    { "GetEffectTriggerSpell", &LuaSpellEntry::GetEffectTriggerSpell },
-    { "GetEffectPointsPerComboPoint", &LuaSpellEntry::GetEffectPointsPerComboPoint },
-    { "GetEffectSpellClassMask", &LuaSpellEntry::GetEffectSpellClassMask },
-    { "GetSpellVisual", &LuaSpellEntry::GetSpellVisual },
-    { "GetSpellIconID", &LuaSpellEntry::GetSpellIconID },
-    { "GetActiveIconID", &LuaSpellEntry::GetActiveIconID },
-    { "GetSpellPriority", &LuaSpellEntry::GetSpellPriority },
-    { "GetSpellName", &LuaSpellEntry::GetSpellName },
-    { "GetRank", &LuaSpellEntry::GetRank },
-    { "GetManaCostPercentage", &LuaSpellEntry::GetManaCostPercentage },
-    { "GetStartRecoveryCategory", &LuaSpellEntry::GetStartRecoveryCategory },
-    { "GetStartRecoveryTime", &LuaSpellEntry::GetStartRecoveryTime },
-    { "GetMaxTargetLevel", &LuaSpellEntry::GetMaxTargetLevel },
-    { "GetSpellFamilyName", &LuaSpellEntry::GetSpellFamilyName },
-    { "GetSpellFamilyFlags", &LuaSpellEntry::GetSpellFamilyFlags },
-    { "GetMaxAffectedTargets", &LuaSpellEntry::GetMaxAffectedTargets },
-    { "GetDmgClass", &LuaSpellEntry::GetDmgClass },
-    { "GetPreventionType", &LuaSpellEntry::GetPreventionType },
-    { "GetEffectDamageMultiplier", &LuaSpellEntry::GetEffectDamageMultiplier },
-    { "GetTotemCategory", &LuaSpellEntry::GetTotemCategory },
-    { "GetAreaGroupId", &LuaSpellEntry::GetAreaGroupId },
-    { "GetSchoolMask", &LuaSpellEntry::GetSchoolMask },
-    { "GetRuneCostID", &LuaSpellEntry::GetRuneCostID },
-    { "GetEffectBonusMultiplier", &LuaSpellEntry::GetEffectBonusMultiplier },
-
-    // Setters
-    { "SetCategory", &LuaSpellEntry::SetCategory },
-    { "SetDispel", &LuaSpellEntry::SetDispel },
-    { "SetMechanic", &LuaSpellEntry::SetMechanic },
-    { "SetAttributes", &LuaSpellEntry::SetAttributes },
-    { "SetAttributesEx", &LuaSpellEntry::SetAttributesEx },
-    { "SetAttributesEx2", &LuaSpellEntry::SetAttributesEx2 },
-    { "SetAttributesEx3", &LuaSpellEntry::SetAttributesEx3 },
-    { "SetAttributesEx4", &LuaSpellEntry::SetAttributesEx4 },
-    { "SetAttributesEx5", &LuaSpellEntry::SetAttributesEx5 },
-    { "SetAttributesEx6", &LuaSpellEntry::SetAttributesEx6 },
-    { "SetAttributesEx7", &LuaSpellEntry::SetAttributesEx7 },
-    { "SetStances", &LuaSpellEntry::SetStances },
-    { "SetStancesNot", &LuaSpellEntry::SetStancesNot },
-    { "SetTargets", &LuaSpellEntry::SetTargets },
-    { "SetTargetCreatureType", &LuaSpellEntry::SetTargetCreatureType },
-    { "SetRequiresSpellFocus", &LuaSpellEntry::SetRequiresSpellFocus },
-    { "SetFacingCasterFlags", &LuaSpellEntry::SetFacingCasterFlags },
-    { "SetCasterAuraState", &LuaSpellEntry::SetCasterAuraState },
-    { "SetTargetAuraState", &LuaSpellEntry::SetTargetAuraState },
-    { "SetCasterAuraStateNot", &LuaSpellEntry::SetCasterAuraStateNot },
-    { "SetTargetAuraStateNot", &LuaSpellEntry::SetTargetAuraStateNot },
-    { "SetCasterAuraSpell", &LuaSpellEntry::SetCasterAuraSpell },
-    { "SetTargetAuraSpell", &LuaSpellEntry::SetTargetAuraSpell },
-    { "SetExcludeCasterAuraSpell", &LuaSpellEntry::SetExcludeCasterAuraSpell },
-    { "SetExcludeTargetAuraSpell", &LuaSpellEntry::SetExcludeTargetAuraSpell },
-    { "SetRecoveryTime", &LuaSpellEntry::SetRecoveryTime },
-    { "SetCategoryRecoveryTime", &LuaSpellEntry::SetCategoryRecoveryTime },
-    { "SetInterruptFlags", &LuaSpellEntry::SetInterruptFlags },
-    { "SetAuraInterruptFlags", &LuaSpellEntry::SetAuraInterruptFlags },
-    { "SetChannelInterruptFlags", &LuaSpellEntry::SetChannelInterruptFlags },
-    { "SetProcFlags", &LuaSpellEntry::SetProcFlags },
-    { "SetProcChance", &LuaSpellEntry::SetProcChance },
-    { "SetProcCharges", &LuaSpellEntry::SetProcCharges },
-    { "SetMaxLevel", &LuaSpellEntry::SetMaxLevel },
-    { "SetBaseLevel", &LuaSpellEntry::SetBaseLevel },
-    { "SetSpellLevel", &LuaSpellEntry::SetSpellLevel },
-    { "SetPowerType", &LuaSpellEntry::SetPowerType },
-    { "SetManaCost", &LuaSpellEntry::SetManaCost },
-    { "SetManaCostPerlevel", &LuaSpellEntry::SetManaCostPerlevel },
-    { "SetManaPerSecond", &LuaSpellEntry::SetManaPerSecond },
-    { "SetManaPerSecondPerLevel", &LuaSpellEntry::SetManaPerSecondPerLevel },
-    { "SetSpeed", &LuaSpellEntry::SetSpeed },
-    { "SetStackAmount", &LuaSpellEntry::SetStackAmount },
-    { "SetEquippedItemClass", &LuaSpellEntry::SetEquippedItemClass },
-    { "SetEquippedItemSubClassMask", &LuaSpellEntry::SetEquippedItemSubClassMask },
-    { "SetEquippedItemInventoryTypeMask", &LuaSpellEntry::SetEquippedItemInventoryTypeMask },
-    { "SetSpellIconID", &LuaSpellEntry::SetSpellIconID },
-    { "SetActiveIconID", &LuaSpellEntry::SetActiveIconID },
-    { "SetSpellPriority", &LuaSpellEntry::SetSpellPriority },
-    { "SetManaCostPercentage", &LuaSpellEntry::SetManaCostPercentage },
-    { "SetStartRecoveryCategory", &LuaSpellEntry::SetStartRecoveryCategory },
-    { "SetStartRecoveryTime", &LuaSpellEntry::SetStartRecoveryTime },
-    { "SetMaxTargetLevel", &LuaSpellEntry::SetMaxTargetLevel },
-    { "SetSpellFamilyName", &LuaSpellEntry::SetSpellFamilyName },
-    { "SetMaxAffectedTargets", &LuaSpellEntry::SetMaxAffectedTargets },
-    { "SetDmgClass", &LuaSpellEntry::SetDmgClass },
-    { "SetPreventionType", &LuaSpellEntry::SetPreventionType },
-    { "SetSchoolMask", &LuaSpellEntry::SetSchoolMask },
-    { "SetRuneCostID", &LuaSpellEntry::SetRuneCostID },
-
-    { NULL, NULL }
-};
-
-ALERegister<Pet> PetMethods[] =
-{
-    // Getters
-    { "GetPetType", &LuaPet::GetPetType },
-    { "GetDuration", &LuaPet::GetDuration },
-    { "GetHappinessState", &LuaPet::GetHappinessState },
-    { "GetCurrentFoodBenefitLevel", &LuaPet::GetCurrentFoodBenefitLevel },
-    { "GetMaxTalentPointsForLevel", &LuaPet::GetMaxTalentPointsForLevel },
-    { "GetFreeTalentPoints", &LuaPet::GetFreeTalentPoints },
-    { "GetUsedTalentCount", &LuaPet::GetUsedTalentCount },
-    { "GetAuraUpdateMaskForRaid", &LuaPet::GetAuraUpdateMaskForRaid },
-    { "GetOwner", &LuaPet::GetOwner },
-    { "GetPetAutoSpellSize", &LuaPet::GetPetAutoSpellSize },
-    { "GetPetAutoSpellOnPos", &LuaPet::GetPetAutoSpellOnPos },
-
-    // Setters
-    { "SetPetType", &LuaPet::SetPetType },
-    { "SetDuration", &LuaPet::SetDuration },
-    { "SetFreeTalentPoints", &LuaPet::SetFreeTalentPoints },
-    { "SetUsedTalentCount", &LuaPet::SetUsedTalentCount },
-    { "SetAuraUpdateMaskForRaid", &LuaPet::SetAuraUpdateMaskForRaid },
-    { "SetRemoved", &LuaPet::SetRemoved },
-
-    // Boolean
-    { "IsControlled", &LuaPet::IsControlled },
-    { "IsTemporarySummoned", &LuaPet::IsTemporarySummoned },
-    { "IsPermanentPetFor", &LuaPet::IsPermanentPetFor },
-    { "HaveInDiet", &LuaPet::HaveInDiet },
-    { "HasTempSpell", &LuaPet::HasTempSpell },
-    { "IsRemoved", &LuaPet::IsRemoved },
-    { "IsBeingLoaded", &LuaPet::IsBeingLoaded },
-
-    // Other
-    { "CreateBaseAtCreature", &LuaPet::CreateBaseAtCreature },
-    { "GivePetXP", &LuaPet::GivePetXP },
-    { "GivePetLevel", &LuaPet::GivePetLevel },
-    { "SynchronizeLevelWithOwner", &LuaPet::SynchronizeLevelWithOwner },
-    { "ToggleAutocast", &LuaPet::ToggleAutocast },
-    { "LearnPetPassives", &LuaPet::LearnPetPassives },
-    { "CastWhenWillAvailable", &LuaPet::CastWhenWillAvailable },
-    { "ClearCastWhenWillAvailable", &LuaPet::ClearCastWhenWillAvailable },
-    { "AddSpell", &LuaPet::AddSpell },
-    { "LearnSpell", &LuaPet::LearnSpell },
-    { "LearnSpellHighRank", &LuaPet::LearnSpellHighRank },
-    { "InitLevelupSpellsForLevel", &LuaPet::InitLevelupSpellsForLevel },
-    { "UnlearnSpell", &LuaPet::UnlearnSpell },
-    { "RemoveSpell", &LuaPet::RemoveSpell },
-    { "CleanupActionBar", &LuaPet::CleanupActionBar },
-    { "GenerateActionBarData", &LuaPet::GenerateActionBarData },
-    { "InitPetCreateSpells", &LuaPet::InitPetCreateSpells },
-    { "ResetTalents", &LuaPet::ResetTalents },
-    { "InitTalentForLevel", &LuaPet::InitTalentForLevel },
-    { "ResetAuraUpdateMaskForRaid", &LuaPet::ResetAuraUpdateMaskForRaid },
-    { "SavePetToDB", &LuaPet::SavePetToDB },
-    { "Remove", &LuaPet::Remove },
-
-    { NULL, NULL }
-};
-
-ALERegister<Loot> LootMethods[] =
-{
-    // Get
-    { "GetMoney", &LuaLoot::GetMoney },
-    { "GetItems", &LuaLoot::GetItems },
-    { "GetQuestItems", &LuaLoot::GetQuestItems },
-    { "GetUnlootedCount", &LuaLoot::GetUnlootedCount },
-    { "GetLootType", &LuaLoot::GetLootType },
-    { "GetRoundRobinPlayer", &LuaLoot::GetRoundRobinPlayer },
-    { "GetLootOwner", &LuaLoot::GetLootOwner },
-    { "GetContainer", &LuaLoot::GetContainer },
-    { "GetSourceWorldObject", &LuaLoot::GetSourceWorldObject },
-    { "GetItemCount", &LuaLoot::GetItemCount },
-    { "GetMaxSlotForPlayer", &LuaLoot::GetMaxSlotForPlayer },
 
-    // Set
-    { "AddItem", &LuaLoot::AddItem },
-    { "RemoveItem", &LuaLoot::RemoveItem },
-    { "SetMoney", &LuaLoot::SetMoney },
-    { "SetUnlootedCount", &LuaLoot::SetUnlootedCount },
-    { "UpdateItemIndex", &LuaLoot::UpdateItemIndex },
-    { "SetItemLooted", &LuaLoot::SetItemLooted },
-    { "SetLootType", &LuaLoot::SetLootType },
-    { "SetRoundRobinPlayer", &LuaLoot::SetRoundRobinPlayer },
-    { "SetLootOwner", &LuaLoot::SetLootOwner },
-    { "SetContainer", &LuaLoot::SetContainer },
-    { "SetSourceWorldObject", &LuaLoot::SetSourceWorldObject },
-    { "Clear", &LuaLoot::Clear },
-    { "AddLooter", &LuaLoot::AddLooter },
-    { "RemoveLooter", &LuaLoot::RemoveLooter },
+#include "ALERegistry.h"
+#include "CreatureData.h"
+#include "ObjectGuid.h"
 
-    // Boolean
-    { "HasItem", &LuaLoot::HasItem },
-    { "HasQuestItems", &LuaLoot::HasQuestItems },
-    { "HasItemForAll", &LuaLoot::HasItemForAll },
-    { "HasOverThresholdItem", &LuaLoot::HasOverThresholdItem },
-    { "IsLooted", &LuaLoot::IsLooted },
-    { "IsEmpty", &LuaLoot::IsEmpty },
-
-    { NULL, NULL }
-};
-
-ALERegister<Transport> TransportMethods[] =
-{
-    // Getters
-    { "GetPassengers", &LuaTransport::GetPassengers },
-
-    // Boolean
-    { "IsMotionTransport", &LuaTransport::IsMotionTransport },
-
-    // Other
-    { "AddPassenger", &LuaTransport::AddPassenger },
-    { "RemovePassenger", &LuaTransport::RemovePassenger },
-    { "EnableMovement", &LuaTransport::EnableMovement },
-
-    { NULL, NULL }
-};
-
-// fix compile error about accessing vehicle destructor
-template<> int ALETemplate<Vehicle>::CollectGarbage(lua_State* L)
-{
-    ASSERT(!manageMemory);
-
-    // Get object pointer (and check type, no error)
-    ALEObject* obj = ALE::CHECKOBJ<ALEObject>(L, 1, false);
-    delete obj;
-    return 0;
-}
-
-// Template by Mud from http://stackoverflow.com/questions/4484437/lua-integer-type/4485511#4485511
-template<> int ALETemplate<unsigned long long>::Add(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) + ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-template<> int ALETemplate<unsigned long long>::Substract(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) - ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-template<> int ALETemplate<unsigned long long>::Multiply(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) * ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-template<> int ALETemplate<unsigned long long>::Divide(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) / ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-template<> int ALETemplate<unsigned long long>::Mod(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) % ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-// template<> int ALETemplate<unsigned long long>::UnaryMinus(lua_State* L) { ALE::Push(L, -ALE::CHECKVAL<unsigned long long>(L, 1)); return 1; }
-template<> int ALETemplate<unsigned long long>::Equal(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) == ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-template<> int ALETemplate<unsigned long long>::Less(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) < ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-template<> int ALETemplate<unsigned long long>::LessOrEqual(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<unsigned long long>(L, 1) <= ALE::CHECKVAL<unsigned long long>(L, 2)); return 1; }
-template<> int ALETemplate<unsigned long long>::Pow(lua_State* L)
-{
-    ALE::Push(L, static_cast<unsigned long long>(powl(static_cast<long double>(ALE::CHECKVAL<unsigned long long>(L, 1)), static_cast<long double>(ALE::CHECKVAL<unsigned long long>(L, 2)))));
-    return 1;
-}
-template<> int ALETemplate<unsigned long long>::ToString(lua_State* L)
-{
-    unsigned long long l = ALE::CHECKVAL<unsigned long long>(L, 1);
-    std::ostringstream ss;
-    ss << l;
-    ALE::Push(L, ss.str());
-    return 1;
+/*
+ * Every game object crossing the C++/Lua boundary carries its ObjectGuid, and
+ * many methods return one (GetGUID, GetOwnerGUID, ...). Exposing it as a real
+ * usertype replaces the old boxed "long long"/"unsigned long long" userdata:
+ * guids compare with ==, print with tostring() and never lose precision the
+ * way Lua numbers would.
+ */
+namespace LuaObjectGuid
+{
+    /**
+     * Returns the low (counter) part of the guid, unique per object type.
+     *
+     * @return uint32 counter
+     */
+    uint32 GetCounter(ObjectGuid guid)
+    {
+        return guid.GetCounter();
+    }
+
+    /**
+     * Returns the entry id encoded in the guid (creature/gameobject template entry), or 0.
+     *
+     * @return uint32 entry
+     */
+    uint32 GetEntry(ObjectGuid guid)
+    {
+        return guid.GetEntry();
+    }
+
+    /**
+     * Returns 'true' if the guid is empty (references nothing).
+     *
+     * @return bool isEmpty
+     */
+    bool IsEmpty(ObjectGuid guid)
+    {
+        return guid.IsEmpty();
+    }
+
+    /**
+     * Returns 'true' if the guid belongs to a player.
+     *
+     * @return bool isPlayer
+     */
+    bool IsPlayer(ObjectGuid guid)
+    {
+        return guid.IsPlayer();
+    }
+
+    /**
+     * Returns 'true' if the guid belongs to a creature, pet or vehicle.
+     *
+     * @return bool isCreature
+     */
+    bool IsCreature(ObjectGuid guid)
+    {
+        return guid.IsAnyTypeCreature();
+    }
+
+    /**
+     * Returns 'true' if the guid belongs to a gameobject.
+     *
+     * @return bool isGameObject
+     */
+    bool IsGameObject(ObjectGuid guid)
+    {
+        return guid.IsGameObject();
+    }
+
+    /**
+     * Returns 'true' if the guid belongs to an item.
+     *
+     * @return bool isItem
+     */
+    bool IsItem(ObjectGuid guid)
+    {
+        return guid.IsItem();
+    }
+
+    /**
+     * Returns a readable representation of the guid, e.g. "Creature/0/12345".
+     *
+     * @return string guidString
+     */
+    std::string ToString(ObjectGuid guid)
+    {
+        return guid.ToString();
+    }
 }
 
-template<> int ALETemplate<long long>::Add(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) + ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::Substract(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) - ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::Multiply(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) * ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::Divide(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) / ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::Mod(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) % ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::UnaryMinus(lua_State* L) { ALE::Push(L, -ALE::CHECKVAL<long long>(L, 1)); return 1; }
-template<> int ALETemplate<long long>::Equal(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) == ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::Less(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) < ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::LessOrEqual(lua_State* L) { ALE::Push(L, ALE::CHECKVAL<long long>(L, 1) <= ALE::CHECKVAL<long long>(L, 2)); return 1; }
-template<> int ALETemplate<long long>::Pow(lua_State* L)
-{
-    ALE::Push(L, static_cast<long long>(powl(static_cast<long double>(ALE::CHECKVAL<long long>(L, 1)), static_cast<long double>(ALE::CHECKVAL<long long>(L, 2)))));
-    return 1;
-}
-template<> int ALETemplate<long long>::ToString(lua_State* L)
-{
-    long long l = ALE::CHECKVAL<long long>(L, 1);
-    std::ostringstream ss;
-    ss << l;
-    ALE::Push(L, ss.str());
-    return 1;
+namespace
+{
+    void RegisterObjectGuid(sol::state& lua)
+    {
+        sol::usertype<ObjectGuid> type = lua.new_usertype<ObjectGuid>("ObjectGuid", sol::no_constructor);
+
+        type["GetCounter"]   = &LuaObjectGuid::GetCounter;
+        type["GetEntry"]     = &LuaObjectGuid::GetEntry;
+        type["IsEmpty"]      = &LuaObjectGuid::IsEmpty;
+        type["IsPlayer"]     = &LuaObjectGuid::IsPlayer;
+        type["IsCreature"]   = &LuaObjectGuid::IsCreature;
+        type["IsGameObject"] = &LuaObjectGuid::IsGameObject;
+        type["IsItem"]       = &LuaObjectGuid::IsItem;
+        type["ToString"]     = &LuaObjectGuid::ToString;
+
+        type[sol::meta_function::to_string] = &LuaObjectGuid::ToString;
+    }
+
+    // Some methods return a CreatureTemplate pointer; the type is registered
+    // without methods (as it always was) so those returns are valid Lua values.
+    void RegisterCreatureTemplate(sol::state& lua)
+    {
+        lua.new_usertype<CreatureTemplate>("CreatureTemplate", sol::no_constructor);
+    }
 }
 
 void RegisterFunctions(ALE* E)
 {
-    ALEGlobal::SetMethods(E, GlobalMethods);
-
-    ALETemplate<Object>::Register(E, "Object");
-    ALETemplate<Object>::SetMethods(E, ObjectMethods);
-
-    ALETemplate<WorldObject>::Register(E, "WorldObject");
-    ALETemplate<WorldObject>::SetMethods(E, ObjectMethods);
-    ALETemplate<WorldObject>::SetMethods(E, WorldObjectMethods);
-
-    ALETemplate<Unit>::Register(E, "Unit");
-    ALETemplate<Unit>::SetMethods(E, ObjectMethods);
-    ALETemplate<Unit>::SetMethods(E, WorldObjectMethods);
-    ALETemplate<Unit>::SetMethods(E, UnitMethods);
-
-    ALETemplate<Player>::Register(E, "Player");
-    ALETemplate<Player>::SetMethods(E, ObjectMethods);
-    ALETemplate<Player>::SetMethods(E, WorldObjectMethods);
-    ALETemplate<Player>::SetMethods(E, UnitMethods);
-    ALETemplate<Player>::SetMethods(E, PlayerMethods);
-
-    ALETemplate<Creature>::Register(E, "Creature");
-    ALETemplate<Creature>::SetMethods(E, ObjectMethods);
-    ALETemplate<Creature>::SetMethods(E, WorldObjectMethods);
-    ALETemplate<Creature>::SetMethods(E, UnitMethods);
-    ALETemplate<Creature>::SetMethods(E, CreatureMethods);
-
-    ALETemplate<GameObject>::Register(E, "GameObject");
-    ALETemplate<GameObject>::SetMethods(E, ObjectMethods);
-    ALETemplate<GameObject>::SetMethods(E, WorldObjectMethods);
-    ALETemplate<GameObject>::SetMethods(E, GameObjectMethods);
-
-    ALETemplate<Transport>::Register(E, "Transport");
-    ALETemplate<Transport>::SetMethods(E, ObjectMethods);
-    ALETemplate<Transport>::SetMethods(E, WorldObjectMethods);
-    ALETemplate<Transport>::SetMethods(E, GameObjectMethods);
-    ALETemplate<Transport>::SetMethods(E, TransportMethods);
-    
-    ALETemplate<Corpse>::Register(E, "Corpse");
-    ALETemplate<Corpse>::SetMethods(E, ObjectMethods);
-    ALETemplate<Corpse>::SetMethods(E, WorldObjectMethods);
-    ALETemplate<Corpse>::SetMethods(E, CorpseMethods);
-
-    ALETemplate<Item>::Register(E, "Item");
-    ALETemplate<Item>::SetMethods(E, ObjectMethods);
-    ALETemplate<Item>::SetMethods(E, ItemMethods);
-
-    ALETemplate<ItemTemplate>::Register(E, "ItemTemplate");
-    ALETemplate<ItemTemplate>::SetMethods(E, ItemTemplateMethods);
-
-    ALETemplate<Vehicle>::Register(E, "Vehicle");
-    ALETemplate<Vehicle>::SetMethods(E, VehicleMethods);
-
-    ALETemplate<Group>::Register(E, "Group");
-    ALETemplate<Group>::SetMethods(E, GroupMethods);
-
-    ALETemplate<Guild>::Register(E, "Guild");
-    ALETemplate<Guild>::SetMethods(E, GuildMethods);
-
-    ALETemplate<Aura>::Register(E, "Aura");
-    ALETemplate<Aura>::SetMethods(E, AuraMethods);
-
-    ALETemplate<Spell>::Register(E, "Spell");
-    ALETemplate<Spell>::SetMethods(E, SpellMethods);
-
-    ALETemplate<Quest>::Register(E, "Quest");
-    ALETemplate<Quest>::SetMethods(E, QuestMethods);
-
-    ALETemplate<Map>::Register(E, "Map");
-    ALETemplate<Map>::SetMethods(E, MapMethods);
-
-    ALETemplate<AuctionHouseEntry>::Register(E, "AuctionHouseEntry");
-    ALETemplate<AuctionHouseEntry>::SetMethods(E, AuctionMethods);
-
-    ALETemplate<BattleGround>::Register(E, "BattleGround");
-    ALETemplate<BattleGround>::SetMethods(E, BattleGroundMethods);
-
-    ALETemplate<ChatHandler>::Register(E, "ChatHandler");
-    ALETemplate<ChatHandler>::SetMethods(E, ChatHandlerMethods);
-
-    ALETemplate<WorldPacket>::Register(E, "WorldPacket", true);
-    ALETemplate<WorldPacket>::SetMethods(E, PacketMethods);
-
-    ALETemplate<ALEQuery>::Register(E, "ALEQuery", true);
-    ALETemplate<ALEQuery>::SetMethods(E, QueryMethods);
-
-    ALETemplate<AchievementEntry>::Register(E, "AchievementEntry");
-    ALETemplate<AchievementEntry>::SetMethods(E, AchievementMethods);
-
-    ALETemplate<Roll>::Register(E, "Roll");
-    ALETemplate<Roll>::SetMethods(E, RollMethods);
-
-    ALETemplate<GmTicket>::Register(E, "Ticket");
-    ALETemplate<GmTicket>::SetMethods(E, TicketMethods);
-
-    ALETemplate<SpellInfo>::Register(E, "SpellInfo");
-    ALETemplate<SpellInfo>::SetMethods(E, SpellInfoMethods);
-
-    ALETemplate<GemPropertiesEntry>::Register(E, "GemPropertiesEntry");
-    ALETemplate<GemPropertiesEntry>::SetMethods(E, GemPropertiesEntryMethods);
-
-    ALETemplate<SpellEntry>::Register(E, "SpellEntry");
-    ALETemplate<SpellEntry>::SetMethods(E, SpellEntryMethods);
-
-    ALETemplate<CreatureTemplate>::Register(E, "CreatureTemplate");
-
-    ALETemplate<Loot>::Register(E, "Loot");
-    ALETemplate<Loot>::SetMethods(E, LootMethods);
-
-    ALETemplate<long long>::Register(E, "long long", true);
-
-    ALETemplate<unsigned long long>::Register(E, "unsigned long long", true);
+    sol::state& lua = E->lua;
+
+    RegisterGlobalMethods(lua);
+
+    RegisterObjectGuid(lua);
+    RegisterCreatureTemplate(lua);
+
+    // The handle hierarchy, most-derived types after their bases.
+    RegisterObjectMethods(lua);
+    RegisterWorldObjectMethods(lua);
+    RegisterUnitMethods(lua);
+    RegisterPlayerMethods(lua);
+    RegisterCreatureMethods(lua);
+    RegisterGameObjectMethods(lua);
+    RegisterTransportMethods(lua);
+    RegisterCorpseMethods(lua);
+    RegisterItemMethods(lua);
+    RegisterPetMethods(lua);
+
+    // Manager-resolved handles.
+    RegisterMapMethods(lua);
+    RegisterGroupMethods(lua);
+    RegisterGuildMethods(lua);
+
+    // Event-scoped types, only valid during the event that provided them.
+    RegisterAuraMethods(lua);
+    RegisterSpellMethods(lua);
+    RegisterVehicleMethods(lua);
+    RegisterBattleGroundMethods(lua);
+    RegisterChatHandlerMethods(lua);
+    RegisterTicketMethods(lua);
+    RegisterRollMethods(lua);
+    RegisterLootMethods(lua);
+
+    // Static game data.
+    RegisterAchievementMethods(lua);
+    RegisterItemTemplateMethods(lua);
+    RegisterQuestMethods(lua);
+    RegisterSpellInfoMethods(lua);
+    RegisterSpellEntryMethods(lua);
+    RegisterGemPropertiesEntryMethods(lua);
+
+    // Value types.
+    RegisterWorldPacketMethods(lua);
+    RegisterALEQueryMethods(lua);
 }
diff --git a/src/LuaEngine/hooks/AllCreatureHooks.cpp b/src/LuaEngine/hooks/AllCreatureHooks.cpp
index f32fe110e1..9ca140d940 100644
--- a/src/LuaEngine/hooks/AllCreatureHooks.cpp
+++ b/src/LuaEngine/hooks/AllCreatureHooks.cpp
@@ -5,11 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -32,246 +29,101 @@ using namespace Hooks;
 void ALE::OnAllCreatureAddToWorld(Creature* creature)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_ADD);
-    Push(creature);
-    CallAllFunctions(AllCreatureEventBindings, key);
+    CallAll(*AllCreatureEventBindings, key, creature);
 }
 
 void ALE::OnAllCreatureRemoveFromWorld(Creature* creature)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_REMOVE);
-    Push(creature);
-    CallAllFunctions(AllCreatureEventBindings, key);
+    CallAll(*AllCreatureEventBindings, key, creature);
 }
 
 void ALE::OnAllCreatureSelectLevel(const CreatureTemplate* cinfo, Creature* creature)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_SELECT_LEVEL);
-    Push(cinfo);
-    Push(creature);
-    CallAllFunctions(AllCreatureEventBindings, key);
+    CallAll(*AllCreatureEventBindings, key, cinfo, creature);
 }
 
 void ALE::OnAllCreatureBeforeSelectLevel(const CreatureTemplate* cinfo, Creature* creature, uint8& level)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_BEFORE_SELECT_LEVEL);
-    Push(cinfo);
-    Push(creature);
-    Push(level);
-    int levelIndex = lua_gettop(L);
-    int n = SetupStack(AllCreatureEventBindings, key, 3);
-
-    while (n > 0)
+    level = CallAllFold(*AllCreatureEventBindings, key, level, [&](auto const& callback, uint8 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            level = CHECKVAL<uint8>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(level, levelIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, cinfo, creature, current);
+    });
 }
 
 void ALE::OnAllCreatureAuraApply(Creature* me, Aura* aura)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_AURA_APPLY);
-    Push(me);
-    Push(aura);
-    CallAllFunctions(AllCreatureEventBindings, key);
+    CallAll(*AllCreatureEventBindings, key, me, aura);
 }
 
 void ALE::OnAllCreatureAuraRemove(Creature* me, Aura* aura, AuraRemoveMode mode)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_AURA_REMOVE);
-    Push(me);
-    Push(aura);
-    Push(mode);
-    CallAllFunctions(AllCreatureEventBindings, key);
+    CallAll(*AllCreatureEventBindings, key, me, aura, mode);
 }
 
 void ALE::OnAllCreatureHeal(Creature* me, Unit* target, uint32& gain)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_HEAL);
-    Push(me);
-    Push(target);
-    Push(gain);
-
-    int gainIndex = lua_gettop(L);
-    int n = SetupStack(AllCreatureEventBindings, key, 3);
-    while (n > 0)
+    gain = CallAllFold(*AllCreatureEventBindings, key, gain, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            gain = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(gain, gainIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, me, target, current);
+    });
 }
 
 void ALE::OnAllCreatureDamage(Creature* me, Unit* target, uint32& damage)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_DAMAGE);
-    Push(me);
-    Push(target);
-    Push(damage);
-
-    int damageIndex = lua_gettop(L);
-    int n = SetupStack(AllCreatureEventBindings, key, 3);
-    while (n > 0)
+    damage = CallAllFold(*AllCreatureEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, me, target, current);
+    });
 }
 
 void ALE::OnAllCreatureModifyPeriodicDamageAurasTick(Creature* me, Unit* target, uint32& damage, SpellInfo const* spellInfo)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_MODIFY_PERIODIC_DAMAGE_AURAS_TICK);
-    Push(me);
-    Push(target);
-    Push(damage);
-    Push(spellInfo);
-
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(AllCreatureEventBindings, key, 4);
-    while (n > 0)
+    damage = CallAllFold(*AllCreatureEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, key.event_id, me, target, current, spellInfo);
+    });
 }
 
 void ALE::OnAllCreatureModifyMeleeDamage(Creature* me, Unit* target, uint32& damage)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_MODIFY_MELEE_DAMAGE);
-    Push(me);
-    Push(target);
-    Push(damage);
-
-    int damageIndex = lua_gettop(L);
-    int n = SetupStack(AllCreatureEventBindings, key, 3);
-    while (n > 0)
+    damage = CallAllFold(*AllCreatureEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, me, target, current);
+    });
 }
 
 void ALE::OnAllCreatureModifySpellDamageTaken(Creature* me, Unit* target, int32& damage, SpellInfo const* spellInfo)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_MODIFY_SPELL_DAMAGE_TAKEN);
-    Push(me);
-    Push(target);
-    Push(damage);
-    Push(spellInfo);
-
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(AllCreatureEventBindings, key, 4);
-    while (n > 0)
+    damage = CallAllFold(*AllCreatureEventBindings, key, damage, [&](auto const& callback, int32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<int32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, key.event_id, me, target, current, spellInfo);
+    });
 }
 
 void ALE::OnAllCreatureModifyHealReceived(Creature* me, Unit* target, uint32& heal, SpellInfo const* spellInfo)
 {
     START_HOOK(ALL_CREATURE_EVENT_ON_MODIFY_HEAL_RECEIVED);
-    Push(me);
-    Push(target);
-    Push(heal);
-    Push(spellInfo);
-
-    int healIndex = lua_gettop(L) - 1;
-    int n = SetupStack(AllCreatureEventBindings, key, 4);
-    while (n > 0)
+    heal = CallAllFold(*AllCreatureEventBindings, key, heal, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            heal = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(heal, healIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, key.event_id, me, target, current, spellInfo);
+    });
 }
 
 uint32 ALE::OnAllCreatureDealDamage(Creature* me, Unit* target, uint32 damage, DamageEffectType damagetype)
 {
     START_HOOK_WITH_RETVAL(ALL_CREATURE_EVENT_ON_DEAL_DAMAGE, damage);
-    uint32 result = damage;
-    Push(me);
-    Push(target);
-    Push(damage);
-    Push(damagetype);
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(AllCreatureEventBindings, key, 4);
-
-    while (n > 0)
+    return CallAllFold(*AllCreatureEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            result = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(result, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
-    return result;
+        return Call(callback, key.event_id, me, target, current, damagetype);
+    });
 }
diff --git a/src/LuaEngine/hooks/BattleGroundHooks.cpp b/src/LuaEngine/hooks/BattleGroundHooks.cpp
index ec70cf5a15..c9d131259b 100644
--- a/src/LuaEngine/hooks/BattleGroundHooks.cpp
+++ b/src/LuaEngine/hooks/BattleGroundHooks.cpp
@@ -5,10 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -23,36 +21,23 @@ using namespace Hooks;
 void ALE::OnBGStart(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId)
 {
     START_HOOK(BG_EVENT_ON_START);
-    Push(bg);
-    Push(bgId);
-    Push(instanceId);
-    CallAllFunctions(BGEventBindings, key);
+    CallAll(*BGEventBindings, key, bg, bgId, instanceId);
 }
 
 void ALE::OnBGEnd(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId, TeamId winner)
 {
     START_HOOK(BG_EVENT_ON_END);
-    Push(bg);
-    Push(bgId);
-    Push(instanceId);
-    Push(winner);
-    CallAllFunctions(BGEventBindings, key);
+    CallAll(*BGEventBindings, key, bg, bgId, instanceId, winner);
 }
 
 void ALE::OnBGCreate(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId)
 {
     START_HOOK(BG_EVENT_ON_CREATE);
-    Push(bg);
-    Push(bgId);
-    Push(instanceId);
-    CallAllFunctions(BGEventBindings, key);
+    CallAll(*BGEventBindings, key, bg, bgId, instanceId);
 }
 
 void ALE::OnBGDestroy(BattleGround* bg, BattleGroundTypeId bgId, uint32 instanceId)
 {
     START_HOOK(BG_EVENT_ON_PRE_DESTROY);
-    Push(bg);
-    Push(bgId);
-    Push(instanceId);
-    CallAllFunctions(BGEventBindings, key);
+    CallAll(*BGEventBindings, key, bg, bgId, instanceId);
 }
diff --git a/src/LuaEngine/hooks/CreatureHooks.cpp b/src/LuaEngine/hooks/CreatureHooks.cpp
index 9fca834e48..d1513cafc6 100644
--- a/src/LuaEngine/hooks/CreatureHooks.cpp
+++ b/src/LuaEngine/hooks/CreatureHooks.cpp
@@ -5,99 +5,77 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
+// Creature events can be bound to every creature of an entry and/or to one
+// specific spawn (see RegisterCreatureEvent / RegisterUniqueCreatureEvent).
 #define START_HOOK(EVENT, CREATURE) \
     if (!ALEConfig::GetInstance().IsALEEnabled())\
         return;\
     auto entry_key = EntryKey<CreatureEvents>(EVENT, CREATURE->GetEntry());\
-    auto unique_key = UniqueObjectKey<CreatureEvents>(EVENT, CREATURE->GET_GUID(), CREATURE->GetInstanceId());\
-    if (!CreatureEventBindings->HasBindingsFor(entry_key))\
-        if (!CreatureUniqueBindings->HasBindingsFor(unique_key))\
-            return;\
+    auto unique_key = UniqueObjectKey<CreatureEvents>(EVENT, CREATURE->GetGUID(), CREATURE->GetInstanceId());\
+    if (!CreatureEventBindings->HasBindingsFor(entry_key) && !CreatureUniqueBindings->HasBindingsFor(unique_key))\
+        return;\
     LOCK_ALE
 
 #define START_HOOK_WITH_RETVAL(EVENT, CREATURE, RETVAL) \
     if (!ALEConfig::GetInstance().IsALEEnabled())\
         return RETVAL;\
     auto entry_key = EntryKey<CreatureEvents>(EVENT, CREATURE->GetEntry());\
-    auto unique_key = UniqueObjectKey<CreatureEvents>(EVENT, CREATURE->GET_GUID(), CREATURE->GetInstanceId());\
-    if (!CreatureEventBindings->HasBindingsFor(entry_key))\
-        if (!CreatureUniqueBindings->HasBindingsFor(unique_key))\
-            return RETVAL;\
+    auto unique_key = UniqueObjectKey<CreatureEvents>(EVENT, CREATURE->GetGUID(), CREATURE->GetInstanceId());\
+    if (!CreatureEventBindings->HasBindingsFor(entry_key) && !CreatureUniqueBindings->HasBindingsFor(unique_key))\
+        return RETVAL;\
     LOCK_ALE
 
 void ALE::OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, Creature* pTarget)
 {
     START_HOOK(CREATURE_EVENT_ON_DUMMY_EFFECT, pTarget);
-    Push(pCaster);
-    Push(spellId);
-    Push(effIndex);
-    Push(pTarget);
-    CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    CallAll(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, pCaster, spellId, effIndex, pTarget);
 }
 
 bool ALE::OnQuestAccept(Player* pPlayer, Creature* pCreature, Quest const* pQuest)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_QUEST_ACCEPT, pCreature, false);
-    Push(pPlayer);
-    Push(pCreature);
-    Push(pQuest);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, pPlayer, pCreature, pQuest);
 }
 
 bool ALE::OnQuestReward(Player* pPlayer, Creature* pCreature, Quest const* pQuest, uint32 opt)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_QUEST_REWARD, pCreature, false);
-    Push(pPlayer);
-    Push(pCreature);
-    Push(pQuest);
-    Push(opt);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, pPlayer, pCreature, pQuest, opt);
 }
 
 void ALE::GetDialogStatus(const Player* pPlayer, const Creature* pCreature)
 {
     START_HOOK(CREATURE_EVENT_ON_DIALOG_STATUS, pCreature);
-    Push(pPlayer);
-    Push(pCreature);
-    CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    CallAll(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, pPlayer, pCreature);
 }
 
 void ALE::OnAddToWorld(Creature* pCreature)
 {
     START_HOOK(CREATURE_EVENT_ON_ADD, pCreature);
-    Push(pCreature);
-    CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    CallAll(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, pCreature);
 }
 
 void ALE::OnRemoveFromWorld(Creature* pCreature)
 {
     START_HOOK(CREATURE_EVENT_ON_REMOVE, pCreature);
-    Push(pCreature);
-    CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    CallAll(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, pCreature);
 }
 
 bool ALE::OnSummoned(Creature* pCreature, Unit* pSummoner)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SUMMONED, pCreature, false);
-    Push(pCreature);
-    Push(pSummoner);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, pCreature, pSummoner);
 }
 
 bool ALE::UpdateAI(Creature* me, const uint32 diff)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_AIUPDATE, me, false);
-    Push(me);
-    Push(diff);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, diff);
 }
 
 //Called for reaction at enter to combat if not in combat yet (enemy can be NULL)
@@ -105,9 +83,7 @@ bool ALE::UpdateAI(Creature* me, const uint32 diff)
 bool ALE::EnterCombat(Creature* me, Unit* target)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_ENTER_COMBAT, me, false);
-    Push(me);
-    Push(target);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, target);
 }
 
 // Called at any Damage from any attacker (before damage apply)
@@ -115,30 +91,22 @@ bool ALE::DamageTaken(Creature* me, Unit* attacker, uint32& damage)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_DAMAGE_TAKEN, me, false);
     bool result = false;
-    Push(me);
-    Push(attacker);
-    Push(damage);
-    int damageIndex = lua_gettop(L);
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 3);
 
-    while (n > 0)
+    // Handlers return (override, newDamage): `override` stops the default
+    // behaviour, `newDamage` feeds the handlers after it and the damage apply.
+    for (sol::protected_function const& callback : GetCreatureCallbacks(entry_key, unique_key))
     {
-        int r = CallOneFunction(n--, 3, 2);
+        sol::protected_function_result callResult = Call(callback, entry_key.event_id, me, attacker, damage);
+        if (!callResult.valid())
+            continue;
 
-        if (lua_isboolean(L, r + 0) && lua_toboolean(L, r + 0))
+        if (callResult.get<sol::optional<bool>>(0) == sol::optional<bool>(true))
             result = true;
 
-        if (lua_isnumber(L, r + 1))
-        {
-            damage = ALE::CHECKVAL<uint32>(L, r + 1);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 2);
+        if (sol::optional<uint32> newDamage = callResult.get<sol::optional<uint32>>(1))
+            damage = *newDamage;
     }
 
-    CleanUpStack(3);
     return result;
 }
 
@@ -147,55 +115,42 @@ bool ALE::JustDied(Creature* me, Unit* killer)
 {
     On_Reset(me);
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_DIED, me, false);
-    Push(me);
-    Push(killer);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, killer);
 }
 
 //Called at creature killing another unit
 bool ALE::KilledUnit(Creature* me, Unit* victim)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_TARGET_DIED, me, false);
-    Push(me);
-    Push(victim);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, victim);
 }
 
 // Called when the creature summon successfully other creature
 bool ALE::JustSummoned(Creature* me, Creature* summon)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_JUST_SUMMONED_CREATURE, me, false);
-    Push(me);
-    Push(summon);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, summon);
 }
 
 // Called when a summoned creature is despawned
 bool ALE::SummonedCreatureDespawn(Creature* me, Creature* summon)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SUMMONED_CREATURE_DESPAWN, me, false);
-    Push(me);
-    Push(summon);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, summon);
 }
 
 //Called at waypoint reached or PointMovement end
 bool ALE::MovementInform(Creature* me, uint32 type, uint32 id)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_REACH_WP, me, false);
-    Push(me);
-    Push(type);
-    Push(id);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, type, id);
 }
 
 // Called before EnterCombat even before the creature is in combat.
 bool ALE::AttackStart(Creature* me, Unit* target)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_PRE_COMBAT, me, false);
-    Push(me);
-    Push(target);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, target);
 }
 
 // Called for reaction at stopping attack at no attackers or targets
@@ -203,8 +158,7 @@ bool ALE::EnterEvadeMode(Creature* me)
 {
     On_Reset(me);
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_LEAVE_COMBAT, me, false);
-    Push(me);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me);
 }
 
 // Called when creature is spawned or respawned (for reseting variables)
@@ -212,26 +166,21 @@ bool ALE::JustRespawned(Creature* me)
 {
     On_Reset(me);
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SPAWN, me, false);
-    Push(me);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me);
 }
 
 // Called at reaching home after evade
 bool ALE::JustReachedHome(Creature* me)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_REACH_HOME, me, false);
-    Push(me);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me);
 }
 
 // Called at text emote receive from player
 bool ALE::ReceiveEmote(Creature* me, Player* player, uint32 emoteId)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_RECEIVE_EMOTE, me, false);
-    Push(me);
-    Push(player);
-    Push(emoteId);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, player, emoteId);
 }
 
 // called when the corpse of this creature gets removed
@@ -239,290 +188,142 @@ bool ALE::CorpseRemoved(Creature* me, uint32& respawnDelay)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_CORPSE_REMOVED, me, false);
     bool result = false;
-    Push(me);
-    Push(respawnDelay);
-    int respawnDelayIndex = lua_gettop(L);
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 2);
 
-    while (n > 0)
+    // Handlers return (override, newRespawnDelay).
+    for (sol::protected_function const& callback : GetCreatureCallbacks(entry_key, unique_key))
     {
-        int r = CallOneFunction(n--, 2, 2);
+        sol::protected_function_result callResult = Call(callback, entry_key.event_id, me, respawnDelay);
+        if (!callResult.valid())
+            continue;
 
-        if (lua_isboolean(L, r + 0) && lua_toboolean(L, r + 0))
+        if (callResult.get<sol::optional<bool>>(0) == sol::optional<bool>(true))
             result = true;
 
-        if (lua_isnumber(L, r + 1))
-        {
-            respawnDelay = ALE::CHECKVAL<uint32>(L, r + 1);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(respawnDelay, respawnDelayIndex);
-        }
-
-        lua_pop(L, 2);
+        if (sol::optional<uint32> newDelay = callResult.get<sol::optional<uint32>>(1))
+            respawnDelay = *newDelay;
     }
 
-    CleanUpStack(2);
     return result;
 }
 
 bool ALE::MoveInLineOfSight(Creature* me, Unit* who)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_MOVE_IN_LOS, me, false);
-    Push(me);
-    Push(who);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, who);
 }
 
 // Called on creature initial spawn, respawn, death, evade (leave combat)
 void ALE::On_Reset(Creature* me) // Not an override, custom
 {
     START_HOOK(CREATURE_EVENT_ON_RESET, me);
-    Push(me);
-    CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    CallAll(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, me);
 }
 
 // Called when hit by a spell
 bool ALE::SpellHit(Creature* me, WorldObject* caster, SpellInfo const* spell)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_HIT_BY_SPELL, me, false);
-    Push(me);
-    Push(caster);
-    Push(spell->Id); // Pass spell object?
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, caster, spell->Id);
 }
 
 // Called when spell hits a target
 bool ALE::SpellHitTarget(Creature* me, WorldObject* target, SpellInfo const* spell)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SPELL_HIT_TARGET, me, false);
-    Push(me);
-    Push(target);
-    Push(spell->Id); // Pass spell object?
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, target, spell->Id);
 }
 
 bool ALE::SummonedCreatureDies(Creature* me, Creature* summon, Unit* killer)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_SUMMONED_CREATURE_DIED, me, false);
-    Push(me);
-    Push(summon);
-    Push(killer);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, summon, killer);
 }
 
 // Called when owner takes damage
 bool ALE::OwnerAttackedBy(Creature* me, Unit* attacker)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_OWNER_ATTACKED_AT, me, false);
-    Push(me);
-    Push(attacker);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, attacker);
 }
 
 // Called when owner attacks something
 bool ALE::OwnerAttacked(Creature* me, Unit* target)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_OWNER_ATTACKED, me, false);
-    Push(me);
-    Push(target);
-    return CallAllFunctionsBool(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    return CallAllBool(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, false, me, target);
 }
 
 void ALE::OnCreatureAuraApply(Creature* me, Aura* aura)
 {
     START_HOOK(CREATURE_EVENT_ON_AURA_APPLY, me);
-    Push(me);
-    Push(aura);
-    CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    CallAll(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, me, aura);
 }
 
 void ALE::OnCreatureAuraRemove(Creature* me, Aura* aura, AuraRemoveMode mode)
 {
     START_HOOK(CREATURE_EVENT_ON_AURA_REMOVE, me);
-    Push(me);
-    Push(aura);
-    Push(mode);
-    CallAllFunctions(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key);
+    CallAll(*CreatureEventBindings, *CreatureUniqueBindings, entry_key, unique_key, me, aura, mode);
 }
 
 void ALE::OnCreatureHeal(Creature* me, Unit* target, uint32& gain)
 {
     START_HOOK(CREATURE_EVENT_ON_HEAL, me);
-    Push(me);
-    Push(target);
-    Push(gain);
-
-    int gainIndex = lua_gettop(L);
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 3);
-    while (n > 0)
+    gain = FoldCallbacks(GetCreatureCallbacks(entry_key, unique_key), gain, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            gain = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(gain, gainIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, entry_key.event_id, me, target, current);
+    });
 }
 
 void ALE::OnCreatureDamage(Creature* me, Unit* target, uint32& damage)
 {
     START_HOOK(CREATURE_EVENT_ON_DAMAGE, me);
-    Push(me);
-    Push(target);
-    Push(damage);
-
-    int damageIndex = lua_gettop(L);
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 3);
-    while (n > 0)
+    damage = FoldCallbacks(GetCreatureCallbacks(entry_key, unique_key), damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, entry_key.event_id, me, target, current);
+    });
 }
 
 void ALE::OnCreatureModifyPeriodicDamageAurasTick(Creature* me, Unit* target, uint32& damage, SpellInfo const* spellInfo)
 {
     START_HOOK(CREATURE_EVENT_ON_MODIFY_PERIODIC_DAMAGE_AURAS_TICK, me);
-    Push(me);
-    Push(target);
-    Push(damage);
-    Push(spellInfo);
-
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 4);
-    while (n > 0)
+    damage = FoldCallbacks(GetCreatureCallbacks(entry_key, unique_key), damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, entry_key.event_id, me, target, current, spellInfo);
+    });
 }
 
 void ALE::OnCreatureModifyMeleeDamage(Creature* me, Unit* target, uint32& damage)
 {
     START_HOOK(CREATURE_EVENT_ON_MODIFY_MELEE_DAMAGE, me);
-    Push(me);
-    Push(target);
-    Push(damage);
-
-    int damageIndex = lua_gettop(L);
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 3);
-    while (n > 0)
+    damage = FoldCallbacks(GetCreatureCallbacks(entry_key, unique_key), damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, entry_key.event_id, me, target, current);
+    });
 }
 
 void ALE::OnCreatureModifySpellDamageTaken(Creature* me, Unit* target, int32& damage, SpellInfo const* spellInfo)
 {
     START_HOOK(CREATURE_EVENT_ON_MODIFY_SPELL_DAMAGE_TAKEN, me);
-    Push(me);
-    Push(target);
-    Push(damage);
-    Push(spellInfo);
-
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 4);
-    while (n > 0)
+    damage = FoldCallbacks(GetCreatureCallbacks(entry_key, unique_key), damage, [&](auto const& callback, int32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<int32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, entry_key.event_id, me, target, current, spellInfo);
+    });
 }
 
 void ALE::OnCreatureModifyHealReceived(Creature* me, Unit* target, uint32& heal, SpellInfo const* spellInfo)
 {
     START_HOOK(CREATURE_EVENT_ON_MODIFY_HEAL_RECEIVED, me);
-    Push(me);
-    Push(target);
-    Push(heal);
-    Push(spellInfo);
-
-    int healIndex = lua_gettop(L) - 1;
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 4);
-    while (n > 0)
+    heal = FoldCallbacks(GetCreatureCallbacks(entry_key, unique_key), heal, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            heal = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(heal, healIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, entry_key.event_id, me, target, current, spellInfo);
+    });
 }
 
 uint32 ALE::OnCreatureDealDamage(Creature* me, Unit* target, uint32 damage, DamageEffectType damagetype)
 {
     START_HOOK_WITH_RETVAL(CREATURE_EVENT_ON_DEAL_DAMAGE, me, damage);
-    uint32 result = damage;
-    Push(me);
-    Push(target);
-    Push(damage);
-    Push(damagetype);
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(CreatureEventBindings, CreatureUniqueBindings, entry_key, unique_key, 4);
-
-    while (n > 0)
+    return FoldCallbacks(GetCreatureCallbacks(entry_key, unique_key), damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            result = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(result, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
-    return result;
+        return Call(callback, entry_key.event_id, me, target, current, damagetype);
+    });
 }
diff --git a/src/LuaEngine/hooks/GameObjectHooks.cpp b/src/LuaEngine/hooks/GameObjectHooks.cpp
index 7dd8508f4f..9d451b5f3d 100644
--- a/src/LuaEngine/hooks/GameObjectHooks.cpp
+++ b/src/LuaEngine/hooks/GameObjectHooks.cpp
@@ -5,12 +5,9 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
 #include "ALEEventMgr.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -33,106 +30,78 @@ using namespace Hooks;
 void ALE::OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, GameObject* pTarget)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_DUMMY_EFFECT, pTarget->GetEntry());
-    Push(pCaster);
-    Push(spellId);
-    Push(effIndex);
-    Push(pTarget);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pCaster, spellId, effIndex, pTarget);
 }
 
 void ALE::UpdateAI(GameObject* pGameObject, uint32 diff)
 {
     pGameObject->ALEEvents->Update(diff);
     START_HOOK(GAMEOBJECT_EVENT_ON_AIUPDATE, pGameObject->GetEntry());
-    Push(pGameObject);
-    Push(diff);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject, diff);
 }
 
 bool ALE::OnQuestAccept(Player* pPlayer, GameObject* pGameObject, Quest const* pQuest)
 {
     START_HOOK_WITH_RETVAL(GAMEOBJECT_EVENT_ON_QUEST_ACCEPT, pGameObject->GetEntry(), false);
-    Push(pPlayer);
-    Push(pGameObject);
-    Push(pQuest);
-    return CallAllFunctionsBool(GameObjectEventBindings, key);
+    return CallAllBool(*GameObjectEventBindings, key, false, pPlayer, pGameObject, pQuest);
 }
 
 bool ALE::OnQuestReward(Player* pPlayer, GameObject* pGameObject, Quest const* pQuest, uint32 opt)
 {
     START_HOOK_WITH_RETVAL(GAMEOBJECT_EVENT_ON_QUEST_REWARD, pGameObject->GetEntry(), false);
-    Push(pPlayer);
-    Push(pGameObject);
-    Push(pQuest);
-    Push(opt);
-    return CallAllFunctionsBool(GameObjectEventBindings, key);
+    return CallAllBool(*GameObjectEventBindings, key, false, pPlayer, pGameObject, pQuest, opt);
 }
 
 void ALE::GetDialogStatus(const Player* pPlayer, const GameObject* pGameObject)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_DIALOG_STATUS, pGameObject->GetEntry());
-    Push(pPlayer);
-    Push(pGameObject);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pPlayer, pGameObject);
 }
 
 void ALE::OnDestroyed(GameObject* pGameObject, WorldObject* attacker)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_DESTROYED, pGameObject->GetEntry());
-    Push(pGameObject);
-    Push(attacker);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject, attacker);
 }
 
 void ALE::OnDamaged(GameObject* pGameObject, WorldObject* attacker)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_DAMAGED, pGameObject->GetEntry());
-    Push(pGameObject);
-    Push(attacker);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject, attacker);
 }
 
 void ALE::OnLootStateChanged(GameObject* pGameObject, uint32 state)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_LOOT_STATE_CHANGE, pGameObject->GetEntry());
-    Push(pGameObject);
-    Push(state);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject, state);
 }
 
 void ALE::OnGameObjectStateChanged(GameObject* pGameObject, uint32 state)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_GO_STATE_CHANGED, pGameObject->GetEntry());
-    Push(pGameObject);
-    Push(state);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject, state);
 }
 
 void ALE::OnSpawn(GameObject* pGameObject)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_SPAWN, pGameObject->GetEntry());
-    Push(pGameObject);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject);
 }
 
 void ALE::OnAddToWorld(GameObject* pGameObject)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_ADD, pGameObject->GetEntry());
-    Push(pGameObject);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject);
 }
 
 void ALE::OnRemoveFromWorld(GameObject* pGameObject)
 {
     START_HOOK(GAMEOBJECT_EVENT_ON_REMOVE, pGameObject->GetEntry());
-    Push(pGameObject);
-    CallAllFunctions(GameObjectEventBindings, key);
+    CallAll(*GameObjectEventBindings, key, pGameObject);
 }
 
 bool ALE::OnGameObjectUse(Player* pPlayer, GameObject* pGameObject)
 {
     START_HOOK_WITH_RETVAL(GAMEOBJECT_EVENT_ON_USE, pGameObject->GetEntry(), false);
-    Push(pGameObject);
-    Push(pPlayer);
-    return CallAllFunctionsBool(GameObjectEventBindings, key);
+    return CallAllBool(*GameObjectEventBindings, key, false, pGameObject, pPlayer);
 }
diff --git a/src/LuaEngine/hooks/GossipHooks.cpp b/src/LuaEngine/hooks/GossipHooks.cpp
index 5fa324516f..ddc8638ad4 100644
--- a/src/LuaEngine/hooks/GossipHooks.cpp
+++ b/src/LuaEngine/hooks/GossipHooks.cpp
@@ -5,11 +5,8 @@
 */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -29,36 +26,37 @@ using namespace Hooks;
         return RETVAL;\
     LOCK_ALE
 
+namespace
+{
+    // Gossip codes are passed as nil when the option had no input box.
+    sol::object CodeOrNil(sol::state_view lua, std::string const& code)
+    {
+        if (code.empty())
+            return sol::make_object(lua, sol::nil);
+
+        return sol::make_object(lua, code);
+    }
+}
+
 bool ALE::OnGossipHello(Player* pPlayer, GameObject* pGameObject)
 {
     START_HOOK_WITH_RETVAL(GameObjectGossipBindings, GOSSIP_EVENT_ON_HELLO, pGameObject->GetEntry(), false);
     pPlayer->PlayerTalkClass->ClearMenus();
-    Push(pPlayer);
-    Push(pGameObject);
-    return CallAllFunctionsBool(GameObjectGossipBindings, key, true);
+    return CallAllBool(*GameObjectGossipBindings, key, true, pPlayer, pGameObject);
 }
 
 bool ALE::OnGossipSelect(Player* pPlayer, GameObject* pGameObject, uint32 sender, uint32 action)
 {
     START_HOOK_WITH_RETVAL(GameObjectGossipBindings, GOSSIP_EVENT_ON_SELECT, pGameObject->GetEntry(), false);
     pPlayer->PlayerTalkClass->ClearMenus();
-    Push(pPlayer);
-    Push(pGameObject);
-    Push(sender);
-    Push(action);
-    return CallAllFunctionsBool(GameObjectGossipBindings, key, true);
+    return CallAllBool(*GameObjectGossipBindings, key, true, pPlayer, pGameObject, sender, action);
 }
 
 bool ALE::OnGossipSelectCode(Player* pPlayer, GameObject* pGameObject, uint32 sender, uint32 action, const char* code)
 {
     START_HOOK_WITH_RETVAL(GameObjectGossipBindings, GOSSIP_EVENT_ON_SELECT, pGameObject->GetEntry(), false);
     pPlayer->PlayerTalkClass->ClearMenus();
-    Push(pPlayer);
-    Push(pGameObject);
-    Push(sender);
-    Push(action);
-    Push(code);
-    return CallAllFunctionsBool(GameObjectGossipBindings, key, true);
+    return CallAllBool(*GameObjectGossipBindings, key, true, pPlayer, pGameObject, sender, action, code);
 }
 
 void ALE::HandleGossipSelectOption(Player* pPlayer, uint32 menuId, uint32 sender, uint32 action, const std::string& code)
@@ -66,82 +64,58 @@ void ALE::HandleGossipSelectOption(Player* pPlayer, uint32 menuId, uint32 sender
     START_HOOK(PlayerGossipBindings, GOSSIP_EVENT_ON_SELECT, menuId);
     pPlayer->PlayerTalkClass->ClearMenus();
 
-    Push(pPlayer); // receiver
-    Push(pPlayer); // sender, just not to mess up the amount of args.
-    Push(sender);
-    Push(action);
-    if (code.empty())
-        Push();
-    else
-        Push(code);
-
-    CallAllFunctions(PlayerGossipBindings, key);
+    // The player is passed twice: as the receiver and as the sender,
+    // to keep the same argument layout as the other gossip events.
+    CallAll(*PlayerGossipBindings, key, pPlayer, pPlayer, sender, action, CodeOrNil(lua, code));
 }
 
 bool ALE::OnItemGossip(Player* pPlayer, Item* pItem, SpellCastTargets const& /*targets*/)
 {
     START_HOOK_WITH_RETVAL(ItemGossipBindings, GOSSIP_EVENT_ON_HELLO, pItem->GetEntry(), true);
     pPlayer->PlayerTalkClass->ClearMenus();
-    Push(pPlayer);
-    Push(pItem);
-    return CallAllFunctionsBool(ItemGossipBindings, key, true);
+    return CallAllBool(*ItemGossipBindings, key, true, pPlayer, pItem);
 }
 
 void ALE::HandleGossipSelectOption(Player* pPlayer, Item* pItem, uint32 sender, uint32 action, const std::string& code)
 {
     START_HOOK(ItemGossipBindings, GOSSIP_EVENT_ON_SELECT, pItem->GetEntry());
     pPlayer->PlayerTalkClass->ClearMenus();
-
-    Push(pPlayer);
-    Push(pItem);
-    Push(sender);
-    Push(action);
-    if (code.empty())
-        Push();
-    else
-        Push(code);
-
-    CallAllFunctions(ItemGossipBindings, key);
+    CallAll(*ItemGossipBindings, key, pPlayer, pItem, sender, action, CodeOrNil(lua, code));
 }
 
 bool ALE::OnGossipHello(Player* pPlayer, Creature* pCreature)
 {
     START_HOOK_WITH_RETVAL(CreatureGossipBindings, GOSSIP_EVENT_ON_HELLO, pCreature->GetEntry(), false);
     pPlayer->PlayerTalkClass->ClearMenus();
-    Push(pPlayer);
-    Push(pCreature);
-    return CallAllFunctionsBool(CreatureGossipBindings, key, true);
+    return CallAllBool(*CreatureGossipBindings, key, true, pPlayer, pCreature);
 }
 
 bool ALE::OnGossipSelect(Player* pPlayer, Creature* pCreature, uint32 sender, uint32 action)
 {
     START_HOOK_WITH_RETVAL(CreatureGossipBindings, GOSSIP_EVENT_ON_SELECT, pCreature->GetEntry(), false);
+
+    // Restore the menu if no handler overrode the default behaviour.
     auto originalMenu = *pPlayer->PlayerTalkClass;
     pPlayer->PlayerTalkClass->ClearMenus();
-    Push(pPlayer);
-    Push(pCreature);
-    Push(sender);
-    Push(action);
-    auto preventDefault = CallAllFunctionsBool(CreatureGossipBindings, key, true);
-    if (!preventDefault) {
+
+    bool preventDefault = CallAllBool(*CreatureGossipBindings, key, true, pPlayer, pCreature, sender, action);
+    if (!preventDefault)
         *pPlayer->PlayerTalkClass = originalMenu;
-    }
+
     return preventDefault;
 }
 
 bool ALE::OnGossipSelectCode(Player* pPlayer, Creature* pCreature, uint32 sender, uint32 action, const char* code)
 {
     START_HOOK_WITH_RETVAL(CreatureGossipBindings, GOSSIP_EVENT_ON_SELECT, pCreature->GetEntry(), false);
+
+    // Restore the menu if no handler overrode the default behaviour.
     auto originalMenu = *pPlayer->PlayerTalkClass;
     pPlayer->PlayerTalkClass->ClearMenus();
-    Push(pPlayer);
-    Push(pCreature);
-    Push(sender);
-    Push(action);
-    Push(code);
-    auto preventDefault = CallAllFunctionsBool(CreatureGossipBindings, key, true);
-    if (!preventDefault) {
+
+    bool preventDefault = CallAllBool(*CreatureGossipBindings, key, true, pPlayer, pCreature, sender, action, code);
+    if (!preventDefault)
         *pPlayer->PlayerTalkClass = originalMenu;
-    }
+
     return preventDefault;
 }
diff --git a/src/LuaEngine/hooks/GroupHooks.cpp b/src/LuaEngine/hooks/GroupHooks.cpp
index aac809d4aa..a8968a4083 100644
--- a/src/LuaEngine/hooks/GroupHooks.cpp
+++ b/src/LuaEngine/hooks/GroupHooks.cpp
@@ -5,10 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -23,49 +21,35 @@ using namespace Hooks;
 void ALE::OnAddMember(Group* group, ObjectGuid guid)
 {
     START_HOOK(GROUP_EVENT_ON_MEMBER_ADD);
-    Push(group);
-    Push(guid);
-    CallAllFunctions(GroupEventBindings, key);
+    CallAll(*GroupEventBindings, key, group, guid);
 }
 
 void ALE::OnInviteMember(Group* group, ObjectGuid guid)
 {
     START_HOOK(GROUP_EVENT_ON_MEMBER_INVITE);
-    Push(group);
-    Push(guid);
-    CallAllFunctions(GroupEventBindings, key);
+    CallAll(*GroupEventBindings, key, group, guid);
 }
 
 void ALE::OnRemoveMember(Group* group, ObjectGuid guid, uint8 method)
 {
     START_HOOK(GROUP_EVENT_ON_MEMBER_REMOVE);
-    Push(group);
-    Push(guid);
-    Push(method);
-    CallAllFunctions(GroupEventBindings, key);
+    CallAll(*GroupEventBindings, key, group, guid, method);
 }
 
 void ALE::OnChangeLeader(Group* group, ObjectGuid newLeaderGuid, ObjectGuid oldLeaderGuid)
 {
     START_HOOK(GROUP_EVENT_ON_LEADER_CHANGE);
-    Push(group);
-    Push(newLeaderGuid);
-    Push(oldLeaderGuid);
-    CallAllFunctions(GroupEventBindings, key);
+    CallAll(*GroupEventBindings, key, group, newLeaderGuid, oldLeaderGuid);
 }
 
 void ALE::OnDisband(Group* group)
 {
     START_HOOK(GROUP_EVENT_ON_DISBAND);
-    Push(group);
-    CallAllFunctions(GroupEventBindings, key);
+    CallAll(*GroupEventBindings, key, group);
 }
 
 void ALE::OnCreate(Group* group, ObjectGuid leaderGuid, GroupType groupType)
 {
     START_HOOK(GROUP_EVENT_ON_CREATE);
-    Push(group);
-    Push(leaderGuid);
-    Push(groupType);
-    CallAllFunctions(GroupEventBindings, key);
+    CallAll(*GroupEventBindings, key, group, leaderGuid, groupType);
 }
diff --git a/src/LuaEngine/hooks/GuildHooks.cpp b/src/LuaEngine/hooks/GuildHooks.cpp
index 8b3adf9a69..6f53d7ebf3 100644
--- a/src/LuaEngine/hooks/GuildHooks.cpp
+++ b/src/LuaEngine/hooks/GuildHooks.cpp
@@ -5,10 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -23,142 +21,78 @@ using namespace Hooks;
 void ALE::OnAddMember(Guild* guild, Player* player, uint32 plRank)
 {
     START_HOOK(GUILD_EVENT_ON_ADD_MEMBER);
-    Push(guild);
-    Push(player);
-    Push(plRank);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, player, plRank);
 }
 
 void ALE::OnRemoveMember(Guild* guild, Player* player, bool isDisbanding)
 {
     START_HOOK(GUILD_EVENT_ON_REMOVE_MEMBER);
-    Push(guild);
-    Push(player);
-    Push(isDisbanding);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, player, isDisbanding);
 }
 
 void ALE::OnMOTDChanged(Guild* guild, const std::string& newMotd)
 {
     START_HOOK(GUILD_EVENT_ON_MOTD_CHANGE);
-    Push(guild);
-    Push(newMotd);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, newMotd);
 }
 
 void ALE::OnInfoChanged(Guild* guild, const std::string& newInfo)
 {
     START_HOOK(GUILD_EVENT_ON_INFO_CHANGE);
-    Push(guild);
-    Push(newInfo);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, newInfo);
 }
 
 void ALE::OnCreate(Guild* guild, Player* leader, const std::string& name)
 {
     START_HOOK(GUILD_EVENT_ON_CREATE);
-    Push(guild);
-    Push(leader);
-    Push(name);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, leader, name);
 }
 
 void ALE::OnDisband(Guild* guild)
 {
     START_HOOK(GUILD_EVENT_ON_DISBAND);
-    Push(guild);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild);
 }
 
 void ALE::OnMemberWitdrawMoney(Guild* guild, Player* player, uint32& amount, bool isRepair)
 {
     START_HOOK(GUILD_EVENT_ON_MONEY_WITHDRAW);
-    Push(guild);
-    Push(player);
-    Push(amount);
-    Push(isRepair); // isRepair not a part of Mangos, implement?
-    int amountIndex = lua_gettop(L) - 1;
-    int n = SetupStack(GuildEventBindings, key, 4);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 4, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            amount = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(amount, amountIndex);
-        }
 
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+    // A handler that returns a number changes the amount, for the handlers
+    // after it and for the withdrawal itself.
+    amount = CallAllFold(*GuildEventBindings, key, amount, [&](auto const& callback, uint32 current)
+    {
+        return Call(callback, key.event_id, guild, player, current, isRepair);
+    });
 }
 
 void ALE::OnMemberDepositMoney(Guild* guild, Player* player, uint32& amount)
 {
     START_HOOK(GUILD_EVENT_ON_MONEY_DEPOSIT);
-    Push(guild);
-    Push(player);
-    Push(amount);
-    int amountIndex = lua_gettop(L);
-    int n = SetupStack(GuildEventBindings, key, 3);
 
-    while (n > 0)
+    // A handler that returns a number changes the amount, for the handlers
+    // after it and for the deposit itself.
+    amount = CallAllFold(*GuildEventBindings, key, amount, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            amount = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(amount, amountIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, guild, player, current);
+    });
 }
 
 void ALE::OnItemMove(Guild* guild, Player* player, Item* pItem, bool isSrcBank, uint8 srcContainer, uint8 srcSlotId,
     bool isDestBank, uint8 destContainer, uint8 destSlotId)
 {
     START_HOOK(GUILD_EVENT_ON_ITEM_MOVE);
-    Push(guild);
-    Push(player);
-    Push(pItem);
-    Push(isSrcBank);
-    Push(srcContainer);
-    Push(srcSlotId);
-    Push(isDestBank);
-    Push(destContainer);
-    Push(destSlotId);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, player, pItem, isSrcBank, srcContainer, srcSlotId, isDestBank, destContainer, destSlotId);
 }
 
 void ALE::OnEvent(Guild* guild, uint8 eventType, uint32 playerGuid1, uint32 playerGuid2, uint8 newRank)
 {
     START_HOOK(GUILD_EVENT_ON_EVENT);
-    Push(guild);
-    Push(eventType);
-    Push(playerGuid1);
-    Push(playerGuid2);
-    Push(newRank);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, eventType, playerGuid1, playerGuid2, newRank);
 }
 
 void ALE::OnBankEvent(Guild* guild, uint8 eventType, uint8 tabId, uint32 playerGuid, uint32 itemOrMoney, uint16 itemStackCount, uint8 destTabId)
 {
     START_HOOK(GUILD_EVENT_ON_BANK_EVENT);
-    Push(guild);
-    Push(eventType);
-    Push(tabId);
-    Push(playerGuid);
-    Push(itemOrMoney);
-    Push(itemStackCount);
-    Push(destTabId);
-    CallAllFunctions(GuildEventBindings, key);
+    CallAll(*GuildEventBindings, key, guild, eventType, tabId, playerGuid, itemOrMoney, itemStackCount, destTabId);
 }
diff --git a/src/LuaEngine/hooks/InstanceHooks.cpp b/src/LuaEngine/hooks/InstanceHooks.cpp
index 113ca2b348..254d40809f 100644
--- a/src/LuaEngine/hooks/InstanceHooks.cpp
+++ b/src/LuaEngine/hooks/InstanceHooks.cpp
@@ -5,15 +5,14 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
 #include "ALEInstanceAI.h"
 
 using namespace Hooks;
 
+// Instance handlers receive (event, instance_data, map, ...) so they can keep
+// their state in the instance data table.
 #define START_HOOK(EVENT, AI) \
     if (!ALEConfig::GetInstance().IsALEEnabled())\
         return;\
@@ -21,9 +20,7 @@ using namespace Hooks;
     auto instanceKey = EntryKey<InstanceEvents>(EVENT, AI->instance->GetInstanceId());\
     if (!MapEventBindings->HasBindingsFor(mapKey) && !InstanceEventBindings->HasBindingsFor(instanceKey))\
         return;\
-    LOCK_ALE;\
-    PushInstanceData(L, AI);\
-    Push(AI->instance)
+    LOCK_ALE
 
 #define START_HOOK_WITH_RETVAL(EVENT, AI, RETVAL) \
     if (!ALEConfig::GetInstance().IsALEEnabled())\
@@ -32,52 +29,46 @@ using namespace Hooks;
     auto instanceKey = EntryKey<InstanceEvents>(EVENT, AI->instance->GetInstanceId());\
     if (!MapEventBindings->HasBindingsFor(mapKey) && !InstanceEventBindings->HasBindingsFor(instanceKey))\
         return RETVAL;\
-    LOCK_ALE;\
-    PushInstanceData(L, AI);\
-    Push(AI->instance)
+    LOCK_ALE
 
 void ALE::OnInitialize(ALEInstanceAI* ai)
 {
     START_HOOK(INSTANCE_EVENT_ON_INITIALIZE, ai);
-    CallAllFunctions(MapEventBindings, InstanceEventBindings, mapKey, instanceKey);
+    CallAll(*MapEventBindings, *InstanceEventBindings, mapKey, instanceKey, GetInstanceData(ai), ai->instance);
 }
 
 void ALE::OnLoad(ALEInstanceAI* ai)
 {
     START_HOOK(INSTANCE_EVENT_ON_LOAD, ai);
-    CallAllFunctions(MapEventBindings, InstanceEventBindings, mapKey, instanceKey);
+    CallAll(*MapEventBindings, *InstanceEventBindings, mapKey, instanceKey, GetInstanceData(ai), ai->instance);
 }
 
 void ALE::OnUpdateInstance(ALEInstanceAI* ai, uint32 diff)
 {
     START_HOOK(INSTANCE_EVENT_ON_UPDATE, ai);
-    Push(diff);
-    CallAllFunctions(MapEventBindings, InstanceEventBindings, mapKey, instanceKey);
+    CallAll(*MapEventBindings, *InstanceEventBindings, mapKey, instanceKey, GetInstanceData(ai), ai->instance, diff);
 }
 
 void ALE::OnPlayerEnterInstance(ALEInstanceAI* ai, Player* player)
 {
     START_HOOK(INSTANCE_EVENT_ON_PLAYER_ENTER, ai);
-    Push(player);
-    CallAllFunctions(MapEventBindings, InstanceEventBindings, mapKey, instanceKey);
+    CallAll(*MapEventBindings, *InstanceEventBindings, mapKey, instanceKey, GetInstanceData(ai), ai->instance, player);
 }
 
 void ALE::OnCreatureCreate(ALEInstanceAI* ai, Creature* creature)
 {
     START_HOOK(INSTANCE_EVENT_ON_CREATURE_CREATE, ai);
-    Push(creature);
-    CallAllFunctions(MapEventBindings, InstanceEventBindings, mapKey, instanceKey);
+    CallAll(*MapEventBindings, *InstanceEventBindings, mapKey, instanceKey, GetInstanceData(ai), ai->instance, creature);
 }
 
 void ALE::OnGameObjectCreate(ALEInstanceAI* ai, GameObject* gameobject)
 {
     START_HOOK(INSTANCE_EVENT_ON_GAMEOBJECT_CREATE, ai);
-    Push(gameobject);
-    CallAllFunctions(MapEventBindings, InstanceEventBindings, mapKey, instanceKey);
+    CallAll(*MapEventBindings, *InstanceEventBindings, mapKey, instanceKey, GetInstanceData(ai), ai->instance, gameobject);
 }
 
 bool ALE::OnCheckEncounterInProgress(ALEInstanceAI* ai)
 {
     START_HOOK_WITH_RETVAL(INSTANCE_EVENT_ON_CHECK_ENCOUNTER_IN_PROGRESS, ai, false);
-    return CallAllFunctionsBool(MapEventBindings, InstanceEventBindings, mapKey, instanceKey);
+    return CallAllBool(*MapEventBindings, *InstanceEventBindings, mapKey, instanceKey, false, GetInstanceData(ai), ai->instance);
 }
diff --git a/src/LuaEngine/hooks/ItemHooks.cpp b/src/LuaEngine/hooks/ItemHooks.cpp
index 9bc347480c..ae60b84195 100644
--- a/src/LuaEngine/hooks/ItemHooks.cpp
+++ b/src/LuaEngine/hooks/ItemHooks.cpp
@@ -5,11 +5,9 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
+#include "Spell.h"
 
 using namespace Hooks;
 
@@ -32,25 +30,18 @@ using namespace Hooks;
 void ALE::OnDummyEffect(WorldObject* pCaster, uint32 spellId, SpellEffIndex effIndex, Item* pTarget)
 {
     START_HOOK(ITEM_EVENT_ON_DUMMY_EFFECT, pTarget->GetEntry());
-    Push(pCaster);
-    Push(spellId);
-    Push(effIndex);
-    Push(pTarget);
-    CallAllFunctions(ItemEventBindings, key);
+    CallAll(*ItemEventBindings, key, pCaster, spellId, effIndex, pTarget);
 }
 
 bool ALE::OnQuestAccept(Player* pPlayer, Item* pItem, Quest const* pQuest)
 {
     START_HOOK_WITH_RETVAL(ITEM_EVENT_ON_QUEST_ACCEPT, pItem->GetEntry(), false);
-    Push(pPlayer);
-    Push(pItem);
-    Push(pQuest);
-    return CallAllFunctionsBool(ItemEventBindings, key);
+    return CallAllBool(*ItemEventBindings, key, false, pPlayer, pItem, pQuest);
 }
 
 bool ALE::OnUse(Player* pPlayer, Item* pItem, SpellCastTargets const& targets)
 {
-    ObjectGuid guid = pItem->GET_GUID();
+    ObjectGuid guid = pItem->GetGUID();
     bool castSpell = true;
 
     if (!OnItemUse(pPlayer, pItem, targets))
@@ -81,37 +72,31 @@ bool ALE::OnUse(Player* pPlayer, Item* pItem, SpellCastTargets const& targets)
 bool ALE::OnItemUse(Player* pPlayer, Item* pItem, SpellCastTargets const& targets)
 {
     START_HOOK_WITH_RETVAL(ITEM_EVENT_ON_USE, pItem->GetEntry(), true);
-    Push(pPlayer);
-    Push(pItem);
-
-    if (GameObject* target = targets.GetGOTarget())
-        Push(target);
-    else if (Item* target = targets.GetItemTarget())
-        Push(target);
-    else if (Corpse* target = targets.GetCorpseTarget())
-        Push(target);
-    else if (Unit* target = targets.GetUnitTarget())
-        Push(target);
-    else if (WorldObject* target = targets.GetObjectTarget())
-        Push(target);
-    else
-        Push();
-
-    return CallAllFunctionsBool(ItemEventBindings, key, true);
+
+    // The handler receives whatever the item was used on, or nil.
+    sol::object target = sol::make_object(lua, sol::nil);
+    if (GameObject* goTarget = targets.GetGOTarget())
+        target = sol::make_object(lua, GameObjectRef(goTarget));
+    else if (Item* itemTarget = targets.GetItemTarget())
+        target = sol::make_object(lua, ItemRef(itemTarget));
+    else if (Corpse* corpseTarget = targets.GetCorpseTarget())
+        target = sol::make_object(lua, CorpseRef(corpseTarget));
+    else if (Unit* unitTarget = targets.GetUnitTarget())
+        target = ALEBind::ToLuaDynamic(lua, unitTarget);
+    else if (WorldObject* objectTarget = targets.GetObjectTarget())
+        target = ALEBind::ToLuaDynamic(lua, objectTarget);
+
+    return CallAllBool(*ItemEventBindings, key, true, pPlayer, pItem, target);
 }
 
 bool ALE::OnExpire(Player* pPlayer, ItemTemplate const* pProto)
 {
     START_HOOK_WITH_RETVAL(ITEM_EVENT_ON_EXPIRE, pProto->ItemId, false);
-    Push(pPlayer);
-    Push(pProto->ItemId);
-    return CallAllFunctionsBool(ItemEventBindings, key);
+    return CallAllBool(*ItemEventBindings, key, false, pPlayer, pProto->ItemId);
 }
 
 bool ALE::OnRemove(Player* pPlayer, Item* pItem)
 {
     START_HOOK_WITH_RETVAL(ITEM_EVENT_ON_REMOVE, pItem->GetEntry(), false);
-    Push(pPlayer);
-    Push(pItem);
-    return CallAllFunctionsBool(ItemEventBindings, key);
+    return CallAllBool(*ItemEventBindings, key, false, pPlayer, pItem);
 }
diff --git a/src/LuaEngine/hooks/PacketHooks.cpp b/src/LuaEngine/hooks/PacketHooks.cpp
index e09cd941f4..02ca38bed2 100644
--- a/src/LuaEngine/hooks/PacketHooks.cpp
+++ b/src/LuaEngine/hooks/PacketHooks.cpp
@@ -5,11 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -29,60 +26,53 @@ using namespace Hooks;
         return;\
     LOCK_ALE
 
+namespace
+{
+    // Handlers receive a copy of the packet; a handler returning false blocks it.
+    template<typename ALEType, typename BindingsType, typename KeyType>
+    void DispatchPacketEvent(ALEType* engine, BindingsType& bindings, KeyType const& key,
+        WorldPacket const& packet, Player* player, bool& result)
+    {
+        for (sol::protected_function const& callback : bindings.GetCallbacksFor(key))
+        {
+            sol::protected_function_result callResult = engine->Call(callback, key.event_id, WorldPacket(packet), player);
+            if (!callResult.valid())
+                continue;
+
+            if (sol::optional<bool> value = callResult.template get<sol::optional<bool>>(0))
+                if (!*value)
+                    result = false;
+        }
+    }
+}
+
 bool ALE::OnPacketSend(WorldSession* session, const WorldPacket& packet)
 {
     bool result = true;
-    Player* player = NULL;
+    Player* player = nullptr;
     if (session)
         player = session->GetPlayer();
     OnPacketSendAny(player, packet, result);
     OnPacketSendOne(player, packet, result);
     return result;
 }
+
 void ALE::OnPacketSendAny(Player* player, const WorldPacket& packet, bool& result)
 {
     START_HOOK_SERVER(SERVER_EVENT_ON_PACKET_SEND);
-    Push(new WorldPacket(packet));
-    Push(player);
-    int n = SetupStack(ServerEventBindings, key, 2);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 2, 1);
-
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(2);
+    DispatchPacketEvent(this, *ServerEventBindings, key, packet, player, result);
 }
 
 void ALE::OnPacketSendOne(Player* player, const WorldPacket& packet, bool& result)
 {
     START_HOOK_PACKET(PACKET_EVENT_ON_PACKET_SEND, packet.GetOpcode());
-    Push(new WorldPacket(packet));
-    Push(player);
-    int n = SetupStack(PacketEventBindings, key, 2);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 2, 1);
-
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(2);
+    DispatchPacketEvent(this, *PacketEventBindings, key, packet, player, result);
 }
 
 bool ALE::OnPacketReceive(WorldSession* session, WorldPacket const& packet)
 {
     bool result = true;
-    Player* player = NULL;
+    Player* player = nullptr;
     if (session)
         player = session->GetPlayer();
     OnPacketReceiveAny(player, packet, result);
@@ -93,39 +83,11 @@ bool ALE::OnPacketReceive(WorldSession* session, WorldPacket const& packet)
 void ALE::OnPacketReceiveAny(Player* player, WorldPacket const& packet, bool& result)
 {
     START_HOOK_SERVER(SERVER_EVENT_ON_PACKET_RECEIVE);
-    Push(new WorldPacket(packet));
-    Push(player);
-    int n = SetupStack(ServerEventBindings, key, 2);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 2, 1);
-
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(2);
+    DispatchPacketEvent(this, *ServerEventBindings, key, packet, player, result);
 }
 
 void ALE::OnPacketReceiveOne(Player* player, WorldPacket const& packet, bool& result)
 {
     START_HOOK_PACKET(PACKET_EVENT_ON_PACKET_RECEIVE, packet.GetOpcode());
-    Push(new WorldPacket(packet));
-    Push(player);
-    int n = SetupStack(PacketEventBindings, key, 2);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 2, 1);
-
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(2);
+    DispatchPacketEvent(this, *PacketEventBindings, key, packet, player, result);
 }
diff --git a/src/LuaEngine/hooks/PlayerHooks.cpp b/src/LuaEngine/hooks/PlayerHooks.cpp
index 7649274840..a507c4caa9 100644
--- a/src/LuaEngine/hooks/PlayerHooks.cpp
+++ b/src/LuaEngine/hooks/PlayerHooks.cpp
@@ -5,11 +5,11 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
+#include "Channel.h"
+
+#include <algorithm>
 
 using namespace Hooks;
 
@@ -32,11 +32,7 @@ using namespace Hooks;
 void ALE::OnLearnTalents(Player* pPlayer, uint32 talentId, uint32 talentRank, uint32 spellid)
 {
     START_HOOK(PLAYER_EVENT_ON_LEARN_TALENTS);
-    Push(pPlayer);
-    Push(talentId);
-    Push(talentRank);
-    Push(spellid);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, talentId, talentRank, spellid);
 }
 
 bool ALE::OnCommand(ChatHandler& handler, const char* text)
@@ -55,922 +51,530 @@ bool ALE::OnCommand(ChatHandler& handler, const char* text)
     }
 
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_COMMAND, true);
-    Push(player);
-    Push(text);
-    Push(&handler);
-    return CallAllFunctionsBool(PlayerEventBindings, key, true);
+    return CallAllBool(*PlayerEventBindings, key, true, player, text, &handler);
 }
 
 void ALE::OnLootItem(Player* pPlayer, Item* pItem, uint32 count, ObjectGuid guid)
 {
     START_HOOK(PLAYER_EVENT_ON_LOOT_ITEM);
-    Push(pPlayer);
-    Push(pItem);
-    Push(count);
-    Push(guid);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, pItem, count, guid);
 }
 
 void ALE::OnLootMoney(Player* pPlayer, uint32 amount)
 {
     START_HOOK(PLAYER_EVENT_ON_LOOT_MONEY);
-    Push(pPlayer);
-    Push(amount);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, amount);
 }
 
 void ALE::OnFirstLogin(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_FIRST_LOGIN);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnRepop(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_REPOP);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnResurrect(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_RESURRECT);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnQuestAbandon(Player* pPlayer, uint32 questId)
 {
     START_HOOK(PLAYER_EVENT_ON_QUEST_ABANDON);
-    Push(pPlayer);
-    Push(questId);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, questId);
 }
 
 void ALE::OnEquip(Player* pPlayer, Item* pItem, uint8 bag, uint8 slot)
 {
     START_HOOK(PLAYER_EVENT_ON_EQUIP);
-    Push(pPlayer);
-    Push(pItem);
-    Push(bag);
-    Push(slot);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, pItem, bag, slot);
 }
 
 InventoryResult ALE::OnCanUseItem(const Player* pPlayer, uint32 itemEntry)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CAN_USE_ITEM, EQUIP_ERR_OK);
-    InventoryResult result = EQUIP_ERR_OK;
-    Push(pPlayer);
-    Push(itemEntry);
-    int n = SetupStack(PlayerEventBindings, key, 2);
 
-    while (n > 0)
+    // A handler that returns a number overrides the equip result.
+    uint32 result = CallAllFold(*PlayerEventBindings, key, static_cast<uint32>(EQUIP_ERR_OK),
+        [&](auto const& callback, uint32 /*current*/)
     {
-        int r = CallOneFunction(n--, 2, 1);
-
-        if (lua_isnumber(L, r))
-            result = (InventoryResult)CHECKVAL<uint32>(L, r);
-
-        lua_pop(L, 1);
-    }
+        return Call(callback, key.event_id, pPlayer, itemEntry);
+    });
 
-    CleanUpStack(2);
-    return result;
+    return static_cast<InventoryResult>(result);
 }
+
 void ALE::OnPlayerEnterCombat(Player* pPlayer, Unit* pEnemy)
 {
     START_HOOK(PLAYER_EVENT_ON_ENTER_COMBAT);
-    Push(pPlayer);
-    Push(pEnemy);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, pEnemy);
 }
 
 void ALE::OnPlayerLeaveCombat(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_LEAVE_COMBAT);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnPVPKill(Player* pKiller, Player* pKilled)
 {
     START_HOOK(PLAYER_EVENT_ON_KILL_PLAYER);
-    Push(pKiller);
-    Push(pKilled);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pKiller, pKilled);
 }
 
 void ALE::OnCreatureKill(Player* pKiller, Creature* pKilled)
 {
     START_HOOK(PLAYER_EVENT_ON_KILL_CREATURE);
-    Push(pKiller);
-    Push(pKilled);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pKiller, pKilled);
 }
 
 void ALE::OnPlayerKilledByCreature(Creature* pKiller, Player* pKilled)
 {
     START_HOOK(PLAYER_EVENT_ON_KILLED_BY_CREATURE);
-    Push(pKiller);
-    Push(pKilled);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pKiller, pKilled);
 }
 
 void ALE::OnLevelChanged(Player* pPlayer, uint8 oldLevel)
 {
     START_HOOK(PLAYER_EVENT_ON_LEVEL_CHANGE);
-    Push(pPlayer);
-    Push(oldLevel);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, oldLevel);
 }
 
 void ALE::OnFreeTalentPointsChanged(Player* pPlayer, uint32 newPoints)
 {
     START_HOOK(PLAYER_EVENT_ON_TALENTS_CHANGE);
-    Push(pPlayer);
-    Push(newPoints);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, newPoints);
 }
 
 void ALE::OnTalentsReset(Player* pPlayer, bool noCost)
 {
     START_HOOK(PLAYER_EVENT_ON_TALENTS_RESET);
-    Push(pPlayer);
-    Push(noCost);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, noCost);
 }
 
 void ALE::OnMoneyChanged(Player* pPlayer, int32& amount)
 {
     START_HOOK(PLAYER_EVENT_ON_MONEY_CHANGE);
-    Push(pPlayer);
-    Push(amount);
-    int amountIndex = lua_gettop(L);
-    int n = SetupStack(PlayerEventBindings, key, 2);
-
-    while (n > 0)
+    amount = CallAllFold(*PlayerEventBindings, key, amount, [&](auto const& callback, int32 current)
     {
-        int r = CallOneFunction(n--, 2, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            amount = CHECKVAL<int32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(amount, amountIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(2);
+        return Call(callback, key.event_id, pPlayer, current);
+    });
 }
 
 void ALE::OnGiveXP(Player* pPlayer, uint32& amount, Unit* pVictim, uint8 xpSource)
 {
     START_HOOK(PLAYER_EVENT_ON_GIVE_XP);
-    Push(pPlayer);
-    Push(amount);
-    Push(pVictim);
-    Push(xpSource);
-    int amountIndex = lua_gettop(L) - 1;
-    int n = SetupStack(PlayerEventBindings, key, 4);
-
-    while (n > 0)
+    amount = CallAllFold(*PlayerEventBindings, key, amount, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            amount = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(amount, amountIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, key.event_id, pPlayer, current, pVictim, xpSource);
+    });
 }
 
 bool ALE::OnReputationChange(Player* pPlayer, uint32 factionID, int32& standing, bool incremental)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_REPUTATION_CHANGE, true);
     bool result = true;
-    Push(pPlayer);
-    Push(factionID);
-    Push(standing);
-    Push(incremental);
-    int standingIndex = lua_gettop(L) - 1;
-    int n = SetupStack(PlayerEventBindings, key, 4);
-
-    while (n > 0)
+
+    // A handler that returns a number changes the new standing;
+    // returning -1 blocks the change entirely.
+    for (sol::protected_function const& callback : PlayerEventBindings->GetCallbacksFor(key))
     {
-        int r = CallOneFunction(n--, 4, 1);
+        sol::protected_function_result callResult = Call(callback, key.event_id, pPlayer, factionID, standing, incremental);
+        if (!callResult.valid())
+            continue;
 
-        if (lua_isnumber(L, r))
+        if (sol::optional<int32> newStanding = callResult.get<sol::optional<int32>>(0))
         {
-            standing = CHECKVAL<int32>(L, r);
+            standing = *newStanding;
             if (standing == -1)
                 result = false;
-            // Update the stack for subsequent calls.
-            ReplaceArgument(standing, standingIndex);
         }
-
-        lua_pop(L, 1);
     }
 
-    CleanUpStack(4);
     return result;
 }
 
 void ALE::OnDuelRequest(Player* pTarget, Player* pChallenger)
 {
     START_HOOK(PLAYER_EVENT_ON_DUEL_REQUEST);
-    Push(pTarget);
-    Push(pChallenger);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pTarget, pChallenger);
 }
 
 void ALE::OnDuelStart(Player* pStarter, Player* pChallenger)
 {
     START_HOOK(PLAYER_EVENT_ON_DUEL_START);
-    Push(pStarter);
-    Push(pChallenger);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pStarter, pChallenger);
 }
 
 void ALE::OnDuelEnd(Player* pWinner, Player* pLoser, DuelCompleteType type)
 {
     START_HOOK(PLAYER_EVENT_ON_DUEL_END);
-    Push(pWinner);
-    Push(pLoser);
-    Push(type);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pWinner, pLoser, type);
 }
 
 void ALE::OnEmote(Player* pPlayer, uint32 emote)
 {
     START_HOOK(PLAYER_EVENT_ON_EMOTE);
-    Push(pPlayer);
-    Push(emote);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, emote);
 }
 
 void ALE::OnTextEmote(Player* pPlayer, uint32 textEmote, uint32 emoteNum, ObjectGuid guid)
 {
     START_HOOK(PLAYER_EVENT_ON_TEXT_EMOTE);
-    Push(pPlayer);
-    Push(textEmote);
-    Push(emoteNum);
-    Push(guid);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, textEmote, emoteNum, guid);
 }
 
 void ALE::OnPlayerSpellCast(Player* pPlayer, Spell* pSpell, bool skipCheck)
 {
     START_HOOK(PLAYER_EVENT_ON_SPELL_CAST);
-    Push(pPlayer);
-    Push(pSpell);
-    Push(skipCheck);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, pSpell, skipCheck);
 }
 
 void ALE::OnLogin(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_LOGIN);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnLogout(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_LOGOUT);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnCreate(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_CHARACTER_CREATE);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnDelete(uint32 guidlow)
 {
     START_HOOK(PLAYER_EVENT_ON_CHARACTER_DELETE);
-    Push(guidlow);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, guidlow);
 }
 
 void ALE::OnSave(Player* pPlayer)
 {
     START_HOOK(PLAYER_EVENT_ON_SAVE);
-    Push(pPlayer);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer);
 }
 
 void ALE::OnBindToInstance(Player* pPlayer, Difficulty difficulty, uint32 mapid, bool permanent)
 {
     START_HOOK(PLAYER_EVENT_ON_BIND_TO_INSTANCE);
-    Push(pPlayer);
-    Push(difficulty);
-    Push(mapid);
-    Push(permanent);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, difficulty, mapid, permanent);
 }
 
 void ALE::OnUpdateArea(Player* pPlayer, uint32 oldArea, uint32 newArea)
 {
     START_HOOK(PLAYER_EVENT_ON_UPDATE_AREA);
-    Push(pPlayer);
-    Push(oldArea);
-    Push(newArea);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, oldArea, newArea);
 }
 
 void ALE::OnUpdateZone(Player* pPlayer, uint32 newZone, uint32 newArea)
 {
     START_HOOK(PLAYER_EVENT_ON_UPDATE_ZONE);
-    Push(pPlayer);
-    Push(newZone);
-    Push(newArea);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, pPlayer, newZone, newArea);
 }
 
 void ALE::OnMapChanged(Player* player)
 {
     START_HOOK(PLAYER_EVENT_ON_MAP_CHANGE);
-    Push(player);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player);
 }
 
-bool ALE::OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg)
+/*
+ * Shared implementation of the chat events: handlers return
+ * (false to block the message, new message text to rewrite it).
+ * `extra` is the chat context (group, guild, channel id, receiver, ...).
+ */
+bool ALE::DispatchChatEvent(EventKey<Hooks::PlayerEvents> const& key, Player* pPlayer, std::string& msg,
+    uint32 type, uint32 lang, sol::optional<sol::object> extra)
 {
-    if (lang == LANG_ADDON)
-        return OnAddonMessage(pPlayer, type, msg, NULL, NULL, NULL, NULL);
-
-    START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CHAT, true);
     bool result = true;
-    Push(pPlayer);
-    Push(msg);
-    Push(type);
-    Push(lang);
-    int n = SetupStack(PlayerEventBindings, key, 4);
 
-    while (n > 0)
+    for (sol::protected_function const& callback : PlayerEventBindings->GetCallbacksFor(key))
     {
-        int r = CallOneFunction(n--, 4, 2);
+        sol::protected_function_result callResult = extra
+            ? Call(callback, key.event_id, pPlayer, msg, type, lang, *extra)
+            : Call(callback, key.event_id, pPlayer, msg, type, lang);
+        if (!callResult.valid())
+            continue;
 
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
+        if (callResult.get<sol::optional<bool>>(0) == sol::optional<bool>(false))
             result = false;
 
-        if (lua_isstring(L, r + 1))
-            msg = std::string(lua_tostring(L, r + 1));
-
-        lua_pop(L, 2);
+        if (sol::optional<std::string> newMessage = callResult.get<sol::optional<std::string>>(1))
+            msg = *newMessage;
     }
 
-    CleanUpStack(4);
     return result;
 }
 
-bool ALE::OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Group* pGroup)
+bool ALE::OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg)
 {
     if (lang == LANG_ADDON)
-        return OnAddonMessage(pPlayer, type, msg, NULL, NULL, pGroup, NULL);
+        return OnAddonMessage(pPlayer, type, msg, nullptr, nullptr, nullptr, nullptr);
 
-    START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_GROUP_CHAT, true);
-    bool result = true;
-    Push(pPlayer);
-    Push(msg);
-    Push(type);
-    Push(lang);
-    Push(pGroup);
-    int n = SetupStack(PlayerEventBindings, key, 5);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 5, 2);
-
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        if (lua_isstring(L, r + 1))
-            msg = std::string(lua_tostring(L, r + 1));
+    START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CHAT, true);
+    return DispatchChatEvent(key, pPlayer, msg, type, lang, sol::nullopt);
+}
 
-        lua_pop(L, 2);
-    }
+bool ALE::OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Group* pGroup)
+{
+    if (lang == LANG_ADDON)
+        return OnAddonMessage(pPlayer, type, msg, nullptr, nullptr, pGroup, nullptr);
 
-    CleanUpStack(5);
-    return result;
+    START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_GROUP_CHAT, true);
+    return DispatchChatEvent(key, pPlayer, msg, type, lang, sol::make_object(lua, GroupRef(pGroup)));
 }
 
 bool ALE::OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Guild* pGuild)
 {
     if (lang == LANG_ADDON)
-        return OnAddonMessage(pPlayer, type, msg, NULL, pGuild, NULL, NULL);
+        return OnAddonMessage(pPlayer, type, msg, nullptr, pGuild, nullptr, nullptr);
 
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_GUILD_CHAT, true);
-    bool result = true;
-    Push(pPlayer);
-    Push(msg);
-    Push(type);
-    Push(lang);
-    Push(pGuild);
-    int n = SetupStack(PlayerEventBindings, key, 5);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 5, 2);
-
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        if (lua_isstring(L, r + 1))
-            msg = std::string(lua_tostring(L, r + 1));
-
-        lua_pop(L, 2);
-    }
-
-    CleanUpStack(5);
-    return result;
+    return DispatchChatEvent(key, pPlayer, msg, type, lang, sol::make_object(lua, GuildRef(pGuild)));
 }
 
 bool ALE::OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Channel* pChannel)
 {
     if (lang == LANG_ADDON)
-        return OnAddonMessage(pPlayer, type, msg, NULL, NULL, NULL, pChannel);
+        return OnAddonMessage(pPlayer, type, msg, nullptr, nullptr, nullptr, pChannel);
 
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CHANNEL_CHAT, true);
-    bool result = true;
-    Push(pPlayer);
-    Push(msg);
-    Push(type);
-    Push(lang);
-    Push(pChannel->IsConstant() ? static_cast<int32>(pChannel->GetChannelId()) : -static_cast<int32>(pChannel->GetChannelDBId()));
-    int n = SetupStack(PlayerEventBindings, key, 5);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 5, 2);
 
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        if (lua_isstring(L, r + 1))
-            msg = std::string(lua_tostring(L, r + 1));
-
-        lua_pop(L, 2);
-    }
-
-    CleanUpStack(5);
-    return result;
+    // Built-in channels are passed by id, custom channels by negated DB id.
+    int32 channelId = pChannel->IsConstant()
+        ? static_cast<int32>(pChannel->GetChannelId())
+        : -static_cast<int32>(pChannel->GetChannelDBId());
+    return DispatchChatEvent(key, pPlayer, msg, type, lang, sol::make_object(lua, channelId));
 }
 
 bool ALE::OnChat(Player* pPlayer, uint32 type, uint32 lang, std::string& msg, Player* pReceiver)
 {
     if (lang == LANG_ADDON)
-        return OnAddonMessage(pPlayer, type, msg, pReceiver, NULL, NULL, NULL);
+        return OnAddonMessage(pPlayer, type, msg, pReceiver, nullptr, nullptr, nullptr);
 
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_WHISPER, true);
-    bool result = true;
-    Push(pPlayer);
-    Push(msg);
-    Push(type);
-    Push(lang);
-    Push(pReceiver);
-    int n = SetupStack(PlayerEventBindings, key, 5);
-
-    while (n > 0)
-    {
-        int r = CallOneFunction(n--, 5, 2);
-
-        if (lua_isboolean(L, r + 0) && !lua_toboolean(L, r + 0))
-            result = false;
-
-        if (lua_isstring(L, r + 1))
-            msg = std::string(lua_tostring(L, r + 1));
-
-        lua_pop(L, 2);
-    }
-
-    CleanUpStack(5);
-    return result;
+    return DispatchChatEvent(key, pPlayer, msg, type, lang, sol::make_object(lua, PlayerRef(pReceiver)));
 }
 
 void ALE::OnPetAddedToWorld(Player* player, Creature* pet)
 {
     START_HOOK(PLAYER_EVENT_ON_PET_ADDED_TO_WORLD);
-    Push(player);
-    Push(pet);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, pet);
 }
 
 void ALE::OnLearnSpell(Player* player, uint32 spellId)
 {
     START_HOOK(PLAYER_EVENT_ON_LEARN_SPELL);
-    Push(player);
-    Push(spellId);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, spellId);
 }
 
 void ALE::OnAchiComplete(Player* player, AchievementEntry const* achievement)
 {
     START_HOOK(PLAYER_EVENT_ON_ACHIEVEMENT_COMPLETE);
-    Push(player);
-    Push(achievement);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, achievement);
 }
 
 void ALE::OnFfaPvpStateUpdate(Player* player, bool hasFfaPvp)
 {
     START_HOOK(PLAYER_EVENT_ON_FFAPVP_CHANGE);
-    Push(player);
-    Push(hasFfaPvp);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, hasFfaPvp);
 }
 
 bool ALE::OnCanInitTrade(Player* player, Player* target)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CAN_INIT_TRADE, true);
-    Push(player);
-    Push(target);
-    return CallAllFunctionsBool(PlayerEventBindings, key);
+    return CallAllBool(*PlayerEventBindings, key, true, player, target);
 }
 
 bool ALE::OnCanSendMail(Player* player, ObjectGuid receiverGuid, ObjectGuid mailbox, std::string& subject, std::string& body, uint32 money, uint32 cod, Item* item)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CAN_SEND_MAIL, true);
-    Push(player);
-    Push(receiverGuid);
-    Push(mailbox);
-    Push(subject);
-    Push(body);
-    Push(money);
-    Push(cod);
-    Push(item);
-    return CallAllFunctionsBool(PlayerEventBindings, key);
+    return CallAllBool(*PlayerEventBindings, key, true, player, receiverGuid, mailbox, subject, body, money, cod, item);
 }
 
 bool ALE::OnCanJoinLfg(Player* player, uint8 roles, lfg::LfgDungeonSet& dungeons, const std::string& comment)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CAN_JOIN_LFG, true);
-    Push(player);
-    Push(roles);
 
-    lua_newtable(L);
-    int table = lua_gettop(L);
+    // The dungeon set is passed as an array-like table.
+    sol::table dungeonTable = lua.create_table();
     uint32 counter = 1;
     for (uint32 dungeon : dungeons)
-    {
-        ALE::Push(L, dungeon);
-        lua_rawseti(L, table, counter);
-        ++counter;
-    }
-    lua_settop(L, table);
-    ++push_counter;
+        dungeonTable[counter++] = dungeon;
 
-    Push(comment);
-    return CallAllFunctionsBool(PlayerEventBindings, key);
+    return CallAllBool(*PlayerEventBindings, key, true, player, roles, dungeonTable, comment);
 }
 
 void ALE::OnQuestRewardItem(Player* player, Item* item, uint32 count)
 {
     START_HOOK(PLAYER_EVENT_ON_QUEST_REWARD_ITEM);
-    Push(player);
-    Push(item);
-    Push(count);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, item, count);
 }
 
 void ALE::OnCreateItem(Player* player, Item* item, uint32 count)
 {
     START_HOOK(PLAYER_EVENT_ON_CREATE_ITEM);
-    Push(player);
-    Push(item);
-    Push(count);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, item, count);
 }
 
 void ALE::OnStoreNewItem(Player* player, Item* item, uint32 count)
 {
     START_HOOK(PLAYER_EVENT_ON_STORE_NEW_ITEM);
-    Push(player);
-    Push(item);
-    Push(count);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, item, count);
 }
 
 void ALE::OnPlayerCompleteQuest(Player* player, Quest const* quest)
 {
     START_HOOK(PLAYER_EVENT_ON_COMPLETE_QUEST);
-    Push(player);
-    Push(quest);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, quest);
 }
 
 bool ALE::OnCanGroupInvite(Player* player, std::string& memberName)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CAN_GROUP_INVITE, true);
-    Push(player);
-    Push(memberName);
-    return CallAllFunctionsBool(PlayerEventBindings, key);
+    return CallAllBool(*PlayerEventBindings, key, true, player, memberName);
 }
 
 void ALE::OnGroupRollRewardItem(Player* player, Item* item, uint32 count, RollVote voteType, Roll* roll)
 {
     START_HOOK(PLAYER_EVENT_ON_GROUP_ROLL_REWARD_ITEM);
-    Push(player);
-    Push(item);
-    Push(count);
-    Push(voteType);
-    Push(roll);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, item, count, voteType, roll);
 }
 
 void ALE::OnBattlegroundDesertion(Player* player, const BattlegroundDesertionType type)
 {
     START_HOOK(PLAYER_EVENT_ON_BG_DESERTION);
-    Push(player);
-    Push(type);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, type);
 }
 
 void ALE::OnCreatureKilledByPet(Player* player, Creature* killed)
 {
     START_HOOK(PLAYER_EVENT_ON_PET_KILL);
-    Push(player);
-    Push(killed);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, killed);
 }
 
 bool ALE::OnPlayerCanUpdateSkill(Player* player, uint32 skill_id)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CAN_UPDATE_SKILL, true);
-    Push(player);
-    Push(skill_id);
-    return CallAllFunctionsBool(PlayerEventBindings, key);
+    return CallAllBool(*PlayerEventBindings, key, true, player, skill_id);
 }
 
 void ALE::OnPlayerBeforeUpdateSkill(Player* player, uint32 skill_id, uint32& value, uint32 max, uint32 step)
 {
     START_HOOK(PLAYER_EVENT_ON_BEFORE_UPDATE_SKILL);
-    Push(player);
-    Push(skill_id);
-    Push(value);
-    Push(max);
-    Push(step);
-
-    int valueIndex = lua_gettop(L) -2;
-    int n = SetupStack(PlayerEventBindings, key, 5);
-    while (n > 0)
+    value = CallAllFold(*PlayerEventBindings, key, value, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 5, 1);
-        if (lua_isnumber(L, r))
-        {
-            value = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(value, valueIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(5);
+        return Call(callback, key.event_id, player, skill_id, current, max, step);
+    });
 }
 
 void ALE::OnPlayerUpdateSkill(Player* player, uint32 skill_id, uint32 value, uint32 max, uint32 step, uint32 new_value)
 {
     START_HOOK(PLAYER_EVENT_ON_UPDATE_SKILL);
-    Push(player);
-    Push(skill_id);
-    Push(value);
-    Push(max);
-    Push(step);
-    Push(new_value);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, skill_id, value, max, step, new_value);
 }
 
 bool ALE::CanPlayerResurrect(Player* player)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_CAN_RESURRECT, true);
-    Push(player);
-    return CallAllFunctionsBool(PlayerEventBindings, key);
+    return CallAllBool(*PlayerEventBindings, key, true, player);
 }
 
 void ALE::OnPlayerReleasedGhost(Player* player)
 {
     START_HOOK(PLAYER_EVENT_ON_RELEASED_GHOST);
-    Push(player);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player);
 }
 
 void ALE::OnPlayerQuestAccept(Player* player, Quest const* quest)
 {
     START_HOOK(PLAYER_EVENT_ON_QUEST_ACCEPT);
-    Push(player);
-    Push(quest);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, quest);
 }
 
 void ALE::OnPlayerAuraApply(Player* player, Aura* aura)
 {
     START_HOOK(PLAYER_EVENT_ON_AURA_APPLY);
-    Push(player);
-    Push(aura);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, aura);
 }
 
 void ALE::OnPlayerHeal(Player* player, Unit* target, uint32& gain)
 {
     START_HOOK(PLAYER_EVENT_ON_HEAL);
-    Push(player);
-    Push(target);
-    Push(gain);
-
-    int gainIndex = lua_gettop(L);
-    int n = SetupStack(PlayerEventBindings, key, 3);
-    while (n > 0)
+    gain = CallAllFold(*PlayerEventBindings, key, gain, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            gain = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(gain, gainIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, player, target, current);
+    });
 }
 
 void ALE::OnPlayerDamage(Player* player, Unit* target, uint32& damage)
 {
     START_HOOK(PLAYER_EVENT_ON_DAMAGE);
-    Push(player);
-    Push(target);
-    Push(damage);
-
-    int damageIndex = lua_gettop(L);
-    int n = SetupStack(PlayerEventBindings, key, 3);
-    while (n > 0)
+    damage = CallAllFold(*PlayerEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, player, target, current);
+    });
 }
 
 void ALE::OnPlayerAuraRemove(Player* player, Aura* aura, AuraRemoveMode mode)
 {
     START_HOOK(PLAYER_EVENT_ON_AURA_REMOVE);
-    Push(player);
-    Push(aura);
-    Push(mode);
-    CallAllFunctions(PlayerEventBindings, key);
+    CallAll(*PlayerEventBindings, key, player, aura, mode);
 }
 
 void ALE::OnPlayerModifyPeriodicDamageAurasTick(Player* player, Unit* target, uint32& damage, SpellInfo const* spellInfo)
 {
     START_HOOK(PLAYER_EVENT_ON_MODIFY_PERIODIC_DAMAGE_AURAS_TICK);
-    Push(player);
-    Push(target);
-    Push(damage);
-    Push(spellInfo);
-
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(PlayerEventBindings, key, 4);
-    while (n > 0)
+    damage = CallAllFold(*PlayerEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, key.event_id, player, target, current, spellInfo);
+    });
 }
 
 void ALE::OnPlayerModifyMeleeDamage(Player* player, Unit* target, uint32& damage)
 {
     START_HOOK(PLAYER_EVENT_ON_MODIFY_MELEE_DAMAGE);
-    Push(player);
-    Push(target);
-    Push(damage);
-
-    int damageIndex = lua_gettop(L);
-    int n = SetupStack(PlayerEventBindings, key, 3);
-    while (n > 0)
+    damage = CallAllFold(*PlayerEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 3, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(3);
+        return Call(callback, key.event_id, player, target, current);
+    });
 }
 
 void ALE::OnPlayerModifySpellDamageTaken(Player* player, Unit* target, int32& damage, SpellInfo const* spellInfo)
 {
     START_HOOK(PLAYER_EVENT_ON_MODIFY_SPELL_DAMAGE_TAKEN);
-    Push(player);
-    Push(target);
-    Push(damage);
-    Push(spellInfo);
-
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(PlayerEventBindings, key, 4);
-    while (n > 0)
+    damage = CallAllFold(*PlayerEventBindings, key, damage, [&](auto const& callback, int32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            damage = CHECKVAL<int32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(damage, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, key.event_id, player, target, current, spellInfo);
+    });
 }
 
 void ALE::OnPlayerModifyHealReceived(Player* player, Unit* target, uint32& heal, SpellInfo const* spellInfo)
 {
     START_HOOK(PLAYER_EVENT_ON_MODIFY_HEAL_RECEIVED);
-    Push(player);
-    Push(target);
-    Push(heal);
-    Push(spellInfo);
-
-    int healIndex = lua_gettop(L) - 1;
-    int n = SetupStack(PlayerEventBindings, key, 4);
-    while (n > 0)
+    heal = CallAllFold(*PlayerEventBindings, key, heal, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-        if (lua_isnumber(L, r))
-        {
-            heal = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(heal, healIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
+        return Call(callback, key.event_id, player, target, current, spellInfo);
+    });
 }
 
 uint32 ALE::OnPlayerDealDamage(Player* player, Unit* target, uint32 damage, DamageEffectType damagetype)
 {
     START_HOOK_WITH_RETVAL(PLAYER_EVENT_ON_DEAL_DAMAGE, damage);
-    Push(player);
-    Push(target);
-    Push(damage);
-    Push(damagetype);
-    int damageIndex = lua_gettop(L) - 1;
-    int n = SetupStack(PlayerEventBindings, key, 4);
-    
-    uint32 result = damage;
-    while (n > 0)
+    return CallAllFold(*PlayerEventBindings, key, damage, [&](auto const& callback, uint32 current)
     {
-        int r = CallOneFunction(n--, 4, 1);
-
-        if (lua_isnumber(L, r))
-        {
-            result = CHECKVAL<uint32>(L, r);
-            // Update the stack for subsequent calls.
-            ReplaceArgument(result, damageIndex);
-        }
-
-        lua_pop(L, 1);
-    }
-
-    CleanUpStack(4);
-    return result;
+        return Call(callback, key.event_id, player, target, current, damagetype);
+    });
 }
diff --git a/src/LuaEngine/hooks/ServerHooks.cpp b/src/LuaEngine/hooks/ServerHooks.cpp
index f305c97b7e..ca9118d8f5 100644
--- a/src/LuaEngine/hooks/ServerHooks.cpp
+++ b/src/LuaEngine/hooks/ServerHooks.cpp
@@ -5,12 +5,13 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
 #include "ALEEventMgr.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
+#include "AuctionHouseMgr.h"
+#include "Channel.h"
+#include "GameEventMgr.h"
+#include "ObjectAccessor.h"
 
 using namespace Hooks;
 
@@ -33,220 +34,153 @@ using namespace Hooks;
 bool ALE::OnAddonMessage(Player* sender, uint32 type, std::string& msg, Player* receiver, Guild* guild, Group* group, Channel* channel)
 {
     START_HOOK_WITH_RETVAL(ADDON_EVENT_ON_MESSAGE, true);
-    Push(sender);
-    Push(type);
 
-    auto delimeter_position = msg.find('\t');
-    if (delimeter_position == std::string::npos)
-    {
-        Push(msg); // prefix
-        Push(); // msg
-    }
+    // Addon messages are "prefix\tcontent"; the handler receives them split.
+    sol::object prefix;
+    sol::object content = sol::make_object(lua, sol::nil);
+
+    auto delimiterPosition = msg.find('\t');
+    if (delimiterPosition == std::string::npos)
+        prefix = sol::make_object(lua, msg);
     else
     {
-        std::string prefix = msg.substr(0, delimeter_position);
-        std::string content = msg.substr(delimeter_position + 1, std::string::npos);
-        Push(prefix);
-        Push(content);
+        prefix = sol::make_object(lua, msg.substr(0, delimiterPosition));
+        content = sol::make_object(lua, msg.substr(delimiterPosition + 1));
     }
 
+    // The last argument is whoever the message was sent to:
+    // a player, a guild, a group, a channel id, or nil.
+    sol::object target = sol::make_object(lua, sol::nil);
     if (receiver)
-        Push(receiver);
+        target = sol::make_object(lua, PlayerRef(receiver));
     else if (guild)
-        Push(guild);
+        target = sol::make_object(lua, GuildRef(guild));
     else if (group)
-        Push(group);
+        target = sol::make_object(lua, GroupRef(group));
     else if (channel)
-        Push(channel->GetChannelId());
-    else
-        Push();
+    {
+        // Same contract as the channel chat hook: built-in channels by id,
+        // custom channels by negated DB id.
+        int32 channelId = channel->IsConstant()
+            ? static_cast<int32>(channel->GetChannelId())
+            : -static_cast<int32>(channel->GetChannelDBId());
+        target = sol::make_object(lua, channelId);
+    }
 
-    return CallAllFunctionsBool(ServerEventBindings, key, true);
+    return CallAllBool(*ServerEventBindings, key, true, sender, type, prefix, content, target);
 }
 
-void ALE::OnTimedEvent(int funcRef, uint32 delay, uint32 calls, WorldObject* obj)
+void ALE::OnTimedEvent(sol::protected_function const& callback, uint64 eventId, uint32 delay, uint32 calls, WorldObject* obj)
 {
     LOCK_ALE;
-    ASSERT(!event_level);
-
-    // Get function
-    lua_rawgeti(L, LUA_REGISTRYINDEX, funcRef);
-
-    // Push parameters
-    Push(L, funcRef);
-    Push(L, delay);
-    Push(L, calls);
-    Push(L, obj);
-
-    // Call function
-    ExecuteCall(4, 0);
-
-    ASSERT(!event_level);
-    InvalidateObjects();
+    CallFunction(callback, eventId, delay, calls, ALEBind::ToLuaDynamic(lua, obj));
 }
 
 void ALE::OnGameEventStart(uint32 eventid)
 {
     START_HOOK(GAME_EVENT_START);
-    Push(eventid);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, eventid);
 }
 
 void ALE::OnGameEventStop(uint32 eventid)
 {
     START_HOOK(GAME_EVENT_STOP);
-    Push(eventid);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, eventid);
 }
 
 void ALE::OnLuaStateClose()
 {
     START_HOOK(ALE_EVENT_ON_LUA_STATE_CLOSE);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key);
 }
 
 void ALE::OnLuaStateOpen()
 {
     START_HOOK(ALE_EVENT_ON_LUA_STATE_OPEN);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key);
 }
 
 // AreaTrigger
 bool ALE::OnAreaTrigger(Player* pPlayer, AreaTriggerEntry const* pTrigger)
 {
     START_HOOK_WITH_RETVAL(TRIGGER_EVENT_ON_TRIGGER, false);
-    Push(pPlayer);
-    Push(pTrigger->entry);
-
-    return CallAllFunctionsBool(ServerEventBindings, key);
+    return CallAllBool(*ServerEventBindings, key, false, pPlayer, pTrigger->entry);
 }
 
 // Weather
 void ALE::OnChange(Weather* /*weather*/, uint32 zone, WeatherState state, float grade)
 {
     START_HOOK(WEATHER_EVENT_ON_CHANGE);
-    Push(zone);
-    Push(state);
-    Push(grade);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, zone, state, grade);
 }
 
 // Auction House
 void ALE::OnAdd(AuctionHouseObject* /*ah*/, AuctionEntry* entry)
 {
-    Player* owner = eObjectAccessor()FindPlayer(entry->owner);
-
-    Item* item = eAuctionMgr->GetAItem(entry->item_guid);
-    uint32 expiretime = entry->expire_time;
-
+    Player* owner = ObjectAccessor::FindPlayer(entry->owner);
+    Item* item = sAuctionMgr->GetAItem(entry->item_guid);
     if (!owner || !item)
         return;
 
     START_HOOK(AUCTION_EVENT_ON_ADD);
-    Push(entry->Id);
-    Push(owner);
-    Push(item);
-    Push(expiretime);
-    Push(entry->buyout);
-    Push(entry->startbid);
-    Push(entry->bid);
-    Push(entry->bidder);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, entry->Id, owner, item, entry->expire_time, entry->buyout, entry->startbid, entry->bid, entry->bidder);
 }
 
 void ALE::OnRemove(AuctionHouseObject* /*ah*/, AuctionEntry* entry)
 {
-    Player* owner = eObjectAccessor()FindPlayer(entry->owner);
-
-    Item* item = eAuctionMgr->GetAItem(entry->item_guid);
-    uint32 expiretime = entry->expire_time;
-
+    Player* owner = ObjectAccessor::FindPlayer(entry->owner);
+    Item* item = sAuctionMgr->GetAItem(entry->item_guid);
     if (!owner || !item)
         return;
 
     START_HOOK(AUCTION_EVENT_ON_REMOVE);
-    Push(entry->Id);
-    Push(owner);
-    Push(item);
-    Push(expiretime);
-    Push(entry->buyout);
-    Push(entry->startbid);
-    Push(entry->bid);
-    Push(entry->bidder);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, entry->Id, owner, item, entry->expire_time, entry->buyout, entry->startbid, entry->bid, entry->bidder);
 }
 
 void ALE::OnSuccessful(AuctionHouseObject* /*ah*/, AuctionEntry* entry)
 {
-    Player* owner = eObjectAccessor()FindPlayer(entry->owner);
-
-    Item* item = eAuctionMgr->GetAItem(entry->item_guid);
-    uint32 expiretime = entry->expire_time;
-
+    Player* owner = ObjectAccessor::FindPlayer(entry->owner);
+    Item* item = sAuctionMgr->GetAItem(entry->item_guid);
     if (!owner || !item)
         return;
 
     START_HOOK(AUCTION_EVENT_ON_SUCCESSFUL);
-    Push(entry->Id);
-    Push(owner);
-    Push(item);
-    Push(expiretime);
-    Push(entry->buyout);
-    Push(entry->startbid);
-    Push(entry->bid);
-    Push(entry->bidder);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, entry->Id, owner, item, entry->expire_time, entry->buyout, entry->startbid, entry->bid, entry->bidder);
 }
 
 void ALE::OnExpire(AuctionHouseObject* /*ah*/, AuctionEntry* entry)
 {
-    Player* owner = eObjectAccessor()FindPlayer(entry->owner);
-
-    Item* item = eAuctionMgr->GetAItem(entry->item_guid);
-    uint32 expiretime = entry->expire_time;
-
+    Player* owner = ObjectAccessor::FindPlayer(entry->owner);
+    Item* item = sAuctionMgr->GetAItem(entry->item_guid);
     if (!owner || !item)
         return;
 
     START_HOOK(AUCTION_EVENT_ON_EXPIRE);
-    Push(entry->Id);
-    Push(owner);
-    Push(item);
-    Push(expiretime);
-    Push(entry->buyout);
-    Push(entry->startbid);
-    Push(entry->bid);
-    Push(entry->bidder);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, entry->Id, owner, item, entry->expire_time, entry->buyout, entry->startbid, entry->bid, entry->bidder);
 }
 
 void ALE::OnOpenStateChange(bool open)
 {
     START_HOOK(WORLD_EVENT_ON_OPEN_STATE_CHANGE);
-    Push(open);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, open);
 }
 
 void ALE::OnConfigLoad(bool reload, bool isBefore)
 {
     START_HOOK(WORLD_EVENT_ON_CONFIG_LOAD);
-    Push(reload);
-    Push(isBefore);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, reload, isBefore);
 }
 
 void ALE::OnShutdownInitiate(ShutdownExitCode code, ShutdownMask mask)
 {
     START_HOOK(WORLD_EVENT_ON_SHUTDOWN_INIT);
-    Push(code);
-    Push(mask);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, code, mask);
 }
 
 void ALE::OnShutdownCancel()
 {
     START_HOOK(WORLD_EVENT_ON_SHUTDOWN_CANCEL);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key);
 }
 
 void ALE::OnWorldUpdate(uint32 diff)
@@ -262,73 +196,60 @@ void ALE::OnWorldUpdate(uint32 diff)
     queryProcessor.ProcessReadyCallbacks();
 
     START_HOOK(WORLD_EVENT_ON_UPDATE);
-    Push(diff);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, diff);
 }
 
 void ALE::OnStartup()
 {
     START_HOOK(WORLD_EVENT_ON_STARTUP);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key);
 }
 
 void ALE::OnShutdown()
 {
     START_HOOK(WORLD_EVENT_ON_SHUTDOWN);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key);
 }
 
 /* Map */
 void ALE::OnCreate(Map* map)
 {
     START_HOOK(MAP_EVENT_ON_CREATE);
-    Push(map);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, map);
 }
 
 void ALE::OnDestroy(Map* map)
 {
     START_HOOK(MAP_EVENT_ON_DESTROY);
-    Push(map);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, map);
 }
 
 void ALE::OnPlayerEnter(Map* map, Player* player)
 {
     START_HOOK(MAP_EVENT_ON_PLAYER_ENTER);
-    Push(map);
-    Push(player);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, map, player);
 }
 
 void ALE::OnPlayerLeave(Map* map, Player* player)
 {
     START_HOOK(MAP_EVENT_ON_PLAYER_LEAVE);
-    Push(map);
-    Push(player);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, map, player);
 }
 
 void ALE::OnUpdate(Map* map, uint32 diff)
 {
     START_HOOK(MAP_EVENT_ON_UPDATE);
-    // enable this for multithread
-    // eventMgr->globalProcessor->Update(diff);
-    Push(map);
-    Push(diff);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, map, diff);
 }
 
 void ALE::OnRemove(GameObject* gameobject)
 {
     START_HOOK(WORLD_EVENT_ON_DELETE_GAMEOBJECT);
-    Push(gameobject);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, gameobject);
 }
 
 void ALE::OnRemove(Creature* creature)
 {
     START_HOOK(WORLD_EVENT_ON_DELETE_CREATURE);
-    Push(creature);
-    CallAllFunctions(ServerEventBindings, key);
+    CallAll(*ServerEventBindings, key, creature);
 }
diff --git a/src/LuaEngine/hooks/SpellHooks.cpp b/src/LuaEngine/hooks/SpellHooks.cpp
index 8c0801893e..3d7a2651a4 100644
--- a/src/LuaEngine/hooks/SpellHooks.cpp
+++ b/src/LuaEngine/hooks/SpellHooks.cpp
@@ -5,11 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -21,40 +18,20 @@ using namespace Hooks;
         return;\
     LOCK_ALE
 
-#define START_HOOK_WITH_RETVAL(EVENT, ENTRY, RETVAL) \
-    if (!ALEConfig::GetInstance().IsALEEnabled())\
-        return RETVAL;\
-    auto key = EntryKey<SpellEvents>(EVENT, ENTRY);\
-    if (!SpellEventBindings->HasBindingsFor(key))\
-        return RETVAL;\
-    LOCK_ALE
-
 void ALE::OnSpellCastCancel(Unit* caster, Spell* spell, SpellInfo const* spellInfo, bool bySelf)
 {
     START_HOOK(SPELL_EVENT_ON_CAST_CANCEL, spellInfo->Id);
-    Push(caster);
-    Push(spell);
-    Push(bySelf);
-
-    CallAllFunctions(SpellEventBindings, key);
+    CallAll(*SpellEventBindings, key, caster, spell, bySelf);
 }
 
 void ALE::OnSpellCast(Unit* caster, Spell* spell, SpellInfo const* spellInfo, bool skipCheck)
 {
     START_HOOK(SPELL_EVENT_ON_CAST, spellInfo->Id);
-    Push(caster);
-    Push(spell);
-    Push(skipCheck);
-
-    CallAllFunctions(SpellEventBindings, key);
+    CallAll(*SpellEventBindings, key, caster, spell, skipCheck);
 }
 
 void ALE::OnSpellPrepare(Unit* caster, Spell* spell, SpellInfo const* spellInfo)
 {
     START_HOOK(SPELL_EVENT_ON_PREPARE, spellInfo->Id);
-    Push(caster);
-    Push(spell);
-
-    CallAllFunctions(SpellEventBindings, key);
+    CallAll(*SpellEventBindings, key, caster, spell);
 }
-
diff --git a/src/LuaEngine/hooks/TicketHooks.cpp b/src/LuaEngine/hooks/TicketHooks.cpp
index 0aa538624d..499f0f2fb1 100644
--- a/src/LuaEngine/hooks/TicketHooks.cpp
+++ b/src/LuaEngine/hooks/TicketHooks.cpp
@@ -5,11 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALEIncludes.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -24,28 +21,23 @@ using namespace Hooks;
 void ALE::OnTicketCreate(GmTicket* ticket)
 {
     START_HOOK(TICKET_EVENT_ON_CREATE);
-    Push(ticket);
-    CallAllFunctions(TicketEventBindings, key);
+    CallAll(*TicketEventBindings, key, ticket);
 }
 
 void ALE::OnTicketUpdateLastChange(GmTicket* ticket)
 {
     START_HOOK(TICKET_EVENT_UPDATE_LAST_CHANGE);
-    Push(ticket);
-    CallAllFunctions(TicketEventBindings, key);
+    CallAll(*TicketEventBindings, key, ticket);
 }
 
 void ALE::OnTicketClose(GmTicket* ticket)
 {
     START_HOOK(TICKET_EVENT_ON_CLOSE);
-    Push(ticket);
-    CallAllFunctions(TicketEventBindings, key);
+    CallAll(*TicketEventBindings, key, ticket);
 }
 
 void ALE::OnTicketResolve(GmTicket* ticket)
 {
     START_HOOK(TICKET_EVENT_ON_RESOLVE);
-    Push(ticket);
-    CallAllFunctions(TicketEventBindings, key);
+    CallAll(*TicketEventBindings, key, ticket);
 }
-
diff --git a/src/LuaEngine/hooks/VehicleHooks.cpp b/src/LuaEngine/hooks/VehicleHooks.cpp
index f03a9657f9..694daca1b1 100644
--- a/src/LuaEngine/hooks/VehicleHooks.cpp
+++ b/src/LuaEngine/hooks/VehicleHooks.cpp
@@ -5,10 +5,8 @@
  */
 
 #include "Hooks.h"
-#include "HookHelpers.h"
 #include "LuaEngine.h"
 #include "BindingMap.h"
-#include "ALETemplate.h"
 
 using namespace Hooks;
 
@@ -23,38 +21,29 @@ using namespace Hooks;
 void ALE::OnInstall(Vehicle* vehicle)
 {
     START_HOOK(VEHICLE_EVENT_ON_INSTALL);
-    Push(vehicle);
-    CallAllFunctions(VehicleEventBindings, key);
+    CallAll(*VehicleEventBindings, key, vehicle);
 }
 
 void ALE::OnUninstall(Vehicle* vehicle)
 {
     START_HOOK(VEHICLE_EVENT_ON_UNINSTALL);
-    Push(vehicle);
-    CallAllFunctions(VehicleEventBindings, key);
+    CallAll(*VehicleEventBindings, key, vehicle);
 }
 
 void ALE::OnInstallAccessory(Vehicle* vehicle, Creature* accessory)
 {
     START_HOOK(VEHICLE_EVENT_ON_INSTALL_ACCESSORY);
-    Push(vehicle);
-    Push(accessory);
-    CallAllFunctions(VehicleEventBindings, key);
+    CallAll(*VehicleEventBindings, key, vehicle, accessory);
 }
 
 void ALE::OnAddPassenger(Vehicle* vehicle, Unit* passenger, int8 seatId)
 {
     START_HOOK(VEHICLE_EVENT_ON_ADD_PASSENGER);
-    Push(vehicle);
-    Push(passenger);
-    Push(seatId);
-    CallAllFunctions(VehicleEventBindings, key);
+    CallAll(*VehicleEventBindings, key, vehicle, passenger, seatId);
 }
 
 void ALE::OnRemovePassenger(Vehicle* vehicle, Unit* passenger)
 {
     START_HOOK(VEHICLE_EVENT_ON_REMOVE_PASSENGER);
-    Push(vehicle);
-    Push(passenger);
-    CallAllFunctions(VehicleEventBindings, key);
+    CallAll(*VehicleEventBindings, key, vehicle, passenger);
 }
diff --git a/src/LuaEngine/lmarshal.cpp b/src/LuaEngine/lmarshal.cpp
deleted file mode 100644
index 936d677766..0000000000
--- a/src/LuaEngine/lmarshal.cpp
+++ /dev/null
@@ -1,580 +0,0 @@
-/*
- * lmarshal.c
- * A Lua library for serializing and deserializing Lua values
- * Richard Hundt <richardhundt@gmail.com>, Eluna Lua Engine <https://elunaluaengine.github.io/>
- *
- * License: MIT
- *
- * Copyright (c) 2010 Richard Hundt
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use,
- * copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following
- * conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
- * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
- * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
- * OTHER DEALINGS IN THE SOFTWARE.
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <cstdint>
-#include "ALECompat.h"
-
-#if LUA_VERSION_NUM == 501 && !defined(luaL_setfuncs)
-    #define luaL_setfuncs(L, l, n) luaL_register(L, NULL, l)
-#endif
-
-#define MAR_TREF 1
-#define MAR_TVAL 2
-#define MAR_TUSR 3
-
-#define MAR_CHR 1
-#define MAR_I32 4
-#define MAR_I64 8
-
-#define MAR_MAGIC 0x8f
-#define SEEN_IDX  3
-
-#define MAR_ENV_IDX_KEY  "E"
-#define MAR_NUPS_IDX_KEY "n"
-
-typedef struct mar_Buffer {
-    size_t size;
-    size_t seek;
-    size_t head;
-    char*  data;
-} mar_Buffer;
-
-static int mar_encode_table(lua_State *L, mar_Buffer *buf, size_t *idx);
-static int mar_decode_table(lua_State *L, const char* buf, size_t len, size_t *idx);
-
-static void buf_init(lua_State *L, mar_Buffer *buf)
-{
-    buf->size = 128;
-    buf->seek = 0;
-    buf->head = 0;
-    if (!(buf->data = (char*)malloc(buf->size))) luaL_error(L, "Out of memory!");
-}
-
-static void buf_done(lua_State* /*L*/, mar_Buffer *buf)
-{
-    free(buf->data);
-}
-
-static int buf_write(lua_State* L, const char* str, size_t len, mar_Buffer *buf)
-{
-    if (len > UINT32_MAX) luaL_error(L, "buffer too long");
-    if (buf->size - buf->head < len) {
-        size_t new_size = buf->size << 1;
-        size_t cur_head = buf->head;
-        while (new_size - cur_head <= len) {
-            new_size = new_size << 1;
-        }
-        char* data = (char*)realloc(buf->data, new_size);
-        if (!data) {
-            return luaL_error(L, "Out of memory!");
-        }
-        buf->data = data;
-        buf->size = new_size;
-    }
-    memcpy(&buf->data[buf->head], str, len);
-    buf->head += len;
-    return 0;
-}
-
-static const char* buf_read(lua_State* /*L*/, mar_Buffer *buf, size_t *len)
-{
-    if (buf->seek < buf->head) {
-        buf->seek = buf->head;
-        *len = buf->seek;
-        return buf->data;
-    }
-    *len = 0;
-    return NULL;
-}
-
-static void mar_encode_value(lua_State *L, mar_Buffer *buf, int val, size_t *idx)
-{
-    size_t l;
-    int val_type = lua_type(L, val);
-    lua_pushvalue(L, val);
-
-    buf_write(L, (const char*)&val_type, MAR_CHR, buf);
-    switch (val_type) {
-    case LUA_TBOOLEAN: {
-        int int_val = lua_toboolean(L, -1);
-        buf_write(L, (const char*)&int_val, MAR_CHR, buf);
-        break;
-    }
-    case LUA_TSTRING: {
-        const char *str_val = lua_tolstring(L, -1, &l);
-        buf_write(L, (const char*)&l, MAR_I32, buf);
-        buf_write(L, str_val, l, buf);
-        break;
-    }
-    case LUA_TNUMBER: {
-        lua_Number num_val = lua_tonumber(L, -1);
-        buf_write(L, (const char*)&num_val, MAR_I64, buf);
-        break;
-    }
-    case LUA_TTABLE: {
-        int tag, ref;
-        lua_pushvalue(L, -1);
-        lua_rawget(L, SEEN_IDX);
-        if (!lua_isnil(L, -1)) {
-            ref = lua_tointeger(L, -1);
-            tag = MAR_TREF;
-            buf_write(L, (const char*)&tag, MAR_CHR, buf);
-            buf_write(L, (const char*)&ref, MAR_I32, buf);
-            lua_pop(L, 1);
-        }
-        else {
-            mar_Buffer rec_buf;
-            lua_pop(L, 1); /* pop nil */
-            if (luaL_getmetafield(L, -1, "__persist")) {
-                tag = MAR_TUSR;
-
-                lua_pushvalue(L, -2); /* self */
-                lua_call(L, 1, 1);
-                if (!lua_isfunction(L, -1)) {
-                    luaL_error(L, "__persist must return a function");
-                }
-
-                lua_remove(L, -2); /* __persist */
-
-                lua_newtable(L);
-                lua_pushvalue(L, -2); /* callback */
-                lua_rawseti(L, -2, 1);
-
-                buf_init(L, &rec_buf);
-                mar_encode_table(L, &rec_buf, idx);
-
-                buf_write(L, (const char*)&tag, MAR_CHR, buf);
-                buf_write(L, (const char*)&rec_buf.head, MAR_I32, buf);
-                buf_write(L, rec_buf.data, rec_buf.head, buf);
-                buf_done(L, &rec_buf);
-                lua_pop(L, 1);
-            }
-            else {
-                tag = MAR_TVAL;
-
-                lua_pushvalue(L, -1);
-                lua_pushinteger(L, (*idx)++);
-                lua_rawset(L, SEEN_IDX);
-
-                lua_pushvalue(L, -1);
-                buf_init(L, &rec_buf);
-                mar_encode_table(L, &rec_buf, idx);
-                lua_pop(L, 1);
-
-                buf_write(L, (const char*)&tag, MAR_CHR, buf);
-                buf_write(L, (const char*)&rec_buf.head, MAR_I32, buf);
-                buf_write(L, rec_buf.data,rec_buf.head, buf);
-                buf_done(L, &rec_buf);
-            }
-        }
-        break;
-    }
-    case LUA_TFUNCTION: {
-        int tag, ref;
-        lua_pushvalue(L, -1);
-        lua_rawget(L, SEEN_IDX);
-        if (!lua_isnil(L, -1)) {
-            ref = lua_tointeger(L, -1);
-            tag = MAR_TREF;
-            buf_write(L, (const char*)&tag, MAR_CHR, buf);
-            buf_write(L, (const char*)&ref, MAR_I32, buf);
-            lua_pop(L, 1);
-        }
-        else {
-            mar_Buffer rec_buf;
-            unsigned char i;
-            lua_Debug ar;
-            lua_pop(L, 1); /* pop nil */
-
-            lua_pushvalue(L, -1);
-            lua_getinfo(L, ">nuS", &ar);
-            if (ar.what[0] != 'L') {
-                luaL_error(L, "attempt to persist a C function '%s'", ar.name);
-            }
-            tag = MAR_TVAL;
-            lua_pushvalue(L, -1);
-            lua_pushinteger(L, (*idx)++);
-            lua_rawset(L, SEEN_IDX);
-
-            lua_pushvalue(L, -1);
-            buf_init(L, &rec_buf);
-            lua_dump(L, (lua_Writer)buf_write, &rec_buf);
-
-            buf_write(L, (const char*)&tag, MAR_CHR, buf);
-            buf_write(L, (const char*)&rec_buf.head, MAR_I32, buf);
-            buf_write(L, rec_buf.data, rec_buf.head, buf);
-            buf_done(L, &rec_buf);
-            lua_pop(L, 1);
-
-            lua_createtable(L, ar.nups, 0);
-            for (i = 1; i <= ar.nups; i++) {
-                const char* upvalue_name = lua_getupvalue(L, -2, i);
-                if (strcmp("_ENV", upvalue_name) == 0) {
-                    lua_pop(L, 1);
-                    // Mark where _ENV is expected.
-                    lua_pushstring(L, MAR_ENV_IDX_KEY);
-                    lua_pushinteger(L, i);
-                    lua_rawset(L, -3);
-                }
-                else {
-                    lua_rawseti(L, -2, i);
-                }
-            }
-            lua_pushstring(L, MAR_NUPS_IDX_KEY);
-            lua_pushnumber(L, ar.nups);
-            lua_rawset(L, -3);
-
-            buf_init(L, &rec_buf);
-            mar_encode_table(L, &rec_buf, idx);
-
-            buf_write(L, (const char*)&rec_buf.head, MAR_I32, buf);
-            buf_write(L, rec_buf.data, rec_buf.head, buf);
-            buf_done(L, &rec_buf);
-            lua_pop(L, 1);
-        }
-
-        break;
-    }
-    case LUA_TUSERDATA: {
-        int tag, ref;
-        lua_pushvalue(L, -1);
-        lua_rawget(L, SEEN_IDX);
-        if (!lua_isnil(L, -1)) {
-            ref = lua_tointeger(L, -1);
-            tag = MAR_TREF;
-            buf_write(L, (const char*)&tag, MAR_CHR, buf);
-            buf_write(L, (const char*)&ref, MAR_I32, buf);
-            lua_pop(L, 1);
-        }
-        else {
-            mar_Buffer rec_buf;
-            lua_pop(L, 1); /* pop nil */
-            if (luaL_getmetafield(L, -1, "__persist")) {
-                tag = MAR_TUSR;
-
-                lua_pushvalue(L, -2);
-                lua_pushinteger(L, (*idx)++);
-                lua_rawset(L, SEEN_IDX);
-
-                lua_pushvalue(L, -2);
-                lua_call(L, 1, 1);
-                if (!lua_isfunction(L, -1)) {
-                    luaL_error(L, "__persist must return a function");
-                }
-                lua_newtable(L);
-                lua_pushvalue(L, -2);
-                lua_rawseti(L, -2, 1);
-                lua_remove(L, -2);
-
-                buf_init(L, &rec_buf);
-                mar_encode_table(L, &rec_buf, idx);
-
-                buf_write(L, (const char*)&tag, MAR_CHR, buf);
-                buf_write(L, (const char*)&rec_buf.head, MAR_I32, buf);
-		        buf_write(L, rec_buf.data, rec_buf.head, buf);
-		        buf_done(L, &rec_buf);
-            }
-            else {
-                luaL_error(L, "attempt to encode userdata (no __persist hook)");
-            }
-            lua_pop(L, 1);
-        }
-        break;
-    }
-    case LUA_TNIL: break;
-    default:
-        luaL_error(L, "invalid value type (%s)", lua_typename(L, val_type));
-    }
-    lua_pop(L, 1);
-}
-
-static int mar_encode_table(lua_State *L, mar_Buffer *buf, size_t *idx)
-{
-    lua_pushnil(L);
-    while (lua_next(L, -2) != 0) {
-        mar_encode_value(L, buf, -2, idx);
-        mar_encode_value(L, buf, -1, idx);
-        lua_pop(L, 1);
-    }
-    return 1;
-}
-
-#define mar_incr_ptr(l) \
-    if (((*p)-buf)+(ptrdiff_t)(l) > (ptrdiff_t)len) luaL_error(L, "bad code"); (*p) += (l);
-
-#define mar_next_len(l,T) \
-    if (((*p)-buf)+(ptrdiff_t)sizeof(T) > (ptrdiff_t)len) luaL_error(L, "bad code"); \
-    l = *(T*)*p; (*p) += sizeof(T);
-
-static void mar_decode_value
-    (lua_State *L, const char *buf, size_t len, const char **p, size_t *idx)
-{
-    size_t l;
-    char val_type = **p;
-    mar_incr_ptr(MAR_CHR);
-    switch (val_type) {
-    case LUA_TBOOLEAN:
-        lua_pushboolean(L, *(char*)*p);
-        mar_incr_ptr(MAR_CHR);
-        break;
-    case LUA_TNUMBER:
-        lua_pushnumber(L, *(lua_Number*)*p);
-        mar_incr_ptr(MAR_I64);
-        break;
-    case LUA_TSTRING:
-        mar_next_len(l, uint32_t);
-        lua_pushlstring(L, *p, l);
-        mar_incr_ptr(l);
-        break;
-    case LUA_TTABLE: {
-        char tag = *(char*)*p;
-        mar_incr_ptr(MAR_CHR);
-        if (tag == MAR_TREF) {
-            int ref;
-            mar_next_len(ref, int);
-            lua_rawgeti(L, SEEN_IDX, ref);
-        }
-        else if (tag == MAR_TVAL) {
-            mar_next_len(l, uint32_t);
-            lua_newtable(L);
-            lua_pushvalue(L, -1);
-            lua_rawseti(L, SEEN_IDX, (*idx)++);
-            mar_decode_table(L, *p, l, idx);
-            mar_incr_ptr(l);
-        }
-        else if (tag == MAR_TUSR) {
-            mar_next_len(l, uint32_t);
-            lua_newtable(L);
-            mar_decode_table(L, *p, l, idx);
-            lua_rawgeti(L, -1, 1);
-            lua_call(L, 0, 1);
-            lua_remove(L, -2);
-            lua_pushvalue(L, -1);
-            lua_rawseti(L, SEEN_IDX, (*idx)++);
-            mar_incr_ptr(l);
-        }
-        else {
-            luaL_error(L, "bad encoded data");
-        }
-        break;
-    }
-    case LUA_TFUNCTION: {
-        unsigned int nups;
-        unsigned int i;
-        mar_Buffer dec_buf;
-        char tag = *(char*)*p;
-        mar_incr_ptr(1);
-        if (tag == MAR_TREF) {
-            int ref;
-            mar_next_len(ref, int);
-            lua_rawgeti(L, SEEN_IDX, ref);
-        }
-        else {
-            mar_next_len(l, uint32_t);
-            dec_buf.data = (char*)*p;
-            dec_buf.size = l;
-            dec_buf.head = l;
-            dec_buf.seek = 0;
-            lua_load(L, (lua_Reader)buf_read, &dec_buf, "=marshal", NULL);
-            mar_incr_ptr(l);
-
-            lua_pushvalue(L, -1);
-            lua_rawseti(L, SEEN_IDX, (*idx)++);
-
-            mar_next_len(l, uint32_t);
-            lua_newtable(L);
-            mar_decode_table(L, *p, l, idx);
-
-            lua_pushstring(L, MAR_ENV_IDX_KEY);
-            lua_rawget(L, -2);
-            if (lua_isnumber(L, -1)) {
-                lua_pushglobaltable(L);
-                lua_rawset(L, -3);
-            }
-            else {
-                lua_pop(L, 1);
-            }
-
-            lua_pushstring(L, MAR_NUPS_IDX_KEY);
-            lua_rawget(L, -2);
-            nups = luaL_checknumber(L, -1);
-            lua_pop(L, 1);
-
-            for (i = 1; i <= nups; i++) {
-                lua_rawgeti(L, -1, i);
-                lua_setupvalue(L, -3, i);
-            }
-
-            lua_pop(L, 1);
-            mar_incr_ptr(l);
-        }
-        break;
-    }
-    case LUA_TUSERDATA: {
-        char tag = *(char*)*p;
-        mar_incr_ptr(MAR_CHR);
-        if (tag == MAR_TREF) {
-            int ref;
-            mar_next_len(ref, int);
-            lua_rawgeti(L, SEEN_IDX, ref);
-        }
-        else if (tag == MAR_TUSR) {
-            mar_next_len(l, uint32_t);
-            lua_newtable(L);
-            mar_decode_table(L, *p, l, idx);
-            lua_rawgeti(L, -1, 1);
-            lua_call(L, 0, 1);
-            lua_remove(L, -2);
-            lua_pushvalue(L, -1);
-            lua_rawseti(L, SEEN_IDX, (*idx)++);
-            mar_incr_ptr(l);
-        }
-        else { /* tag == MAR_TVAL */
-            lua_pushnil(L);
-        }
-        break;
-    }
-    case LUA_TNIL:
-    case LUA_TTHREAD:
-        lua_pushnil(L);
-        break;
-    default:
-        luaL_error(L, "bad code");
-    }
-}
-
-static int mar_decode_table(lua_State *L, const char* buf, size_t len, size_t *idx)
-{
-    const char* p;
-    p = buf;
-    while (p - buf < (ptrdiff_t)len) {
-        mar_decode_value(L, buf, len, &p, idx);
-        mar_decode_value(L, buf, len, &p, idx);
-        lua_rawset(L, -3);
-    }
-    return 1;
-}
-
-int mar_encode(lua_State* L)
-{
-    const unsigned char m = MAR_MAGIC;
-    size_t idx, len;
-    mar_Buffer buf;
-
-    if (lua_isnone(L, 1)) {
-        lua_pushnil(L);
-    }
-    if (lua_isnoneornil(L, 2)) {
-        lua_newtable(L);
-    }
-    else if (!lua_istable(L, 2)) {
-        luaL_error(L, "bad argument #2 to encode (expected table)");
-    }
-    lua_settop(L, 2);
-
-    len = lua_rawlen(L, 2);
-    lua_newtable(L);
-    for (idx = 1; idx <= len; idx++) {
-        lua_rawgeti(L, 2, idx);
-        if (lua_isnil(L, -1)) {
-            lua_pop(L, 1);
-            continue;
-        }
-        lua_pushinteger(L, idx);
-        lua_rawset(L, SEEN_IDX);
-    }
-    lua_pushvalue(L, 1);
-
-    buf_init(L, &buf);
-    buf_write(L, (const char*)&m, 1, &buf);
-
-    mar_encode_value(L, &buf, -1, &idx);
-
-    lua_pop(L, 1);
-
-    lua_pushlstring(L, buf.data, buf.head);
-
-    buf_done(L, &buf);
-
-    lua_remove(L, SEEN_IDX);
-
-    return 1;
-}
-
-int mar_decode(lua_State* L)
-{
-    size_t l, idx, len;
-    const char *p;
-    const char *s = luaL_checklstring(L, 1, &l);
-
-    if (l < 1) luaL_error(L, "bad header");
-    if (*(unsigned char *)s++ != MAR_MAGIC) luaL_error(L, "bad magic");
-    l -= 1;
-
-    if (lua_isnoneornil(L, 2)) {
-        lua_newtable(L);
-    }
-    else if (!lua_istable(L, 2)) {
-        luaL_error(L, "bad argument #2 to decode (expected table)");
-    }
-    lua_settop(L, 2);
-
-    len = lua_rawlen(L, 2);
-    lua_newtable(L);
-    for (idx = 1; idx <= len; idx++) {
-        lua_rawgeti(L, 2, idx);
-        lua_rawseti(L, SEEN_IDX, idx);
-    }
-
-    p = s;
-    mar_decode_value(L, s, l, &p, &idx);
-
-    lua_remove(L, SEEN_IDX);
-    lua_remove(L, 2);
-
-    return 1;
-}
-
-int mar_clone(lua_State* L)
-{
-    mar_encode(L);
-    lua_replace(L, 1);
-    mar_decode(L);
-    return 1;
-}
-
-static const luaL_Reg R[] =
-{
-    {"encode",      mar_encode},
-    {"decode",      mar_decode},
-    {"clone",       mar_clone},
-    {NULL,	    NULL}
-};
-
-int luaopen_marshal(lua_State *L)
-{
-    lua_newtable(L);
-    luaL_setfuncs(L, R, 0);
-    return 1;
-}
-
diff --git a/src/LuaEngine/lmarshal.h b/src/LuaEngine/lmarshal.h
deleted file mode 100644
index fed50b9a79..0000000000
--- a/src/LuaEngine/lmarshal.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/*
- * Copyright (C) 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
- * This program is free software licensed under GPL version 3
- * Please see the included DOCS/LICENSE.md for more information
- */
-
-extern "C" {
-#include "lua.h"
-}
-
-int mar_encode(lua_State* L);
-int mar_decode(lua_State* L);
diff --git a/src/LuaEngine/methods/ALEQueryMethods.h b/src/LuaEngine/methods/ALEQueryMethods.cpp
similarity index 53%
rename from src/LuaEngine/methods/ALEQueryMethods.h
rename to src/LuaEngine/methods/ALEQueryMethods.cpp
index 474c4ecddc..94ca595c81 100644
--- a/src/LuaEngine/methods/ALEQueryMethods.h
+++ b/src/LuaEngine/methods/ALEQueryMethods.cpp
@@ -4,10 +4,10 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef QUERYMETHODS_H
-#define QUERYMETHODS_H
+#include "ALEBind.h"
 
-#define RESULT  (*result)
+#include "QueryResult.h"
+#include "StringFormat.h"
 
 /***
  * The result of a database query.
@@ -16,18 +16,13 @@
  *
  * Inherits all methods from: none
  */
-namespace LuaQuery
+namespace LuaALEQuery
 {
-    static void CheckFields(lua_State* L, ALEQuery* result)
+    static void CheckFields(ResultSet* resultset, uint32 field)
     {
-        uint32 field = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 count = RESULT->GetFieldCount();
+        uint32 count = resultset->GetFieldCount();
         if (field >= count)
-        {
-            char arr[256];
-            snprintf(arr, sizeof(arr), "trying to access invalid field index %u. There are %u fields available and the indexes start from 0", field, count);
-            luaL_argerror(L, 2, arr);
-        }
+            throw std::invalid_argument(Acore::StringFormat("trying to access invalid field index {}. There are {} fields available and the indexes start from 0", field, count));
     }
 
     /**
@@ -36,13 +31,11 @@ namespace LuaQuery
      * @param uint32 column
      * @return bool isNull
      */
-    int IsNull(lua_State* L, ALEQuery* result)
+    bool IsNull(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
+        CheckFields(resultset, col);
 
-        ALE::Push(L, RESULT->Fetch()[col].IsNull());
-        return 1;
+        return resultset->Fetch()[col].IsNull();
     }
 
     /**
@@ -50,10 +43,9 @@ namespace LuaQuery
      *
      * @return uint32 columnCount
      */
-    int GetColumnCount(lua_State* L, ALEQuery* result)
+    uint32 GetColumnCount(ResultSet* resultset)
     {
-        ALE::Push(L, RESULT->GetFieldCount());
-        return 1;
+        return resultset->GetFieldCount();
     }
 
     /**
@@ -61,13 +53,12 @@ namespace LuaQuery
      *
      * @return uint32 rowCount
      */
-    int GetRowCount(lua_State* L, ALEQuery* result)
+    uint32 GetRowCount(ResultSet* resultset)
     {
-        if (RESULT->GetRowCount() > (uint32)-1)
-            ALE::Push(L, (uint32)-1);
-        else
-            ALE::Push(L, (uint32)(RESULT->GetRowCount()));
-        return 1;
+        if (resultset->GetRowCount() > (uint32)-1)
+            return (uint32)-1;
+
+        return (uint32)(resultset->GetRowCount());
     }
 
     /**
@@ -76,12 +67,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return bool data
      */
-    int GetBool(lua_State* L, ALEQuery* result)
+    bool GetBool(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<bool>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<bool>();
     }
 
     /**
@@ -90,12 +79,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return uint8 data
      */
-    int GetUInt8(lua_State* L, ALEQuery* result)
+    uint8 GetUInt8(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<uint8>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<uint8>();
     }
 
     /**
@@ -104,12 +91,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return uint16 data
      */
-    int GetUInt16(lua_State* L, ALEQuery* result)
+    uint16 GetUInt16(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<uint16>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<uint16>();
     }
 
     /**
@@ -118,12 +103,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return uint32 data
      */
-    int GetUInt32(lua_State* L, ALEQuery* result)
+    uint32 GetUInt32(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<uint32>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<uint32>();
     }
 
     /**
@@ -132,12 +115,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return uint64 data
      */
-    int GetUInt64(lua_State* L, ALEQuery* result)
+    uint64 GetUInt64(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<uint64>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<uint64>();
     }
 
     /**
@@ -146,12 +127,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return int8 data
      */
-    int GetInt8(lua_State* L, ALEQuery* result)
+    int8 GetInt8(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<int8>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<int8>();
     }
 
     /**
@@ -160,12 +139,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return int16 data
      */
-    int GetInt16(lua_State* L, ALEQuery* result)
+    int16 GetInt16(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<int16>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<int16>();
     }
 
     /**
@@ -174,12 +151,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return int32 data
      */
-    int GetInt32(lua_State* L, ALEQuery* result)
+    int32 GetInt32(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<int32>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<int32>();
     }
 
     /**
@@ -188,12 +163,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return int64 data
      */
-    int GetInt64(lua_State* L, ALEQuery* result)
+    int64 GetInt64(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<int64>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<int64>();
     }
 
     /**
@@ -202,12 +175,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return float data
      */
-    int GetFloat(lua_State* L, ALEQuery* result)
+    float GetFloat(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<float>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<float>();
     }
 
     /**
@@ -216,12 +187,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return double data
      */
-    int GetDouble(lua_State* L, ALEQuery* result)
+    double GetDouble(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<double>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<double>();
     }
 
     /**
@@ -230,12 +199,10 @@ namespace LuaQuery
      * @param uint32 column
      * @return string data
      */
-    int GetString(lua_State* L, ALEQuery* result)
+    std::string GetString(ResultSet* resultset, uint32 col)
     {
-        uint32 col = ALE::CHECKVAL<uint32>(L, 2);
-        CheckFields(L, result);
-        ALE::Push(L, RESULT->Fetch()[col].Get<std::string>());
-        return 1;
+        CheckFields(resultset, col);
+        return resultset->Fetch()[col].Get<std::string>();
     }
 
     /**
@@ -247,10 +214,9 @@ namespace LuaQuery
      *
      * @return bool hadNextRow
      */
-    int NextRow(lua_State* L, ALEQuery* result)
+    bool NextRow(ResultSet* resultset)
     {
-        ALE::Push(L, RESULT->NextRow());
-        return 1;
+        return resultset->NextRow();
     }
 
     /**
@@ -270,22 +236,21 @@ namespace LuaQuery
      *
      * @return table rowData : table filled with row columns and data where `T[column] = data`
      */
-    int GetRow(lua_State* L, ALEQuery* result)
+    sol::table GetRow(ResultSet* resultset, sol::this_state s)
     {
-        uint32 col = RESULT->GetFieldCount();
-        Field* row = RESULT->Fetch();
+        uint32 col = resultset->GetFieldCount();
+        Field* row = resultset->Fetch();
 
-        lua_createtable(L, 0, col);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table(0, col);
 
         for (uint32 i = 0; i < col; ++i)
         {
-            ALE::Push(L, RESULT->GetFieldName(i));
+            std::string fieldName = resultset->GetFieldName(i);
 
             std::string _str = row[i].Get<std::string>();
-            const char* str = _str.c_str();
+            char const* str = _str.c_str();
             if (row[i].IsNull() || !str)
-                ALE::Push(L);
+                tbl[fieldName] = sol::lua_nil;
             else
             {
                 // MYSQL_TYPE_LONGLONG Interpreted as string for lua
@@ -297,20 +262,38 @@ namespace LuaQuery
                     case DatabaseFieldTypes::Int64:
                     case DatabaseFieldTypes::Float:
                     case DatabaseFieldTypes::Double:
-                        ALE::Push(L, strtod(str, NULL));
+                        tbl[fieldName] = strtod(str, NULL);
                         break;
                     default:
-                        ALE::Push(L, str);
+                        tbl[fieldName] = str;
                         break;
                 }
             }
-            lua_rawset(L, tbl);
         }
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
-};
-#undef RESULT
+}
+
+void RegisterALEQueryMethods(sol::state& lua)
+{
+    sol::usertype<ResultSet> type = lua.new_usertype<ResultSet>("ALEQuery", sol::no_constructor);
 
-#endif
+    type["IsNull"]         = &LuaALEQuery::IsNull;
+    type["GetColumnCount"] = &LuaALEQuery::GetColumnCount;
+    type["GetRowCount"]    = &LuaALEQuery::GetRowCount;
+    type["GetBool"]        = &LuaALEQuery::GetBool;
+    type["GetUInt8"]       = &LuaALEQuery::GetUInt8;
+    type["GetUInt16"]      = &LuaALEQuery::GetUInt16;
+    type["GetUInt32"]      = &LuaALEQuery::GetUInt32;
+    type["GetUInt64"]      = &LuaALEQuery::GetUInt64;
+    type["GetInt8"]        = &LuaALEQuery::GetInt8;
+    type["GetInt16"]       = &LuaALEQuery::GetInt16;
+    type["GetInt32"]       = &LuaALEQuery::GetInt32;
+    type["GetInt64"]       = &LuaALEQuery::GetInt64;
+    type["GetFloat"]       = &LuaALEQuery::GetFloat;
+    type["GetDouble"]      = &LuaALEQuery::GetDouble;
+    type["GetString"]      = &LuaALEQuery::GetString;
+    type["NextRow"]        = &LuaALEQuery::NextRow;
+    type["GetRow"]         = &LuaALEQuery::GetRow;
+}
diff --git a/src/LuaEngine/methods/ALERegistry.h b/src/LuaEngine/methods/ALERegistry.h
new file mode 100644
index 0000000000..4b5fc89f7c
--- /dev/null
+++ b/src/LuaEngine/methods/ALERegistry.h
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#ifndef ALEREGISTRY_H
+#define ALEREGISTRY_H
+
+#include <sol/forward.hpp>
+
+/*
+ * One registration function per Lua type, each defined at the bottom of its
+ * methods/<Type>Methods.cpp file. RegisterFunctions (LuaFunctions.cpp) calls
+ * them all on engine startup.
+ */
+
+void RegisterAchievementMethods(sol::state& lua);
+void RegisterALEQueryMethods(sol::state& lua);
+void RegisterAuraMethods(sol::state& lua);
+void RegisterBattleGroundMethods(sol::state& lua);
+void RegisterChatHandlerMethods(sol::state& lua);
+void RegisterCorpseMethods(sol::state& lua);
+void RegisterCreatureMethods(sol::state& lua);
+void RegisterGameObjectMethods(sol::state& lua);
+void RegisterGemPropertiesEntryMethods(sol::state& lua);
+void RegisterGlobalMethods(sol::state& lua);
+void RegisterGroupMethods(sol::state& lua);
+void RegisterGuildMethods(sol::state& lua);
+void RegisterItemMethods(sol::state& lua);
+void RegisterItemTemplateMethods(sol::state& lua);
+void RegisterLootMethods(sol::state& lua);
+void RegisterMapMethods(sol::state& lua);
+void RegisterObjectMethods(sol::state& lua);
+void RegisterPetMethods(sol::state& lua);
+void RegisterPlayerMethods(sol::state& lua);
+void RegisterQuestMethods(sol::state& lua);
+void RegisterRollMethods(sol::state& lua);
+void RegisterSpellEntryMethods(sol::state& lua);
+void RegisterSpellInfoMethods(sol::state& lua);
+void RegisterSpellMethods(sol::state& lua);
+void RegisterTicketMethods(sol::state& lua);
+void RegisterTransportMethods(sol::state& lua);
+void RegisterUnitMethods(sol::state& lua);
+void RegisterVehicleMethods(sol::state& lua);
+void RegisterWorldObjectMethods(sol::state& lua);
+void RegisterWorldPacketMethods(sol::state& lua);
+
+#endif // ALEREGISTRY_H
diff --git a/src/LuaEngine/methods/AchievementMethods.h b/src/LuaEngine/methods/AchievementMethods.cpp
similarity index 58%
rename from src/LuaEngine/methods/AchievementMethods.h
rename to src/LuaEngine/methods/AchievementMethods.cpp
index e5d34e61fa..b21384dfad 100644
--- a/src/LuaEngine/methods/AchievementMethods.h
+++ b/src/LuaEngine/methods/AchievementMethods.cpp
@@ -4,8 +4,11 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef ACHIEVEMENTMETHODS_H
-#define ACHIEVEMENTMETHODS_H
+#include "ALEBind.h"
+
+#include "Common.h"
+#include "DBCStructure.h"
+#include "SharedDefines.h"
 
 /***
  * Represents an entry from the game's achievement database (e.g., achievement earned for completing certain tasks).
@@ -19,10 +22,9 @@ namespace LuaAchievement
      *
      * @return uint32 id
      */
-    int GetId(lua_State* L, AchievementEntry* const achievement)
+    uint32 GetId(AchievementEntry const& achievement)
     {
-        ALE::Push(L, achievement->ID);
-        return 1;
+        return achievement.ID;
     }
 
     /**
@@ -44,16 +46,20 @@ namespace LuaAchievement
      * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the [Achievement] name in
      * @return string name
      */
-    int GetName(lua_State* L, AchievementEntry* const achievement)
+    char const* GetName(AchievementEntry const& achievement, sol::optional<uint8> locale)
     {
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 2, DEFAULT_LOCALE);
-        if (locale >= TOTAL_LOCALES)
-        {
-            return luaL_argerror(L, 2, "valid LocaleConstant expected");
-        }
+        uint8 localeIndex = locale.value_or(DEFAULT_LOCALE);
+        if (localeIndex >= TOTAL_LOCALES)
+            throw std::invalid_argument("valid LocaleConstant expected");
 
-        ALE::Push(L, achievement->name[locale]);
-        return 1;
+        return achievement.name[localeIndex];
     }
-};
-#endif
+}
+
+void RegisterAchievementMethods(sol::state& lua)
+{
+    sol::usertype<AchievementEntry> type = lua.new_usertype<AchievementEntry>("Achievement", sol::no_constructor);
+
+    type["GetId"]   = &LuaAchievement::GetId;
+    type["GetName"] = &LuaAchievement::GetName;
+}
diff --git a/src/LuaEngine/methods/AuraMethods.h b/src/LuaEngine/methods/AuraMethods.cpp
similarity index 62%
rename from src/LuaEngine/methods/AuraMethods.h
rename to src/LuaEngine/methods/AuraMethods.cpp
index 3f63743d25..9bf61e0496 100644
--- a/src/LuaEngine/methods/AuraMethods.h
+++ b/src/LuaEngine/methods/AuraMethods.cpp
@@ -4,8 +4,10 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef AURAMETHODS_H
-#define AURAMETHODS_H
+#include "ALEBind.h"
+
+#include "SpellAuras.h"
+#include "Unit.h"
 
 /***
  * The persistent effect of a [Spell] that remains on a [Unit] after the [Spell]
@@ -26,10 +28,9 @@ namespace LuaAura
      *
      * @return [Unit] caster
      */
-    int GetCaster(lua_State* L, Aura* aura)
+    Unit* GetCaster(Aura* aura)
     {
-        ALE::Push(L, aura->GetCaster());
-        return 1;
+        return aura->GetCaster();
     }
 
     /**
@@ -37,10 +38,9 @@ namespace LuaAura
      *
      * @return string caster_guid : the GUID of the Unit as a decimal string
      */
-    int GetCasterGUID(lua_State* L, Aura* aura)
+    ObjectGuid GetCasterGUID(Aura* aura)
     {
-        ALE::Push(L, aura->GetCasterGUID());
-        return 1;
+        return aura->GetCasterGUID();
     }
 
     /**
@@ -48,10 +48,12 @@ namespace LuaAura
      *
      * @return uint32 caster_level
      */
-    int GetCasterLevel(lua_State* L, Aura* aura)
+    sol::optional<uint8> GetCasterLevel(Aura* aura)
     {
-        ALE::Push(L, aura->GetCaster()->GetLevel());
-        return 1;
+        if (Unit const* caster = aura->GetCaster())
+            return caster->GetLevel();
+
+        return sol::nullopt;
     }
 
     /**
@@ -59,10 +61,9 @@ namespace LuaAura
      *
      * @return int32 duration : amount of time left in milliseconds
      */
-    int GetDuration(lua_State* L, Aura* aura)
+    int32 GetDuration(Aura* aura)
     {
-        ALE::Push(L, aura->GetDuration());
-        return 1;
+        return aura->GetDuration();
     }
 
     /**
@@ -70,10 +71,9 @@ namespace LuaAura
      *
      * @return uint32 aura_id
      */
-    int GetAuraId(lua_State* L, Aura* aura)
+    uint32 GetAuraId(Aura* aura)
     {
-        ALE::Push(L, aura->GetId());
-        return 1;
+        return aura->GetId();
     }
 
     /**
@@ -84,10 +84,9 @@ namespace LuaAura
      *
      * @return int32 max_duration : the maximum duration of the Aura, in milliseconds
      */
-    int GetMaxDuration(lua_State* L, Aura* aura)
+    int32 GetMaxDuration(Aura* aura)
     {
-        ALE::Push(L, aura->GetMaxDuration());
-        return 1;
+        return aura->GetMaxDuration();
     }
 
     /**
@@ -97,10 +96,9 @@ namespace LuaAura
      *
      * @return uint32 stack_amount
      */
-    int GetStackAmount(lua_State* L, Aura* aura)
+    uint8 GetStackAmount(Aura* aura)
     {
-        ALE::Push(L, aura->GetStackAmount());
-        return 1;
+        return aura->GetStackAmount();
     }
 
     /**
@@ -108,10 +106,9 @@ namespace LuaAura
      *
      * @return [Unit] owner
      */
-    int GetOwner(lua_State* L, Aura* aura)
+    WorldObject* GetOwner(Aura* aura)
     {
-        ALE::Push(L, aura->GetOwner());
-        return 1;
+        return aura->GetOwner();
     }
 
     /**
@@ -119,11 +116,9 @@ namespace LuaAura
      *
      * @param int32 duration : the new duration of the Aura, in milliseconds
      */
-    int SetDuration(lua_State* L, Aura* aura)
+    void SetDuration(Aura* aura, int32 duration)
     {
-        int32 duration = ALE::CHECKVAL<int32>(L, 2);
         aura->SetDuration(duration);
-        return 0;
     }
 
     /**
@@ -134,11 +129,9 @@ namespace LuaAura
      *
      * @param int32 duration : the new maximum duration of the Aura, in milliseconds
      */
-    int SetMaxDuration(lua_State* L, Aura* aura)
+    void SetMaxDuration(Aura* aura, int32 duration)
     {
-        int32 duration = ALE::CHECKVAL<int32>(L, 2);
         aura->SetMaxDuration(duration);
-        return 0;
     }
 
     /**
@@ -149,21 +142,34 @@ namespace LuaAura
      *
      * @param uint32 amount
      */
-    int SetStackAmount(lua_State* L, Aura* aura)
+    void SetStackAmount(Aura* aura, uint8 amount)
     {
-        uint8 amount = ALE::CHECKVAL<uint8>(L, 2);
         aura->SetStackAmount(amount);
-        return 0;
     }
 
     /**
      * Remove this [Aura] from the [Unit] it is applied to.
      */
-    int Remove(lua_State* L, Aura* aura)
+    void Remove(Aura* aura)
     {
         aura->Remove();
-        ALE::CHECKOBJ<ALEObject>(L, 1)->Invalidate();
-        return 0;
     }
-};
-#endif
+}
+
+void RegisterAuraMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<Aura>> type = ALEBind::NewHandleType<ScopedRef<Aura>>(lua, "Aura");
+
+    type["GetCaster"]      = ALEBind::Method(&LuaAura::GetCaster);
+    type["GetCasterGUID"]  = ALEBind::Method(&LuaAura::GetCasterGUID);
+    type["GetCasterLevel"] = ALEBind::Method(&LuaAura::GetCasterLevel);
+    type["GetDuration"]    = ALEBind::Method(&LuaAura::GetDuration);
+    type["GetAuraId"]      = ALEBind::Method(&LuaAura::GetAuraId);
+    type["GetMaxDuration"] = ALEBind::Method(&LuaAura::GetMaxDuration);
+    type["GetStackAmount"] = ALEBind::Method(&LuaAura::GetStackAmount);
+    type["GetOwner"]       = ALEBind::Method(&LuaAura::GetOwner);
+    type["SetDuration"]    = ALEBind::Method(&LuaAura::SetDuration);
+    type["SetMaxDuration"] = ALEBind::Method(&LuaAura::SetMaxDuration);
+    type["SetStackAmount"] = ALEBind::Method(&LuaAura::SetStackAmount);
+    type["Remove"]         = ALEBind::Method(&LuaAura::Remove);
+}
diff --git a/src/LuaEngine/methods/BattleGroundMethods.cpp b/src/LuaEngine/methods/BattleGroundMethods.cpp
new file mode 100644
index 0000000000..031a3c71a5
--- /dev/null
+++ b/src/LuaEngine/methods/BattleGroundMethods.cpp
@@ -0,0 +1,214 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#include "ALEBind.h"
+
+#include "Battleground.h"
+#include "Map.h"
+
+/***
+ * Contains the state of a battleground, e.g. Warsong Gulch, Arathi Basin, etc.
+ *
+ * Inherits all methods from: none
+ */
+namespace LuaBattleGround
+{
+    /**
+     * Returns the name of the [BattleGround].
+     *
+     * @return string name
+     */
+    std::string GetName(Battleground* bg)
+    {
+        return bg->GetName();
+    }
+
+    /**
+     * Returns the amount of alive players in the [BattleGround] by the team ID.
+     *
+     * @param [Team] team : team ID
+     * @return uint32 count
+     */
+    uint32 GetAlivePlayersCountByTeam(Battleground* bg, uint32 team)
+    {
+        return bg->GetAlivePlayersCountByTeam((TeamId)team);
+    }
+
+    /**
+     * Returns the [Map] of the [BattleGround].
+     *
+     * @return [Map] map
+     */
+    Map* GetMap(Battleground* bg)
+    {
+        return bg->GetBgMap();
+    }
+
+    /**
+     * Returns the bonus honor given by amount of kills in the specific [BattleGround].
+     *
+     * @param uint32 kills : amount of kills
+     * @return uint32 bonusHonor
+     */
+    uint32 GetBonusHonorFromKillCount(Battleground* bg, uint32 kills)
+    {
+        return bg->GetBonusHonorFromKill(kills);
+    }
+
+    /**
+     * Returns the end time of the [BattleGround].
+     *
+     * @return uint32 endTime
+     */
+    uint32 GetEndTime(Battleground* bg)
+    {
+        return bg->GetEndTime();
+    }
+
+    /**
+     * Returns the amount of free slots for the selected team in the specific [BattleGround].
+     *
+     * @param [Team] team : team ID
+     * @return uint32 freeSlots
+     */
+    uint32 GetFreeSlotsForTeam(Battleground* bg, uint32 team)
+    {
+        return bg->GetFreeSlotsForTeam((TeamId)team);
+    }
+
+    /**
+     * Returns the instance ID of the [BattleGround].
+     *
+     * @return uint32 instanceId
+     */
+    uint32 GetInstanceId(Battleground* bg)
+    {
+        return bg->GetInstanceID();
+    }
+
+    /**
+     * Returns the map ID of the [BattleGround].
+     *
+     * @return uint32 mapId
+     */
+    uint32 GetMapId(Battleground* bg)
+    {
+        return bg->GetMapId();
+    }
+
+    /**
+     * Returns the type ID of the [BattleGround].
+     *
+     * @return [BattleGroundTypeId] typeId
+     */
+    BattlegroundTypeId GetTypeId(Battleground* bg)
+    {
+        return bg->GetBgTypeID();
+    }
+
+    /**
+     * Returns the max allowed [Player] level of the specific [BattleGround].
+     *
+     * @return uint32 maxLevel
+     */
+    uint32 GetMaxLevel(Battleground* bg)
+    {
+        return bg->GetMaxLevel();
+    }
+
+    /**
+     * Returns the minimum allowed [Player] level of the specific [BattleGround].
+     *
+     * @return uint32 minLevel
+     */
+    uint32 GetMinLevel(Battleground* bg)
+    {
+        return bg->GetMinLevel();
+    }
+
+    /**
+     * Returns the maximum allowed [Player] count of the specific [BattleGround].
+     *
+     * @return uint32 maxPlayerCount
+     */
+    uint32 GetMaxPlayers(Battleground* bg)
+    {
+        return bg->GetMaxPlayersPerTeam() * 2;
+    }
+
+    /**
+     * Returns the minimum allowed [Player] count of the specific [BattleGround].
+     *
+     * @return uint32 minPlayerCount
+     */
+    uint32 GetMinPlayers(Battleground* bg)
+    {
+        return bg->GetMinPlayersPerTeam() * 2;
+    }
+
+    /**
+     * Returns the maximum allowed [Player] count per team of the specific [BattleGround].
+     *
+     * @return uint32 maxTeamPlayerCount
+     */
+    uint32 GetMaxPlayersPerTeam(Battleground* bg)
+    {
+        return bg->GetMaxPlayersPerTeam();
+    }
+
+    /**
+     * Returns the minimum allowed [Player] count per team of the specific [BattleGround].
+     *
+     * @return uint32 minTeamPlayerCount
+     */
+    uint32 GetMinPlayersPerTeam(Battleground* bg)
+    {
+        return bg->GetMinPlayersPerTeam();
+    }
+
+    /**
+     * Returns the winning team of the specific [BattleGround].
+     *
+     * @return [Team] team
+     */
+    PvPTeamId GetWinner(Battleground* bg)
+    {
+        return bg->GetWinner();
+    }
+
+    /**
+     * Returns the status of the specific [BattleGround].
+     *
+     * @return [BattleGroundStatus] status
+     */
+    BattlegroundStatus GetStatus(Battleground* bg)
+    {
+        return bg->GetStatus();
+    }
+}
+
+void RegisterBattleGroundMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<Battleground>> type = ALEBind::NewHandleType<ScopedRef<Battleground>>(lua, "BattleGround");
+
+    type["GetName"]                    = ALEBind::Method(&LuaBattleGround::GetName);
+    type["GetAlivePlayersCountByTeam"] = ALEBind::Method(&LuaBattleGround::GetAlivePlayersCountByTeam);
+    type["GetMap"]                     = ALEBind::Method(&LuaBattleGround::GetMap);
+    type["GetBonusHonorFromKillCount"] = ALEBind::Method(&LuaBattleGround::GetBonusHonorFromKillCount);
+    type["GetEndTime"]                 = ALEBind::Method(&LuaBattleGround::GetEndTime);
+    type["GetFreeSlotsForTeam"]        = ALEBind::Method(&LuaBattleGround::GetFreeSlotsForTeam);
+    type["GetInstanceId"]              = ALEBind::Method(&LuaBattleGround::GetInstanceId);
+    type["GetMapId"]                   = ALEBind::Method(&LuaBattleGround::GetMapId);
+    type["GetTypeId"]                  = ALEBind::Method(&LuaBattleGround::GetTypeId);
+    type["GetMaxLevel"]                = ALEBind::Method(&LuaBattleGround::GetMaxLevel);
+    type["GetMinLevel"]                = ALEBind::Method(&LuaBattleGround::GetMinLevel);
+    type["GetMaxPlayers"]              = ALEBind::Method(&LuaBattleGround::GetMaxPlayers);
+    type["GetMinPlayers"]              = ALEBind::Method(&LuaBattleGround::GetMinPlayers);
+    type["GetMaxPlayersPerTeam"]       = ALEBind::Method(&LuaBattleGround::GetMaxPlayersPerTeam);
+    type["GetMinPlayersPerTeam"]       = ALEBind::Method(&LuaBattleGround::GetMinPlayersPerTeam);
+    type["GetWinner"]                  = ALEBind::Method(&LuaBattleGround::GetWinner);
+    type["GetStatus"]                  = ALEBind::Method(&LuaBattleGround::GetStatus);
+}
diff --git a/src/LuaEngine/methods/BattleGroundMethods.h b/src/LuaEngine/methods/BattleGroundMethods.h
deleted file mode 100644
index 70e97bbf2d..0000000000
--- a/src/LuaEngine/methods/BattleGroundMethods.h
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
-* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
-* This program is free software licensed under GPL version 3
-* Please see the included DOCS/LICENSE.md for more information
-*/
-
-#ifndef BATTLEGROUNDMETHODS_H
-#define BATTLEGROUNDMETHODS_H
-
-/***
- * Contains the state of a battleground, e.g. Warsong Gulch, Arathi Basin, etc.
- *
- * Inherits all methods from: none
- */
-namespace LuaBattleGround
-{
-    /**
-     * Returns the name of the [BattleGround].
-     *
-     * @return string name
-     */
-    int GetName(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetName());
-        return 1;
-    }
-
-    /**
-     * Returns the amount of alive players in the [BattleGround] by the team ID.
-     *
-     * @param [Team] team : team ID
-     * @return uint32 count
-     */
-    int GetAlivePlayersCountByTeam(lua_State* L, BattleGround* bg)
-    {
-        uint32 team = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, bg->GetAlivePlayersCountByTeam((TeamId)team));
-        return 1;
-    }
-
-    /**
-     * Returns the [Map] of the [BattleGround].
-     *
-     * @return [Map] map
-     */
-    int GetMap(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetBgMap());
-        return 1;
-    }
-
-    /**
-     * Returns the bonus honor given by amount of kills in the specific [BattleGround].
-     *
-     * @param uint32 kills : amount of kills
-     * @return uint32 bonusHonor
-     */
-    int GetBonusHonorFromKillCount(lua_State* L, BattleGround* bg)
-    {
-        uint32 kills = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, bg->GetBonusHonorFromKill(kills));
-        return 1;
-    }
-
-    /**
-     * Returns the end time of the [BattleGround].
-     *
-     * @return uint32 endTime
-     */
-    int GetEndTime(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetEndTime());
-        return 1;
-    }
-
-    /**
-     * Returns the amount of free slots for the selected team in the specific [BattleGround].
-     *
-     * @param [Team] team : team ID
-     * @return uint32 freeSlots
-     */
-    int GetFreeSlotsForTeam(lua_State* L, BattleGround* bg)
-    {
-        uint32 team = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, bg->GetFreeSlotsForTeam((TeamId)team));
-        return 1;
-    }
-
-    /**
-     * Returns the instance ID of the [BattleGround].
-     *
-     * @return uint32 instanceId
-     */
-    int GetInstanceId(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetInstanceID());
-        return 1;
-    }
-
-    /**
-     * Returns the map ID of the [BattleGround].
-     *
-     * @return uint32 mapId
-     */
-    int GetMapId(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetMapId());
-        return 1;
-    }
-
-    /**
-     * Returns the type ID of the [BattleGround].
-     *
-     * @return [BattleGroundTypeId] typeId
-     */
-    int GetTypeId(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetBgTypeID());
-        return 1;
-    }
-
-    /**
-     * Returns the max allowed [Player] level of the specific [BattleGround].
-     *
-     * @return uint32 maxLevel
-     */
-    int GetMaxLevel(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetMaxLevel());
-        return 1;
-    }
-
-    /**
-     * Returns the minimum allowed [Player] level of the specific [BattleGround].
-     *
-     * @return uint32 minLevel
-     */
-    int GetMinLevel(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetMinLevel());
-        return 1;
-    }
-
-    /**
-     * Returns the maximum allowed [Player] count of the specific [BattleGround].
-     *
-     * @return uint32 maxPlayerCount
-     */
-    int GetMaxPlayers(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetMaxPlayersPerTeam() * 2);
-        return 1;
-    }
-
-    /**
-     * Returns the minimum allowed [Player] count of the specific [BattleGround].
-     *
-     * @return uint32 minPlayerCount
-     */
-    int GetMinPlayers(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetMaxPlayersPerTeam() * 2);
-        return 1;
-    }
-
-    /**
-     * Returns the maximum allowed [Player] count per team of the specific [BattleGround].
-     *
-     * @return uint32 maxTeamPlayerCount
-     */
-    int GetMaxPlayersPerTeam(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetMaxPlayersPerTeam());
-        return 1;
-    }
-
-    /**
-     * Returns the minimum allowed [Player] count per team of the specific [BattleGround].
-     *
-     * @return uint32 minTeamPlayerCount
-     */
-    int GetMinPlayersPerTeam(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetMinPlayersPerTeam());
-        return 1;
-    }
-
-    /**
-     * Returns the winning team of the specific [BattleGround].
-     *
-     * @return [Team] team
-     */
-    int GetWinner(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetWinner());
-        return 1;
-    }
-
-    /**
-     * Returns the status of the specific [BattleGround].
-     *
-     * @return [BattleGroundStatus] status
-     */
-    int GetStatus(lua_State* L, BattleGround* bg)
-    {
-        ALE::Push(L, bg->GetStatus());
-        return 1;
-    }
-};
-#endif
diff --git a/src/LuaEngine/methods/ChatHandlerMethods.h b/src/LuaEngine/methods/ChatHandlerMethods.cpp
similarity index 53%
rename from src/LuaEngine/methods/ChatHandlerMethods.h
rename to src/LuaEngine/methods/ChatHandlerMethods.cpp
index ac6f9a2900..8a417bede9 100644
--- a/src/LuaEngine/methods/ChatHandlerMethods.h
+++ b/src/LuaEngine/methods/ChatHandlerMethods.cpp
@@ -4,8 +4,7 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef CHATHANDLERMETHODS_H
-#define CHATHANDLERMETHODS_H
+#include "ALEBind.h"
 
 #include "Chat.h"
 
@@ -26,19 +25,18 @@ namespace LuaChatHandler
      * @param string text : text to display in chat or console
      * @param uint32 entry : id of the string to display
      */
-    int SendSysMessage(lua_State* L, ChatHandler* handler)
+    void SendSysMessage(ChatHandler* handler, sol::object msg)
     {
-        if (lua_isnumber(L, 2))
+        if (msg.get_type() == sol::type::number)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
+            uint32 entry = msg.as<uint32>();
             handler->SendSysMessage(entry);
         }
         else
         {
-            std::string text = ALE::CHECKVAL<std::string>(L, 2);
+            std::string text = msg.as<std::string>();
             handler->SendSysMessage(text);
         }
-        return 0;
     }
 
     /**
@@ -46,10 +44,9 @@ namespace LuaChatHandler
      *
      * @return bool isConsole
      */
-    int IsConsole(lua_State* L, ChatHandler* handler)
+    bool IsConsole(ChatHandler* handler)
     {
-        ALE::Push(L, handler->IsConsole());
-        return 1;
+        return handler->IsConsole();
     }
 
     /**
@@ -57,10 +54,9 @@ namespace LuaChatHandler
      *
      * @return [Player] player
      */
-    int GetPlayer(lua_State* L, ChatHandler* handler)
+    Player* GetPlayer(ChatHandler* handler)
     {
-        ALE::Push(L, handler->GetPlayer());
-        return 1;
+        return handler->GetPlayer();
     }
 
     /**
@@ -68,11 +64,9 @@ namespace LuaChatHandler
      *
      * @param string text : text to send
      */
-    int SendGlobalSysMessage(lua_State* L, ChatHandler* handler)
+    void SendGlobalSysMessage(ChatHandler* handler, std::string text)
     {
-        std::string text = ALE::CHECKVAL<std::string>(L, 2);
         handler->SendGlobalSysMessage(text.c_str());
-        return 0;
     }
 
     /**
@@ -80,11 +74,9 @@ namespace LuaChatHandler
      *
      * @param string text : text to send
      */
-    int SendGlobalGMSysMessage(lua_State* L, ChatHandler* handler)
+    void SendGlobalGMSysMessage(ChatHandler* handler, std::string text)
     {
-        std::string text = ALE::CHECKVAL<std::string>(L, 2);
         handler->SendGlobalGMSysMessage(text.c_str());
-        return 0;
     }
 
     /**
@@ -94,12 +86,9 @@ namespace LuaChatHandler
      * @param [bool] strong = false : Forces non-player accounts (security level greater than `0`) to go through the regular check if set to `true`.<br>Also, if set to `true`, the current security level will be considered as lower than the [Player]'s security level if the two levels are equal
      * @return [bool] lower
      */
-    int HasLowerSecurity(lua_State* L, ChatHandler* handler)
+    bool HasLowerSecurity(ChatHandler* handler, Player* player, sol::optional<bool> strong)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        bool strong = ALE::CHECKVAL<bool>(L, 3);
-        ALE::Push(L, handler->HasLowerSecurity(player, ObjectGuid::Empty, strong));
-        return 1;
+        return handler->HasLowerSecurity(player, ObjectGuid::Empty, strong.value_or(false));
     }
 
     /**
@@ -109,12 +98,9 @@ namespace LuaChatHandler
      * @param [bool] strong = false : Forces non-player accounts (security level greater than `0`) to go through the regular check if set to `true`.<br>Also, if set to `true`, the current security level will be considered as lower than the `account`'s security level if the two levels are equal
      * @return [bool] lower
      */
-    int HasLowerSecurityAccount(lua_State* L, ChatHandler* handler)
+    bool HasLowerSecurityAccount(ChatHandler* handler, uint32 account, sol::optional<bool> strong)
     {
-        uint32 account = ALE::CHECKVAL<uint32>(L, 2);
-        bool strong = ALE::CHECKVAL<bool>(L, 3);
-        ALE::Push(L, handler->HasLowerSecurityAccount(nullptr, account, strong));
-        return 1;
+        return handler->HasLowerSecurityAccount(nullptr, account, strong.value_or(false));
     }
 
     /**
@@ -122,10 +108,9 @@ namespace LuaChatHandler
      *
      * @return [Player] player
      */
-    int GetSelectedPlayer(lua_State* L, ChatHandler* handler)
+    Player* GetSelectedPlayer(ChatHandler* handler)
     {
-        ALE::Push(L, handler->getSelectedPlayer());
-        return 1;
+        return handler->getSelectedPlayer();
     }
 
     /**
@@ -133,10 +118,9 @@ namespace LuaChatHandler
      *
      * @return [Creature] creature
      */
-    int GetSelectedCreature(lua_State* L, ChatHandler* handler)
+    Creature* GetSelectedCreature(ChatHandler* handler)
     {
-        ALE::Push(L, handler->getSelectedCreature());
-        return 1;
+        return handler->getSelectedCreature();
     }
 
     /**
@@ -144,10 +128,9 @@ namespace LuaChatHandler
      *
      * @return [Unit] unit
      */
-    int GetSelectedUnit(lua_State* L, ChatHandler* handler)
+    Unit* GetSelectedUnit(ChatHandler* handler)
     {
-        ALE::Push(L, handler->getSelectedUnit());
-        return 1;
+        return handler->getSelectedUnit();
     }
 
     /**
@@ -155,10 +138,9 @@ namespace LuaChatHandler
      *
      * @return [WorldObject] object
      */
-    int GetSelectedObject(lua_State* L, ChatHandler* handler)
+    WorldObject* GetSelectedObject(ChatHandler* handler)
     {
-        ALE::Push(L, handler->getSelectedObject());
-        return 1;
+        return handler->getSelectedObject();
     }
 
     /**
@@ -166,10 +148,9 @@ namespace LuaChatHandler
      *
      * @return [Player] player
      */
-    int GetSelectedPlayerOrSelf(lua_State* L, ChatHandler* handler)
+    Player* GetSelectedPlayerOrSelf(ChatHandler* handler)
     {
-        ALE::Push(L, handler->getSelectedPlayerOrSelf());
-        return 1;
+        return handler->getSelectedPlayerOrSelf();
     }
 
     /**
@@ -178,11 +159,9 @@ namespace LuaChatHandler
      * @param [uint32] securityLevel
      * @return [bool] isAvailable
      */
-    int IsAvailable(lua_State* L, ChatHandler* handler)
+    bool IsAvailable(ChatHandler* handler, uint32 securityLevel)
     {
-        uint32 securityLevel = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, handler->IsAvailable(securityLevel));
-        return 1;
+        return handler->IsAvailable(securityLevel);
     }
 
     /**
@@ -190,10 +169,28 @@ namespace LuaChatHandler
      *
      * @return [bool] sentErrorMessage
      */
-    int HasSentErrorMessage(lua_State* L, ChatHandler* handler)
+    bool HasSentErrorMessage(ChatHandler* handler)
     {
-        ALE::Push(L, handler->HasSentErrorMessage());
-        return 1;
+        return handler->HasSentErrorMessage();
     }
 }
-#endif
+
+void RegisterChatHandlerMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<ChatHandler>> type = ALEBind::NewHandleType<ScopedRef<ChatHandler>>(lua, "ChatHandler");
+
+    type["SendSysMessage"]          = ALEBind::Method(&LuaChatHandler::SendSysMessage);
+    type["IsConsole"]               = ALEBind::Method(&LuaChatHandler::IsConsole);
+    type["GetPlayer"]               = ALEBind::Method(&LuaChatHandler::GetPlayer);
+    type["SendGlobalSysMessage"]    = ALEBind::Method(&LuaChatHandler::SendGlobalSysMessage);
+    type["SendGlobalGMSysMessage"]  = ALEBind::Method(&LuaChatHandler::SendGlobalGMSysMessage);
+    type["HasLowerSecurity"]        = ALEBind::Method(&LuaChatHandler::HasLowerSecurity);
+    type["HasLowerSecurityAccount"] = ALEBind::Method(&LuaChatHandler::HasLowerSecurityAccount);
+    type["GetSelectedPlayer"]       = ALEBind::Method(&LuaChatHandler::GetSelectedPlayer);
+    type["GetSelectedCreature"]     = ALEBind::Method(&LuaChatHandler::GetSelectedCreature);
+    type["GetSelectedUnit"]         = ALEBind::Method(&LuaChatHandler::GetSelectedUnit);
+    type["GetSelectedObject"]       = ALEBind::Method(&LuaChatHandler::GetSelectedObject);
+    type["GetSelectedPlayerOrSelf"] = ALEBind::Method(&LuaChatHandler::GetSelectedPlayerOrSelf);
+    type["IsAvailable"]             = ALEBind::Method(&LuaChatHandler::IsAvailable);
+    type["HasSentErrorMessage"]     = ALEBind::Method(&LuaChatHandler::HasSentErrorMessage);
+}
diff --git a/src/LuaEngine/methods/CorpseMethods.h b/src/LuaEngine/methods/CorpseMethods.cpp
similarity index 58%
rename from src/LuaEngine/methods/CorpseMethods.h
rename to src/LuaEngine/methods/CorpseMethods.cpp
index cf8f6f71ed..54b91ce6a5 100644
--- a/src/LuaEngine/methods/CorpseMethods.h
+++ b/src/LuaEngine/methods/CorpseMethods.cpp
@@ -4,8 +4,9 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef CORPSEMETHODS_H
-#define CORPSEMETHODS_H
+#include "ALEBind.h"
+
+#include "Corpse.h"
 
 /***
  * The remains of a [Player] that has died.
@@ -19,10 +20,9 @@ namespace LuaCorpse
      *
      * @return ObjectGuid ownerGUID
      */
-    int GetOwnerGUID(lua_State* L, Corpse* corpse)
+    ObjectGuid GetOwnerGUID(Corpse* corpse)
     {
-        ALE::Push(L, corpse->GetOwnerGUID());
-        return 1;
+        return corpse->GetOwnerGUID();
     }
 
     /**
@@ -30,10 +30,9 @@ namespace LuaCorpse
      *
      * @return uint32 ghostTime
      */
-    int GetGhostTime(lua_State* L, Corpse* corpse)
+    uint32 GetGhostTime(Corpse* corpse)
     {
-        ALE::Push(L, corpse->GetGhostTime());
-        return 1;
+        return corpse->GetGhostTime();
     }
 
     /**
@@ -48,10 +47,9 @@ namespace LuaCorpse
      *
      * @return [CorpseType] corpseType
      */
-    int GetType(lua_State* L, Corpse* corpse)
+    CorpseType GetType(Corpse* corpse)
     {
-        ALE::Push(L, corpse->GetType());
-        return 1;
+        return corpse->GetType();
     }
 
     /**
@@ -59,19 +57,27 @@ namespace LuaCorpse
      *
      * See [Corpse:GetGhostTime].
      */
-    int ResetGhostTime(lua_State* /*L*/, Corpse* corpse)
+    void ResetGhostTime(Corpse* corpse)
     {
         corpse->ResetGhostTime();
-        return 0;
     }
 
     /**
      * Saves the [Corpse] to the database.
      */
-    int SaveToDB(lua_State* /*L*/, Corpse* corpse)
+    void SaveToDB(Corpse* corpse)
     {
         corpse->SaveToDB();
-        return 0;
     }
-};
-#endif
+}
+
+void RegisterCorpseMethods(sol::state& lua)
+{
+    sol::usertype<CorpseRef> type = ALEBind::NewHandleType<CorpseRef, WorldObjectRef, ObjectRef>(lua, "Corpse");
+
+    type["GetOwnerGUID"]   = ALEBind::Method(&LuaCorpse::GetOwnerGUID);
+    type["GetGhostTime"]   = ALEBind::Method(&LuaCorpse::GetGhostTime);
+    type["GetType"]        = ALEBind::Method(&LuaCorpse::GetType);
+    type["ResetGhostTime"] = ALEBind::Method(&LuaCorpse::ResetGhostTime);
+    type["SaveToDB"]       = ALEBind::Method(&LuaCorpse::SaveToDB);
+}
diff --git a/src/LuaEngine/methods/CreatureMethods.h b/src/LuaEngine/methods/CreatureMethods.cpp
similarity index 57%
rename from src/LuaEngine/methods/CreatureMethods.h
rename to src/LuaEngine/methods/CreatureMethods.cpp
index fc8833d851..948a965e50 100644
--- a/src/LuaEngine/methods/CreatureMethods.h
+++ b/src/LuaEngine/methods/CreatureMethods.cpp
@@ -4,8 +4,16 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef CREATUREMETHODS_H
-#define CREATUREMETHODS_H
+#include "ALEBind.h"
+#include "ALEUtility.h"
+
+#include "Creature.h"
+#include "CreatureAI.h"
+#include "MotionMaster.h"
+#include "ObjectMgr.h"
+#include "SpellInfo.h"
+#include "SpellMgr.h"
+#include "ThreatManager.h"
 
 /***
  * Non-[Player] controlled [Unit]s (i.e. NPCs).
@@ -20,10 +28,9 @@ namespace LuaCreature
      *
      * @return bool isRegenerating
      */
-    int IsRegeneratingHealth(lua_State* L, Creature* creature)
+    bool IsRegeneratingHealth(Creature* creature)
     {
-        ALE::Push(L, creature->isRegeneratingHealth());
-        return 1;
+        return creature->isRegeneratingHealth();
     }
 
     /**
@@ -31,12 +38,9 @@ namespace LuaCreature
      *
      * @param bool enable = true : `true` to enable health regeneration, `false` to disable it
      */
-    int SetRegeneratingHealth(lua_State* L, Creature* creature)
+    void SetRegeneratingHealth(Creature* creature, sol::optional<bool> enable)
     {
-        bool enable = ALE::CHECKVAL<bool>(L, 2, true);
-
-        creature->SetRegeneratingHealth(enable);
-        return 0;
+        creature->SetRegeneratingHealth(enable.value_or(true));
     }
 
     /**
@@ -45,10 +49,9 @@ namespace LuaCreature
      *
      * @return bool reputationDisabled
      */
-    int IsReputationGainDisabled(lua_State* L, Creature* creature)
+    bool IsReputationGainDisabled(Creature* creature)
     {
-        ALE::Push(L, creature->IsReputationRewardDisabled());
-        return 1;
+        return creature->IsReputationRewardDisabled();
     }
 
     /**
@@ -58,12 +61,9 @@ namespace LuaCreature
      * @param uint32 questID : the ID of a [Quest]
      * @return bool completesQuest
      */
-    int CanCompleteQuest(lua_State* L, Creature* creature)
+    bool CanCompleteQuest(Creature* creature, uint32 quest_id)
     {
-        uint32 quest_id = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, creature->hasInvolvedQuest(quest_id));
-        return 1;
+        return creature->hasInvolvedQuest(quest_id);
     }
 
     /**
@@ -73,12 +73,9 @@ namespace LuaCreature
      * @param bool mustBeDead = false : if `true`, only returns `true` if the [Creature] is also dead. Otherwise, it must be alive.
      * @return bool targetable
      */
-    int IsTargetableForAttack(lua_State* L, Creature* creature)
+    bool IsTargetableForAttack(Creature* creature, sol::optional<bool> mustBeDead)
     {
-        bool mustBeDead = ALE::CHECKVAL<bool>(L, 2, false);
-
-        ALE::Push(L, creature->isTargetableForAttack(mustBeDead));
-        return 1;
+        return creature->isTargetableForAttack(mustBeDead.value_or(false));
     }
 
     /**
@@ -90,14 +87,9 @@ namespace LuaCreature
      * @param bool checkFaction = true : if `true`, the [Creature] must be the same faction as `friend` to assist
      * @return bool canAssist
      */
-    int CanAssistTo(lua_State* L, Creature* creature)
+    bool CanAssistTo(Creature* creature, Unit* u, Unit* enemy, sol::optional<bool> checkfaction)
     {
-        Unit* u = ALE::CHECKOBJ<Unit>(L, 2);
-        Unit* enemy = ALE::CHECKOBJ<Unit>(L, 3);
-        bool checkfaction = ALE::CHECKVAL<bool>(L, 4, true);
-
-        ALE::Push(L, creature->CanAssistTo(u, enemy, checkfaction));
-        return 1;
+        return creature->CanAssistTo(u, enemy, checkfaction.value_or(true));
     }
 
     /**
@@ -106,10 +98,9 @@ namespace LuaCreature
      *
      * @return bool searchedForAssistance
      */
-    int HasSearchedAssistance(lua_State* L, Creature* creature)
+    bool HasSearchedAssistance(Creature* creature)
     {
-        ALE::Push(L, creature->HasSearchedAssistance());
-        return 1;
+        return creature->HasSearchedAssistance();
     }
 
     /**
@@ -118,12 +109,9 @@ namespace LuaCreature
      *
      * @return bool tapped
      */
-    int IsTappedBy(lua_State* L, Creature* creature)
+    bool IsTappedBy(Creature* creature, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-
-        ALE::Push(L, creature->isTappedBy(player));
-        return 1;
+        return creature->isTappedBy(player);
     }
 
     /**
@@ -132,10 +120,9 @@ namespace LuaCreature
      *
      * @return bool hasLootRecipient
      */
-    int HasLootRecipient(lua_State* L, Creature* creature)
+    bool HasLootRecipient(Creature* creature)
     {
-        ALE::Push(L, creature->hasLootRecipient());
-        return 1;
+        return creature->hasLootRecipient();
     }
 
     /**
@@ -144,10 +131,9 @@ namespace LuaCreature
      *
      * @return bool canAggro
      */
-    int CanAggro(lua_State* L, Creature* creature)
+    bool CanAggro(Creature* creature)
     {
-        ALE::Push(L, !creature->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC));
-        return 1;
+        return !creature->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC);
     }
 
     /**
@@ -156,10 +142,9 @@ namespace LuaCreature
      *
      * @return bool canSwim
      */
-    int CanSwim(lua_State* L, Creature* creature)
+    bool CanSwim(Creature* creature)
     {
-        ALE::Push(L, creature->CanSwim());
-        return 1;
+        return creature->CanSwim();
     }
 
     /**
@@ -168,10 +153,9 @@ namespace LuaCreature
      *
      * @return bool canWalk
      */
-    int CanWalk(lua_State* L, Creature* creature)
+    bool CanWalk(Creature* creature)
     {
-        ALE::Push(L, creature->CanWalk());
-        return 1;
+        return creature->CanWalk();
     }
 
     /**
@@ -180,10 +164,9 @@ namespace LuaCreature
      *
      * @return bool inEvadeMode
      */
-    int IsInEvadeMode(lua_State* L, Creature* creature)
+    bool IsInEvadeMode(Creature* creature)
     {
-        ALE::Push(L, creature->IsInEvadeMode());
-        return 1;
+        return creature->IsInEvadeMode();
     }
 
     /**
@@ -192,10 +175,9 @@ namespace LuaCreature
      *
      * @return bool isElite
      */
-    int IsElite(lua_State* L, Creature* creature)
+    bool IsElite(Creature* creature)
     {
-        ALE::Push(L, creature->isElite());
-        return 1;
+        return creature->isElite();
     }
 
     /**
@@ -204,10 +186,9 @@ namespace LuaCreature
      *
      * @return bool isGuard
      */
-    int IsGuard(lua_State* L, Creature* creature)
+    bool IsGuard(Creature* creature)
     {
-        ALE::Push(L, creature->IsGuard());
-        return 1;
+        return creature->IsGuard();
     }
 
     /**
@@ -216,10 +197,9 @@ namespace LuaCreature
      *
      * @return bool isCivilian
      */
-    int IsCivilian(lua_State* L, Creature* creature)
+    bool IsCivilian(Creature* creature)
     {
-        ALE::Push(L, creature->IsCivilian());
-        return 1;
+        return creature->IsCivilian();
     }
 
     /**
@@ -228,10 +208,9 @@ namespace LuaCreature
      *
      * @return bool isLeader
      */
-    int IsRacialLeader(lua_State* L, Creature* creature)
+    bool IsRacialLeader(Creature* creature)
     {
-        ALE::Push(L, creature->IsRacialLeader());
-        return 1;
+        return creature->IsRacialLeader();
     }
 
     /**
@@ -240,10 +219,9 @@ namespace LuaCreature
      *
      * @return bool isDungeonBoss
      */
-    int IsDungeonBoss(lua_State* L, Creature* creature)
+    bool IsDungeonBoss(Creature* creature)
     {
-        ALE::Push(L, creature->IsDungeonBoss());
-        return 1;
+        return creature->IsDungeonBoss();
     }
 
     /**
@@ -252,10 +230,9 @@ namespace LuaCreature
      *
      * @return bool isWorldBoss
      */
-    int IsWorldBoss(lua_State* L, Creature* creature)
+    bool IsWorldBoss(Creature* creature)
     {
-        ALE::Push(L, creature->isWorldBoss());
-        return 1;
+        return creature->isWorldBoss();
     }
 
     /**
@@ -265,15 +242,12 @@ namespace LuaCreature
      * @param uint32 spellId : the ID of a [Spell]
      * @return bool hasCooldown
      */
-    int HasCategoryCooldown(lua_State* L, Creature* creature)
+    bool HasCategoryCooldown(Creature* creature, uint32 spell)
     {
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 2);
+        if (SpellInfo const* info = sSpellMgr->GetSpellInfo(spell))
+            return info->GetCategory() && creature->HasSpellCooldown(spell);
 
-        if (const SpellInfo* info = sSpellMgr->GetSpellInfo(spell))
-            ALE::Push(L, info->GetCategory() && creature->HasSpellCooldown(spell));
-        else
-            ALE::Push(L, false);
-        return 1;
+        return false;
     }
 
     /**
@@ -283,12 +257,9 @@ namespace LuaCreature
      * @param uint32 spellId : the ID of a [Spell]
      * @return bool hasSpell
      */
-    int HasSpell(lua_State* L, Creature* creature)
+    bool HasSpell(Creature* creature, uint32 id)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, creature->HasSpell(id));
-        return 1;
+        return creature->HasSpell(id);
     }
 
     /**
@@ -298,12 +269,9 @@ namespace LuaCreature
      * @param uint32 questId : the ID of a [Quest]
      * @return bool hasQuest
      */
-    int HasQuest(lua_State* L, Creature* creature)
+    bool HasQuest(Creature* creature, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, creature->hasQuest(questId));
-        return 1;
+        return creature->hasQuest(questId);
     }
 
     /**
@@ -313,12 +281,9 @@ namespace LuaCreature
      * @param uint32 spellId : the ID of a [Spell]
      * @return bool hasCooldown
      */
-    int HasSpellCooldown(lua_State* L, Creature* creature)
+    bool HasSpellCooldown(Creature* creature, uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, creature->HasSpellCooldown(spellId));
-        return 1;
+        return creature->HasSpellCooldown(spellId);
     }
 
     /**
@@ -327,10 +292,9 @@ namespace LuaCreature
      *
      * @return bool canFly
      */
-    int CanFly(lua_State* L, Creature* creature)
+    bool CanFly(Creature* creature)
     {
-        ALE::Push(L, creature->CanFly());
-        return 1;
+        return creature->CanFly();
     }
 
     /**
@@ -339,10 +303,9 @@ namespace LuaCreature
      *
      * @return bool canFly
      */
-    int IsTrigger(lua_State* L, Creature* creature)
+    bool IsTrigger(Creature* creature)
     {
-        ALE::Push(L, creature->IsTrigger());
-        return 1;
+        return creature->IsTrigger();
     }
 
     /**
@@ -350,10 +313,9 @@ namespace LuaCreature
      *
      * @return bool isDamagedEnough
      */
-    int IsDamageEnoughForLootingAndReward(lua_State* L, Creature* creature)
+    bool IsDamageEnoughForLootingAndReward(Creature* creature)
     {
-        ALE::Push(L, creature->IsDamageEnoughForLootingAndReward());
-        return 1;
+        return creature->IsDamageEnoughForLootingAndReward();
     }
 
     /**
@@ -364,12 +326,9 @@ namespace LuaCreature
      * @param [Unit] target
      * @param bool force = true : force [Creature] to attack
      */
-    int CanStartAttack(lua_State* L, Creature* creature) // TODO: Implement core side
+    bool CanStartAttack(Creature* creature, Unit* target) // TODO: Implement core side
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-
-        ALE::Push(L, creature->CanStartAttack(target));
-        return 1;
+        return creature->CanStartAttack(target);
     }
 
     /**
@@ -378,12 +337,9 @@ namespace LuaCreature
      * @param uint16 lootMode
      * @return bool hasLootMode
      */
-    int HasLootMode(lua_State* L, Creature* creature) // TODO: Implement LootMode features
+    bool HasLootMode(Creature* creature, uint16 lootMode) // TODO: Implement LootMode features
     {
-        uint16 lootMode = ALE::CHECKVAL<uint16>(L, 2);
-
-        ALE::Push(L, creature->HasLootMode(lootMode));
-        return 1;
+        return creature->HasLootMode(lootMode);
     }
 
     /**
@@ -394,10 +350,9 @@ namespace LuaCreature
      *
      * @return uint32 respawnDelay : the respawn delay, in seconds
      */
-    int GetRespawnDelay(lua_State* L, Creature* creature)
+    uint32 GetRespawnDelay(Creature* creature)
     {
-        ALE::Push(L, creature->GetRespawnDelay());
-        return 1;
+        return creature->GetRespawnDelay();
     }
 
     /**
@@ -406,10 +361,9 @@ namespace LuaCreature
      *
      * @return float wanderRadius
      */
-    int GetWanderRadius(lua_State* L, Creature* creature)
+    float GetWanderRadius(Creature* creature)
     {
-        ALE::Push(L, creature->GetWanderDistance());
-        return 1;
+        return creature->GetWanderDistance();
     }
 
     /**
@@ -417,10 +371,9 @@ namespace LuaCreature
      *
      * @return uint32 pathId
      */
-    int GetWaypointPath(lua_State* L, Creature* creature)
+    uint32 GetWaypointPath(Creature* creature)
     {
-        ALE::Push(L, creature->GetWaypointPath());
-        return 1;
+        return creature->GetWaypointPath();
     }
 
     /**
@@ -428,10 +381,9 @@ namespace LuaCreature
      *
      * @return uint32 wpId
      */
-    int GetCurrentWaypointId(lua_State* L, Creature* creature)
+    uint32 GetCurrentWaypointId(Creature* creature)
     {
-        ALE::Push(L, creature->GetCurrentWaypointID());
-        return 1;
+        return creature->GetCurrentWaypointID();
     }
 
     /**
@@ -439,10 +391,9 @@ namespace LuaCreature
     *
     * @return uint32 spawnId
     */
-    int GetSpawnId(lua_State* L, Creature* creature)
+    uint32 GetSpawnId(Creature* creature)
     {
-        ALE::Push(L, creature->GetSpawnId());
-        return 1;
+        return creature->GetSpawnId();
     }
 
     /**
@@ -450,10 +401,9 @@ namespace LuaCreature
      *
      * @return [MovementGeneratorType] defaultMovementType
      */
-    int GetDefaultMovementType(lua_State* L, Creature* creature)
+    MovementGeneratorType GetDefaultMovementType(Creature* creature)
     {
-        ALE::Push(L, creature->GetDefaultMovementType());
-        return 1;
+        return creature->GetDefaultMovementType();
     }
 
     /**
@@ -462,12 +412,9 @@ namespace LuaCreature
      * @param [Unit] target
      * @return float aggroRange
      */
-    int GetAggroRange(lua_State* L, Creature* creature)
+    float GetAggroRange(Creature* creature, Unit* target)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-
-        ALE::Push(L, creature->GetAggroRange(target));
-        return 1;
+        return creature->GetAggroRange(target);
     }
 
     /**
@@ -475,10 +422,9 @@ namespace LuaCreature
      *
      * @return [Group] lootRecipientGroup : the group or `nil`
      */
-    int GetLootRecipientGroup(lua_State* L, Creature* creature)
+    Group* GetLootRecipientGroup(Creature* creature)
     {
-        ALE::Push(L, creature->GetLootRecipientGroup());
-        return 1;
+        return creature->GetLootRecipientGroup();
     }
 
     /**
@@ -486,10 +432,9 @@ namespace LuaCreature
      *
      * @return [Player] lootRecipient : the player or `nil`
      */
-    int GetLootRecipient(lua_State* L, Creature* creature)
+    Player* GetLootRecipient(Creature* creature)
     {
-        ALE::Push(L, creature->GetLootRecipient());
-        return 1;
+        return creature->GetLootRecipient();
     }
 
     /**
@@ -501,10 +446,9 @@ namespace LuaCreature
      *
      * @return string scriptName
      */
-    int GetScriptName(lua_State* L, Creature* creature)
+    std::string GetScriptName(Creature* creature)
     {
-        ALE::Push(L, creature->GetScriptName());
-        return 1;
+        return creature->GetScriptName();
     }
 
     /**
@@ -516,10 +460,9 @@ namespace LuaCreature
      *
      * @return string AIName
      */
-    int GetAIName(lua_State* L, Creature* creature)
+    std::string GetAIName(Creature* creature)
     {
-        ALE::Push(L, creature->GetAIName());
-        return 1;
+        return creature->GetAIName();
     }
 
     /**
@@ -530,10 +473,9 @@ namespace LuaCreature
      *
      * @return uint32 scriptID
      */
-    int GetScriptId(lua_State* L, Creature* creature)
+    uint32 GetScriptId(Creature* creature)
     {
-        ALE::Push(L, creature->GetScriptId());
-        return 1;
+        return creature->GetScriptId();
     }
 
     /**
@@ -542,16 +484,12 @@ namespace LuaCreature
      * @param uint32 spellID
      * @return uint32 cooldown : the cooldown, in milliseconds
      */
-    int GetCreatureSpellCooldownDelay(lua_State* L, Creature* creature)
+    uint32 GetCreatureSpellCooldownDelay(Creature* creature, uint32 spell)
     {
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 2);
-
         if (sSpellMgr->GetSpellInfo(spell))
-            ALE::Push(L, creature->GetSpellCooldown(spell));
-        else
-            ALE::Push(L, 0);
+            return creature->GetSpellCooldown(spell);
 
-        return 1;
+        return 0;
     }
 
     /**
@@ -559,10 +497,9 @@ namespace LuaCreature
      *
      * @return uint32 corpseDelay : the delay, in seconds
      */
-    int GetCorpseDelay(lua_State* L, Creature* creature)
+    uint32 GetCorpseDelay(Creature* creature)
     {
-        ALE::Push(L, creature->GetCorpseDelay());
-        return 1;
+        return creature->GetCorpseDelay();
     }
 
     /**
@@ -574,16 +511,12 @@ namespace LuaCreature
      * @return float z
      * @return float o
      */
-    int GetHomePosition(lua_State* L, Creature* creature)
+    std::tuple<float, float, float, float> GetHomePosition(Creature* creature)
     {
         float x, y, z, o;
         creature->GetHomePosition(x, y, z, o);
 
-        ALE::Push(L, x);
-        ALE::Push(L, y);
-        ALE::Push(L, z);
-        ALE::Push(L, o);
-        return 4;
+        return std::tuple<float, float, float, float>(x, y, z, o);
     }
 
     /**
@@ -595,15 +528,9 @@ namespace LuaCreature
      * @param float z
      * @param float o
      */
-    int SetHomePosition(lua_State* L, Creature* creature)
+    void SetHomePosition(Creature* creature, float x, float y, float z, float o)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float z = ALE::CHECKVAL<float>(L, 4);
-        float o = ALE::CHECKVAL<float>(L, 5);
-
         creature->SetHomePosition(x, y, z, o);
-        return 0;
     }
 
     enum SelectAggroTarget
@@ -641,20 +568,19 @@ namespace LuaCreature
     * @param int32 aura = 0 : if positive, the target must have this [Aura]. If negative, the the target must not have this Aura
     * @return [Unit] target : the target, or `nil`
     */
-    int GetAITarget(lua_State* L, Creature* creature)
+    Unit* GetAITarget(Creature* creature, uint32 targetType, sol::optional<bool> playerOnlyArg, sol::optional<uint32> positionArg, sol::optional<float> distArg, sol::optional<int32> auraArg)
     {
-        uint32 targetType = ALE::CHECKVAL<uint32>(L, 2);
-        bool playerOnly = ALE::CHECKVAL<bool>(L, 3, false);
-        uint32 position = ALE::CHECKVAL<uint32>(L, 4, 0);
-        float dist = ALE::CHECKVAL<float>(L, 5, 0.0f);
-        int32 aura = ALE::CHECKVAL<int32>(L, 6, 0);
+        bool playerOnly = playerOnlyArg.value_or(false);
+        uint32 position = positionArg.value_or(0);
+        float dist = distArg.value_or(0.0f);
+        int32 aura = auraArg.value_or(0);
 
         ThreatManager const& threatMgr = creature->GetThreatMgr();
 
         if (threatMgr.IsThreatListEmpty())
-            return 1;
+            return nullptr;
         if (position >= threatMgr.GetThreatListSize())
-            return 1;
+            return nullptr;
 
         std::list<Unit*> targetList;
 
@@ -678,9 +604,9 @@ namespace LuaCreature
         }
 
         if (targetList.empty())
-            return 1;
+            return nullptr;
         if (position >= targetList.size())
-            return 1;
+            return nullptr;
 
         if (targetType == SELECT_TARGET_NEAREST || targetType == SELECT_TARGET_FARTHEST)
             targetList.sort(ALEUtil::ObjectDistanceOrderPred(creature));
@@ -693,18 +619,16 @@ namespace LuaCreature
                     std::list<Unit*>::const_iterator itr = targetList.begin();
                     if (position)
                         std::advance(itr, position);
-                    ALE::Push(L, *itr);
+                    return *itr;
                 }
-                break;
             case SELECT_TARGET_FARTHEST:
             case SELECT_TARGET_BOTTOMAGGRO:
                 {
                     std::list<Unit*>::reverse_iterator ritr = targetList.rbegin();
                     if (position)
                         std::advance(ritr, position);
-                    ALE::Push(L, *ritr);
+                    return *ritr;
                 }
-                break;
             case SELECT_TARGET_RANDOM:
                 {
                     std::list<Unit*>::const_iterator itr = targetList.begin();
@@ -712,15 +636,13 @@ namespace LuaCreature
                         std::advance(itr, urand(0, position));
                     else
                         std::advance(itr, urand(0, targetList.size() - 1));
-                    ALE::Push(L, *itr);
+                    return *itr;
                 }
-                break;
             default:
-                luaL_argerror(L, 2, "SelectAggroTarget expected");
-                break;
+                throw std::invalid_argument("SelectAggroTarget expected");
         }
 
-        return 1;
+        return nullptr;
     }
 
     /**
@@ -728,21 +650,18 @@ namespace LuaCreature
      *
      * @return table targets
      */
-    int GetAITargets(lua_State* L, Creature* creature)
+    sol::table GetAITargets(Creature* creature, sol::this_state s)
     {
         ThreatManager const& threatMgr = creature->GetThreatMgr();
 
-        lua_createtable(L, threatMgr.GetThreatListSize(), 0);
-        int tbl = lua_gettop(L);
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table(static_cast<int>(threatMgr.GetThreatListSize()), 0);
         uint32 i = 0;
+
         for (ThreatReference const* ref : threatMgr.GetSortedThreatList())
-        {
-            ALE::Push(L, ref->GetVictim());
-            lua_rawseti(L, tbl, ++i);
-        }
+            tbl[++i] = ALEBind::ToLuaDynamic(lua, ref->GetVictim());
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -750,10 +669,9 @@ namespace LuaCreature
      *
      * @return int targetsCount
      */
-    int GetAITargetsCount(lua_State* L, Creature* creature)
+    std::size_t GetAITargetsCount(Creature* creature)
     {
-        ALE::Push(L, creature->GetThreatMgr().GetThreatListSize());
-        return 1;
+        return creature->GetThreatMgr().GetThreatListSize();
     }
 
     /**
@@ -764,10 +682,9 @@ namespace LuaCreature
      *
      * @return [NPCFlags] npcFlags
      */
-    int GetNPCFlags(lua_State* L, Creature* creature)
+    uint32 GetNPCFlags(Creature* creature)
     {
-        ALE::Push(L, creature->GetUInt32Value(UNIT_NPC_FLAGS));
-        return 1;
+        return creature->GetUInt32Value(UNIT_NPC_FLAGS);
     }
 
     /**
@@ -777,10 +694,9 @@ namespace LuaCreature
      *
      * @return [UnitFlags] unitFlags
      */
-    int GetUnitFlags(lua_State* L, Creature* creature)
+    uint32 GetUnitFlags(Creature* creature)
     {
-        ALE::Push(L, creature->GetUInt32Value(UNIT_FIELD_FLAGS));
-        return 1;
+        return creature->GetUInt32Value(UNIT_FIELD_FLAGS);
     }
 
     /**
@@ -788,10 +704,9 @@ namespace LuaCreature
      *
      * @return [UnitFlags2] unitFlags2
      */
-    int GetUnitFlagsTwo(lua_State* L, Creature* creature)
+    uint32 GetUnitFlagsTwo(Creature* creature)
     {
-        ALE::Push(L, creature->GetUInt32Value(UNIT_FIELD_FLAGS_2));
-        return 1;
+        return creature->GetUInt32Value(UNIT_FIELD_FLAGS_2);
     }
 
     /**
@@ -802,10 +717,9 @@ namespace LuaCreature
      *
      * @return [ExtraFlags] extraFlags
      */
-    int GetExtraFlags(lua_State* L, Creature* creature)
+    uint32 GetExtraFlags(Creature* creature)
     {
-        ALE::Push(L, creature->GetCreatureTemplate()->flags_extra);
-        return 1;
+        return creature->GetCreatureTemplate()->flags_extra;
     }
 
     /**
@@ -813,10 +727,9 @@ namespace LuaCreature
      *
      * @return [Rank] rank
      */
-    int GetRank(lua_State* L, Creature* creature)
+    uint32 GetRank(Creature* creature)
     {
-        ALE::Push(L, creature->GetCreatureTemplate()->rank);
-        return 1;
+        return creature->GetCreatureTemplate()->rank;
     }
 
     /**
@@ -824,10 +737,9 @@ namespace LuaCreature
      *
      * @return uint32 shieldBlockValue
      */
-    int GetShieldBlockValue(lua_State* L, Creature* creature)
+    uint32 GetShieldBlockValue(Creature* creature)
     {
-        ALE::Push(L, creature->GetShieldBlockValue());
-        return 1;
+        return creature->GetShieldBlockValue();
     }
 
     /**
@@ -836,10 +748,9 @@ namespace LuaCreature
      * @param [Creature] creature : the creature whose loot mode to get
      * @return uint16 lootMode : the loot mode bitmask of the creature
      */
-    int GetLootMode(lua_State* L, Creature* creature) // TODO: Implement LootMode features
+    uint16 GetLootMode(Creature* creature) // TODO: Implement LootMode features
     {
-        ALE::Push(L, creature->GetLootMode());
-        return 1;
+        return creature->GetLootMode();
     }
 
     /**
@@ -847,10 +758,9 @@ namespace LuaCreature
      *
      * @return uint32 dbguid
      */
-    int GetDBTableGUIDLow(lua_State* L, Creature* creature)
+    uint32 GetDBTableGUIDLow(Creature* creature)
     {
-        ALE::Push(L, creature->GetSpawnId());
-        return 1;
+        return creature->GetSpawnId();
     }
 
     /**
@@ -867,11 +777,10 @@ namespace LuaCreature
      *
      * @return [ReactState] state
      */
-    int GetReactState(lua_State* L, Creature* creature)
+    int32 GetReactState(Creature* creature)
     {
         ReactStates state = creature->GetReactState();
-        lua_pushinteger(L, (int)state);
-        return 1;
+        return static_cast<int32>(state);
     }
 
     /**
@@ -879,24 +788,19 @@ namespace LuaCreature
      *
      * @param [NPCFlags] flags
      */
-    int SetNPCFlags(lua_State* L, Creature* creature)
+    void SetNPCFlags(Creature* creature, uint32 flags)
     {
-        uint32 flags = ALE::CHECKVAL<uint32>(L, 2);
-
         creature->SetUInt32Value(UNIT_NPC_FLAGS, flags);
-        return 0;
     }
-    
+
     /**
      * Sets the [Creature]'s Unit flags to `flags`.
      *
      * @param [UnitFlags] flags
      */
-    int SetUnitFlags(lua_State* L, Creature* creature)
+    void SetUnitFlags(Creature* creature, uint32 flags)
     {
-        uint32 flags = ALE::CHECKVAL<uint32>(L, 2);
         creature->SetUInt32Value(UNIT_FIELD_FLAGS, flags);
-        return 0;
     }
 
     /**
@@ -904,11 +808,9 @@ namespace LuaCreature
      *
      * @param [UnitFlags2] flags
      */
-    int SetUnitFlagsTwo(lua_State* L, Creature* creature)
+    void SetUnitFlagsTwo(Creature* creature, uint32 flags)
     {
-        uint32 flags = ALE::CHECKVAL<uint32>(L, 2);
         creature->SetUInt32Value(UNIT_FIELD_FLAGS_2, flags);
-        return 0;
     }
 
     /**
@@ -916,12 +818,9 @@ namespace LuaCreature
      *
      * @param [ReactState] state
      */
-    int SetReactState(lua_State* L, Creature* creature)
+    void SetReactState(Creature* creature, uint32 state)
     {
-        uint32 state = ALE::CHECKVAL<uint32>(L, 2);
-
         creature->SetReactState((ReactStates)state);
-        return 0;
     }
 
     /**
@@ -929,12 +828,9 @@ namespace LuaCreature
      *
      * @param bool disable
      */
-    int SetDisableGravity(lua_State* L, Creature* creature)
+    void SetDisableGravity(Creature* creature, bool disable)
     {
-        bool disable = ALE::CHECKVAL<bool>(L, 2);
-
         creature->SetDisableGravity(disable);
-        return 0;
     }
 
     /**
@@ -943,12 +839,9 @@ namespace LuaCreature
      * @param [Creature] creature : the creature whose loot mode to set
      * @param uint16 lootMode : the loot mode bitmask to apply
      */
-    int SetLootMode(lua_State* L, Creature* creature) // TODO: Implement LootMode features
+    void SetLootMode(Creature* creature, uint16 lootMode) // TODO: Implement LootMode features
     {
-        uint16 lootMode = ALE::CHECKVAL<uint16>(L, 2);
-
         creature->SetLootMode(lootMode);
-        return 0;
     }
 
     /**
@@ -956,12 +849,9 @@ namespace LuaCreature
      *
      * @param [DeathState] deathState
      */
-    int SetDeathState(lua_State* L, Creature* creature)
+    void SetDeathState(Creature* creature, int32 state)
     {
-        int32 state = ALE::CHECKVAL<int32>(L, 2);
-
         creature->setDeathState((DeathState)state);
-        return 0;
     }
 
     /**
@@ -969,12 +859,9 @@ namespace LuaCreature
      *
      * @param bool enable = true : `true` to enable walking, `false` for running
      */
-    int SetWalk(lua_State* L, Creature* creature)           // TODO: Move same to Player ?
+    void SetWalk(Creature* creature, sol::optional<bool> enable)           // TODO: Move same to Player ?
     {
-        bool enable = ALE::CHECKVAL<bool>(L, 2, true);
-
-        creature->SetWalk(enable);
-        return 0;
+        creature->SetWalk(enable.value_or(true));
     }
 
     /**
@@ -984,17 +871,11 @@ namespace LuaCreature
      * @param uint32 off_hand : off hand [Item]'s entry
      * @param uint32 ranged : ranged [Item]'s entry
      */
-    int SetEquipmentSlots(lua_State* L, Creature* creature)
+    void SetEquipmentSlots(Creature* creature, uint32 main_hand, uint32 off_hand, uint32 ranged)
     {
-        uint32 main_hand = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 off_hand = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 ranged = ALE::CHECKVAL<uint32>(L, 4);
-
         creature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 0, main_hand);
         creature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 1, off_hand);
         creature->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID + 2, ranged);
-
-        return 0;
     }
 
     /**
@@ -1002,16 +883,14 @@ namespace LuaCreature
      *
      * @param bool allow = true : `true` to allow aggro, `false` to disable aggro
      */
-    int SetAggroEnabled(lua_State* L, Creature* creature)
+    void SetAggroEnabled(Creature* creature, sol::optional<bool> allowArg)
     {
-        bool allow = ALE::CHECKVAL<bool>(L, 2, true);
+        bool allow = allowArg.value_or(true);
 
         if (allow)
             creature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC);
         else
             creature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IMMUNE_TO_NPC);
-
-        return 0;
     }
 
     /**
@@ -1019,12 +898,9 @@ namespace LuaCreature
      *
      * @param bool disable = true : `true` to disable reputation, `false` to enable
      */
-    int SetDisableReputationGain(lua_State* L, Creature* creature)
+    void SetDisableReputationGain(Creature* creature, sol::optional<bool> disable)
     {
-        bool disable = ALE::CHECKVAL<bool>(L, 2, true);
-
-        creature->SetReputationRewardDisabled(disable);
-        return 0;
+        creature->SetReputationRewardDisabled(disable.value_or(true));
     }
 
     /**
@@ -1033,12 +909,10 @@ namespace LuaCreature
      * This is used by raid bosses to prevent Players from using out-of-combat
      *   actions once the encounter has begun.
      */
-    int SetInCombatWithZone(lua_State* /*L*/, Creature* creature)
+    void SetInCombatWithZone(Creature* creature)
     {
         if (creature->IsAIEnabled)
             creature->AI()->DoZoneInCombat();
-
-        return 0;
     }
 
     /**
@@ -1046,13 +920,9 @@ namespace LuaCreature
      *
      * @param float distance
      */
-    int SetWanderRadius(lua_State* L, Creature* creature)
+    void SetWanderRadius(Creature* creature, float dist)
     {
-        float dist = ALE::CHECKVAL<float>(L, 2);
-
         creature->SetWanderDistance(dist);
-
-        return 0;
     }
 
     /**
@@ -1060,12 +930,9 @@ namespace LuaCreature
      *
      * @param uint32 delay : the delay, in seconds
      */
-    int SetRespawnDelay(lua_State* L, Creature* creature)
+    void SetRespawnDelay(Creature* creature, uint32 delay)
     {
-        uint32 delay = ALE::CHECKVAL<uint32>(L, 2);
-
         creature->SetRespawnDelay(delay);
-        return 0;
     }
 
     /**
@@ -1073,12 +940,9 @@ namespace LuaCreature
      *
      * @param [MovementGeneratorType] type
      */
-    int SetDefaultMovementType(lua_State* L, Creature* creature)
+    void SetDefaultMovementType(Creature* creature, int32 type)
     {
-        int32 type = ALE::CHECKVAL<int32>(L, 2);
-
         creature->SetDefaultMovementType((MovementGeneratorType)type);
-        return 0;
     }
 
     /**
@@ -1086,12 +950,9 @@ namespace LuaCreature
      *
      * @param bool enable = true : `true` to disable searching, `false` to allow
      */
-    int SetNoSearchAssistance(lua_State* L, Creature* creature)
+    void SetNoSearchAssistance(Creature* creature, sol::optional<bool> val)
     {
-        bool val = ALE::CHECKVAL<bool>(L, 2, true);
-
-        creature->SetNoSearchAssistance(val);
-        return 0;
+        creature->SetNoSearchAssistance(val.value_or(true));
     }
 
     /**
@@ -1099,12 +960,9 @@ namespace LuaCreature
      *
      * @param bool enable = true : `true` to disable calling for help, `false` to enable
      */
-    int SetNoCallAssistance(lua_State* L, Creature* creature)
+    void SetNoCallAssistance(Creature* creature, sol::optional<bool> val)
     {
-        bool val = ALE::CHECKVAL<bool>(L, 2, true);
-
-        creature->SetNoCallAssistance(val);
-        return 0;
+        creature->SetNoCallAssistance(val.value_or(true));
     }
 
     /**
@@ -1112,13 +970,9 @@ namespace LuaCreature
      *
      * @param bool enable = true : `true` to enable hovering, `false` to disable
      */
-    int SetHover(lua_State* L, Creature* creature)
+    void SetHover(Creature* creature, sol::optional<bool> enable)
     {
-        bool enable = ALE::CHECKVAL<bool>(L, 2, true);
-
-        creature->SetHover(enable);
-
-        return 0;
+        creature->SetHover(enable.value_or(true));
     }
 
     /**
@@ -1126,39 +980,33 @@ namespace LuaCreature
      *
      * @param uint32 delay = 0 : dely to despawn in milliseconds
      */
-    int DespawnOrUnsummon(lua_State* L, Creature* creature)
+    void DespawnOrUnsummon(Creature* creature, sol::optional<uint32> msTimeToDespawn)
     {
-        uint32 msTimeToDespawn = ALE::CHECKVAL<uint32>(L, 2, 0);
-        creature->DespawnOrUnsummon(Milliseconds(msTimeToDespawn));
-
-        return 0;
+        creature->DespawnOrUnsummon(Milliseconds(msTimeToDespawn.value_or(0)));
     }
 
     /**
      * Respawn this [Creature].
      */
-    int Respawn(lua_State* /*L*/, Creature* creature)
+    void Respawn(Creature* creature)
     {
         creature->Respawn();
-        return 0;
     }
 
     /**
      * Remove this [Creature]'s corpse.
      */
-    int RemoveCorpse(lua_State* /*L*/, Creature* creature)
+    void RemoveCorpse(Creature* creature)
     {
         creature->RemoveCorpse();
-        return 0;
     }
 
     /**
      * Handles this [Creature]'s corpse state after all loot is removed.
      */
-    int AllLootRemovedFromCorpse(lua_State* /*L*/, Creature* creature)
+    void AllLootRemovedFromCorpse(Creature* creature)
     {
         creature->AllLootRemovedFromCorpse();
-        return 0;
     }
 
     /**
@@ -1166,30 +1014,25 @@ namespace LuaCreature
      *
      * @param uint32 delay : the delay, in seconds
      */
-    int SetCorpseDelay(lua_State* L, Creature* creature)
+    void SetCorpseDelay(Creature* creature, uint32 delay)
     {
-        uint32 delay = ALE::CHECKVAL<uint32>(L, 2);
         creature->SetCorpseDelay(delay);
-        return 0;
     }
 
     /**
      * Make the [Creature] start following its waypoint path.
      */
-    int MoveWaypoint(lua_State* /*L*/, Creature* creature)
+    void MoveWaypoint(Creature* creature)
     {
         creature->GetMotionMaster()->MoveWaypoint(creature->GetWaypointPath(), true);
-
-        return 0;
     }
 
     /**
      * Make the [Creature] call for assistance in combat from other nearby [Creature]s.
      */
-    int CallAssistance(lua_State* /*L*/, Creature* creature)
+    void CallAssistance(Creature* creature)
     {
         creature->CallAssistance();
-        return 0;
     }
 
     /**
@@ -1197,21 +1040,17 @@ namespace LuaCreature
      *
      * @param float radius
      */
-    int CallForHelp(lua_State* L, Creature* creature)
+    void CallForHelp(Creature* creature, float radius)
     {
-        float radius = ALE::CHECKVAL<float>(L, 2);
-
         creature->CallForHelp(radius);
-        return 0;
     }
 
     /**
      * Make the [Creature] flee combat to get assistance from a nearby friendly [Creature].
      */
-    int FleeToGetAssistance(lua_State* /*L*/, Creature* creature)
+    void FleeToGetAssistance(Creature* creature)
     {
         creature->DoFleeToGetAssistance();
-        return 0;
     }
 
     /**
@@ -1219,21 +1058,18 @@ namespace LuaCreature
      *
      * @param [Unit] target
      */
-    int AttackStart(lua_State* L, Creature* creature)
+    void AttackStart(Creature* creature, Unit* target)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-
-        creature->AI()->AttackStart(target);
-        return 0;
+        if (creature->IsAIEnabled)
+            creature->AI()->AttackStart(target);
     }
 
     /**
      * Save the [Creature] in the database.
      */
-    int SaveToDB(lua_State* /*L*/, Creature* creature)
+    void SaveToDB(Creature* creature)
     {
         creature->SaveToDB();
-        return 0;
     }
 
     /**
@@ -1241,10 +1077,9 @@ namespace LuaCreature
      *
      * This should be called every update cycle for the Creature's AI.
      */
-    int SelectVictim(lua_State* L, Creature* creature)
+    Unit* SelectVictim(Creature* creature)
     {
-        ALE::Push(L, creature->SelectVictim());
-        return 1;
+        return creature->SelectVictim();
     }
 
     /**
@@ -1253,22 +1088,19 @@ namespace LuaCreature
      * @param uint32 entry : the Creature ID to transform into
      * @param uint32 dataGUIDLow = 0 : use this Creature's model and equipment instead of the defaults
      */
-    int UpdateEntry(lua_State* L, Creature* creature)
+    void UpdateEntry(Creature* creature, uint32 entry, sol::optional<uint32> dataGuidLowArg)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 dataGuidLow = ALE::CHECKVAL<uint32>(L, 3, 0);
+        uint32 dataGuidLow = dataGuidLowArg.value_or(0);
 
-        creature->UpdateEntry(entry, dataGuidLow ? eObjectMgr->GetCreatureData(dataGuidLow) : NULL);
-        return 0;
+        creature->UpdateEntry(entry, dataGuidLow ? sObjectMgr->GetCreatureData(dataGuidLow) : nullptr);
     }
 
     /**
      * Resets [Creature]'s loot mode to default
      */
-    int ResetLootMode(lua_State* /*L*/, Creature* creature) // TODO: Implement LootMode features
+    void ResetLootMode(Creature* creature) // TODO: Implement LootMode features
     {
         creature->ResetLootMode();
-        return 0;
     }
 
     /**
@@ -1276,12 +1108,9 @@ namespace LuaCreature
      *
      * @param uint16 lootMode
      */
-    int RemoveLootMode(lua_State* L, Creature* creature) // TODO: Implement LootMode features
+    void RemoveLootMode(Creature* creature, uint16 lootMode) // TODO: Implement LootMode features
     {
-        uint16 lootMode = ALE::CHECKVAL<uint16>(L, 2);
-
         creature->RemoveLootMode(lootMode);
-        return 0;
     }
 
     /**
@@ -1289,12 +1118,9 @@ namespace LuaCreature
      *
      * @param uint16 lootMode
      */
-    int AddLootMode(lua_State* L, Creature* creature) // TODO: Implement LootMode features
+    void AddLootMode(Creature* creature, uint16 lootMode) // TODO: Implement LootMode features
     {
-        uint16 lootMode = ALE::CHECKVAL<uint16>(L, 2);
-
         creature->AddLootMode(lootMode);
-        return 0;
     }
 
     /**
@@ -1351,15 +1177,15 @@ namespace LuaCreature
      *
      * @return [CreatureFamily] creatureFamily
      */
-    int GetCreatureFamily(lua_State* L, Creature* creature)
+    sol::optional<uint32> GetCreatureFamily(Creature* creature)
     {
         uint32 entry = creature->GetEntry();
 
         CreatureTemplate const* cInfo = sObjectMgr->GetCreatureTemplate(entry);
         if (cInfo)
-            ALE::Push(L, cInfo->family);
+            return cInfo->family;
 
-        return 1;
+        return sol::nullopt;
     }
 
     /**
@@ -1367,10 +1193,106 @@ namespace LuaCreature
      *
      * @return [Loot] loot : the loot object
      */
-    int GetLoot(lua_State* L, Creature* creature)
+    Loot* GetLoot(Creature* creature)
     {
-        ALE::Push(L, &creature->loot);
-        return 1;
+        return &creature->loot;
     }
-};
-#endif
+}
+
+void RegisterCreatureMethods(sol::state& lua)
+{
+    sol::usertype<CreatureRef> type = ALEBind::NewHandleType<CreatureRef, UnitRef, WorldObjectRef, ObjectRef>(lua, "Creature");
+
+    type["IsRegeneratingHealth"]              = ALEBind::Method(&LuaCreature::IsRegeneratingHealth);
+    type["SetRegeneratingHealth"]             = ALEBind::Method(&LuaCreature::SetRegeneratingHealth);
+    type["IsReputationGainDisabled"]          = ALEBind::Method(&LuaCreature::IsReputationGainDisabled);
+    type["CanCompleteQuest"]                  = ALEBind::Method(&LuaCreature::CanCompleteQuest);
+    type["IsTargetableForAttack"]             = ALEBind::Method(&LuaCreature::IsTargetableForAttack);
+    type["CanAssistTo"]                       = ALEBind::Method(&LuaCreature::CanAssistTo);
+    type["HasSearchedAssistance"]             = ALEBind::Method(&LuaCreature::HasSearchedAssistance);
+    type["IsTappedBy"]                        = ALEBind::Method(&LuaCreature::IsTappedBy);
+    type["HasLootRecipient"]                  = ALEBind::Method(&LuaCreature::HasLootRecipient);
+    type["CanAggro"]                          = ALEBind::Method(&LuaCreature::CanAggro);
+    type["CanSwim"]                           = ALEBind::Method(&LuaCreature::CanSwim);
+    type["CanWalk"]                           = ALEBind::Method(&LuaCreature::CanWalk);
+    type["IsInEvadeMode"]                     = ALEBind::Method(&LuaCreature::IsInEvadeMode);
+    type["IsElite"]                           = ALEBind::Method(&LuaCreature::IsElite);
+    type["IsGuard"]                           = ALEBind::Method(&LuaCreature::IsGuard);
+    type["IsCivilian"]                        = ALEBind::Method(&LuaCreature::IsCivilian);
+    type["IsRacialLeader"]                    = ALEBind::Method(&LuaCreature::IsRacialLeader);
+    type["IsDungeonBoss"]                     = ALEBind::Method(&LuaCreature::IsDungeonBoss);
+    type["IsWorldBoss"]                       = ALEBind::Method(&LuaCreature::IsWorldBoss);
+    type["HasCategoryCooldown"]               = ALEBind::Method(&LuaCreature::HasCategoryCooldown);
+    type["HasSpell"]                          = ALEBind::Method(&LuaCreature::HasSpell);
+    type["HasQuest"]                          = ALEBind::Method(&LuaCreature::HasQuest);
+    type["HasSpellCooldown"]                  = ALEBind::Method(&LuaCreature::HasSpellCooldown);
+    type["CanFly"]                            = ALEBind::Method(&LuaCreature::CanFly);
+    type["IsTrigger"]                         = ALEBind::Method(&LuaCreature::IsTrigger);
+    type["IsDamageEnoughForLootingAndReward"] = ALEBind::Method(&LuaCreature::IsDamageEnoughForLootingAndReward);
+    type["CanStartAttack"]                    = ALEBind::Method(&LuaCreature::CanStartAttack);
+    type["HasLootMode"]                       = ALEBind::Method(&LuaCreature::HasLootMode);
+    type["GetRespawnDelay"]                   = ALEBind::Method(&LuaCreature::GetRespawnDelay);
+    type["GetWanderRadius"]                   = ALEBind::Method(&LuaCreature::GetWanderRadius);
+    type["GetWaypointPath"]                   = ALEBind::Method(&LuaCreature::GetWaypointPath);
+    type["GetCurrentWaypointId"]              = ALEBind::Method(&LuaCreature::GetCurrentWaypointId);
+    type["GetSpawnId"]                        = ALEBind::Method(&LuaCreature::GetSpawnId);
+    type["GetDefaultMovementType"]            = ALEBind::Method(&LuaCreature::GetDefaultMovementType);
+    type["GetAggroRange"]                     = ALEBind::Method(&LuaCreature::GetAggroRange);
+    type["GetLootRecipientGroup"]             = ALEBind::Method(&LuaCreature::GetLootRecipientGroup);
+    type["GetLootRecipient"]                  = ALEBind::Method(&LuaCreature::GetLootRecipient);
+    type["GetScriptName"]                     = ALEBind::Method(&LuaCreature::GetScriptName);
+    type["GetAIName"]                         = ALEBind::Method(&LuaCreature::GetAIName);
+    type["GetScriptId"]                       = ALEBind::Method(&LuaCreature::GetScriptId);
+    type["GetCreatureSpellCooldownDelay"]     = ALEBind::Method(&LuaCreature::GetCreatureSpellCooldownDelay);
+    type["GetCorpseDelay"]                    = ALEBind::Method(&LuaCreature::GetCorpseDelay);
+    type["GetHomePosition"]                   = ALEBind::Method(&LuaCreature::GetHomePosition);
+    type["SetHomePosition"]                   = ALEBind::Method(&LuaCreature::SetHomePosition);
+    type["GetAITarget"]                       = ALEBind::Method(&LuaCreature::GetAITarget);
+    type["GetAITargets"]                      = ALEBind::Method(&LuaCreature::GetAITargets);
+    type["GetAITargetsCount"]                 = ALEBind::Method(&LuaCreature::GetAITargetsCount);
+    type["GetNPCFlags"]                       = ALEBind::Method(&LuaCreature::GetNPCFlags);
+    type["GetUnitFlags"]                      = ALEBind::Method(&LuaCreature::GetUnitFlags);
+    type["GetUnitFlagsTwo"]                   = ALEBind::Method(&LuaCreature::GetUnitFlagsTwo);
+    type["GetExtraFlags"]                     = ALEBind::Method(&LuaCreature::GetExtraFlags);
+    type["GetRank"]                           = ALEBind::Method(&LuaCreature::GetRank);
+    type["GetShieldBlockValue"]               = ALEBind::Method(&LuaCreature::GetShieldBlockValue);
+    type["GetLootMode"]                       = ALEBind::Method(&LuaCreature::GetLootMode);
+    type["GetDBTableGUIDLow"]                 = ALEBind::Method(&LuaCreature::GetDBTableGUIDLow);
+    type["GetReactState"]                     = ALEBind::Method(&LuaCreature::GetReactState);
+    type["SetNPCFlags"]                       = ALEBind::Method(&LuaCreature::SetNPCFlags);
+    type["SetUnitFlags"]                      = ALEBind::Method(&LuaCreature::SetUnitFlags);
+    type["SetUnitFlagsTwo"]                   = ALEBind::Method(&LuaCreature::SetUnitFlagsTwo);
+    type["SetReactState"]                     = ALEBind::Method(&LuaCreature::SetReactState);
+    type["SetDisableGravity"]                 = ALEBind::Method(&LuaCreature::SetDisableGravity);
+    type["SetLootMode"]                       = ALEBind::Method(&LuaCreature::SetLootMode);
+    type["SetDeathState"]                     = ALEBind::Method(&LuaCreature::SetDeathState);
+    type["SetWalk"]                           = ALEBind::Method(&LuaCreature::SetWalk);
+    type["SetEquipmentSlots"]                 = ALEBind::Method(&LuaCreature::SetEquipmentSlots);
+    type["SetAggroEnabled"]                   = ALEBind::Method(&LuaCreature::SetAggroEnabled);
+    type["SetDisableReputationGain"]          = ALEBind::Method(&LuaCreature::SetDisableReputationGain);
+    type["SetInCombatWithZone"]               = ALEBind::Method(&LuaCreature::SetInCombatWithZone);
+    type["SetWanderRadius"]                   = ALEBind::Method(&LuaCreature::SetWanderRadius);
+    type["SetRespawnDelay"]                   = ALEBind::Method(&LuaCreature::SetRespawnDelay);
+    type["SetDefaultMovementType"]            = ALEBind::Method(&LuaCreature::SetDefaultMovementType);
+    type["SetNoSearchAssistance"]             = ALEBind::Method(&LuaCreature::SetNoSearchAssistance);
+    type["SetNoCallAssistance"]               = ALEBind::Method(&LuaCreature::SetNoCallAssistance);
+    type["SetHover"]                          = ALEBind::Method(&LuaCreature::SetHover);
+    type["DespawnOrUnsummon"]                 = ALEBind::Method(&LuaCreature::DespawnOrUnsummon);
+    type["Respawn"]                           = ALEBind::Method(&LuaCreature::Respawn);
+    type["RemoveCorpse"]                      = ALEBind::Method(&LuaCreature::RemoveCorpse);
+    type["AllLootRemovedFromCorpse"]          = ALEBind::Method(&LuaCreature::AllLootRemovedFromCorpse);
+    type["SetCorpseDelay"]                    = ALEBind::Method(&LuaCreature::SetCorpseDelay);
+    type["MoveWaypoint"]                      = ALEBind::Method(&LuaCreature::MoveWaypoint);
+    type["CallAssistance"]                    = ALEBind::Method(&LuaCreature::CallAssistance);
+    type["CallForHelp"]                       = ALEBind::Method(&LuaCreature::CallForHelp);
+    type["FleeToGetAssistance"]               = ALEBind::Method(&LuaCreature::FleeToGetAssistance);
+    type["AttackStart"]                       = ALEBind::Method(&LuaCreature::AttackStart);
+    type["SaveToDB"]                          = ALEBind::Method(&LuaCreature::SaveToDB);
+    type["SelectVictim"]                      = ALEBind::Method(&LuaCreature::SelectVictim);
+    type["UpdateEntry"]                       = ALEBind::Method(&LuaCreature::UpdateEntry);
+    type["ResetLootMode"]                     = ALEBind::Method(&LuaCreature::ResetLootMode);
+    type["RemoveLootMode"]                    = ALEBind::Method(&LuaCreature::RemoveLootMode);
+    type["AddLootMode"]                       = ALEBind::Method(&LuaCreature::AddLootMode);
+    type["GetCreatureFamily"]                 = ALEBind::Method(&LuaCreature::GetCreatureFamily);
+    type["GetLoot"]                           = ALEBind::Method(&LuaCreature::GetLoot);
+}
diff --git a/src/LuaEngine/methods/GameObjectMethods.h b/src/LuaEngine/methods/GameObjectMethods.cpp
similarity index 59%
rename from src/LuaEngine/methods/GameObjectMethods.h
rename to src/LuaEngine/methods/GameObjectMethods.cpp
index 43e8ffd33d..b03725e994 100644
--- a/src/LuaEngine/methods/GameObjectMethods.h
+++ b/src/LuaEngine/methods/GameObjectMethods.cpp
@@ -4,8 +4,17 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef GAMEOBJECTMETHODS_H
-#define GAMEOBJECTMETHODS_H
+#include "ALEBind.h"
+
+#include "DatabaseEnv.h"
+#include "GameObject.h"
+#include "Item.h"
+#include "LootMgr.h"
+#include "ObjectAccessor.h"
+#include "ObjectMgr.h"
+#include "SharedDefines.h"
+#include "StringFormat.h"
+#include "Unit.h"
 
 /***
  * Represents a game object in the world, such as doors, chests, and other interactive objects.
@@ -20,12 +29,9 @@ namespace LuaGameObject
      * @param uint32 questId : quest entry Id to check
      * @return bool hasQuest
      */
-    int HasQuest(lua_State* L, GameObject* go)
+    bool HasQuest(GameObject* go, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, go->hasQuest(questId));
-        return 1;
+        return go->hasQuest(questId);
     }
 
     /**
@@ -33,10 +39,9 @@ namespace LuaGameObject
      *
      * @return bool isSpawned
      */
-    int IsSpawned(lua_State* L, GameObject* go)
+    bool IsSpawned(GameObject* go)
     {
-        ALE::Push(L, go->isSpawned());
-        return 1;
+        return go->isSpawned();
     }
 
     /**
@@ -44,10 +49,9 @@ namespace LuaGameObject
      *
      * @return bool isTransport
      */
-    int IsTransport(lua_State* L, GameObject* go)
+    bool IsTransport(GameObject* go)
     {
-        ALE::Push(L, go->IsTransport());
-        return 1;
+        return go->IsTransport();
     }
 
     /**
@@ -55,16 +59,14 @@ namespace LuaGameObject
      *
      * @return bool isActive
      */
-    int IsActive(lua_State* L, GameObject* go)
+    bool IsActive(GameObject* go)
     {
-        ALE::Push(L, go->isActiveObject());
-        return 1;
+        return go->isActiveObject();
     }
 
-    /*int IsDestructible(lua_State* L, GameObject* go) // TODO: Implementation core side
+    /*bool IsDestructible(GameObject* go) // TODO: Implementation core side
     {
-        ALE::Push(L, go->IsDestructibleBuilding());
-        return 1;
+        return go->IsDestructibleBuilding();
     }*/
 
     /**
@@ -72,10 +74,9 @@ namespace LuaGameObject
      *
      * @return uint32 displayId
      */
-    int GetDisplayId(lua_State* L, GameObject* go)
+    uint32 GetDisplayId(GameObject* go)
     {
-        ALE::Push(L, go->GetDisplayId());
-        return 1;
+        return go->GetDisplayId();
     }
 
     /**
@@ -93,10 +94,9 @@ namespace LuaGameObject
      *
      * @return [GOState] goState
      */
-    int GetGoState(lua_State* L, GameObject* go)
+    GOState GetGoState(GameObject* go)
     {
-        ALE::Push(L, go->GetGoState());
-        return 1;
+        return go->GetGoState();
     }
 
     /**
@@ -115,10 +115,9 @@ namespace LuaGameObject
      *
      * @return [LootState] lootState
      */
-    int GetLootState(lua_State* L, GameObject* go)
+    LootState GetLootState(GameObject* go)
     {
-        ALE::Push(L, go->getLootState());
-        return 1;
+        return go->getLootState();
     }
 
     /**
@@ -128,10 +127,9 @@ namespace LuaGameObject
      *
      * @return [Player] player
      */
-    int GetLootRecipient(lua_State* L, GameObject* go)
+    Player* GetLootRecipient(GameObject* go)
     {
-        ALE::Push(L, go->GetLootRecipient());
-        return 1;
+        return go->GetLootRecipient();
     }
 
     /**
@@ -141,10 +139,9 @@ namespace LuaGameObject
      *
      * @return [Group] group
      */
-    int GetLootRecipientGroup(lua_State* L, GameObject* go)
+    Group* GetLootRecipientGroup(GameObject* go)
     {
-        ALE::Push(L, go->GetLootRecipientGroup());
-        return 1;
+        return go->GetLootRecipientGroup();
     }
 
     /**
@@ -152,10 +149,9 @@ namespace LuaGameObject
     *
     * @return uint32 spawnId
     */
-    int GetSpawnId(lua_State* L, GameObject* go)
+    uint32 GetSpawnId(GameObject* go)
     {
-        ALE::Push(L, go->GetSpawnId());
-        return 1;
+        return go->GetSpawnId();
     }
 
     /**
@@ -172,9 +168,9 @@ namespace LuaGameObject
      *
      * @param [GOState] state : all available go states can be seen above
      */
-    int SetGoState(lua_State* L, GameObject* go)
+    void SetGoState(GameObject* go, sol::optional<uint32> stateArg)
     {
-        uint32 state = ALE::CHECKVAL<uint32>(L, 2, 0);
+        uint32 state = stateArg.value_or(0);
 
         if (state == 0)
             go->SetGoState(GO_STATE_ACTIVE);
@@ -182,8 +178,6 @@ namespace LuaGameObject
             go->SetGoState(GO_STATE_READY);
         else if (state == 2)
             go->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
-
-        return 0;
     }
 
     /**
@@ -202,9 +196,9 @@ namespace LuaGameObject
      *
      * @param [LootState] state : all available loot states can be seen above
      */
-    int SetLootState(lua_State* L, GameObject* go)
+    void SetLootState(GameObject* go, sol::optional<uint32> stateArg)
     {
-        uint32 state = ALE::CHECKVAL<uint32>(L, 2, 0);
+        uint32 state = stateArg.value_or(0);
 
         if (state == 0)
             go->SetLootState(GO_NOT_READY);
@@ -214,8 +208,6 @@ namespace LuaGameObject
             go->SetLootState(GO_ACTIVATED);
         else if (state == 3)
             go->SetLootState(GO_JUST_DEACTIVATED);
-
-        return 0;
     }
 
     /**
@@ -226,53 +218,55 @@ namespace LuaGameObject
     * @param uint32 amount = 1 : amount of the [Item] to add to the loot
     * @return uint32 itemGUIDlow : low GUID of the [Item]
     */
-    int AddLoot(lua_State* L, GameObject* go)
+    sol::variadic_results AddLoot(GameObject* go, sol::variadic_args args, sol::this_state s)
     {
-        int i = 1;
-        int argAmount = lua_gettop(L);
+        sol::state_view lua(s);
+        sol::variadic_results results;
 
-        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
-
-        uint8 addedItems = 0;
-        while (i + 2 <= argAmount)
+        // Validate every (entry, amount) pair before touching the DB or the
+        // loot, so an invalid pair cannot abort the call halfway through.
+        std::vector<std::pair<uint32, uint32>> lootItems;
+        for (std::size_t i = 0; i < args.size(); i += 2)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, ++i);
-            uint32 amount = ALE::CHECKVAL<uint32>(L, ++i);
+            uint32 entry = args[i].as<uint32>();
+            // A trailing entry without amount gets the documented default (1).
+            uint32 amount = i + 1 < args.size() ? args[i + 1].as<uint32>() : 1;
 
-            ItemTemplate const* item_proto = eObjectMgr->GetItemTemplate(entry);
+            ItemTemplate const* item_proto = sObjectMgr->GetItemTemplate(entry);
             if (!item_proto)
-            {
-                luaL_error(L, "Item entry %d does not exist", entry);
-                continue;
-            }
+                throw std::runtime_error(Acore::StringFormat("Item entry {} does not exist", entry));
+
             if (amount < 1 || (item_proto->MaxCount > 0 && amount > uint32(item_proto->MaxCount)))
-            {
-                luaL_error(L, "Item entry %d has invalid amount %d", entry, amount);
-                continue;
-            }
+                throw std::runtime_error(Acore::StringFormat("Item entry {} has invalid amount {}", entry, amount));
+
+            lootItems.emplace_back(entry, amount);
+        }
+
+        CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
+
+        for (auto const& [entry, amount] : lootItems)
+        {
             if (Item* item = Item::CreateItem(entry, amount))
             {
                 item->SaveToDB(trans);
                 LootStoreItem storeItem(item->GetEntry(), 0, 100, 0, LOOT_MODE_DEFAULT, 0, item->GetCount(), item->GetCount());
                 go->loot.AddItem(storeItem);
-                ALE::Push(L, item->GetGUID().GetCounter());
-                ++addedItems;
+                results.push_back(sol::make_object(lua, item->GetGUID().GetCounter()));
             }
         }
 
         CharacterDatabase.CommitTransaction(trans);
 
-        return addedItems;
+        return results;
     }
 
     /**
      * Saves [GameObject] to the database
      *
      */
-    int SaveToDB(lua_State* /*L*/, GameObject* go)
+    void SaveToDB(GameObject* go)
     {
         go->SaveToDB();
-        return 0;
     }
 
     /**
@@ -282,17 +276,17 @@ namespace LuaGameObject
      *
      * @param bool deleteFromDB : if true, it will delete the [GameObject] from the database
      */
-    int RemoveFromWorld(lua_State* L, GameObject* go)
+    void RemoveFromWorld(GameObject* go, sol::optional<bool> deleteFromDB)
     {
-        bool deldb = ALE::CHECKVAL<bool>(L, 2, false);
+        bool deldb = deleteFromDB.value_or(false);
 
         // cs_gobject.cpp copy paste
         ObjectGuid ownerGuid = go->GetOwnerGUID();
         if (ownerGuid)
         {
-            Unit* owner = eObjectAccessor()GetUnit(*go, ownerGuid);
+            Unit* owner = ObjectAccessor::GetUnit(*go, ownerGuid);
             if (!owner || !ownerGuid.IsPlayer())
-                return 0;
+                return;
 
             owner->RemoveGameObject(go, false);
         }
@@ -302,9 +296,6 @@ namespace LuaGameObject
 
         go->SetRespawnTime(0);
         go->Delete();
-
-        ALE::CHECKOBJ<ALEObject>(L, 1)->Invalidate();
-        return 0;
     }
 
     /**
@@ -312,12 +303,9 @@ namespace LuaGameObject
      *
      * @param uint32 delay = 0 : cooldown time in seconds to restore the [GameObject] back to normal. 0 for infinite duration
      */
-    int UseDoorOrButton(lua_State* L, GameObject* go)
+    void UseDoorOrButton(GameObject* go, sol::optional<uint32> delay)
     {
-        uint32 delay = ALE::CHECKVAL<uint32>(L, 2, 0);
-
-        go->UseDoorOrButton(delay);
-        return 0;
+        go->UseDoorOrButton(delay.value_or(0));
     }
 
     /**
@@ -325,19 +313,17 @@ namespace LuaGameObject
      *
      * The gameobject may be automatically respawned by the core
      */
-    int Despawn(lua_State* /*L*/, GameObject* go)
+    void Despawn(GameObject* go)
     {
         go->SetLootState(GO_JUST_DEACTIVATED);
-        return 0;
     }
 
     /**
      * Respawns a [GameObject]
      */
-    int Respawn(lua_State* /*L*/, GameObject* go)
+    void Respawn(GameObject* go)
     {
         go->Respawn();
-        return 0;
     }
 
     /**
@@ -347,12 +333,9 @@ namespace LuaGameObject
      *
      * @param int32 delay = 0 : cooldown time in seconds to respawn or despawn the object. 0 means never
      */
-    int SetRespawnTime(lua_State* L, GameObject* go)
+    void SetRespawnTime(GameObject* go, int32 respawn)
     {
-        int32 respawn = ALE::CHECKVAL<int32>(L, 2);
-
         go->SetRespawnTime(respawn);
-        return 0;
     }
 
     /**
@@ -362,12 +345,34 @@ namespace LuaGameObject
      *
      * @param int32 delay = 0 : cooldown time in seconds to respawn or despawn the object. 0 means never
      */
-    int SetRespawnDelay(lua_State* L, GameObject* go)
+    void SetRespawnDelay(GameObject* go, int32 respawn)
     {
-        int32 respawn = ALE::CHECKVAL<int32>(L, 2);
-
         go->SetRespawnDelay(respawn);
-        return 0;
     }
-};
-#endif
+}
+
+void RegisterGameObjectMethods(sol::state& lua)
+{
+    sol::usertype<GameObjectRef> type = ALEBind::NewHandleType<GameObjectRef, WorldObjectRef, ObjectRef>(lua, "GameObject");
+
+    type["HasQuest"]              = ALEBind::Method(&LuaGameObject::HasQuest);
+    type["IsSpawned"]             = ALEBind::Method(&LuaGameObject::IsSpawned);
+    type["IsTransport"]           = ALEBind::Method(&LuaGameObject::IsTransport);
+    type["IsActive"]              = ALEBind::Method(&LuaGameObject::IsActive);
+    type["GetDisplayId"]          = ALEBind::Method(&LuaGameObject::GetDisplayId);
+    type["GetGoState"]            = ALEBind::Method(&LuaGameObject::GetGoState);
+    type["GetLootState"]          = ALEBind::Method(&LuaGameObject::GetLootState);
+    type["GetLootRecipient"]      = ALEBind::Method(&LuaGameObject::GetLootRecipient);
+    type["GetLootRecipientGroup"] = ALEBind::Method(&LuaGameObject::GetLootRecipientGroup);
+    type["GetSpawnId"]            = ALEBind::Method(&LuaGameObject::GetSpawnId);
+    type["SetGoState"]            = ALEBind::Method(&LuaGameObject::SetGoState);
+    type["SetLootState"]          = ALEBind::Method(&LuaGameObject::SetLootState);
+    type["AddLoot"]               = ALEBind::Method(&LuaGameObject::AddLoot);
+    type["SaveToDB"]              = ALEBind::Method(&LuaGameObject::SaveToDB);
+    type["RemoveFromWorld"]       = ALEBind::Method(&LuaGameObject::RemoveFromWorld);
+    type["UseDoorOrButton"]       = ALEBind::Method(&LuaGameObject::UseDoorOrButton);
+    type["Despawn"]               = ALEBind::Method(&LuaGameObject::Despawn);
+    type["Respawn"]               = ALEBind::Method(&LuaGameObject::Respawn);
+    type["SetRespawnTime"]        = ALEBind::Method(&LuaGameObject::SetRespawnTime);
+    type["SetRespawnDelay"]       = ALEBind::Method(&LuaGameObject::SetRespawnDelay);
+}
diff --git a/src/LuaEngine/methods/GemPropertiesEntryMethods.h b/src/LuaEngine/methods/GemPropertiesEntryMethods.cpp
similarity index 59%
rename from src/LuaEngine/methods/GemPropertiesEntryMethods.h
rename to src/LuaEngine/methods/GemPropertiesEntryMethods.cpp
index b76edae2b9..47201472de 100644
--- a/src/LuaEngine/methods/GemPropertiesEntryMethods.h
+++ b/src/LuaEngine/methods/GemPropertiesEntryMethods.cpp
@@ -4,8 +4,10 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef GEMPROPERTIESENTRYMETHODS_H
-#define GEMPROPERTIESENTRYMETHODS_H
+#include "ALEBind.h"
+
+#include "Common.h"
+#include "DBCStructure.h"
 
 /***
  * Represents static gem data used in item enhancement, including spell enchantments triggered by socketed gems.
@@ -20,15 +22,11 @@ namespace LuaGemPropertiesEntry
     /**
      * Returns the ID of a [GemPropertiesEntry].
      *
-     * This method retrieves the ID from a given GemPropertiesEntry instance 
-     * and pushes it onto the Lua stack.
-     *
      * @return uint32 id : The ID of the specified GemPropertiesEntry.
      */
-    int GetId(lua_State* L, GemPropertiesEntry* gemProperties)
+    uint32 GetId(GemPropertiesEntry* gempropertiesentry)
     {
-        ALE::Push(L, gemProperties->ID);
-        return 1;
+        return gempropertiesentry->ID;
     }
 
     /**
@@ -38,11 +36,16 @@ namespace LuaGemPropertiesEntry
      *
      * @return uint32 spellitemenchantement : The spell item enchantment ID.
      */
-    int GetSpellItemEnchantement(lua_State* L, GemPropertiesEntry* entry)
+    uint32 GetSpellItemEnchantement(GemPropertiesEntry* gempropertiesentry)
     {
-        ALE::Push(L, entry->spellitemenchantement);
-        return 1;
+        return gempropertiesentry->spellitemenchantement;
     }
 }
-#endif
 
+void RegisterGemPropertiesEntryMethods(sol::state& lua)
+{
+    sol::usertype<GemPropertiesEntry> type = lua.new_usertype<GemPropertiesEntry>("GemPropertiesEntry", sol::no_constructor);
+
+    type["GetId"]                    = &LuaGemPropertiesEntry::GetId;
+    type["GetSpellItemEnchantement"] = &LuaGemPropertiesEntry::GetSpellItemEnchantement;
+}
diff --git a/src/LuaEngine/methods/GlobalMethods.h b/src/LuaEngine/methods/GlobalMethods.cpp
similarity index 71%
rename from src/LuaEngine/methods/GlobalMethods.h
rename to src/LuaEngine/methods/GlobalMethods.cpp
index cebb7bc6d6..b4b21b262a 100644
--- a/src/LuaEngine/methods/GlobalMethods.h
+++ b/src/LuaEngine/methods/GlobalMethods.cpp
@@ -4,18 +4,45 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef GLOBALMETHODS_H
-#define GLOBALMETHODS_H
+#include "ALEBind.h"
+#include "LuaEngine.h"
 
-#include "BindingMap.h"
 #include "ALEDBCRegistry.h"
+#include "ALEEventMgr.h"
 
 #include "BanMgr.h"
+#include "Config.h"
+#include "DatabaseEnv.h"
+#include "GameEventMgr.h"
+#include "GameObject.h"
 #include "GameTime.h"
-#include "SharedDefines.h"
+#include "GitRevision.h"
+#include "GuildMgr.h"
+#include "Mail.h"
+#include "MapMgr.h"
+#include "ObjectAccessor.h"
+#include "ObjectDefines.h"
+#include "ObjectMgr.h"
+#include "Opcodes.h"
 #include "OutdoorPvPMgr.h"
+#include "QueryCallback.h"
+#include "SharedDefines.h"
+#include "SpellMgr.h"
+#include "StringConvert.h"
+#include "StringFormat.h"
+#include "TemporarySummon.h"
+#include "Util.h"
+#include "WorldPacket.h"
+#include "WorldSessionMgr.h"
 #include "../../../../src/server/scripts/OutdoorPvP/OutdoorPvPNA.h"
 
+#include <algorithm>
+#include <cctype>
+#include <functional>
+#include <list>
+#include <shared_mutex>
+#include <sstream>
+#include <string>
 
 enum BanMode
 {
@@ -36,10 +63,9 @@ namespace LuaGlobalFunctions
      *
      * @return string engineName
      */
-    int GetLuaEngine(lua_State* L)
+    char const* GetLuaEngine()
     {
-        ALE::Push(L, "ALEEngine");
-        return 1;
+        return "ALEEngine";
     }
 
     /**
@@ -49,10 +75,9 @@ namespace LuaGlobalFunctions
      *
      * @return string coreName
      */
-    int GetCoreName(lua_State* L)
+    char const* GetCoreName()
     {
-        ALE::Push(L, CORE_NAME);
-        return 1;
+        return "AzerothCore";
     }
 
     /**
@@ -61,41 +86,28 @@ namespace LuaGlobalFunctions
      * @param string name : name of the value
      * @return string value
      */
-    int GetConfigValue(lua_State* L)
+    sol::object GetConfigValue(std::string key, sol::this_state s)
     {
-        const char* key = ALE::CHECKVAL<const char*>(L, 1);
-        if (!key) return 0;
-        
+        sol::state_view lua(s);
+
         std::string val = sConfigMgr->GetOption<std::string>(key, "", false);
 
         if (val.empty())
-        {
-            ALE::Push(L, val);
-            return 1;
-        }
+            return sol::make_object(lua, val);
 
         std::string lower = val;
         std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
-        
+
         if (lower == "true")
-        {
-            ALE::Push(L, true);
-            return 1;
-        }
+            return sol::make_object(lua, true);
         else if (lower == "false")
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
-        
+            return sol::make_object(lua, false);
+
         auto intVal = Acore::StringTo<uint32>(val);
-        if (intVal) {
-            ALE::Push(L, *intVal);
-            return 1;
-        }
-        
-        ALE::Push(L, val);
-        return 1;
+        if (intVal)
+            return sol::make_object(lua, *intVal);
+
+        return sol::make_object(lua, val);
     }
 
     /**
@@ -105,10 +117,9 @@ namespace LuaGlobalFunctions
      * - for TrinityCore returns the realmID as it is in the conf file.
      * @return uint32 realm ID
      */
-    int GetRealmID(lua_State* L)
+    uint32 GetRealmID()
     {
-        ALE::Push(L, sConfigMgr->GetOption<uint32>("RealmID", 1));
-        return 1;
+        return sConfigMgr->GetOption<uint32>("RealmID", 1);
     }
 
     /**
@@ -120,10 +131,9 @@ namespace LuaGlobalFunctions
      *
      * @return string version
      */
-    int GetCoreVersion(lua_State* L)
+    char const* GetCoreVersion()
     {
-        ALE::Push(L, CORE_VERSION);
-        return 1;
+        return GitRevision::GetFullVersion();
     }
 
     /**
@@ -133,22 +143,20 @@ namespace LuaGlobalFunctions
      *
      * @return int32 expansion
      */
-    int GetCoreExpansion(lua_State* L)
+    int32 GetCoreExpansion()
     {
-        ALE::Push(L, 2);
-        return 1;
+        return 2;
     }
-    
+
     /**
      * Returns the [Map] pointer of the Lua state. Returns null for the "World" state. 
      *
      * @return [Map] map
      */
-    int GetStateMap(lua_State* L)
+    Map* GetStateMap()
     {
         // Until AC supports multistate, this will always return nil
-        ALE::Push(L);
-        return 1;
+        return nullptr;
     }
 
     /**
@@ -156,11 +164,10 @@ namespace LuaGlobalFunctions
      *
      * @return int32 mapId
      */
-    int GetStateMapId(lua_State* L)
+    int32 GetStateMapId()
     {
         // Until AC supports multistate, this will always return -1
-        ALE::Push(L, -1);
-        return 1;
+        return -1;
     }
 
     /**
@@ -168,11 +175,10 @@ namespace LuaGlobalFunctions
      *
      * @return uint32 instanceId
      */
-    int GetStateInstanceId(lua_State* L)
+    uint32 GetStateInstanceId()
     {
         // Until AC supports multistate, this will always return 0
-        ALE::Push(L, 0);
-        return 1;
+        return 0;
     }
 
     /**
@@ -181,12 +187,9 @@ namespace LuaGlobalFunctions
      * @param uint32 questId : [Quest] entry ID
      * @return [Quest] quest
      */
-    int GetQuest(lua_State* L)
+    Quest* GetQuest(uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 1);
-
-        ALE::Push(L, eObjectMgr->GetQuestTemplate(questId));
-        return 1;
+        return const_cast<Quest*>(sObjectMgr->GetQuestTemplate(questId));
     }
 
     /**
@@ -195,11 +198,9 @@ namespace LuaGlobalFunctions
      * @param ObjectGuid guid : guid of the [Player], you can get it with [Object:GetGUID]
      * @return [Player] player
      */
-    int GetPlayerByGUID(lua_State* L)
+    Player* GetPlayerByGUID(ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-        ALE::Push(L, eObjectAccessor()FindPlayer(guid));
-        return 1;
+        return ObjectAccessor::FindPlayer(guid);
     }
 
     /**
@@ -208,11 +209,9 @@ namespace LuaGlobalFunctions
      * @param string name : name of the [Player]
      * @return [Player] player
      */
-    int GetPlayerByName(lua_State* L)
+    Player* GetPlayerByName(std::string name)
     {
-        const char* name = ALE::CHECKVAL<const char*>(L, 1);
-        ALE::Push(L, eObjectAccessor()FindPlayerByName(name));
-        return 1;
+        return ObjectAccessor::FindPlayerByName(name);
     }
 
     /**
@@ -220,10 +219,9 @@ namespace LuaGlobalFunctions
      *
      * @return uint32 time
      */
-    int GetGameTime(lua_State* L)
+    int64 GetGameTime()
     {
-        ALE::Push(L, GameTime::GetGameTime().count());
-        return 1;
+        return GameTime::GetGameTime().count();
     }
 
     /**
@@ -242,18 +240,17 @@ namespace LuaGlobalFunctions
      * @param bool onlyGM = false : optional check if GM only
      * @return table worldPlayers
      */
-    int GetPlayersInWorld(lua_State* L)
+    sol::table GetPlayersInWorld(sol::optional<uint32> teamArg, sol::optional<bool> onlyGMArg, sol::this_state s)
     {
-        uint32 team = ALE::CHECKVAL<uint32>(L, 1, TEAM_NEUTRAL);
-        bool onlyGM = ALE::CHECKVAL<bool>(L, 2, false);
+        uint32 team = teamArg.value_or(TEAM_NEUTRAL);
+        bool onlyGM = onlyGMArg.value_or(false);
 
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         {
             std::shared_lock<std::shared_mutex> lock(*HashMapHolder<Player>::GetLock());
-            const HashMapHolder<Player>::MapType& m = eObjectAccessor()GetPlayers();
+            const HashMapHolder<Player>::MapType& m = ObjectAccessor::GetPlayers();
             for (HashMapHolder<Player>::MapType::const_iterator it = m.begin(); it != m.end(); ++it)
             {
                 if (Player* player = it->second)
@@ -262,16 +259,12 @@ namespace LuaGlobalFunctions
                         continue;
 
                     if ((team == TEAM_NEUTRAL || player->GetTeamId() == team) && (!onlyGM || player->IsGameMaster()))
-                    {
-                        ALE::Push(L, player);
-                        lua_rawseti(L, tbl, ++i);
-                    }
+                        tbl[++i] = PlayerRef(player);
                 }
             }
         }
 
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+        return tbl;
     }
 
     /**
@@ -280,11 +273,9 @@ namespace LuaGlobalFunctions
      * @param string name
      * @return [Guild] guild : the Guild, or `nil` if it doesn't exist
      */
-    int GetGuildByName(lua_State* L)
+    Guild* GetGuildByName(std::string name)
     {
-        const char* name = ALE::CHECKVAL<const char*>(L, 1);
-        ALE::Push(L, eGuildMgr->GetGuildByName(name));
-        return 1;
+        return sGuildMgr->GetGuildByName(name);
     }
 
     /**
@@ -294,13 +285,11 @@ namespace LuaGlobalFunctions
      * @param uint32 instanceId = 0 : required if the map is an instance, otherwise don't pass anything
      * @return [Map] map : the Map, or `nil` if it doesn't exist
      */
-    int GetMapById(lua_State* L)
+    Map* GetMapById(uint32 mapid, sol::optional<uint32> instanceArg)
     {
-        uint32 mapid = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 instance = ALE::CHECKVAL<uint32>(L, 2, 0);
+        uint32 instance = instanceArg.value_or(0);
 
-        ALE::Push(L, eMapMgr->FindMap(mapid, instance));
-        return 1;
+        return sMapMgr->FindMap(mapid, instance);
     }
 
     /**
@@ -309,12 +298,9 @@ namespace LuaGlobalFunctions
      * @param ObjectGuid guid : the guid of a [Guild] leader
      * @return [Guild] guild, or `nil` if it doesn't exist
      */
-    int GetGuildByLeaderGUID(lua_State* L)
+    Guild* GetGuildByLeaderGUID(ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-
-        ALE::Push(L, eGuildMgr->GetGuildByLeader(guid));
-        return 1;
+        return sGuildMgr->GetGuildByLeader(guid);
     }
 
     /**
@@ -322,10 +308,9 @@ namespace LuaGlobalFunctions
      *
      * @return uint32 count
      */
-    int GetPlayerCount(lua_State* L)
+    uint32 GetPlayerCount()
     {
-        ALE::Push(L, eWorldSessionMgr->GetActiveSessionCount());
-        return 1;
+        return sWorldSessionMgr->GetActiveSessionCount();
     }
 
     /**
@@ -338,11 +323,9 @@ namespace LuaGlobalFunctions
      * @param uint32 lowguid : low GUID of the [Player]
      * @return ObjectGuid guid
      */
-    int GetPlayerGUID(lua_State* L)
+    ObjectGuid GetPlayerGUID(uint32 lowguid)
     {
-        uint32 lowguid = ALE::CHECKVAL<uint32>(L, 1);
-        ALE::Push(L, MAKE_NEW_GUID(lowguid, 0, HIGHGUID_PLAYER));
-        return 1;
+        return ObjectGuid(HighGuid::Player, 0, lowguid);
     }
 
     /**
@@ -354,11 +337,9 @@ namespace LuaGlobalFunctions
      * @param uint32 lowguid : low GUID of the [Item]
      * @return ObjectGuid guid
      */
-    int GetItemGUID(lua_State* L)
+    ObjectGuid GetItemGUID(uint32 lowguid)
     {
-        uint32 lowguid = ALE::CHECKVAL<uint32>(L, 1);
-        ALE::Push(L, MAKE_NEW_GUID(lowguid, 0, HIGHGUID_ITEM));
-        return 1;
+        return ObjectGuid(HighGuid::Item, 0, lowguid);
     }
 
     /**
@@ -367,11 +348,9 @@ namespace LuaGlobalFunctions
     * @param uint32 itemID : the item entry ID from `item_template` to look up
     * @return [ItemTemplate] itemTemplate
     */
-    int GetItemTemplate(lua_State* L)
+    ItemTemplate* GetItemTemplate(uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-        ALE::Push(L, eObjectMgr->GetItemTemplate(entry));
-        return 1;
+        return const_cast<ItemTemplate*>(sObjectMgr->GetItemTemplate(entry));
     }
 
     /**
@@ -385,12 +364,9 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : entry ID of the [GameObject]
      * @return ObjectGuid guid
      */
-    int GetObjectGUID(lua_State* L)
+    ObjectGuid GetObjectGUID(uint32 lowguid, uint32 entry)
     {
-        uint32 lowguid = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, MAKE_NEW_GUID(lowguid, entry, HIGHGUID_GAMEOBJECT));
-        return 1;
+        return ObjectGuid(HighGuid::GameObject, entry, lowguid);
     }
 
     /**
@@ -404,12 +380,9 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : entry ID of the [Creature]
      * @return ObjectGuid guid
      */
-    int GetUnitGUID(lua_State* L)
+    ObjectGuid GetUnitGUID(uint32 lowguid, uint32 entry)
     {
-        uint32 lowguid = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, MAKE_NEW_GUID(lowguid, entry, HIGHGUID_UNIT));
-        return 1;
+        return ObjectGuid(HighGuid::Unit, entry, lowguid);
     }
 
     /**
@@ -431,12 +404,9 @@ namespace LuaGlobalFunctions
      * @param ObjectGuid guid : GUID of an [Object]
      * @return uint32 lowguid : low GUID of the [Object]
      */
-    int GetGUIDLow(lua_State* L)
+    uint32 GetGUIDLow(ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-
-        ALE::Push(L, guid.GetCounter());
-        return 1;
+        return guid.GetCounter();
     }
 
     /**
@@ -459,19 +429,18 @@ namespace LuaGlobalFunctions
      * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the [Item] name in
      * @return string itemLink
      */
-    int GetItemLink(lua_State* L)
+    std::string GetItemLink(uint32 entry, sol::optional<uint8> localeArg)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 2, DEFAULT_LOCALE);
+        uint8 locale = localeArg.value_or(DEFAULT_LOCALE);
         if (locale >= TOTAL_LOCALES)
-            return luaL_argerror(L, 2, "valid LocaleConstant expected");
+            throw std::invalid_argument("valid LocaleConstant expected");
 
-        const ItemTemplate* temp = eObjectMgr->GetItemTemplate(entry);
+        const ItemTemplate* temp = sObjectMgr->GetItemTemplate(entry);
         if (!temp)
-            return luaL_argerror(L, 1, "valid ItemEntry expected");
+            throw std::invalid_argument("valid ItemEntry expected");
 
         std::string name = temp->Name1;
-        if (ItemLocale const* il = eObjectMgr->GetItemLocale(entry))
+        if (ItemLocale const* il = sObjectMgr->GetItemLocale(entry))
             ObjectMgr::GetLocaleString(il->Name, static_cast<LocaleConstant>(locale), name);
 
         std::ostringstream oss;
@@ -480,8 +449,7 @@ namespace LuaGlobalFunctions
             "0:0:0:0:" <<
             "0:0:0:0|h[" << name << "]|h|r";
 
-        ALE::Push(L, oss.str());
-        return 1;
+        return oss.str();
     }
 
     /**
@@ -494,11 +462,9 @@ namespace LuaGlobalFunctions
      * @param ObjectGuid guid : GUID of an [Object]
      * @return int32 typeId : type ID of the [Object]
      */
-    int GetGUIDType(lua_State* L)
+    int32 GetGUIDType(ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-        ALE::Push(L, static_cast<int>(guid.GetHigh()));
-        return 1;
+        return static_cast<int>(guid.GetHigh());
     }
 
     /**
@@ -509,11 +475,9 @@ namespace LuaGlobalFunctions
      * @param ObjectGuid guid : GUID of an [Creature] or [GameObject]
      * @return uint32 entry : entry ID, or `0` if `guid` is not a [Creature] or [GameObject]
      */
-    int GetGUIDEntry(lua_State* L)
+    uint32 GetGUIDEntry(ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-        ALE::Push(L, guid.GetEntry());
-        return 1;
+        return guid.GetEntry();
     }
 
     /**
@@ -522,12 +486,10 @@ namespace LuaGlobalFunctions
      * @param ObjectGuid guid : the ObjectGuid to get packed size for
      * @return number size
      */
-    int GetPackedGUIDSize(lua_State* L)
+    int32 GetPackedGUIDSize(ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
         PackedGuid packedGuid(guid);
-        ALE::Push(L, static_cast<int>(packedGuid.size()));
-        return 1;
+        return static_cast<int>(packedGuid.size());
     }
 
     /**
@@ -550,20 +512,18 @@ namespace LuaGlobalFunctions
      * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the name in
      * @return string areaOrZoneName
      */
-    int GetAreaName(lua_State* L)
+    char const* GetAreaName(uint32 areaOrZoneId, sol::optional<uint8> localeArg)
     {
-        uint32 areaOrZoneId = ALE::CHECKVAL<uint32>(L, 1);
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 2, DEFAULT_LOCALE);
+        uint8 locale = localeArg.value_or(DEFAULT_LOCALE);
         if (locale >= TOTAL_LOCALES)
-            return luaL_argerror(L, 2, "valid LocaleConstant expected");
+            throw std::invalid_argument("valid LocaleConstant expected");
 
         AreaTableEntry const* areaEntry = sAreaTableStore.LookupEntry(areaOrZoneId);
 
         if (!areaEntry)
-            return luaL_argerror(L, 1, "valid Area or Zone ID expected");
+            throw std::invalid_argument("valid Area or Zone ID expected");
 
-        ALE::Push(L, areaEntry->area_name[locale]);
-        return 1;
+        return areaEntry->area_name[locale];
     }
 
     /**
@@ -571,71 +531,35 @@ namespace LuaGlobalFunctions
      *
      * @return table activeEvents
      */
-    int GetActiveGameEvents(lua_State* L)
+    sol::table GetActiveGameEvents(sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 counter = 1;
-        GameEventMgr::ActiveEvents const& activeEvents = eGameEventMgr->GetActiveEventList();
+        GameEventMgr::ActiveEvents const& activeEvents = sGameEventMgr->GetActiveEventList();
 
         for (GameEventMgr::ActiveEvents::const_iterator i = activeEvents.begin(); i != activeEvents.end(); ++i)
         {
-            ALE::Push(L, *i);
-            lua_rawseti(L, tbl, counter);
+            tbl[counter] = *i;
 
             counter++;
         }
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
-    static int RegisterEntryHelper(lua_State* L, int regtype)
+    static sol::object RegisterEntryHelper(uint8 regtype, uint32 id, uint32 ev, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 ev = ALE::CHECKVAL<uint32>(L, 2);
-        luaL_checktype(L, 3, LUA_TFUNCTION);
-        uint32 shots = ALE::CHECKVAL<uint32>(L, 4, 0);
-
-        lua_pushvalue(L, 3);
-        int functionRef = luaL_ref(L, LUA_REGISTRYINDEX);
-        if (functionRef >= 0)
-            return ALE::GetALE(L)->Register(L, regtype, id, ObjectGuid(), 0, ev, functionRef, shots);
-        else
-            luaL_argerror(L, 3, "unable to make a ref to function");
-        return 0;
+        return sALE->Register(regtype, id, ObjectGuid::Empty, 0, ev, std::move(callback), shots.value_or(0));
     }
 
-    static int RegisterEventHelper(lua_State* L, int regtype)
+    static sol::object RegisterEventHelper(uint8 regtype, uint32 ev, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        uint32 ev = ALE::CHECKVAL<uint32>(L, 1);
-        luaL_checktype(L, 2, LUA_TFUNCTION);
-        uint32 shots = ALE::CHECKVAL<uint32>(L, 3, 0);
-
-        lua_pushvalue(L, 2);
-        int functionRef = luaL_ref(L, LUA_REGISTRYINDEX);
-        if (functionRef >= 0)
-            return ALE::GetALE(L)->Register(L, regtype, 0, ObjectGuid(), 0, ev, functionRef, shots);
-        else
-            luaL_argerror(L, 2, "unable to make a ref to function");
-        return 0;
+        return sALE->Register(regtype, 0, ObjectGuid::Empty, 0, ev, std::move(callback), shots.value_or(0));
     }
 
-    static int RegisterUniqueHelper(lua_State* L, int regtype)
+    static sol::object RegisterUniqueHelper(uint8 regtype, ObjectGuid guid, uint32 instanceId, uint32 ev, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-        uint32 instanceId = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 ev = ALE::CHECKVAL<uint32>(L, 3);
-        luaL_checktype(L, 4, LUA_TFUNCTION);
-        uint32 shots = ALE::CHECKVAL<uint32>(L, 5, 0);
-
-        lua_pushvalue(L, 4);
-        int functionRef = luaL_ref(L, LUA_REGISTRYINDEX);
-        if (functionRef >= 0)
-            return ALE::GetALE(L)->Register(L, regtype, 0, guid, instanceId, ev, functionRef, shots);
-        else
-            luaL_argerror(L, 4, "unable to make a ref to function");
-        return 0;
+        return sALE->Register(regtype, 0, guid, instanceId, ev, std::move(callback), shots.value_or(0));
     }
 
     /**
@@ -708,9 +632,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterServerEvent(lua_State* L)
+    sol::object RegisterServerEvent(uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEventHelper(L, Hooks::REGTYPE_SERVER);
+        return RegisterEventHelper(Hooks::REGTYPE_SERVER, event, std::move(callback), shots);
     }
 
     /**
@@ -806,9 +730,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterPlayerEvent(lua_State* L)
+    sol::object RegisterPlayerEvent(uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEventHelper(L, Hooks::REGTYPE_PLAYER);
+        return RegisterEventHelper(Hooks::REGTYPE_PLAYER, event, std::move(callback), shots);
     }
 
     /**
@@ -843,9 +767,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterGuildEvent(lua_State* L)
+    sol::object RegisterGuildEvent(uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEventHelper(L, Hooks::REGTYPE_GUILD);
+        return RegisterEventHelper(Hooks::REGTYPE_GUILD, event, std::move(callback), shots);
     }
 
     /**
@@ -875,9 +799,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterGroupEvent(lua_State* L)
+    sol::object RegisterGroupEvent(uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEventHelper(L, Hooks::REGTYPE_GROUP);
+        return RegisterEventHelper(Hooks::REGTYPE_GROUP, event, std::move(callback), shots);
     }
 
     /**
@@ -903,9 +827,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterBGEvent(lua_State* L)
+    sol::object RegisterBGEvent(uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEventHelper(L, Hooks::REGTYPE_BG);
+        return RegisterEventHelper(Hooks::REGTYPE_BG, event, std::move(callback), shots);
     }
 
     /**
@@ -932,9 +856,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterPacketEvent(lua_State* L)
+    sol::object RegisterPacketEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_PACKET);
+        return RegisterEntryHelper(Hooks::REGTYPE_PACKET, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -959,9 +883,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterCreatureGossipEvent(lua_State* L)
+    sol::object RegisterCreatureGossipEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_CREATURE_GOSSIP);
+        return RegisterEntryHelper(Hooks::REGTYPE_CREATURE_GOSSIP, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -986,9 +910,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterGameObjectGossipEvent(lua_State* L)
+    sol::object RegisterGameObjectGossipEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_GAMEOBJECT_GOSSIP);
+        return RegisterEntryHelper(Hooks::REGTYPE_GAMEOBJECT_GOSSIP, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -1016,9 +940,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterItemEvent(lua_State* L)
+    sol::object RegisterItemEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_ITEM);
+        return RegisterEntryHelper(Hooks::REGTYPE_ITEM, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -1043,9 +967,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterItemGossipEvent(lua_State* L)
+    sol::object RegisterItemGossipEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_ITEM_GOSSIP);
+        return RegisterEntryHelper(Hooks::REGTYPE_ITEM_GOSSIP, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -1070,9 +994,9 @@ namespace LuaGlobalFunctions
      * @param function function : function to register
      * @param uint32 shots = 0 : the number of times the function will be called, 0 means "always call this function"
      */
-    int RegisterMapEvent(lua_State* L)
+    sol::object RegisterMapEvent(uint32 map_id, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_MAP);
+        return RegisterEntryHelper(Hooks::REGTYPE_MAP, map_id, event, std::move(callback), shots);
     }
 
     /**
@@ -1097,9 +1021,9 @@ namespace LuaGlobalFunctions
      * @param function function : function to register
      * @param uint32 shots = 0 : the number of times the function will be called, 0 means "always call this function"
      */
-    int RegisterInstanceEvent(lua_State* L)
+    sol::object RegisterInstanceEvent(uint32 instance_id, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_INSTANCE);
+        return RegisterEntryHelper(Hooks::REGTYPE_INSTANCE, instance_id, event, std::move(callback), shots);
     }
 
     /**
@@ -1126,9 +1050,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterPlayerGossipEvent(lua_State* L)
+    sol::object RegisterPlayerGossipEvent(uint32 menu_id, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_PLAYER_GOSSIP);
+        return RegisterEntryHelper(Hooks::REGTYPE_PLAYER_GOSSIP, menu_id, event, std::move(callback), shots);
     }
 
     /**
@@ -1197,9 +1121,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterCreatureEvent(lua_State* L)
+    sol::object RegisterCreatureEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_CREATURE);
+        return RegisterEntryHelper(Hooks::REGTYPE_CREATURE, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -1269,9 +1193,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterUniqueCreatureEvent(lua_State* L)
+    sol::object RegisterUniqueCreatureEvent(ObjectGuid guid, uint32 instance_id, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterUniqueHelper(L, Hooks::REGTYPE_CREATURE);
+        return RegisterUniqueHelper(Hooks::REGTYPE_CREATURE, guid, instance_id, event, std::move(callback), shots);
     }
 
     /**
@@ -1308,9 +1232,9 @@ namespace LuaGlobalFunctions
      *
      * @return function cancel : a function that cancels the binding when called
      */
-    int RegisterGameObjectEvent(lua_State* L)
+    sol::object RegisterGameObjectEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_GAMEOBJECT);
+        return RegisterEntryHelper(Hooks::REGTYPE_GAMEOBJECT, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -1332,9 +1256,9 @@ namespace LuaGlobalFunctions
      * @param function function : function to register
      * @param uint32 shots = 0 : the number of times the function will be called, 0 means "always call this function"
      */
-    int RegisterTicketEvent(lua_State* L)
+    sol::object RegisterTicketEvent(uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEventHelper(L, Hooks::REGTYPE_TICKET);
+        return RegisterEventHelper(Hooks::REGTYPE_TICKET, event, std::move(callback), shots);
     }
 
     /**
@@ -1355,9 +1279,9 @@ namespace LuaGlobalFunctions
      * @param function function : function to register
      * @param uint32 shots = 0 : the number of times the function will be called, 0 means "always call this function"
      */
-    int RegisterSpellEvent(lua_State* L)
+    sol::object RegisterSpellEvent(uint32 entry, uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEntryHelper(L, Hooks::REGTYPE_SPELL);
+        return RegisterEntryHelper(Hooks::REGTYPE_SPELL, entry, event, std::move(callback), shots);
     }
 
     /**
@@ -1387,18 +1311,26 @@ namespace LuaGlobalFunctions
      * @param function function : function to register
      * @param uint32 shots = 0 : the number of times the function will be called, 0 means "always call this function"
      */
-    int RegisterAllCreatureEvent(lua_State* L)
+    sol::object RegisterAllCreatureEvent(uint32 event, sol::protected_function callback, sol::optional<uint32> shots)
     {
-        return RegisterEventHelper(L, Hooks::REGTYPE_ALL_CREATURE);
+        return RegisterEventHelper(Hooks::REGTYPE_ALL_CREATURE, event, std::move(callback), shots);
     }
 
     /**
      * Reloads the Lua engine.
      */
-    int ReloadALE(lua_State* /*L*/)
+    void ReloadALE()
     {
         ALE::ReloadALE();
-        return 0;
+    }
+
+    static void PrintRunCommandOutput(void* /*callbackArg*/, std::string_view view)
+    {
+        std::string str = { view.begin(), view.end() };
+        // Remove trailing spaces and line breaks
+        while (!str.empty() && std::isspace(static_cast<unsigned char>(str.back())))
+            str.pop_back();
+        ALE_LOG_INFO("{}", str);
     }
 
     /**
@@ -1406,18 +1338,9 @@ namespace LuaGlobalFunctions
      *
      * @param string command : the command to run
      */
-    int RunCommand(lua_State* L)
+    void RunCommand(std::string command)
     {
-        const char* command = ALE::CHECKVAL<const char*>(L, 1);
-
-        eWorld->QueueCliCommand(new CliCommandHolder(nullptr, command, [](void*, std::string_view view)
-        {
-            std::string str = { view.begin(), view.end() };
-            str.erase(std::find_if(str.rbegin(), str.rend(), [](unsigned char ch) { return !std::isspace(ch); }).base(), str.end()); // Remove trailing spaces and line breaks
-            ALE_LOG_INFO("{}", str);
-        }, nullptr));
-
-        return 0;
+        sWorld->QueueCliCommand(new CliCommandHolder(nullptr, command.c_str(), &PrintRunCommandOutput, nullptr));
     }
 
     /**
@@ -1425,45 +1348,23 @@ namespace LuaGlobalFunctions
      *
      * @param string message : message to send
      */
-    int SendWorldMessage(lua_State* L)
+    void SendWorldMessage(std::string message)
     {
-        const char* message = ALE::CHECKVAL<const char*>(L, 1);
-        eWorldSessionMgr->SendServerMessage(SERVER_MSG_STRING, message);
-        return 0;
+        sWorldSessionMgr->SendServerMessage(SERVER_MSG_STRING, message);
     }
 
-    template <typename T>
-    static int DBQueryAsync(lua_State* L, DatabaseWorkerPool<T>& db)
+    static void ForwardAsyncQueryResult(sol::protected_function callback, QueryResult result)
     {
-        const char* query = ALE::CHECKVAL<const char*>(L, 1);
-        luaL_checktype(L, 2, LUA_TFUNCTION);
-        lua_pushvalue(L, 2);
-        int funcRef = luaL_ref(L, LUA_REGISTRYINDEX);
-        if (funcRef == LUA_REFNIL || funcRef == LUA_NOREF)
-        {
-            luaL_argerror(L, 2, "unable to make a ref to function");
-            return 0;
-        }
-
-        ALE::GALE->queryProcessor.AddCallback(db.AsyncQuery(query).WithCallback([L, funcRef](QueryResult result)
-            {
-                ALEQuery* eq = result ? new ALEQuery(result) : nullptr;
-
-                LOCK_ALE;
-
-                // Get function
-                lua_rawgeti(L, LUA_REGISTRYINDEX, funcRef);
+        LOCK_ALE;
 
-                // Push parameters
-                ALE::Push(L, eq);
-
-                // Call function
-                ALE::GALE->ExecuteCall(1, 0);
-
-                luaL_unref(L, LUA_REGISTRYINDEX, funcRef);
-            }));
+        sALE->CallFunction(callback, result);
+    }
 
-        return 0;
+    template <typename T>
+    static void DBQueryAsync(DatabaseWorkerPool<T>& db, std::string const& query, sol::protected_function callback)
+    {
+        sALE->queryProcessor.AddCallback(db.AsyncQuery(query.c_str())
+            .WithCallback(std::bind(&ForwardAsyncQueryResult, std::move(callback), std::placeholders::_1)));
     }
 
     /**
@@ -1484,20 +1385,9 @@ namespace LuaGlobalFunctions
      * @param string sql : query to execute
      * @return [ALEQuery] results or nil if no rows found or nil if no rows found
      */
-    int WorldDBQuery(lua_State* L)
+    QueryResult WorldDBQuery(std::string query)
     {
-        const char* query = ALE::CHECKVAL<const char*>(L, 1);
-
-        int numArgs = lua_gettop(L);
-        if (numArgs > 1)
-            query = ALE::FormatQuery(L, query).c_str();
-
-        ALEQuery result = WorldDatabase.Query(query);
-        if (result)
-            ALE::Push(L, new ALEQuery(result));
-        else
-            ALE::Push(L);
-        return 1;
+        return WorldDatabase.Query(query.c_str());
     }
 
     /**
@@ -1519,9 +1409,9 @@ namespace LuaGlobalFunctions
      * @param string sql : query to execute
      * @param function callback : function that will be called when the results are available
      */
-    int WorldDBQueryAsync(lua_State* L)
+    void WorldDBQueryAsync(std::string query, sol::protected_function callback)
     {
-        return DBQueryAsync(L, WorldDatabase);
+        DBQueryAsync(WorldDatabase, query, std::move(callback));
     }
 
     /**
@@ -1537,16 +1427,9 @@ namespace LuaGlobalFunctions
      *
      * @param string sql : query to execute
      */
-    int WorldDBExecute(lua_State* L)
+    void WorldDBExecute(std::string query)
     {
-        const char* query = ALE::CHECKVAL<const char*>(L, 1);
-
-        int numArgs = lua_gettop(L);
-        if (numArgs > 1)
-            query = ALE::FormatQuery(L, query).c_str();
-
-        WorldDatabase.Execute(query);
-        return 0;
+        WorldDatabase.Execute(query.c_str());
     }
 
     /**
@@ -1561,20 +1444,9 @@ namespace LuaGlobalFunctions
      * @param string sql : query to execute
      * @return [ALEQuery] results or nil if no rows found
      */
-    int CharDBQuery(lua_State* L)
+    QueryResult CharDBQuery(std::string query)
     {
-        const char* query = ALE::CHECKVAL<const char*>(L, 1);
-
-        int numArgs = lua_gettop(L);
-        if (numArgs > 1)
-            query = ALE::FormatQuery(L, query).c_str();
-
-        QueryResult result = CharacterDatabase.Query(query);
-        if (result)
-            ALE::Push(L, new QueryResult(result));
-        else
-            ALE::Push(L);
-        return 1;
+        return CharacterDatabase.Query(query.c_str());
     }
 
     /**
@@ -1589,9 +1461,9 @@ namespace LuaGlobalFunctions
      * @param string sql : query to execute
      * @param function callback : function that will be called when the results are available
      */
-    int CharDBQueryAsync(lua_State* L)
+    void CharDBQueryAsync(std::string query, sol::protected_function callback)
     {
-        return DBQueryAsync(L, CharacterDatabase);
+        DBQueryAsync(CharacterDatabase, query, std::move(callback));
     }
 
     /**
@@ -1607,16 +1479,9 @@ namespace LuaGlobalFunctions
      *
      * @param string sql : query to execute
      */
-    int CharDBExecute(lua_State* L)
+    void CharDBExecute(std::string query)
     {
-        const char* query = ALE::CHECKVAL<const char*>(L, 1);
-
-        int numArgs = lua_gettop(L);
-        if (numArgs > 1)
-            query = ALE::FormatQuery(L, query).c_str();
-
-        CharacterDatabase.Execute(query);
-        return 0;
+        CharacterDatabase.Execute(query.c_str());
     }
 
     /**
@@ -1631,20 +1496,9 @@ namespace LuaGlobalFunctions
      * @param string sql : query to execute
      * @return [ALEQuery] results or nil if no rows found
      */
-    int AuthDBQuery(lua_State* L)
+    QueryResult AuthDBQuery(std::string query)
     {
-        const char* query = ALE::CHECKVAL<const char*>(L, 1);
-
-        int numArgs = lua_gettop(L);
-        if (numArgs > 1)
-            query = ALE::FormatQuery(L, query).c_str();
-
-        QueryResult result = LoginDatabase.Query(query);
-        if (result)
-            ALE::Push(L, new QueryResult(result));
-        else
-            ALE::Push(L);
-        return 1;
+        return LoginDatabase.Query(query.c_str());
     }
 
     /**
@@ -1659,9 +1513,9 @@ namespace LuaGlobalFunctions
      * @param string sql : query to execute
      * @param function callback : function that will be called when the results are available
      */
-    int AuthDBQueryAsync(lua_State* L)
+    void AuthDBQueryAsync(std::string query, sol::protected_function callback)
     {
-        return DBQueryAsync(L, LoginDatabase);
+        DBQueryAsync(LoginDatabase, query, std::move(callback));
     }
 
     /**
@@ -1677,16 +1531,9 @@ namespace LuaGlobalFunctions
      *
      * @param string sql : query to execute
      */
-    int AuthDBExecute(lua_State* L)
+    void AuthDBExecute(std::string query)
     {
-        const char* query = ALE::CHECKVAL<const char*>(L, 1);
-
-        int numArgs = lua_gettop(L);
-        if (numArgs > 1)
-            query = ALE::FormatQuery(L, query).c_str();
-            
-        LoginDatabase.Execute(query);
-        return 0;
+        LoginDatabase.Execute(query.c_str());
     }
 
     /**
@@ -1707,35 +1554,23 @@ namespace LuaGlobalFunctions
      * @param uint32 repeats = 1 : how many times for the event to repeat, 0 is infinite
      * @return int eventId : unique ID for the timed event used to cancel it or nil
      */
-    int CreateLuaEvent(lua_State* L)
+    uint64 CreateLuaEvent(sol::protected_function callback, sol::object delay, sol::optional<uint32> repeatsArg)
     {
-        luaL_checktype(L, 1, LUA_TFUNCTION);
         uint32 min, max;
-        if (lua_istable(L, 2))
+        if (delay.is<sol::table>())
         {
-            ALE::Push(L, 1);
-            lua_gettable(L, 2);
-            min = ALE::CHECKVAL<uint32>(L, -1);
-            ALE::Push(L, 2);
-            lua_gettable(L, 2);
-            max = ALE::CHECKVAL<uint32>(L, -1);
-            lua_pop(L, 2);
+            sol::table delayTable = delay.as<sol::table>();
+            min = delayTable.get<uint32>(1);
+            max = delayTable.get<uint32>(2);
         }
         else
-            min = max = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 repeats = ALE::CHECKVAL<uint32>(L, 3, 1);
+            min = max = delay.as<uint32>();
+        uint32 repeats = repeatsArg.value_or(1);
 
         if (min > max)
-            return luaL_argerror(L, 2, "min is bigger than max delay");
+            throw std::invalid_argument("min is bigger than max delay");
 
-        lua_pushvalue(L, 1);
-        int functionRef = luaL_ref(L, LUA_REGISTRYINDEX);
-        if (functionRef != LUA_REFNIL && functionRef != LUA_NOREF)
-        {
-            ALE::GetALE(L)->eventMgr->globalProcessor->AddEvent(functionRef, min, max, repeats);
-            ALE::Push(L, functionRef);
-        }
-        return 1;
+        return sALE->eventMgr->globalProcessor->AddEvent(std::move(callback), min, max, repeats);
     }
 
     /**
@@ -1744,17 +1579,15 @@ namespace LuaGlobalFunctions
      * @param int eventId : event Id to remove
      * @param bool all_Events = false : remove from all events, not just global
      */
-    int RemoveEventById(lua_State* L)
+    void RemoveEventById(uint64 eventId, sol::optional<bool> allEventsArg)
     {
-        int eventId = ALE::CHECKVAL<int>(L, 1);
-        bool all_Events = ALE::CHECKVAL<bool>(L, 1, false);
+        bool all_Events = allEventsArg.value_or(false);
 
         // not thread safe
         if (all_Events)
-            ALE::GetALE(L)->eventMgr->SetState(eventId, LUAEVENT_STATE_ABORT);
+            sALE->eventMgr->SetState(eventId, LUAEVENT_STATE_ABORT);
         else
-            ALE::GetALE(L)->eventMgr->globalProcessor->SetState(eventId, LUAEVENT_STATE_ABORT);
-        return 0;
+            sALE->eventMgr->globalProcessor->SetState(eventId, LUAEVENT_STATE_ABORT);
     }
 
     /**
@@ -1762,16 +1595,15 @@ namespace LuaGlobalFunctions
      *
      * @param bool all_Events = false : remove all events, not just global
      */
-    int RemoveEvents(lua_State* L)
+    void RemoveEvents(sol::optional<bool> allEventsArg)
     {
-        bool all_Events = ALE::CHECKVAL<bool>(L, 1, false);
+        bool all_Events = allEventsArg.value_or(false);
 
         // not thread safe
         if (all_Events)
-            ALE::GetALE(L)->eventMgr->SetStates(LUAEVENT_STATE_ABORT);
+            sALE->eventMgr->SetStates(LUAEVENT_STATE_ABORT);
         else
-            ALE::GetALE(L)->eventMgr->globalProcessor->SetStates(LUAEVENT_STATE_ABORT);
-        return 0;
+            sALE->eventMgr->globalProcessor->SetStates(LUAEVENT_STATE_ABORT);
     }
 
     /**
@@ -1790,33 +1622,20 @@ namespace LuaGlobalFunctions
      * @param uint32 phase = 1 : phase to put the [Creature] or [GameObject] in
      * @return [WorldObject] worldObject : returns [Creature] or [GameObject]
      */
-    int PerformIngameSpawn(lua_State* L)
-    {
-        int spawntype = ALE::CHECKVAL<int>(L, 1);
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 mapID = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 instanceID = ALE::CHECKVAL<uint32>(L, 4);
-
-        float x = ALE::CHECKVAL<float>(L, 5);
-        float y = ALE::CHECKVAL<float>(L, 6);
-        float z = ALE::CHECKVAL<float>(L, 7);
-        float o = ALE::CHECKVAL<float>(L, 8);
-        bool save = ALE::CHECKVAL<bool>(L, 9, false);
-        uint32 durorresptime = ALE::CHECKVAL<uint32>(L, 10, 0);
-        uint32 phase = ALE::CHECKVAL<uint32>(L, 11, PHASEMASK_NORMAL);
-        
+    WorldObject* PerformIngameSpawn(int32 spawntype, uint32 entry, uint32 mapID, uint32 instanceID,
+        float x, float y, float z, float o,
+        sol::optional<bool> saveArg, sol::optional<uint32> durorresptimeArg, sol::optional<uint32> phaseArg)
+    {
+        bool save = saveArg.value_or(false);
+        uint32 durorresptime = durorresptimeArg.value_or(0);
+        uint32 phase = phaseArg.value_or(PHASEMASK_NORMAL);
+
         if (!phase)
-        {
-            ALE::Push(L);
-            return 1;
-        }
+            return nullptr;
 
-        Map* map = eMapMgr->FindMap(mapID, instanceID);
+        Map* map = sMapMgr->FindMap(mapID, instanceID);
         if (!map)
-        {
-            ALE::Push(L);
-            return 1;
-        }
+            return nullptr;
 
         Position pos = { x, y, z, o };
 
@@ -1828,8 +1647,7 @@ namespace LuaGlobalFunctions
                 if (!creature->Create(map->GenerateLowGuid<HighGuid::Unit>(), map, phase, entry, 0, x, y, z, o))
                 {
                     delete creature;
-                    ALE::Push(L);
-                    return 1;
+                    return nullptr;
                 }
 
                 creature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()), phase);
@@ -1845,47 +1663,35 @@ namespace LuaGlobalFunctions
                 if (!creature->LoadCreatureFromDB(db_guid, map, true, true))
                 {
                     delete creature;
-                    ALE::Push(L);
-                    return 1;
+                    return nullptr;
                 }
 
-                eObjectMgr->AddCreatureToGrid(db_guid, eObjectMgr->GetCreatureData(db_guid));
-                ALE::Push(L, creature);
+                sObjectMgr->AddCreatureToGrid(db_guid, sObjectMgr->GetCreatureData(db_guid));
+                return creature;
             }
             else
             {
-                TempSummon* creature = map->SummonCreature(entry, pos, NULL, durorresptime);
+                TempSummon* creature = map->SummonCreature(entry, pos, nullptr, durorresptime);
                 if (!creature)
-                {
-                    ALE::Push(L);
-                    return 1;
-                }
+                    return nullptr;
 
                 if (durorresptime)
                     creature->SetTempSummonType(TEMPSUMMON_TIMED_OR_DEAD_DESPAWN);
                 else
                     creature->SetTempSummonType(TEMPSUMMON_MANUAL_DESPAWN);
 
-                ALE::Push(L, creature);
+                return creature;
             }
-
-            return 1;
         }
 
         if (spawntype == 2) // Spawn object
         {
-            const GameObjectTemplate* objectInfo = eObjectMgr->GetGameObjectTemplate(entry);
+            const GameObjectTemplate* objectInfo = sObjectMgr->GetGameObjectTemplate(entry);
             if (!objectInfo)
-            {
-                ALE::Push(L);
-                return 1;
-            }
+                return nullptr;
 
             if (objectInfo->displayId && !sGameObjectDisplayInfoStore.LookupEntry(objectInfo->displayId))
-            {
-                ALE::Push(L);
-                return 1;
-            }
+                return nullptr;
 
             GameObject* object = new GameObject;
             uint32 guidLow = map->GenerateLowGuid<HighGuid::GameObject>();
@@ -1893,8 +1699,7 @@ namespace LuaGlobalFunctions
             if (!object->Create(guidLow, entry, map, phase, x, y, z, o, G3D::Quat(0.0f, 0.0f, 0.0f, 0.0f), 100, GO_STATE_READY))
             {
                 delete object;
-                ALE::Push(L);
-                return 1;
+                return nullptr;
             }
 
             if (durorresptime)
@@ -1915,19 +1720,16 @@ namespace LuaGlobalFunctions
                 if (!object->LoadGameObjectFromDB(guidLow, map, true))
                 {
                     delete object;
-                    ALE::Push(L);
-                    return 1;
+                    return nullptr;
                 }
 
-                eObjectMgr->AddGameobjectToGrid(guidLow, eObjectMgr->GetGameObjectData(guidLow));
+                sObjectMgr->AddGameobjectToGrid(guidLow, sObjectMgr->GetGameObjectData(guidLow));
             }
             else
                 map->AddToMap(object);
-            ALE::Push(L, object);
-            return 1;
+            return object;
         }
-        ALE::Push(L);
-        return 1;
+        return nullptr;
     }
 
     /**
@@ -1937,15 +1739,12 @@ namespace LuaGlobalFunctions
      * @param uint32 size : the size of the packet
      * @return [WorldPacket] packet
      */
-    int CreatePacket(lua_State* L)
+    WorldPacket CreatePacket(uint32 opcode, size_t size)
     {
-        uint32 opcode = ALE::CHECKVAL<uint32>(L, 1);
-        size_t size = ALE::CHECKVAL<size_t>(L, 2);
         if (opcode >= NUM_MSG_TYPES)
-            return luaL_argerror(L, 1, "valid opcode expected");
+            throw std::invalid_argument("valid opcode expected");
 
-        ALE::Push(L, new WorldPacket((OpcodesList)opcode, size));
-        return 1;
+        return WorldPacket(static_cast<Opcodes>(opcode), size);
     }
 
     /**
@@ -1957,19 +1756,11 @@ namespace LuaGlobalFunctions
      * @param uint32 incrtime : combined with maxcount, incrtime tells how often (in seconds) the vendor list is refreshed and the limited [Item] copies are restocked
      * @param uint32 extendedcost : unique cost of an [Item], such as conquest points for example
      */
-    int AddVendorItem(lua_State* L)
+    void AddVendorItem(uint32 entry, uint32 item, int32 maxcount, uint32 incrtime, uint32 extendedcost)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 item = ALE::CHECKVAL<uint32>(L, 2);
-        int maxcount = ALE::CHECKVAL<int>(L, 3);
-        uint32 incrtime = ALE::CHECKVAL<uint32>(L, 4);
-        uint32 extendedcost = ALE::CHECKVAL<uint32>(L, 5);
-
-        if (!eObjectMgr->IsVendorItemValid(entry, item, maxcount, incrtime, extendedcost))
-            return 0;
-        eObjectMgr->AddVendorItem(entry, item, maxcount, incrtime, extendedcost);
-
-        return 0;
+        if (!sObjectMgr->IsVendorItemValid(entry, item, maxcount, incrtime, extendedcost))
+            return;
+        sObjectMgr->AddVendorItem(entry, item, maxcount, incrtime, extendedcost);
     }
 
     /**
@@ -1978,15 +1769,12 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : [Creature] entry Id
      * @param uint32 item : [Item] entry Id
      */
-    int VendorRemoveItem(lua_State* L)
+    void VendorRemoveItem(uint32 entry, uint32 item)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 item = ALE::CHECKVAL<uint32>(L, 2);
-        if (!eObjectMgr->GetCreatureTemplate(entry))
-            return luaL_argerror(L, 1, "valid CreatureEntry expected");
+        if (!sObjectMgr->GetCreatureTemplate(entry))
+            throw std::invalid_argument("valid CreatureEntry expected");
 
-        eObjectMgr->RemoveVendorItem(entry, item);
-        return 0;
+        sObjectMgr->RemoveVendorItem(entry, item);
     }
 
     /**
@@ -1994,18 +1782,15 @@ namespace LuaGlobalFunctions
      *
      * @param uint32 entry : [Creature] entry Id
      */
-    int VendorRemoveAllItems(lua_State* L)
+    void VendorRemoveAllItems(uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-        VendorItemData const* items = eObjectMgr->GetNpcVendorItemList(entry);
+        VendorItemData const* items = sObjectMgr->GetNpcVendorItemList(entry);
         if (!items || items->Empty())
-            return 0;
+            return;
 
         auto const& itemlist = items->m_items;
         for (auto itr = itemlist.rbegin(); itr != itemlist.rend(); ++itr)
-            eObjectMgr->RemoveVendorItem(entry, (*itr)->item);
-        return 0;
+            sObjectMgr->RemoveVendorItem(entry, (*itr)->item);
     }
 
     /**
@@ -2013,11 +1798,9 @@ namespace LuaGlobalFunctions
      *
      * @param [Player] player : [Player] to kick
      */
-    int Kick(lua_State* L)
+    void Kick(Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 1);
         player->GetSession()->KickPlayer();
-        return 0;
     }
 
     /**
@@ -2037,13 +1820,10 @@ namespace LuaGlobalFunctions
      * @param string whoBanned = "" : the [Player]'s name that banned the account, character or IP, this is optional
      * @return int result : status of the ban. 0 if success, 1 if syntax error, 2 if target not found, 3 if a longer ban already exists, nil if unknown result
      */
-    int Ban(lua_State* L)
+    sol::optional<int32> Ban(int32 banMode, std::string nameOrIP, uint32 duration, sol::optional<std::string> reasonArg, sol::optional<std::string> whoBannedArg)
     {
-        int banMode = ALE::CHECKVAL<int>(L, 1);
-        std::string nameOrIP = ALE::CHECKVAL<std::string>(L, 2);
-        uint32 duration = ALE::CHECKVAL<uint32>(L, 3);
-        const char* reason = ALE::CHECKVAL<const char*>(L, 4, "");
-        const char* whoBanned = ALE::CHECKVAL<const char*>(L, 5, "");
+        std::string reason = reasonArg.value_or("");
+        std::string whoBanned = whoBannedArg.value_or("");
 
         const int BAN_ACCOUNT = 0;
         const int BAN_CHARACTER = 1;
@@ -2053,18 +1833,18 @@ namespace LuaGlobalFunctions
         {
             case BAN_ACCOUNT:
                 if (!Utf8ToUpperOnlyLatin(nameOrIP))
-                    return luaL_argerror(L, 2, "invalid account name");
+                    throw std::invalid_argument("invalid account name");
                 break;
             case BAN_CHARACTER:
                 if (!normalizePlayerName(nameOrIP))
-                    return luaL_argerror(L, 2, "invalid character name");
+                    throw std::invalid_argument("invalid character name");
                 break;
             case BAN_IP:
                 if (!IsIPAddress(nameOrIP.c_str()))
-                    return luaL_argerror(L, 2, "invalid ip");
+                    throw std::invalid_argument("invalid ip");
                 break;
             default:
-                return luaL_argerror(L, 1, "unknown banmode");
+                throw std::invalid_argument("unknown banmode");
         }
 
         BanReturn result;
@@ -2084,28 +1864,23 @@ namespace LuaGlobalFunctions
         switch (result)
         {
         case BanReturn::BAN_SUCCESS:
-            ALE::Push(L, 0);
-            break;
+            return 0;
         case BanReturn::BAN_SYNTAX_ERROR:
-            ALE::Push(L, 1);
-            break;
+            return 1;
         case BanReturn::BAN_NOTFOUND:
-            ALE::Push(L, 2);
-            break;
+            return 2;
         case BanReturn::BAN_LONGER_EXISTS:
-            ALE::Push(L, 3);
-            break;
+            return 3;
         }
-        return 1;
+        return sol::nullopt;
     }
 
     /**
      * Saves all [Player]s.
      */
-    int SaveAllPlayers(lua_State* /*L*/)
+    void SaveAllPlayers()
     {
-        eObjectAccessor()SaveAllPlayers();
-        return 0;
+        ObjectAccessor::SaveAllPlayers();
     }
 
     /**
@@ -2137,18 +1912,15 @@ namespace LuaGlobalFunctions
      * @param uint32 amount = 0 : amount of the [Item] to send with mail
      * @return uint32 itemGUIDlow : low GUID of the item. Up to 12 values returned, returns nil if no further items are sent
      */
-    int SendMail(lua_State* L)
+    sol::variadic_results SendMail(std::string subject, std::string text, uint32 receiverGUIDLow,
+        sol::optional<uint32> senderGUIDLowArg, sol::optional<uint32> stationaryArg, sol::optional<uint32> delayArg,
+        sol::optional<uint32> moneyArg, sol::optional<uint32> codArg, sol::this_state s, sol::variadic_args itemArgs)
     {
-        int i = 0;
-        std::string subject = ALE::CHECKVAL<std::string>(L, ++i);
-        std::string text = ALE::CHECKVAL<std::string>(L, ++i);
-        uint32 receiverGUIDLow = ALE::CHECKVAL<uint32>(L, ++i);
-        uint32 senderGUIDLow = ALE::CHECKVAL<uint32>(L, ++i, 0);
-        uint32 stationary = ALE::CHECKVAL<uint32>(L, ++i, MAIL_STATIONERY_DEFAULT);
-        uint32 delay = ALE::CHECKVAL<uint32>(L, ++i, 0);
-        uint32 money = ALE::CHECKVAL<uint32>(L, ++i, 0);
-        uint32 cod = ALE::CHECKVAL<uint32>(L, ++i, 0);
-        int argAmount = lua_gettop(L);
+        uint32 senderGUIDLow = senderGUIDLowArg.value_or(0);
+        uint32 stationary = stationaryArg.value_or(MAIL_STATIONERY_DEFAULT);
+        uint32 delay = delayArg.value_or(0);
+        uint32 money = moneyArg.value_or(0);
+        uint32 cod = codArg.value_or(0);
 
         MailSender sender(MAIL_NORMAL, senderGUIDLow, (MailStationery)stationary);
         MailDraft draft(subject, text);
@@ -2159,36 +1931,32 @@ namespace LuaGlobalFunctions
             draft.AddMoney(money);
 
         CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
+        sol::variadic_results results;
         uint8 addedItems = 0;
-        while (addedItems <= MAX_MAIL_ITEMS && i + 2 <= argAmount)
+        std::size_t argIndex = 0;
+        while (addedItems <= MAX_MAIL_ITEMS && argIndex + 2 <= itemArgs.size())
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, ++i);
-            uint32 amount = ALE::CHECKVAL<uint32>(L, ++i);
+            uint32 entry = itemArgs.get<uint32>(argIndex++);
+            uint32 amount = itemArgs.get<uint32>(argIndex++);
 
-            ItemTemplate const* item_proto = eObjectMgr->GetItemTemplate(entry);
+            ItemTemplate const* item_proto = sObjectMgr->GetItemTemplate(entry);
             if (!item_proto)
-            {
-                luaL_error(L, "Item entry %d does not exist", entry);
-                continue;
-            }
+                throw std::runtime_error(Acore::StringFormat("Item entry {} does not exist", entry));
             if (amount < 1 || (item_proto->MaxCount > 0 && amount > uint32(item_proto->MaxCount)))
-            {
-                luaL_error(L, "Item entry %d has invalid amount %d", entry, amount);
-                continue;
-            }
+                throw std::runtime_error(Acore::StringFormat("Item entry {} has invalid amount {}", entry, amount));
             if (Item* item = Item::CreateItem(entry, amount))
             {
                 item->SaveToDB(trans);
                 draft.AddItem(item);
-                ALE::Push(L, item->GetGUID().GetCounter());
+                results.push_back(sol::make_object(s, item->GetGUID().GetCounter()));
                 ++addedItems;
             }
         }
 
-        Player* receiverPlayer = eObjectAccessor()FindPlayer(MAKE_NEW_GUID(receiverGUIDLow, 0, HIGHGUID_PLAYER));
+        Player* receiverPlayer = ObjectAccessor::FindPlayer(ObjectGuid(HighGuid::Player, 0, receiverGUIDLow));
         draft.SendMailTo(trans, MailReceiver(receiverPlayer, receiverGUIDLow), sender, MAIL_CHECK_MASK_NONE, delay);
         CharacterDatabase.CommitTransaction(trans);
-        return addedItems;
+        return results;
     }
 
     /**
@@ -2198,12 +1966,9 @@ namespace LuaGlobalFunctions
      * @param uint32 b
      * @return uint32 result
      */
-    int bit_and(lua_State* L)
+    uint32 bit_and(uint32 a, uint32 b)
     {
-        uint32 a = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 b = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, a & b);
-        return 1;
+        return a & b;
     }
 
     /**
@@ -2213,12 +1978,9 @@ namespace LuaGlobalFunctions
      * @param uint32 b
      * @return uint32 result
      */
-    int bit_or(lua_State* L)
+    uint32 bit_or(uint32 a, uint32 b)
     {
-        uint32 a = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 b = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, a | b);
-        return 1;
+        return a | b;
     }
 
     /**
@@ -2228,12 +1990,9 @@ namespace LuaGlobalFunctions
      * @param uint32 b
      * @return uint32 result
      */
-    int bit_lshift(lua_State* L)
+    uint32 bit_lshift(uint32 a, uint32 b)
     {
-        uint32 a = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 b = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, a << b);
-        return 1;
+        return a << b;
     }
 
     /**
@@ -2243,12 +2002,9 @@ namespace LuaGlobalFunctions
      * @param uint32 b
      * @return uint32 result
      */
-    int bit_rshift(lua_State* L)
+    uint32 bit_rshift(uint32 a, uint32 b)
     {
-        uint32 a = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 b = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, a >> b);
-        return 1;
+        return a >> b;
     }
 
     /**
@@ -2258,12 +2014,9 @@ namespace LuaGlobalFunctions
      * @param uint32 b
      * @return uint32 result
      */
-    int bit_xor(lua_State* L)
+    uint32 bit_xor(uint32 a, uint32 b)
     {
-        uint32 a = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 b = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, a ^ b);
-        return 1;
+        return a ^ b;
     }
 
     /**
@@ -2272,11 +2025,9 @@ namespace LuaGlobalFunctions
      * @param uint32 a
      * @return uint32 result
      */
-    int bit_not(lua_State* L)
+    uint32 bit_not(uint32 a)
     {
-        uint32 a = ALE::CHECKVAL<uint32>(L, 1);
-        ALE::Push(L, ~a);
-        return 1;
+        return ~a;
     }
 
     /**
@@ -2301,73 +2052,38 @@ namespace LuaGlobalFunctions
      * @param uint32 pathId = 0 : path Id of the taxi path
      * @return uint32 actualPathId
      */
-    int AddTaxiPath(lua_State* L)
+    uint32 AddTaxiPath(sol::table waypoints, uint32 mountA, uint32 mountH, sol::optional<uint32> priceArg, sol::optional<uint32> pathIdArg)
     {
-        luaL_checktype(L, 1, LUA_TTABLE);
-        uint32 mountA = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 mountH = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 price = ALE::CHECKVAL<uint32>(L, 4, 0);
-        uint32 pathId = ALE::CHECKVAL<uint32>(L, 5, 0);
-        lua_pushvalue(L, 1);
-        // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}
+        uint32 price = priceArg.value_or(0);
+        uint32 pathId = pathIdArg.value_or(0);
 
         std::list<TaxiPathNodeEntry> nodes;
 
-        int start = lua_gettop(L);
-        int end = start;
-
-        ALE::Push(L);
-        // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, nil
-        while (lua_next(L, -2) != 0)
+        std::size_t nodeCount = waypoints.size();
+        for (std::size_t i = 1; i <= nodeCount; ++i)
         {
-            // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, key, value
-            luaL_checktype(L, -1, LUA_TTABLE);
-            ALE::Push(L);
-            // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, key, value, nil
-            while (lua_next(L, -2) != 0)
-            {
-                // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, key, value, key2, value2
-                lua_insert(L, end++);
-                // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, value2, key, value, key2
-            }
-            // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, value2, key, value
-            if (start == end)
-                continue;
-            if (end - start < 4) // no mandatory args, dont add
-                return luaL_argerror(L, 1, "all waypoints do not have mandatory arguments");
+            sol::optional<sol::table> node = waypoints.get<sol::optional<sol::table>>(i);
+            if (!node)
+                throw std::invalid_argument("table expected as waypoint");
+
+            if (node->size() < 4) // no mandatory args, dont add
+                throw std::invalid_argument("all waypoints do not have mandatory arguments");
 
-            while (end - start < 8) // fill optional args with 0
-            {
-                ALE::Push(L, 0);
-                lua_insert(L, end++);
-                // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, node, key, value
-            }
             TaxiPathNodeEntry entry;
             // mandatory
-            entry.mapid = ALE::CHECKVAL<uint32>(L, start);
-            entry.x = ALE::CHECKVAL<float>(L, start + 1);
-            entry.y = ALE::CHECKVAL<float>(L, start + 2);
-            entry.z = ALE::CHECKVAL<float>(L, start + 3);
+            entry.mapid = node->get<uint32>(1);
+            entry.x = node->get<float>(2);
+            entry.y = node->get<float>(3);
+            entry.z = node->get<float>(4);
             // optional
-            entry.actionFlag = ALE::CHECKVAL<uint32>(L, start + 4, 0);
-            entry.delay = ALE::CHECKVAL<uint32>(L, start + 5, 0);
+            entry.actionFlag = node->get_or<uint32>(5, 0);
+            entry.delay = node->get_or<uint32>(6, 0);
 
             nodes.push_back(entry);
-
-            while (end != start) // remove args
-                if (!lua_isnone(L, --end))
-                    lua_remove(L, end);
-            // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, key, value
-
-            lua_pop(L, 1);
-            // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}, key
         }
-        // Stack: {nodes}, mountA, mountH, price, pathid, {nodes}
-        lua_pop(L, 1);
-        // Stack: {nodes}, mountA, mountH, price, pathid
 
         if (nodes.size() < 2)
-            return 1;
+            return pathId;
         if (!pathId)
             pathId = sTaxiPathNodesByPath.size();
         if (sTaxiPathNodesByPath.size() <= pathId)
@@ -2396,7 +2112,7 @@ namespace LuaGlobalFunctions
             sTaxiPathNodesByPath[pathId][index++] = new TaxiPathNodeEntry(entry);
         }
         if (startNode >= nodeId)
-            return 1;
+            return pathId;
 
         TaxiPathEntry* pathEntry = new TaxiPathEntry();
         pathEntry->from = startNode;
@@ -2406,8 +2122,7 @@ namespace LuaGlobalFunctions
         sTaxiPathStore.SetEntry(pathId, pathEntry);
         sTaxiPathSetBySource[startNode][nodeId - 1] = pathEntry;
 
-        ALE::Push(L, pathId);
-        return 1;
+        return pathId;
     }
 
     /**
@@ -2415,11 +2130,10 @@ namespace LuaGlobalFunctions
      *
      * @return bool isCompatibilityMode
      */
-    int IsCompatibilityMode(lua_State* L)
+    bool IsCompatibilityMode()
     {
         // Until AC supports multistate, this will always return true
-        ALE::Push(L, true);
-        return 1;
+        return true;
     }
 
     /**
@@ -2448,13 +2162,9 @@ namespace LuaGlobalFunctions
      * @param uint8 slot : the slot the [Item] is in within the bag, you can get this with [Item:GetSlot]
      * @return bool isInventoryPos
      */
-    int IsInventoryPos(lua_State* L)
+    bool IsInventoryPos(uint8 bag, uint8 slot)
     {
-        uint8 bag = ALE::CHECKVAL<uint8>(L, 1);
-        uint8 slot = ALE::CHECKVAL<uint8>(L, 2);
-
-        ALE::Push(L, Player::IsInventoryPos(bag, slot));
-        return 1;
+        return Player::IsInventoryPos(bag, slot);
     }
 
     /**
@@ -2466,13 +2176,9 @@ namespace LuaGlobalFunctions
      * @param uint8 slot : the slot the [Item] is in within the bag, you can get this with [Item:GetSlot]
      * @return bool isEquipmentPosition
      */
-    int IsEquipmentPos(lua_State* L)
+    bool IsEquipmentPos(uint8 bag, uint8 slot)
     {
-        uint8 bag = ALE::CHECKVAL<uint8>(L, 1);
-        uint8 slot = ALE::CHECKVAL<uint8>(L, 2);
-
-        ALE::Push(L, Player::IsEquipmentPos(bag, slot));
-        return 1;
+        return Player::IsEquipmentPos(bag, slot);
     }
 
     /**
@@ -2484,13 +2190,9 @@ namespace LuaGlobalFunctions
      * @param uint8 slot : the slot the [Item] is in within the bag, you can get this with [Item:GetSlot]
      * @return bool isBankPosition
      */
-    int IsBankPos(lua_State* L)
+    bool IsBankPos(uint8 bag, uint8 slot)
     {
-        uint8 bag = ALE::CHECKVAL<uint8>(L, 1);
-        uint8 slot = ALE::CHECKVAL<uint8>(L, 2);
-
-        ALE::Push(L, Player::IsBankPos(bag, slot));
-        return 1;
+        return Player::IsBankPos(bag, slot);
     }
 
     /**
@@ -2502,13 +2204,9 @@ namespace LuaGlobalFunctions
      * @param uint8 slot : the slot the [Item] is in within the bag, you can get this with [Item:GetSlot]
      * @return bool isBagPosition
      */
-    int IsBagPos(lua_State* L)
+    bool IsBagPos(uint8 bag, uint8 slot)
     {
-        uint8 bag = ALE::CHECKVAL<uint8>(L, 1);
-        uint8 slot = ALE::CHECKVAL<uint8>(L, 2);
-
-        ALE::Push(L, Player::IsBagPos((bag << 8) + slot));
-        return 1;
+        return Player::IsBagPos((bag << 8) + slot);
     }
 
     /**
@@ -2517,12 +2215,9 @@ namespace LuaGlobalFunctions
      * @param uint16 eventId : the event id to check.
      * @return bool isActive
      */
-    int IsGameEventActive(lua_State* L)
+    bool IsGameEventActive(uint16 eventId)
     {
-        uint16 eventId = ALE::CHECKVAL<uint16>(L, 1);
-
-        ALE::Push(L, eGameEventMgr->IsActiveEvent(eventId));
-        return 1;
+        return sGameEventMgr->IsActiveEvent(eventId);
     }
 
     /**
@@ -2530,10 +2225,9 @@ namespace LuaGlobalFunctions
      *
      * @return uint32 currTime : the current time, in milliseconds
      */
-    int GetCurrTime(lua_State* L)
+    uint32 GetCurrTime()
     {
-        ALE::Push(L, ALEUtil::GetCurrTime());
-        return 1;
+        return ALEUtil::GetCurrTime();
     }
 
     /**
@@ -2542,23 +2236,20 @@ namespace LuaGlobalFunctions
      * @param uint32 oldTime : an old timestamp, in milliseconds
      * @return uint32 timeDiff : the difference, in milliseconds
      */
-    int GetTimeDiff(lua_State* L)
+    uint32 GetTimeDiff(uint32 oldtimems)
     {
-        uint32 oldtimems = ALE::CHECKVAL<uint32>(L, 1);
-
-        ALE::Push(L, ALEUtil::GetTimeDiff(oldtimems));
-        return 1;
+        return ALEUtil::GetTimeDiff(oldtimems);
     }
 
-    static std::string GetStackAsString(lua_State* L)
+    static std::string BuildLogString(sol::variadic_args const& args)
     {
+        sol::state_view lua(args.lua_state());
+        sol::protected_function tostring = lua["tostring"];
+
         std::ostringstream oss;
-        int top = lua_gettop(L);
-        for (int i = 1; i <= top; ++i)
-        {
-            oss << luaL_tolstring(L, i, NULL);
-            lua_pop(L, 1);
-        }
+        for (sol::stack_proxy arg : args)
+            oss << tostring(arg).get<std::string>();
+
         return oss.str();
     }
 
@@ -2567,10 +2258,9 @@ namespace LuaGlobalFunctions
      *
      * @param ...
      */
-    int PrintInfo(lua_State* L)
+    void PrintInfo(sol::variadic_args args)
     {
-        ALE_LOG_INFO("{}", GetStackAsString(L));
-        return 0;
+        ALE_LOG_INFO("{}", BuildLogString(args));
     }
 
     /**
@@ -2578,10 +2268,9 @@ namespace LuaGlobalFunctions
      *
      * @param ...
      */
-    int PrintError(lua_State* L)
+    void PrintError(sol::variadic_args args)
     {
-        ALE_LOG_ERROR("{}", GetStackAsString(L));
-        return 0;
+        ALE_LOG_ERROR("{}", BuildLogString(args));
     }
 
     /**
@@ -2589,10 +2278,9 @@ namespace LuaGlobalFunctions
      *
      * @param ...
      */
-    int PrintDebug(lua_State* L)
+    void PrintDebug(sol::variadic_args args)
     {
-        ALE_LOG_DEBUG("{}", GetStackAsString(L));
-        return 0;
+        ALE_LOG_DEBUG("{}", BuildLogString(args));
     }
 
     /**
@@ -2601,13 +2289,11 @@ namespace LuaGlobalFunctions
     * @param uint16 eventId : the event id to start.
     * @param bool force = false : set `true` to force start the event.
     */
-    int StartGameEvent(lua_State* L)
+    void StartGameEvent(uint16 eventId, sol::optional<bool> forceArg)
     {
-        uint16 eventId = ALE::CHECKVAL<uint16>(L, 1);
-        bool force = ALE::CHECKVAL<bool>(L, 2, false);
+        bool force = forceArg.value_or(false);
 
-        eGameEventMgr->StartEvent(eventId, force);
-        return 0;
+        sGameEventMgr->StartEvent(eventId, force);
     }
 
     /**
@@ -2616,13 +2302,11 @@ namespace LuaGlobalFunctions
     * @param uint16 eventId : the event id to stop.
     * @param bool force = false : set `true` to force stop the event.
     */
-    int StopGameEvent(lua_State* L)
+    void StopGameEvent(uint16 eventId, sol::optional<bool> forceArg)
     {
-        uint16 eventId = ALE::CHECKVAL<uint16>(L, 1);
-        bool force = ALE::CHECKVAL<bool>(L, 2, false);
+        bool force = forceArg.value_or(false);
 
-        eGameEventMgr->StopEvent(eventId, force);
-        return 0;
+        sGameEventMgr->StopEvent(eventId, force);
     }
 
     /**
@@ -2657,56 +2341,42 @@ namespace LuaGlobalFunctions
      * @param string contentType : the body's content-type
      * @param function function : function that will be called when the request is executed
      */
-    int HttpRequest(lua_State* L)
+    void HttpRequest(std::string httpVerb, std::string url, sol::object arg3,
+        sol::optional<sol::object> arg4, sol::optional<sol::object> arg5, sol::optional<sol::object> arg6)
     {
-        std::string httpVerb = ALE::CHECKVAL<std::string>(L, 1);
-        std::string url = ALE::CHECKVAL<std::string>(L, 2);
         std::string body;
         std::string bodyContentType;
         httplib::Headers headers;
 
-        int headersIdx = 3;
-        int callbackIdx = 3;
+        sol::object headersOrCallback = arg3;
+        sol::object callbackAfterHeaders = arg4.value_or(sol::object());
 
-        if (!lua_istable(L, headersIdx) && lua_isstring(L, headersIdx) && lua_isstring(L, headersIdx + 1))
+        if (arg3.get_type() == sol::type::string && arg4 && arg4->get_type() == sol::type::string)
         {
-            body = ALE::CHECKVAL<std::string>(L, 3);
-            bodyContentType = ALE::CHECKVAL<std::string>(L, 4);
-            headersIdx = 5;
-            callbackIdx = 5;
+            body = arg3.as<std::string>();
+            bodyContentType = arg4->as<std::string>();
+            headersOrCallback = arg5.value_or(sol::object());
+            callbackAfterHeaders = arg6.value_or(sol::object());
         }
 
-        if (lua_istable(L, headersIdx))
+        sol::object callbackObject = headersOrCallback;
+        if (headersOrCallback.get_type() == sol::type::table)
         {
-            ++callbackIdx;
-
-            lua_pushnil(L); // First key
-            while (lua_next(L, headersIdx) != 0)
+            sol::table headerTable = headersOrCallback.as<sol::table>();
+            for (auto const& pair : headerTable)
             {
-                // Uses 'key' (at index -2) and 'value' (at index -1)
-                if (lua_isstring(L, -2))
-                {
-                    std::string key(lua_tostring(L, -2));
-                    std::string value(lua_tostring(L, -1));
-                    headers.insert(std::pair<std::string, std::string>(key, value));
-                }
-                // Removes 'value'; keeps 'key' for next iteration
-                lua_pop(L, 1);
+                if (pair.first.get_type() == sol::type::string
+                    && (pair.second.get_type() == sol::type::string || pair.second.get_type() == sol::type::number))
+                    headers.insert(std::pair<std::string, std::string>(pair.first.as<std::string>(), pair.second.as<std::string>()));
             }
-        }
 
-        lua_pushvalue(L, callbackIdx);
-        int funcRef = luaL_ref(L, LUA_REGISTRYINDEX);
-        if (funcRef >= 0)
-        {
-            ALE::GALE->httpManager.PushRequest(new HttpWorkItem(funcRef, httpVerb, url, body, bodyContentType, headers));
-        }
-        else
-        {
-            luaL_argerror(L, callbackIdx, "unable to make a ref to function");
+            callbackObject = callbackAfterHeaders;
         }
 
-        return 0;
+        if (callbackObject.get_type() != sol::type::function)
+            throw std::invalid_argument("function expected for the HTTP request callback");
+
+        sALE->httpManager.PushRequest(new HttpWorkItem(callbackObject.as<sol::protected_function>(), httpVerb, url, body, bodyContentType, headers));
     }
 
     /**
@@ -2723,22 +2393,21 @@ namespace LuaGlobalFunctions
      * @param string n_str
      * @return int64 value
      */
-    int CreateLongLong(lua_State* L)
+    int64 CreateLongLong(sol::optional<sol::object> value)
     {
         long long init = 0;
-        if (lua_isstring(L, 1))
+        if (value && value->get_type() == sol::type::string)
         {
-            std::string str = ALE::CHECKVAL<std::string>(L, 1);
+            std::string str = value->as<std::string>();
             std::istringstream iss(str);
             iss >> init;
             if (iss.bad())
-                return luaL_argerror(L, 1, "long long (as string) could not be converted");
+                throw std::invalid_argument("long long (as string) could not be converted");
         }
-        else if (!lua_isnoneornil(L, 1))
-            init = ALE::CHECKVAL<long long>(L, 1);
+        else if (value && value->get_type() != sol::type::lua_nil)
+            init = value->as<long long>();
 
-        ALE::Push(L, init);
-        return 1;
+        return init;
     }
 
     /**
@@ -2755,22 +2424,21 @@ namespace LuaGlobalFunctions
      * @param string n_str
      * @return uint64 value
      */
-    int CreateULongLong(lua_State* L)
+    uint64 CreateULongLong(sol::optional<sol::object> value)
     {
         unsigned long long init = 0;
-        if (lua_isstring(L, 1))
+        if (value && value->get_type() == sol::type::string)
         {
-            std::string str = ALE::CHECKVAL<std::string>(L, 1);
+            std::string str = value->as<std::string>();
             std::istringstream iss(str);
             iss >> init;
             if (iss.bad())
-                return luaL_argerror(L, 1, "unsigned long long (as string) could not be converted");
+                throw std::invalid_argument("unsigned long long (as string) could not be converted");
         }
-        else if (!lua_isnoneornil(L, 1))
-            init = ALE::CHECKVAL<unsigned long long>(L, 1);
+        else if (value && value->get_type() != sol::type::lua_nil)
+            init = value->as<unsigned long long>();
 
-        ALE::Push(L, init);
-        return 1;
+        return init;
     }
 
     /**
@@ -2784,20 +2452,19 @@ namespace LuaGlobalFunctions
      * @proto (event_type)
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterBGEvent]
      */
-    int ClearBattleGroundEvents(lua_State* L)
+    void ClearBattleGroundEvents(sol::optional<uint32> eventTypeArg)
     {
         typedef EventKey<Hooks::BGEvents> Key;
 
-        if (lua_isnoneornil(L, 1))
+        if (!eventTypeArg)
         {
-            ALE::GetALE(L)->BGEventBindings->Clear();
+            sALE->BGEventBindings->Clear();
         }
         else
         {
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 1);
-            ALE::GetALE(L)->BGEventBindings->Clear(Key((Hooks::BGEvents)event_type));
+            uint32 event_type = *eventTypeArg;
+            sALE->BGEventBindings->Clear(Key((Hooks::BGEvents)event_type));
         }
-        return 0;
     }
 
     /**
@@ -2815,25 +2482,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of one or more [Creature]s whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterCreatureEvent]
      */
-    int ClearCreatureEvents(lua_State* L)
+    void ClearCreatureEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::CreatureEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::CREATURE_EVENT_COUNT; ++i)
-                E->CreatureEventBindings->Clear(Key((Hooks::CreatureEvents)i, entry));
+                sALE->CreatureEventBindings->Clear(Key((Hooks::CreatureEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->CreatureEventBindings->Clear(Key((Hooks::CreatureEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->CreatureEventBindings->Clear(Key((Hooks::CreatureEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -2852,27 +2514,20 @@ namespace LuaGlobalFunctions
      * @param uint32 instance_id : the instance ID of a single [Creature] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterCreatureEvent]
      */
-    int ClearUniqueCreatureEvents(lua_State* L)
+    void ClearUniqueCreatureEvents(ObjectGuid guid, uint32 instanceId, sol::optional<uint32> eventTypeArg)
     {
         typedef UniqueObjectKey<Hooks::CreatureEvents> Key;
 
-        if (lua_isnoneornil(L, 3))
+        if (!eventTypeArg)
         {
-            ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-            uint32 instanceId = ALE::CHECKVAL<uint32>(L, 2);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::CREATURE_EVENT_COUNT; ++i)
-                E->CreatureUniqueBindings->Clear(Key((Hooks::CreatureEvents)i, guid, instanceId));
+                sALE->CreatureUniqueBindings->Clear(Key((Hooks::CreatureEvents)i, guid, instanceId));
         }
         else
         {
-            ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 1);
-            uint32 instanceId = ALE::CHECKVAL<uint32>(L, 2);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 3);
-            ALE::GetALE(L)->CreatureUniqueBindings->Clear(Key((Hooks::CreatureEvents)event_type, guid, instanceId));
+            uint32 event_type = *eventTypeArg;
+            sALE->CreatureUniqueBindings->Clear(Key((Hooks::CreatureEvents)event_type, guid, instanceId));
         }
-        return 0;
     }
 
     /**
@@ -2890,25 +2545,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of a [Creature] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterCreatureGossipEvent]
      */
-    int ClearCreatureGossipEvents(lua_State* L)
+    void ClearCreatureGossipEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::GossipEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::GOSSIP_EVENT_COUNT; ++i)
-                E->CreatureGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
+                sALE->CreatureGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->CreatureGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->CreatureGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -2926,25 +2576,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of a [GameObject] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterGameObjectEvent]
      */
-    int ClearGameObjectEvents(lua_State* L)
+    void ClearGameObjectEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::GameObjectEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::GAMEOBJECT_EVENT_COUNT; ++i)
-                E->GameObjectEventBindings->Clear(Key((Hooks::GameObjectEvents)i, entry));
+                sALE->GameObjectEventBindings->Clear(Key((Hooks::GameObjectEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->GameObjectEventBindings->Clear(Key((Hooks::GameObjectEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->GameObjectEventBindings->Clear(Key((Hooks::GameObjectEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -2962,25 +2607,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of a [GameObject] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterGameObjectGossipEvent]
      */
-    int ClearGameObjectGossipEvents(lua_State* L)
+    void ClearGameObjectGossipEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::GossipEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::GOSSIP_EVENT_COUNT; ++i)
-                E->GameObjectGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
+                sALE->GameObjectGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->GameObjectGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->GameObjectGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -2994,20 +2634,19 @@ namespace LuaGlobalFunctions
      * @proto (event_type)
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterGroupEvent]
      */
-    int ClearGroupEvents(lua_State* L)
+    void ClearGroupEvents(sol::optional<uint32> eventTypeArg)
     {
         typedef EventKey<Hooks::GroupEvents> Key;
 
-        if (lua_isnoneornil(L, 1))
+        if (!eventTypeArg)
         {
-            ALE::GetALE(L)->GroupEventBindings->Clear();
+            sALE->GroupEventBindings->Clear();
         }
         else
         {
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 1);
-            ALE::GetALE(L)->GroupEventBindings->Clear(Key((Hooks::GroupEvents)event_type));
+            uint32 event_type = *eventTypeArg;
+            sALE->GroupEventBindings->Clear(Key((Hooks::GroupEvents)event_type));
         }
-        return 0;
     }
 
     /**
@@ -3021,20 +2660,19 @@ namespace LuaGlobalFunctions
      * @proto (event_type)
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterGuildEvent]
      */
-    int ClearGuildEvents(lua_State* L)
+    void ClearGuildEvents(sol::optional<uint32> eventTypeArg)
     {
         typedef EventKey<Hooks::GuildEvents> Key;
 
-        if (lua_isnoneornil(L, 1))
+        if (!eventTypeArg)
         {
-            ALE::GetALE(L)->GuildEventBindings->Clear();
+            sALE->GuildEventBindings->Clear();
         }
         else
         {
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 1);
-            ALE::GetALE(L)->GuildEventBindings->Clear(Key((Hooks::GuildEvents)event_type));
+            uint32 event_type = *eventTypeArg;
+            sALE->GuildEventBindings->Clear(Key((Hooks::GuildEvents)event_type));
         }
-        return 0;
     }
 
     /**
@@ -3052,25 +2690,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of an [Item] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterItemEvent]
      */
-    int ClearItemEvents(lua_State* L)
+    void ClearItemEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::ItemEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::ITEM_EVENT_COUNT; ++i)
-                E->ItemEventBindings->Clear(Key((Hooks::ItemEvents)i, entry));
+                sALE->ItemEventBindings->Clear(Key((Hooks::ItemEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->ItemEventBindings->Clear(Key((Hooks::ItemEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->ItemEventBindings->Clear(Key((Hooks::ItemEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -3088,25 +2721,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of an [Item] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterItemGossipEvent]
      */
-    int ClearItemGossipEvents(lua_State* L)
+    void ClearItemGossipEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::GossipEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::GOSSIP_EVENT_COUNT; ++i)
-                E->ItemGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
+                sALE->ItemGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->ItemGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->ItemGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -3121,25 +2749,20 @@ namespace LuaGlobalFunctions
      * @param uint32 opcode : the type of [WorldPacket] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterPacketEvent]
      */
-    int ClearPacketEvents(lua_State* L)
+    void ClearPacketEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::PacketEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::PACKET_EVENT_COUNT; ++i)
-                E->PacketEventBindings->Clear(Key((Hooks::PacketEvents)i, entry));
+                sALE->PacketEventBindings->Clear(Key((Hooks::PacketEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->PacketEventBindings->Clear(Key((Hooks::PacketEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->PacketEventBindings->Clear(Key((Hooks::PacketEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -3153,20 +2776,19 @@ namespace LuaGlobalFunctions
      * @proto (event_type)
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterPlayerEvent]
      */
-    int ClearPlayerEvents(lua_State* L)
+    void ClearPlayerEvents(sol::optional<uint32> eventTypeArg)
     {
         typedef EventKey<Hooks::PlayerEvents> Key;
 
-        if (lua_isnoneornil(L, 1))
+        if (!eventTypeArg)
         {
-            ALE::GetALE(L)->PlayerEventBindings->Clear();
+            sALE->PlayerEventBindings->Clear();
         }
         else
         {
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 1);
-            ALE::GetALE(L)->PlayerEventBindings->Clear(Key((Hooks::PlayerEvents)event_type));
+            uint32 event_type = *eventTypeArg;
+            sALE->PlayerEventBindings->Clear(Key((Hooks::PlayerEvents)event_type));
         }
-        return 0;
     }
 
     /**
@@ -3181,25 +2803,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the low GUID of a [Player] whose handlers will be cleared
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterPlayerGossipEvent]
      */
-    int ClearPlayerGossipEvents(lua_State* L)
+    void ClearPlayerGossipEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::GossipEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::GOSSIP_EVENT_COUNT; ++i)
-                E->PlayerGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
+                sALE->PlayerGossipBindings->Clear(Key((Hooks::GossipEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->PlayerGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->PlayerGossipBindings->Clear(Key((Hooks::GossipEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -3213,20 +2830,19 @@ namespace LuaGlobalFunctions
      * @proto (event_type)
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterServerEvent]
      */
-    int ClearServerEvents(lua_State* L)
+    void ClearServerEvents(sol::optional<uint32> eventTypeArg)
     {
         typedef EventKey<Hooks::ServerEvents> Key;
 
-        if (lua_isnoneornil(L, 1))
+        if (!eventTypeArg)
         {
-            ALE::GetALE(L)->ServerEventBindings->Clear();
+            sALE->ServerEventBindings->Clear();
         }
         else
         {
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 1);
-            ALE::GetALE(L)->ServerEventBindings->Clear(Key((Hooks::ServerEvents)event_type));
+            uint32 event_type = *eventTypeArg;
+            sALE->ServerEventBindings->Clear(Key((Hooks::ServerEvents)event_type));
         }
-        return 0;
     }
 
     /**
@@ -3241,26 +2857,20 @@ namespace LuaGlobalFunctions
      * @param uint32 map_id : the ID of a [Map]
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterPlayerGossipEvent]
      */
-    int ClearMapEvents(lua_State* L)
+    void ClearMapEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::InstanceEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::INSTANCE_EVENT_COUNT; ++i)
-                E->MapEventBindings->Clear(Key((Hooks::InstanceEvents)i, entry));
+                sALE->MapEventBindings->Clear(Key((Hooks::InstanceEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->MapEventBindings->Clear(Key((Hooks::InstanceEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->MapEventBindings->Clear(Key((Hooks::InstanceEvents)event_type, entry));
         }
-
-        return 0;
     }
 
     /**
@@ -3275,26 +2885,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of an instance of a [Map]
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterInstanceEvent]
      */
-    int ClearInstanceEvents(lua_State* L)
+    void ClearInstanceEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::InstanceEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::INSTANCE_EVENT_COUNT; ++i)
-                E->InstanceEventBindings->Clear(Key((Hooks::InstanceEvents)i, entry));
+                sALE->InstanceEventBindings->Clear(Key((Hooks::InstanceEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->InstanceEventBindings->Clear(Key((Hooks::InstanceEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->InstanceEventBindings->Clear(Key((Hooks::InstanceEvents)event_type, entry));
         }
-
-        return 0;
     }
 
     /**
@@ -3308,20 +2912,19 @@ namespace LuaGlobalFunctions
      * @proto (event_type)
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterTicketEvent]
      */
-    int ClearTicketEvents(lua_State* L)
+    void ClearTicketEvents(sol::optional<uint32> eventTypeArg)
     {
         typedef EventKey<Hooks::TicketEvents> Key;
 
-        if (lua_isnoneornil(L, 1))
+        if (!eventTypeArg)
         {
-            ALE::GetALE(L)->TicketEventBindings->Clear();
+            sALE->TicketEventBindings->Clear();
         }
         else
         {
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 1);
-            ALE::GetALE(L)->TicketEventBindings->Clear(Key((Hooks::TicketEvents)event_type));
+            uint32 event_type = *eventTypeArg;
+            sALE->TicketEventBindings->Clear(Key((Hooks::TicketEvents)event_type));
         }
-        return 0;
     }
 
     /**
@@ -3337,25 +2940,20 @@ namespace LuaGlobalFunctions
      * @param uint32 entry : the ID of a [Spell]s
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterSpellEvent]
      */
-    int ClearSpellEvents(lua_State* L)
+    void ClearSpellEvents(uint32 entry, sol::optional<uint32> eventTypeArg)
     {
         typedef EntryKey<Hooks::SpellEvents> Key;
 
-        if (lua_isnoneornil(L, 2))
+        if (!eventTypeArg)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-
-            ALE* E = ALE::GetALE(L);
             for (uint32 i = 1; i < Hooks::SPELL_EVENT_COUNT; ++i)
-                E->SpellEventBindings->Clear(Key((Hooks::SpellEvents)i, entry));
+                sALE->SpellEventBindings->Clear(Key((Hooks::SpellEvents)i, entry));
         }
         else
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 1);
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 2);
-            ALE::GetALE(L)->SpellEventBindings->Clear(Key((Hooks::SpellEvents)event_type, entry));
+            uint32 event_type = *eventTypeArg;
+            sALE->SpellEventBindings->Clear(Key((Hooks::SpellEvents)event_type, entry));
         }
-        return 0;
     }
 
     /**
@@ -3369,20 +2967,19 @@ namespace LuaGlobalFunctions
      * @proto (event_type)
      * @param uint32 event_type : the event whose handlers will be cleared, see [Global:RegisterAllCreatureEvent]
      */
-    int ClearAllCreatureEvents(lua_State* L)
+    void ClearAllCreatureEvents(sol::optional<uint32> eventTypeArg)
     {
         typedef EventKey<Hooks::AllCreatureEvents> Key;
 
-        if (lua_isnoneornil(L, 1))
+        if (!eventTypeArg)
         {
-            ALE::GetALE(L)->AllCreatureEventBindings->Clear();
+            sALE->AllCreatureEventBindings->Clear();
         }
         else
         {
-            uint32 event_type = ALE::CHECKVAL<uint32>(L, 1);
-            ALE::GetALE(L)->AllCreatureEventBindings->Clear(Key((Hooks::AllCreatureEvents)event_type));
+            uint32 event_type = *eventTypeArg;
+            sALE->AllCreatureEventBindings->Clear(Key((Hooks::AllCreatureEvents)event_type));
         }
-        return 0;
     }
 
     /**
@@ -3396,14 +2993,12 @@ namespace LuaGlobalFunctions
      * @return int16 the ID of the team to own Halaa
      * @return float the slider position.
      */
-    int GetOwnerHalaa(lua_State* L)
+    std::tuple<TeamId, float> GetOwnerHalaa()
     {
         OutdoorPvPNA* nagrandPvp = (OutdoorPvPNA*)sOutdoorPvPMgr->GetOutdoorPvPToZoneId(3518);
         OPvPCapturePointNA* halaa = nagrandPvp->GetCapturePoint();
-        ALE::Push(L, halaa->GetControllingFaction());
-        ALE::Push(L, halaa->GetSlider());
 
-        return 2;
+        return std::tuple<TeamId, float>(halaa->GetControllingFaction(), halaa->GetSlider());
     }
 
     /**
@@ -3413,10 +3008,8 @@ namespace LuaGlobalFunctions
      *
      * @param uint16 teamId : the ID of the team to own Halaa
      */
-    int SetOwnerHalaa(lua_State* L)
+    void SetOwnerHalaa(uint16 teamId)
     {
-        uint16 teamId = ALE::CHECKVAL<uint16>(L, 1);
-
         OutdoorPvPNA* nagrandPvp = (OutdoorPvPNA*)sOutdoorPvPMgr->GetOutdoorPvPToZoneId(3518);
         OPvPCapturePointNA* halaa = nagrandPvp->GetCapturePoint();
 
@@ -3430,10 +3023,8 @@ namespace LuaGlobalFunctions
         }
         else
         {
-            return luaL_argerror(L, 1, "0 for Alliance or 1 for Horde expected");
+            throw std::invalid_argument("0 for Alliance or 1 for Horde expected");
         }
-
-        return 0;
     }
 
     /**
@@ -3446,12 +3037,8 @@ namespace LuaGlobalFunctions
      *
      * @return string, string : The localized OptionText and BoxText for the gossip menu option, or the default text if no localization is found.
      */
-    int GetGossipMenuOptionLocale(lua_State* L)
+    std::tuple<std::string, std::string> GetGossipMenuOptionLocale(uint32 menuId, uint32 optionId, uint8 locale)
     {
-        uint32 menuId = ALE::CHECKVAL<uint32>(L, 1);
-        uint32 optionId = ALE::CHECKVAL<uint32>(L, 2);
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 3);
-
         std::string strOptionText;
         std::string strBoxText;
 
@@ -3480,9 +3067,7 @@ namespace LuaGlobalFunctions
             }
         }
 
-        ALE::Push(L, strOptionText);
-        ALE::Push(L, strBoxText);
-        return 2;
+        return std::tuple<std::string, std::string>(strOptionText, strBoxText);
     }
 
     /**
@@ -3495,39 +3080,27 @@ namespace LuaGlobalFunctions
      * @return uint32 pos_z
      * @return uint32 pos_o
      */
-    int GetMapEntrance(lua_State* L)
+    sol::optional<std::tuple<float, float, float, float>> GetMapEntrance(uint32 mapId)
     {
-        uint32 mapId = ALE::CHECKVAL<uint32>(L, 1);
         AreaTriggerTeleport const* at = sObjectMgr->GetMapEntranceTrigger(mapId);
 
         if (!at)
-        {
-            lua_pushnil(L);
-            return 1;
-        }
-
-        ALE::Push(L, at->target_X);
-        ALE::Push(L, at->target_Y);
-        ALE::Push(L, at->target_Z);
-        ALE::Push(L, at->target_Orientation);
+            return sol::nullopt;
 
-        return 5;
+        return std::tuple<float, float, float, float>(at->target_X, at->target_Y, at->target_Z, at->target_Orientation);
     }
-      
-    /**  
+
+    /**
      * Get the [SpellInfo] for the specified [Spell] id
      *
      * @param uint32 spellId : the ID of the spell
      * @return [SpellInfo] spellInfo
      */
-    int GetSpellInfo(lua_State* L)
+    SpellInfo* GetSpellInfo(uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 1);
-        ALE::Push(L, sSpellMgr->GetSpellInfo(spellId));
-        return 1;
-
+        return const_cast<SpellInfo*>(sSpellMgr->GetSpellInfo(spellId));
     }
-  
+
     /**
      * Returns an entry from the specified DBC (DatabaseClient) store.
      *
@@ -3538,10 +3111,9 @@ namespace LuaGlobalFunctions
      *
      * @return [DBCStore] store : The requested DBC store instance
      */
-    int LookupEntry(lua_State* L)
+    sol::object LookupEntry(std::string dbcName, uint32 id, sol::this_state s)
     {
-        const char* dbcName = ALE::CHECKVAL<const char*>(L, 1);
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
+        sol::state_view lua(s);
 
         for (const auto& dbc : dbcRegistry)
         {
@@ -3549,14 +3121,137 @@ namespace LuaGlobalFunctions
             {
                 const void* entry = dbc.lookupFunction(id);
                 if (!entry)
-                    return 0;
+                    return sol::make_object(lua, sol::lua_nil);
 
-                dbc.pushFunction(L, entry);
-                return 1;
+                return dbc.makeObject(lua, entry);
             }
         }
 
-        return luaL_error(L, "Invalid DBC name: %s", dbcName);
+        throw std::runtime_error(Acore::StringFormat("Invalid DBC name: {}", dbcName));
     }
 }
-#endif
+
+void RegisterGlobalMethods(sol::state& lua)
+{
+    lua["GetLuaEngine"]                 = ALEBind::Function(&LuaGlobalFunctions::GetLuaEngine);
+    lua["GetCoreName"]                  = ALEBind::Function(&LuaGlobalFunctions::GetCoreName);
+    lua["GetConfigValue"]               = ALEBind::Function(&LuaGlobalFunctions::GetConfigValue);
+    lua["GetRealmID"]                   = ALEBind::Function(&LuaGlobalFunctions::GetRealmID);
+    lua["GetCoreVersion"]               = ALEBind::Function(&LuaGlobalFunctions::GetCoreVersion);
+    lua["GetCoreExpansion"]             = ALEBind::Function(&LuaGlobalFunctions::GetCoreExpansion);
+    lua["GetStateMap"]                  = ALEBind::Function(&LuaGlobalFunctions::GetStateMap);
+    lua["GetStateMapId"]                = ALEBind::Function(&LuaGlobalFunctions::GetStateMapId);
+    lua["GetStateInstanceId"]           = ALEBind::Function(&LuaGlobalFunctions::GetStateInstanceId);
+    lua["GetQuest"]                     = ALEBind::Function(&LuaGlobalFunctions::GetQuest);
+    lua["GetPlayerByGUID"]              = ALEBind::Function(&LuaGlobalFunctions::GetPlayerByGUID);
+    lua["GetPlayerByName"]              = ALEBind::Function(&LuaGlobalFunctions::GetPlayerByName);
+    lua["GetGameTime"]                  = ALEBind::Function(&LuaGlobalFunctions::GetGameTime);
+    lua["GetPlayersInWorld"]            = ALEBind::Function(&LuaGlobalFunctions::GetPlayersInWorld);
+    lua["GetGuildByName"]               = ALEBind::Function(&LuaGlobalFunctions::GetGuildByName);
+    lua["GetMapById"]                   = ALEBind::Function(&LuaGlobalFunctions::GetMapById);
+    lua["GetGuildByLeaderGUID"]         = ALEBind::Function(&LuaGlobalFunctions::GetGuildByLeaderGUID);
+    lua["GetPlayerCount"]               = ALEBind::Function(&LuaGlobalFunctions::GetPlayerCount);
+    lua["GetPlayerGUID"]                = ALEBind::Function(&LuaGlobalFunctions::GetPlayerGUID);
+    lua["GetItemGUID"]                  = ALEBind::Function(&LuaGlobalFunctions::GetItemGUID);
+    lua["GetItemTemplate"]              = ALEBind::Function(&LuaGlobalFunctions::GetItemTemplate);
+    lua["GetObjectGUID"]                = ALEBind::Function(&LuaGlobalFunctions::GetObjectGUID);
+    lua["GetUnitGUID"]                  = ALEBind::Function(&LuaGlobalFunctions::GetUnitGUID);
+    lua["GetGUIDLow"]                   = ALEBind::Function(&LuaGlobalFunctions::GetGUIDLow);
+    lua["GetItemLink"]                  = ALEBind::Function(&LuaGlobalFunctions::GetItemLink);
+    lua["GetGUIDType"]                  = ALEBind::Function(&LuaGlobalFunctions::GetGUIDType);
+    lua["GetGUIDEntry"]                 = ALEBind::Function(&LuaGlobalFunctions::GetGUIDEntry);
+    lua["GetPackedGUIDSize"]            = ALEBind::Function(&LuaGlobalFunctions::GetPackedGUIDSize);
+    lua["GetAreaName"]                  = ALEBind::Function(&LuaGlobalFunctions::GetAreaName);
+    lua["GetActiveGameEvents"]          = ALEBind::Function(&LuaGlobalFunctions::GetActiveGameEvents);
+    lua["RegisterServerEvent"]          = ALEBind::Function(&LuaGlobalFunctions::RegisterServerEvent);
+    lua["RegisterPlayerEvent"]          = ALEBind::Function(&LuaGlobalFunctions::RegisterPlayerEvent);
+    lua["RegisterGuildEvent"]           = ALEBind::Function(&LuaGlobalFunctions::RegisterGuildEvent);
+    lua["RegisterGroupEvent"]           = ALEBind::Function(&LuaGlobalFunctions::RegisterGroupEvent);
+    lua["RegisterBGEvent"]              = ALEBind::Function(&LuaGlobalFunctions::RegisterBGEvent);
+    lua["RegisterPacketEvent"]          = ALEBind::Function(&LuaGlobalFunctions::RegisterPacketEvent);
+    lua["RegisterCreatureGossipEvent"]  = ALEBind::Function(&LuaGlobalFunctions::RegisterCreatureGossipEvent);
+    lua["RegisterGameObjectGossipEvent"] = ALEBind::Function(&LuaGlobalFunctions::RegisterGameObjectGossipEvent);
+    lua["RegisterItemEvent"]            = ALEBind::Function(&LuaGlobalFunctions::RegisterItemEvent);
+    lua["RegisterItemGossipEvent"]      = ALEBind::Function(&LuaGlobalFunctions::RegisterItemGossipEvent);
+    lua["RegisterMapEvent"]             = ALEBind::Function(&LuaGlobalFunctions::RegisterMapEvent);
+    lua["RegisterInstanceEvent"]        = ALEBind::Function(&LuaGlobalFunctions::RegisterInstanceEvent);
+    lua["RegisterPlayerGossipEvent"]    = ALEBind::Function(&LuaGlobalFunctions::RegisterPlayerGossipEvent);
+    lua["RegisterCreatureEvent"]        = ALEBind::Function(&LuaGlobalFunctions::RegisterCreatureEvent);
+    lua["RegisterUniqueCreatureEvent"]  = ALEBind::Function(&LuaGlobalFunctions::RegisterUniqueCreatureEvent);
+    lua["RegisterGameObjectEvent"]      = ALEBind::Function(&LuaGlobalFunctions::RegisterGameObjectEvent);
+    lua["RegisterTicketEvent"]          = ALEBind::Function(&LuaGlobalFunctions::RegisterTicketEvent);
+    lua["RegisterSpellEvent"]           = ALEBind::Function(&LuaGlobalFunctions::RegisterSpellEvent);
+    lua["RegisterAllCreatureEvent"]     = ALEBind::Function(&LuaGlobalFunctions::RegisterAllCreatureEvent);
+    lua["ReloadALE"]                    = ALEBind::Function(&LuaGlobalFunctions::ReloadALE);
+    lua["RunCommand"]                   = ALEBind::Function(&LuaGlobalFunctions::RunCommand);
+    lua["SendWorldMessage"]             = ALEBind::Function(&LuaGlobalFunctions::SendWorldMessage);
+    lua["WorldDBQuery"]                 = ALEBind::Function(&LuaGlobalFunctions::WorldDBQuery);
+    lua["WorldDBQueryAsync"]            = ALEBind::Function(&LuaGlobalFunctions::WorldDBQueryAsync);
+    lua["WorldDBExecute"]               = ALEBind::Function(&LuaGlobalFunctions::WorldDBExecute);
+    lua["CharDBQuery"]                  = ALEBind::Function(&LuaGlobalFunctions::CharDBQuery);
+    lua["CharDBQueryAsync"]             = ALEBind::Function(&LuaGlobalFunctions::CharDBQueryAsync);
+    lua["CharDBExecute"]                = ALEBind::Function(&LuaGlobalFunctions::CharDBExecute);
+    lua["AuthDBQuery"]                  = ALEBind::Function(&LuaGlobalFunctions::AuthDBQuery);
+    lua["AuthDBQueryAsync"]             = ALEBind::Function(&LuaGlobalFunctions::AuthDBQueryAsync);
+    lua["AuthDBExecute"]                = ALEBind::Function(&LuaGlobalFunctions::AuthDBExecute);
+    lua["CreateLuaEvent"]               = ALEBind::Function(&LuaGlobalFunctions::CreateLuaEvent);
+    lua["RemoveEventById"]              = ALEBind::Function(&LuaGlobalFunctions::RemoveEventById);
+    lua["RemoveEvents"]                 = ALEBind::Function(&LuaGlobalFunctions::RemoveEvents);
+    lua["PerformIngameSpawn"]           = ALEBind::Function(&LuaGlobalFunctions::PerformIngameSpawn);
+    lua["CreatePacket"]                 = ALEBind::Function(&LuaGlobalFunctions::CreatePacket);
+    lua["AddVendorItem"]                = ALEBind::Function(&LuaGlobalFunctions::AddVendorItem);
+    lua["VendorRemoveItem"]             = ALEBind::Function(&LuaGlobalFunctions::VendorRemoveItem);
+    lua["VendorRemoveAllItems"]         = ALEBind::Function(&LuaGlobalFunctions::VendorRemoveAllItems);
+    lua["Kick"]                         = ALEBind::Function(&LuaGlobalFunctions::Kick);
+    lua["Ban"]                          = ALEBind::Function(&LuaGlobalFunctions::Ban);
+    lua["SaveAllPlayers"]               = ALEBind::Function(&LuaGlobalFunctions::SaveAllPlayers);
+    lua["SendMail"]                     = ALEBind::Function(&LuaGlobalFunctions::SendMail);
+    lua["bit_and"]                      = ALEBind::Function(&LuaGlobalFunctions::bit_and);
+    lua["bit_or"]                       = ALEBind::Function(&LuaGlobalFunctions::bit_or);
+    lua["bit_lshift"]                   = ALEBind::Function(&LuaGlobalFunctions::bit_lshift);
+    lua["bit_rshift"]                   = ALEBind::Function(&LuaGlobalFunctions::bit_rshift);
+    lua["bit_xor"]                      = ALEBind::Function(&LuaGlobalFunctions::bit_xor);
+    lua["bit_not"]                      = ALEBind::Function(&LuaGlobalFunctions::bit_not);
+    lua["AddTaxiPath"]                  = ALEBind::Function(&LuaGlobalFunctions::AddTaxiPath);
+    lua["IsCompatibilityMode"]          = ALEBind::Function(&LuaGlobalFunctions::IsCompatibilityMode);
+    lua["IsInventoryPos"]               = ALEBind::Function(&LuaGlobalFunctions::IsInventoryPos);
+    lua["IsEquipmentPos"]               = ALEBind::Function(&LuaGlobalFunctions::IsEquipmentPos);
+    lua["IsBankPos"]                    = ALEBind::Function(&LuaGlobalFunctions::IsBankPos);
+    lua["IsBagPos"]                     = ALEBind::Function(&LuaGlobalFunctions::IsBagPos);
+    lua["IsGameEventActive"]            = ALEBind::Function(&LuaGlobalFunctions::IsGameEventActive);
+    lua["GetCurrTime"]                  = ALEBind::Function(&LuaGlobalFunctions::GetCurrTime);
+    lua["GetTimeDiff"]                  = ALEBind::Function(&LuaGlobalFunctions::GetTimeDiff);
+    lua["PrintInfo"]                    = ALEBind::Function(&LuaGlobalFunctions::PrintInfo);
+    lua["PrintError"]                   = ALEBind::Function(&LuaGlobalFunctions::PrintError);
+    lua["PrintDebug"]                   = ALEBind::Function(&LuaGlobalFunctions::PrintDebug);
+    lua["StartGameEvent"]               = ALEBind::Function(&LuaGlobalFunctions::StartGameEvent);
+    lua["StopGameEvent"]                = ALEBind::Function(&LuaGlobalFunctions::StopGameEvent);
+    lua["HttpRequest"]                  = ALEBind::Function(&LuaGlobalFunctions::HttpRequest);
+    lua["CreateLongLong"]               = ALEBind::Function(&LuaGlobalFunctions::CreateLongLong);
+    lua["CreateULongLong"]              = ALEBind::Function(&LuaGlobalFunctions::CreateULongLong);
+    lua["ClearBattleGroundEvents"]      = ALEBind::Function(&LuaGlobalFunctions::ClearBattleGroundEvents);
+    lua["ClearCreatureEvents"]          = ALEBind::Function(&LuaGlobalFunctions::ClearCreatureEvents);
+    lua["ClearUniqueCreatureEvents"]    = ALEBind::Function(&LuaGlobalFunctions::ClearUniqueCreatureEvents);
+    lua["ClearCreatureGossipEvents"]    = ALEBind::Function(&LuaGlobalFunctions::ClearCreatureGossipEvents);
+    lua["ClearGameObjectEvents"]        = ALEBind::Function(&LuaGlobalFunctions::ClearGameObjectEvents);
+    lua["ClearGameObjectGossipEvents"]  = ALEBind::Function(&LuaGlobalFunctions::ClearGameObjectGossipEvents);
+    lua["ClearGroupEvents"]             = ALEBind::Function(&LuaGlobalFunctions::ClearGroupEvents);
+    lua["ClearGuildEvents"]             = ALEBind::Function(&LuaGlobalFunctions::ClearGuildEvents);
+    lua["ClearItemEvents"]              = ALEBind::Function(&LuaGlobalFunctions::ClearItemEvents);
+    lua["ClearItemGossipEvents"]        = ALEBind::Function(&LuaGlobalFunctions::ClearItemGossipEvents);
+    lua["ClearPacketEvents"]            = ALEBind::Function(&LuaGlobalFunctions::ClearPacketEvents);
+    lua["ClearPlayerEvents"]            = ALEBind::Function(&LuaGlobalFunctions::ClearPlayerEvents);
+    lua["ClearPlayerGossipEvents"]      = ALEBind::Function(&LuaGlobalFunctions::ClearPlayerGossipEvents);
+    lua["ClearServerEvents"]            = ALEBind::Function(&LuaGlobalFunctions::ClearServerEvents);
+    lua["ClearMapEvents"]               = ALEBind::Function(&LuaGlobalFunctions::ClearMapEvents);
+    lua["ClearInstanceEvents"]          = ALEBind::Function(&LuaGlobalFunctions::ClearInstanceEvents);
+    lua["ClearTicketEvents"]            = ALEBind::Function(&LuaGlobalFunctions::ClearTicketEvents);
+    lua["ClearSpellEvents"]             = ALEBind::Function(&LuaGlobalFunctions::ClearSpellEvents);
+    lua["ClearAllCreatureEvents"]       = ALEBind::Function(&LuaGlobalFunctions::ClearAllCreatureEvents);
+    lua["GetOwnerHalaa"]                = ALEBind::Function(&LuaGlobalFunctions::GetOwnerHalaa);
+    lua["SetOwnerHalaa"]                = ALEBind::Function(&LuaGlobalFunctions::SetOwnerHalaa);
+    lua["GetGossipMenuOptionLocale"]    = ALEBind::Function(&LuaGlobalFunctions::GetGossipMenuOptionLocale);
+    lua["GetMapEntrance"]               = ALEBind::Function(&LuaGlobalFunctions::GetMapEntrance);
+    lua["GetSpellInfo"]                 = ALEBind::Function(&LuaGlobalFunctions::GetSpellInfo);
+    lua["LookupEntry"]                  = ALEBind::Function(&LuaGlobalFunctions::LookupEntry);
+}
diff --git a/src/LuaEngine/methods/GroupMethods.h b/src/LuaEngine/methods/GroupMethods.cpp
similarity index 56%
rename from src/LuaEngine/methods/GroupMethods.h
rename to src/LuaEngine/methods/GroupMethods.cpp
index 5c0fc37b74..d1178e71fd 100644
--- a/src/LuaEngine/methods/GroupMethods.h
+++ b/src/LuaEngine/methods/GroupMethods.cpp
@@ -4,8 +4,11 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef GROUPMETHODS_H
-#define GROUPMETHODS_H
+#include "ALEBind.h"
+
+#include "Group.h"
+#include "Player.h"
+#include "WorldPacket.h"
 
 /***
  * Represents a player group in the game, such as a party or raid.
@@ -20,11 +23,9 @@ namespace LuaGroup
      * @param ObjectGuid guid : guid of a possible leader
      * @return bool isLeader
      */
-    int IsLeader(lua_State* L, Group* group)
+    bool IsLeader(Group* group, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        ALE::Push(L, group->IsLeader(guid));
-        return 1;
+        return group->IsLeader(guid);
     }
 
     /**
@@ -32,10 +33,9 @@ namespace LuaGroup
      *
      * @return bool isFull
      */
-    int IsFull(lua_State* L, Group* group)
+    bool IsFull(Group* group)
     {
-        ALE::Push(L, group->IsFull());
-        return 1;
+        return group->IsFull();
     }
 
     /**
@@ -43,10 +43,9 @@ namespace LuaGroup
      *
      * @return bool isLFGGroup
      */
-    int IsLFGGroup(lua_State* L, Group* group)
+    bool IsLFGGroup(Group* group)
     {
-        ALE::Push(L, group->isLFGGroup());
-        return 1;
+        return group->isLFGGroup();
     }
 
     /**
@@ -54,10 +53,9 @@ namespace LuaGroup
      *
      * @return bool isRaid
      */
-    int IsRaidGroup(lua_State* L, Group* group)
+    bool IsRaidGroup(Group* group)
     {
-        ALE::Push(L, group->isRaidGroup());
-        return 1;
+        return group->isRaidGroup();
     }
 
     /**
@@ -65,10 +63,9 @@ namespace LuaGroup
      *
      * @return bool isBG
      */
-    int IsBGGroup(lua_State* L, Group* group)
+    bool IsBGGroup(Group* group)
     {
-        ALE::Push(L, group->isBGGroup());
-        return 1;
+        return group->isBGGroup();
     }
 
     /**
@@ -77,11 +74,9 @@ namespace LuaGroup
      * @param ObjectGuid guid : guid of a player
      * @return bool isMember
      */
-    int IsMember(lua_State* L, Group* group)
+    bool IsMember(Group* group, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        ALE::Push(L, group->IsMember(guid));
-        return 1;
+        return group->IsMember(guid);
     }
 
     /**
@@ -90,11 +85,9 @@ namespace LuaGroup
      * @param ObjectGuid guid : guid of a player
      * @return bool isAssistant
      */
-    int IsAssistant(lua_State* L, Group* group)
+    bool IsAssistant(Group* group, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        ALE::Push(L, group->IsAssistant(guid));
-        return 1;
+        return group->IsAssistant(guid);
     }
 
     /**
@@ -104,12 +97,9 @@ namespace LuaGroup
      * @param [Player] player2 : second [Player] to check
      * @return bool sameSubGroup
      */
-    int SameSubGroup(lua_State* L, Group* group)
+    bool SameSubGroup(Group* group, Player* player1, Player* player2)
     {
-        Player* player1 = ALE::CHECKOBJ<Player>(L, 2);
-        Player* player2 = ALE::CHECKOBJ<Player>(L, 3);
-        ALE::Push(L, group->SameSubGroup(player1, player2));
-        return 1;
+        return group->SameSubGroup(player1, player2);
     }
 
     /**
@@ -118,18 +108,12 @@ namespace LuaGroup
      * @param uint8 subGroup : subGroup ID to check
      * @return bool hasFreeSlot
      */
-    int HasFreeSlotSubGroup(lua_State* L, Group* group)
+    bool HasFreeSlotSubGroup(Group* group, uint8 subGroup)
     {
-        uint8 subGroup = ALE::CHECKVAL<uint8>(L, 2);
-
         if (subGroup >= MAX_RAID_SUBGROUPS)
-        {
-            luaL_argerror(L, 2, "valid subGroup ID expected");
-            return 0;
-        }
+            throw std::invalid_argument("valid subGroup ID expected");
 
-        ALE::Push(L, group->HasFreeSlotSubGroup(subGroup));
-        return 1;
+        return group->HasFreeSlotSubGroup(subGroup);
     }
 
     /**
@@ -138,15 +122,10 @@ namespace LuaGroup
      * @param [Player] player : [Player] to add to the group
      * @return bool added : true if member was added
      */
-    int AddMember(lua_State* L, Group* group)
+    bool AddMember(Group* group, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-
         if (player->GetGroup() || !group->IsCreated() || group->IsFull())
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
+            return false;
 
         if (player->GetGroupInvite())
             player->UninviteFromGroup();
@@ -155,20 +134,17 @@ namespace LuaGroup
         if (success)
             group->BroadcastGroupUpdate();
 
-        ALE::Push(L, success);
-        return 1;
+        return success;
     }
 
-    /*int IsLFGGroup(lua_State* L, Group* group) // TODO: Implementation
+    /*bool IsLFGGroup(Group* group) // TODO: Implementation
     {
-        ALE::Push(L, group->isLFGGroup());
-        return 1;
+        return group->isLFGGroup();
     }*/
 
-    /*int IsBFGroup(lua_State* L, Group* group) // TODO: Implementation
+    /*bool IsBFGroup(Group* group) // TODO: Implementation
     {
-        ALE::Push(L, group->isBFGroup());
-        return 1;
+        return group->isBFGroup();
     }*/
 
     /**
@@ -176,10 +152,9 @@ namespace LuaGroup
      *
      * @return table groupPlayers : table of [Player]s
      */
-    int GetMembers(lua_State* L, Group* group)
+    sol::table GetMembers(Group* group, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (GroupReference* itr = group->GetFirstMember(); itr; itr = itr->next())
@@ -189,12 +164,10 @@ namespace LuaGroup
             if (!member || !member->GetSession())
                 continue;
 
-            ALE::Push(L, member);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = PlayerRef(member);
         }
 
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+        return tbl;
     }
 
     /**
@@ -202,10 +175,9 @@ namespace LuaGroup
      *
      * @return ObjectGuid leaderGUID
      */
-    int GetLeaderGUID(lua_State* L, Group* group)
+    ObjectGuid GetLeaderGUID(Group* group)
     {
-        ALE::Push(L, group->GetLeaderGUID());
-        return 1;
+        return group->GetLeaderGUID();
     }
 
     /**
@@ -213,10 +185,9 @@ namespace LuaGroup
      *
      * @return ObjectGuid groupGUID
      */
-    int GetGUID(lua_State* L, Group* group)
+    ObjectGuid GetGUID(Group* group)
     {
-        ALE::Push(L, group->GET_GUID());
-        return 1;
+        return group->GetGUID();
     }
 
     /**
@@ -225,12 +196,9 @@ namespace LuaGroup
      * @param string name : the [Player]'s name
      * @return ObjectGuid memberGUID
      */
-    int GetMemberGUID(lua_State* L, Group* group)
+    ObjectGuid GetMemberGUID(Group* group, std::string const& name)
     {
-        const char* name = ALE::CHECKVAL<const char*>(L, 2);
-
-        ALE::Push(L, group->GetMemberGUID(name));
-        return 1;
+        return group->GetMemberGUID(name);
     }
 
     /**
@@ -238,10 +206,9 @@ namespace LuaGroup
      *
      * @return uint32 memberCount
      */
-    int GetMembersCount(lua_State* L, Group* group)
+    uint32 GetMembersCount(Group* group)
     {
-        ALE::Push(L, group->GetMembersCount());
-        return 1;
+        return group->GetMembersCount();
     }
 
     /**
@@ -260,10 +227,9 @@ namespace LuaGroup
      *
      * @return [GroupType] groupType
      */
-    int GetGroupType(lua_State* L, Group* group)
+    GroupType GetGroupType(Group* group)
     {
-        ALE::Push(L, group->GetGroupType());
-        return 1;
+        return group->GetGroupType();
     }
 
     /**
@@ -272,11 +238,9 @@ namespace LuaGroup
      * @param ObjectGuid guid : guid of the player
      * @return uint8 subGroupID : a valid subgroup ID or MAX_RAID_SUBGROUPS+1
      */
-    int GetMemberGroup(lua_State* L, Group* group)
+    uint8 GetMemberGroup(Group* group, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        ALE::Push(L, group->GetMemberGroup(guid));
-        return 1;
+        return group->GetMemberGroup(guid);
     }
 
     /**
@@ -284,12 +248,10 @@ namespace LuaGroup
      *
      * @param ObjectGuid guid : guid of the new leader
      */
-    int SetLeader(lua_State* L, Group* group)
+    void SetLeader(Group* group, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         group->ChangeLeader(guid);
         group->SendUpdate();
-        return 0;
     }
 
     /**
@@ -299,14 +261,9 @@ namespace LuaGroup
      * @param bool ignorePlayersInBg : ignores [Player]s in a battleground
      * @param ObjectGuid ignore : ignore a [Player] by their GUID
      */
-    int SendPacket(lua_State* L, Group* group)
+    void SendPacket(Group* group, WorldPacket* data, bool ignorePlayersInBg, ObjectGuid ignore)
     {
-        WorldPacket* data = ALE::CHECKOBJ<WorldPacket>(L, 2);
-        bool ignorePlayersInBg = ALE::CHECKVAL<bool>(L, 3);
-        ObjectGuid ignore = ALE::CHECKVAL<ObjectGuid>(L, 4);
-
         group->BroadcastPacket(data, ignorePlayersInBg, -1, ignore);
-        return 0;
     }
 
     /**
@@ -326,33 +283,27 @@ namespace LuaGroup
      * @param [RemoveMethod] method : method used to remove the player
      * @return bool removed
      */
-    int RemoveMember(lua_State* L, Group* group)
+    bool RemoveMember(Group* group, ObjectGuid guid, sol::optional<uint32> method)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        uint32 method = ALE::CHECKVAL<uint32>(L, 3, 0);
-
-        ALE::Push(L, group->RemoveMember(guid, (RemoveMethod)method));
-        return 1;
+        return group->RemoveMember(guid, (RemoveMethod)method.value_or(0));
     }
 
     /**
      * Disbands this [Group]
      *
      */
-    int Disband(lua_State* /*L*/, Group* group)
+    void Disband(Group* group)
     {
         group->Disband();
-        return 0;
     }
 
     /**
      * Converts this [Group] to a raid [Group]
      *
      */
-    int ConvertToRaid(lua_State* /*L*/, Group* group)
+    void ConvertToRaid(Group* group)
     {
         group->ConvertToRaid();
-        return 0;
     }
 
     /**
@@ -361,22 +312,15 @@ namespace LuaGroup
      * @param ObjectGuid guid : guid of the player to move
      * @param uint8 groupID : the subGroup's ID
      */
-    int SetMembersGroup(lua_State* L, Group* group)
+    void SetMembersGroup(Group* group, ObjectGuid guid, uint8 subGroup)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        uint8 subGroup = ALE::CHECKVAL<uint8>(L, 3);
-
         if (subGroup >= MAX_RAID_SUBGROUPS)
-        {
-            luaL_argerror(L, 3, "valid subGroup ID expected");
-            return 0;
-        }
+            throw std::invalid_argument("valid subGroup ID expected");
 
         if (!group->HasFreeSlotSubGroup(subGroup))
-            return 0;
+            return;
 
         group->ChangeMembersGroup(guid, subGroup);
-        return 0;
     }
 
     /**
@@ -386,22 +330,17 @@ namespace LuaGroup
      * @param ObjectGuid target : GUID of the icon target, 0 is to clear the icon
      * @param ObjectGuid setter : GUID of the icon setter
      */
-    int SetTargetIcon(lua_State* L, Group* group)
+    void SetTargetIcon(Group* group, uint8 icon, ObjectGuid target, sol::optional<ObjectGuid> setter)
     {
-        uint8 icon = ALE::CHECKVAL<uint8>(L, 2);
-        ObjectGuid target = ALE::CHECKVAL<ObjectGuid>(L, 3);
-        ObjectGuid setter = ALE::CHECKVAL<ObjectGuid>(L, 4, ObjectGuid());
-
         if (icon >= TARGETICONCOUNT)
-            return luaL_argerror(L, 2, "valid target icon expected");
+            throw std::invalid_argument("valid target icon expected");
 
-        group->SetTargetIcon(icon, setter, target);
-        return 0;
+        group->SetTargetIcon(icon, setter.value_or(ObjectGuid()), target);
     }
 
     /**
      * Sets or removes a flag for a [Group] member
-     * 
+     *
      * <pre>
      * enum GroupMemberFlags
      * {
@@ -410,26 +349,49 @@ namespace LuaGroup
      *     MEMBER_FLAG_MAINASSIST  = 0x04,
      * };
      * </pre>
-     * 
+     *
      * @param ObjectGuid target : GUID of the target
      * @param bool apply : add the `flag` if `true`, remove the `flag` otherwise
      * @param [GroupMemberFlags] flag : the flag to set or unset
      */
-    int SetMemberFlag(lua_State* L, Group* group)
+    void SetMemberFlag(Group* group, ObjectGuid target, bool apply, uint32 flag)
     {
-        ObjectGuid target = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        bool apply = ALE::CHECKVAL<bool>(L, 3);
-        GroupMemberFlags flag = static_cast<GroupMemberFlags>(ALE::CHECKVAL<uint32>(L, 4));
-
-        group->SetGroupMemberFlag(target, apply, flag);
-        return 0;
+        group->SetGroupMemberFlag(target, apply, static_cast<GroupMemberFlags>(flag));
     }
 
-    /*int ConvertToLFG(lua_State* L, Group* group) // TODO: Implementation
+    /*void ConvertToLFG(Group* group) // TODO: Implementation
     {
         group->ConvertToLFG();
-        return 0;
     }*/
-};
+}
 
-#endif
+void RegisterGroupMethods(sol::state& lua)
+{
+    sol::usertype<GroupRef> type = ALEBind::NewHandleType<GroupRef>(lua, "Group");
+
+    type["IsLeader"]            = ALEBind::Method(&LuaGroup::IsLeader);
+    type["IsFull"]              = ALEBind::Method(&LuaGroup::IsFull);
+    type["IsLFGGroup"]          = ALEBind::Method(&LuaGroup::IsLFGGroup);
+    type["IsRaidGroup"]         = ALEBind::Method(&LuaGroup::IsRaidGroup);
+    type["IsBGGroup"]           = ALEBind::Method(&LuaGroup::IsBGGroup);
+    type["IsMember"]            = ALEBind::Method(&LuaGroup::IsMember);
+    type["IsAssistant"]         = ALEBind::Method(&LuaGroup::IsAssistant);
+    type["SameSubGroup"]        = ALEBind::Method(&LuaGroup::SameSubGroup);
+    type["HasFreeSlotSubGroup"] = ALEBind::Method(&LuaGroup::HasFreeSlotSubGroup);
+    type["AddMember"]           = ALEBind::Method(&LuaGroup::AddMember);
+    type["GetMembers"]          = ALEBind::Method(&LuaGroup::GetMembers);
+    type["GetLeaderGUID"]       = ALEBind::Method(&LuaGroup::GetLeaderGUID);
+    type["GetGUID"]             = ALEBind::Method(&LuaGroup::GetGUID);
+    type["GetMemberGUID"]       = ALEBind::Method(&LuaGroup::GetMemberGUID);
+    type["GetMembersCount"]     = ALEBind::Method(&LuaGroup::GetMembersCount);
+    type["GetGroupType"]        = ALEBind::Method(&LuaGroup::GetGroupType);
+    type["GetMemberGroup"]      = ALEBind::Method(&LuaGroup::GetMemberGroup);
+    type["SetLeader"]           = ALEBind::Method(&LuaGroup::SetLeader);
+    type["SendPacket"]          = ALEBind::Method(&LuaGroup::SendPacket);
+    type["RemoveMember"]        = ALEBind::Method(&LuaGroup::RemoveMember);
+    type["Disband"]             = ALEBind::Method(&LuaGroup::Disband);
+    type["ConvertToRaid"]       = ALEBind::Method(&LuaGroup::ConvertToRaid);
+    type["SetMembersGroup"]     = ALEBind::Method(&LuaGroup::SetMembersGroup);
+    type["SetTargetIcon"]       = ALEBind::Method(&LuaGroup::SetTargetIcon);
+    type["SetMemberFlag"]       = ALEBind::Method(&LuaGroup::SetMemberFlag);
+}
diff --git a/src/LuaEngine/methods/GuildMethods.h b/src/LuaEngine/methods/GuildMethods.cpp
similarity index 57%
rename from src/LuaEngine/methods/GuildMethods.h
rename to src/LuaEngine/methods/GuildMethods.cpp
index 979f564a9e..5aca0b4cf6 100644
--- a/src/LuaEngine/methods/GuildMethods.h
+++ b/src/LuaEngine/methods/GuildMethods.cpp
@@ -4,8 +4,15 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef GUILDMETHODS_H
-#define GUILDMETHODS_H
+#include "ALEBind.h"
+
+#include "DatabaseEnv.h"
+#include "Guild.h"
+#include "ObjectAccessor.h"
+#include "Player.h"
+#include "WorldPacket.h"
+
+#include <shared_mutex>
 
 /***
  * Represents a player guild. Used to manage guild members, ranks, guild bank.
@@ -21,30 +28,27 @@ namespace LuaGuild
      *
      * @return table guildPlayers : table of [Player]s
      */
-    int GetMembers(lua_State* L, Guild* guild)
+    sol::table GetMembers(Guild* guild, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         {
             std::shared_lock<std::shared_mutex> lock(*HashMapHolder<Player>::GetLock());
-            const HashMapHolder<Player>::MapType& m = eObjectAccessor()GetPlayers();
+            HashMapHolder<Player>::MapType const& m = ObjectAccessor::GetPlayers();
             for (HashMapHolder<Player>::MapType::const_iterator it = m.begin(); it != m.end(); ++it)
             {
                 if (Player* player = it->second)
                 {
                     if (player->IsInWorld() && player->GetGuildId() == guild->GetId())
                     {
-                        ALE::Push(L, player);
-                        lua_rawseti(L, tbl, ++i);
+                        tbl[++i] = PlayerRef(player);
                     }
                 }
             }
         }
 
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+        return tbl;
     }
 
     /**
@@ -52,10 +56,9 @@ namespace LuaGuild
      *
      * @return uint32 memberCount
      */
-    int GetMemberCount(lua_State* L, Guild* guild)
+    uint32 GetMemberCount(Guild* guild)
     {
-        ALE::Push(L, guild->GetMemberCount());
-        return 1;
+        return guild->GetMemberCount();
     }
 
     /**
@@ -63,10 +66,9 @@ namespace LuaGuild
      *
      * @return [Player] leader
      */
-    int GetLeader(lua_State* L, Guild* guild)
+    Player* GetLeader(Guild* guild)
     {
-        ALE::Push(L, eObjectAccessor()FindPlayer(guild->GetLeaderGUID()));
-        return 1;
+        return ObjectAccessor::FindPlayer(guild->GetLeaderGUID());
     }
 
     /**
@@ -74,10 +76,9 @@ namespace LuaGuild
      *
      * @return ObjectGuid leaderGUID
      */
-    int GetLeaderGUID(lua_State* L, Guild* guild)
+    ObjectGuid GetLeaderGUID(Guild* guild)
     {
-        ALE::Push(L, guild->GetLeaderGUID());
-        return 1;
+        return guild->GetLeaderGUID();
     }
 
     /**
@@ -85,10 +86,9 @@ namespace LuaGuild
      *
      * @return uint32 entryId
      */
-    int GetId(lua_State* L, Guild* guild)
+    uint32 GetId(Guild* guild)
     {
-        ALE::Push(L, guild->GetId());
-        return 1;
+        return guild->GetId();
     }
 
     /**
@@ -96,10 +96,9 @@ namespace LuaGuild
      *
      * @return string guildName
      */
-    int GetName(lua_State* L, Guild* guild)
+    std::string GetName(Guild* guild)
     {
-        ALE::Push(L, guild->GetName());
-        return 1;
+        return guild->GetName();
     }
 
     /**
@@ -107,10 +106,9 @@ namespace LuaGuild
      *
      * @return string guildMOTD
      */
-    int GetMOTD(lua_State* L, Guild* guild)
+    std::string GetMOTD(Guild* guild)
     {
-        ALE::Push(L, guild->GetMOTD());
-        return 1;
+        return guild->GetMOTD();
     }
 
     /**
@@ -118,10 +116,9 @@ namespace LuaGuild
      *
      * @return string guildInfo
      */
-    int GetInfo(lua_State* L, Guild* guild)
+    std::string GetInfo(Guild* guild)
     {
-        ALE::Push(L, guild->GetInfo());
-        return 1;
+        return guild->GetInfo();
     }
 
     /**
@@ -129,12 +126,9 @@ namespace LuaGuild
      *
      * @param [Player] leader : the [Player] leader to change
      */
-    int SetLeader(lua_State* L, Guild* guild)
+    void SetLeader(Guild* guild, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-
         guild->HandleSetLeader(player->GetSession(), player->GetName());
-        return 0;
     }
 
     /**
@@ -143,12 +137,9 @@ namespace LuaGuild
      * @param uint8 tabId : the ID of the tab specified
      * @param string info : the information to be set to the bank tab
      */
-    int SetBankTabText(lua_State* L, Guild* guild)
+    void SetBankTabText(Guild* guild, uint8 tabId, std::string text)
     {
-        uint8 tabId = ALE::CHECKVAL<uint8>(L, 2);
-        const char* text = ALE::CHECKVAL<const char*>(L, 3);
         guild->SetBankTabText(tabId, text);
-        return 0;
     }
 
     // SendPacketToGuild(packet)
@@ -157,12 +148,9 @@ namespace LuaGuild
      *
      * @param [WorldPacket] packet : the [WorldPacket] to be sent to the [Player]s
      */
-    int SendPacket(lua_State* L, Guild* guild)
+    void SendPacket(Guild* guild, WorldPacket* data)
     {
-        WorldPacket* data = ALE::CHECKOBJ<WorldPacket>(L, 2);
-
         guild->BroadcastPacket(data);
-        return 0;
     }
 
     // SendPacketToRankedInGuild(packet, rankId)
@@ -172,22 +160,17 @@ namespace LuaGuild
      * @param [WorldPacket] packet : the [WorldPacket] to be sent to the [Player]s
      * @param uint8 rankId : the rank ID
      */
-    int SendPacketToRanked(lua_State* L, Guild* guild)
+    void SendPacketToRanked(Guild* guild, WorldPacket* data, uint8 ranked)
     {
-        WorldPacket* data = ALE::CHECKOBJ<WorldPacket>(L, 2);
-        uint8 ranked = ALE::CHECKVAL<uint8>(L, 3);
-
         guild->BroadcastPacketToRank(data, ranked);
-        return 0;
     }
 
     /**
      * Disbands the [Guild]
      */
-    int Disband(lua_State* /*L*/, Guild* guild)
+    void Disband(Guild* guild)
     {
         guild->Disband();
-        return 0;
     }
 
     /**
@@ -198,13 +181,9 @@ namespace LuaGuild
      * @param [Player] player : the [Player] to be added to the guild
      * @param uint8 rankId : the rank ID
      */
-    int AddMember(lua_State* L, Guild* guild)
+    void AddMember(Guild* guild, Player* player, sol::optional<uint8> rankId)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        uint8 rankId = ALE::CHECKVAL<uint8>(L, 3, GUILD_RANK_NONE);
-
-        guild->AddMember(player->GET_GUID(), rankId);
-        return 0;
+        guild->AddMember(player->GetGUID(), rankId.value_or(GUILD_RANK_NONE));
     }
 
     /**
@@ -213,13 +192,9 @@ namespace LuaGuild
      * @param [Player] player : the [Player] to be removed from the guild
      * @param bool isDisbanding : default 'false', should only be set to 'true' if the guild is triggered to disband
      */
-    int DeleteMember(lua_State* L, Guild* guild)
+    void DeleteMember(Guild* guild, Player* player, sol::optional<bool> isDisbanding)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        bool isDisbanding = ALE::CHECKVAL<bool>(L, 3, false);
-
-        guild->DeleteMember(player->GET_GUID(), isDisbanding);
-        return 0;
+        guild->DeleteMember(player->GetGUID(), isDisbanding.value_or(false));
     }
 
     /**
@@ -228,13 +203,9 @@ namespace LuaGuild
      * @param [Player] player : the [Player] to be promoted/demoted
      * @param uint8 rankId : the rank ID
      */
-    int SetMemberRank(lua_State* L, Guild* guild)
+    void SetMemberRank(Guild* guild, Player* player, uint8 newRank)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        uint8 newRank = ALE::CHECKVAL<uint8>(L, 3);
-
-        guild->ChangeMemberRank(player->GET_GUID(), newRank);
-        return 0;
+        guild->ChangeMemberRank(player->GetGUID(), newRank);
     }
 
     /**
@@ -242,78 +213,58 @@ namespace LuaGuild
      *
      * @param string name : new name of this guild
      */
-    int SetName(lua_State* L, Guild* guild)
+    void SetName(Guild* guild, std::string name)
     {
-        std::string name = ALE::CHECKVAL<std::string>(L, 2);
-        
         guild->SetName(name);
-        return 0;
     }
 
     /**
      * Update [Player] data in [Guild] member list.
-     * 
+     *
      *     enum GuildMemberData
      *     {
      *         GUILD_MEMBER_DATA_ZONEID =  0
      *         GUILD_MEMBER_DATA_LEVEL  =  1
      *     };
-     * 
+     *
      *  @param [Player] player : plkayer you need to update data
      *  @param [GuildMemberData] dataid : data you need to update
      *  @param uint32 value
      */
-    int UpdateMemberData(lua_State* L, Guild* guild)
+    void UpdateMemberData(Guild* guild, Player* player, uint8 dataid, uint32 value)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        uint8 dataid = ALE::CHECKVAL<uint8>(L, 3);
-        uint32 value = ALE::CHECKVAL<uint32>(L, 4);
-
         guild->UpdateMemberData(player, dataid, value);
-        return 0;
     }
 
     /**
      * Send message to [Guild] from specific [Player].
-     * 
+     *
      * @param [Player] player : the [Player] is the author of the message
      * @param bool officerOnly : send message only on officer channel
      * @param string msg : the message you need to send
      * @param uint32 lang : language the [Player] will speak
      */
-    int SendMessage(lua_State* L, Guild* guild)
+    void SendMessage(Guild* guild, Player* player, sol::optional<bool> officerOnly, std::string msg, sol::optional<uint32> language)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        bool officerOnly = ALE::CHECKVAL<bool>(L, 3, false);
-        std::string msg = ALE::CHECKVAL<std::string>(L, 4);
-        uint32 language = ALE::CHECKVAL<uint32>(L, 5, false);
-
-        guild->BroadcastToGuild(player->GetSession(), officerOnly, msg, language);
-        return 0;
+        guild->BroadcastToGuild(player->GetSession(), officerOnly.value_or(false), msg, language.value_or(0));
     }
 
     /**
      * Invites [Guild] members to events based on level and rank filters.
-     * 
+     *
      * @param [Player] player : who sends the invitation
      * @param uint32 minLevel : the required min level
      * @param uint32 maxLevel : the required max level
      * @param uint32 minRank : the required min rank
      */
-    int MassInviteToEvent(lua_State* L, Guild* guild)
-    { 
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        uint32 minLevel = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 maxLevel = ALE::CHECKVAL<uint32>(L, 4);
-        uint32 minRank = ALE::CHECKVAL<uint32>(L, 5);
-
+    void MassInviteToEvent(Guild* guild, Player* player, uint32 minLevel, uint32 maxLevel, uint32 minRank)
+    {
         guild->MassInviteToEvent(player->GetSession(), minLevel, maxLevel, minRank);
-        return 0;
     }
 
     /**
      * Swap item from a specific tab and slot [Guild] bank to another one.
-     * 
+     *
      * @param [Player] player : who Swap the item
      * @param uint8 tabId : source tab id
      * @param uint8 slotId : source slot id
@@ -321,22 +272,14 @@ namespace LuaGuild
      * @param uint8 destSlotId : destination slot id
      * @param uint8 splitedAmount : if the item is stackable, how much should be swaped
      */
-    int SwapItems(lua_State* L, Guild* guild)
-    { 
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        uint8 tabId = ALE::CHECKVAL<uint32>(L, 3);
-        uint8 slotId = ALE::CHECKVAL<uint32>(L, 4);
-        uint8 destTabId = ALE::CHECKVAL<uint32>(L, 5);
-        uint8 destSlotId = ALE::CHECKVAL<uint32>(L, 6);
-        uint32 splitedAmount = ALE::CHECKVAL<uint32>(L, 7);
-
+    void SwapItems(Guild* guild, Player* player, uint8 tabId, uint8 slotId, uint8 destTabId, uint8 destSlotId, uint32 splitedAmount)
+    {
         guild->SwapItems(player, tabId, slotId, destTabId, destSlotId, splitedAmount);
-        return 0;
     }
 
     /**
      * Swap an item from a specific tab and location in the [guild] bank to the bags and locations in the inventory of a specific [player] and vice versa.
-     * 
+     *
      * @param [Player] player : who Swap the item
      * @param bool toChar : the item goes to the [Player]'s inventory or comes from the [Player]'s inventory
      * @param uint8 tabId : tab id
@@ -345,68 +288,84 @@ namespace LuaGuild
      * @param uint8 playerSlotId : slot id
      * @param uint32 splitedAmount : if the item is stackable, how much should be swaped
      */
-    int SwapItemsWithInventory(lua_State* L, Guild* guild)
-    { 
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        bool toChar = ALE::CHECKVAL<bool>(L, 3, false);
-        uint8 tabId = ALE::CHECKVAL<uint8>(L, 4);
-        uint8 slotId = ALE::CHECKVAL<uint8>(L, 5);
-        uint8 playerBag = ALE::CHECKVAL<uint8>(L, 6);
-        uint8 playerSlotId = ALE::CHECKVAL<uint8>(L, 7);
-        uint32 splitedAmount = ALE::CHECKVAL<uint32>(L, 8);
-
-        guild->SwapItemsWithInventory(player, toChar, tabId, slotId, playerBag, playerSlotId, splitedAmount);
-        return 0;
+    void SwapItemsWithInventory(Guild* guild, Player* player, sol::optional<bool> toChar, uint8 tabId, uint8 slotId, uint8 playerBag, uint8 playerSlotId, uint32 splitedAmount)
+    {
+        guild->SwapItemsWithInventory(player, toChar.value_or(false), tabId, slotId, playerBag, playerSlotId, splitedAmount);
     }
 
     /**
      * Return the total bank money.
-     * 
+     *
      * @return number totalBankMoney
      */
-    int GetTotalBankMoney(lua_State* L, Guild* guild)
-    { 
-        ALE::Push(L, guild->GetTotalBankMoney());
-        return 1;
+    uint64 GetTotalBankMoney(Guild* guild)
+    {
+        return guild->GetTotalBankMoney();
     }
 
     /**
      * Return the created date.
-     * 
+     *
      * @return uint64 created date
      */
-    int GetCreatedDate(lua_State* L, Guild* guild)
-    { 
-        ALE::Push(L, guild->GetCreatedDate());
-        return 1;
+    time_t GetCreatedDate(Guild* guild)
+    {
+        return guild->GetCreatedDate();
     }
 
     /**
      * Resets the number of item withdraw in all tab's for all [Guild] members.
      */
-    int ResetTimes(lua_State* /*L*/, Guild* guild)
-    { 
+    void ResetTimes(Guild* guild)
+    {
         guild->ResetTimes();
-        return 0;
     }
 
     /**
      * Modify the [Guild] bank money. You can deposit or withdraw.
-     * 
+     *
      * @param uint64 amount : amount to add or remove
      * @param bool add : true (add money) | false (withdraw money)
      * @return bool is_applied
      */
-    int ModifyBankMoney(lua_State* L, Guild* guild)
-    { 
-        uint64 amount = ALE::CHECKVAL<uint64>(L, 2);
-        bool add = ALE::CHECKVAL<bool>(L, 2);
-
+    bool ModifyBankMoney(Guild* guild, uint64 amount, bool add)
+    {
         CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
-        ALE::Push(L, guild->ModifyBankMoney(trans, amount, add));
+        bool applied = guild->ModifyBankMoney(trans, amount, add);
 
         CharacterDatabase.CommitTransaction(trans);
-        return 1;
+        return applied;
     }
-};
-#endif
+}
+
+void RegisterGuildMethods(sol::state& lua)
+{
+    sol::usertype<GuildRef> type = ALEBind::NewHandleType<GuildRef>(lua, "Guild");
+
+    type["GetMembers"]             = ALEBind::Method(&LuaGuild::GetMembers);
+    type["GetMemberCount"]         = ALEBind::Method(&LuaGuild::GetMemberCount);
+    type["GetLeader"]              = ALEBind::Method(&LuaGuild::GetLeader);
+    type["GetLeaderGUID"]          = ALEBind::Method(&LuaGuild::GetLeaderGUID);
+    type["GetId"]                  = ALEBind::Method(&LuaGuild::GetId);
+    type["GetName"]                = ALEBind::Method(&LuaGuild::GetName);
+    type["GetMOTD"]                = ALEBind::Method(&LuaGuild::GetMOTD);
+    type["GetInfo"]                = ALEBind::Method(&LuaGuild::GetInfo);
+    type["SetLeader"]              = ALEBind::Method(&LuaGuild::SetLeader);
+    type["SetBankTabText"]         = ALEBind::Method(&LuaGuild::SetBankTabText);
+    type["SendPacket"]             = ALEBind::Method(&LuaGuild::SendPacket);
+    type["SendPacketToRanked"]     = ALEBind::Method(&LuaGuild::SendPacketToRanked);
+    type["Disband"]                = ALEBind::Method(&LuaGuild::Disband);
+    type["AddMember"]              = ALEBind::Method(&LuaGuild::AddMember);
+    type["DeleteMember"]           = ALEBind::Method(&LuaGuild::DeleteMember);
+    type["SetMemberRank"]          = ALEBind::Method(&LuaGuild::SetMemberRank);
+    type["SetName"]                = ALEBind::Method(&LuaGuild::SetName);
+    type["UpdateMemberData"]       = ALEBind::Method(&LuaGuild::UpdateMemberData);
+    type["SendMessage"]            = ALEBind::Method(&LuaGuild::SendMessage);
+    type["MassInviteToEvent"]      = ALEBind::Method(&LuaGuild::MassInviteToEvent);
+    type["SwapItems"]              = ALEBind::Method(&LuaGuild::SwapItems);
+    type["SwapItemsWithInventory"] = ALEBind::Method(&LuaGuild::SwapItemsWithInventory);
+    type["GetTotalBankMoney"]      = ALEBind::Method(&LuaGuild::GetTotalBankMoney);
+    type["GetCreatedDate"]         = ALEBind::Method(&LuaGuild::GetCreatedDate);
+    type["ResetTimes"]             = ALEBind::Method(&LuaGuild::ResetTimes);
+    type["ModifyBankMoney"]        = ALEBind::Method(&LuaGuild::ModifyBankMoney);
+}
diff --git a/src/LuaEngine/methods/ItemMethods.h b/src/LuaEngine/methods/ItemMethods.cpp
similarity index 54%
rename from src/LuaEngine/methods/ItemMethods.h
rename to src/LuaEngine/methods/ItemMethods.cpp
index 06ddf1d4da..d75d24c3c6 100644
--- a/src/LuaEngine/methods/ItemMethods.h
+++ b/src/LuaEngine/methods/ItemMethods.cpp
@@ -4,8 +4,19 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef ITEMMETHODS_H
-#define ITEMMETHODS_H
+#include "ALEBind.h"
+
+#include "Bag.h"
+#include "Common.h"
+#include "DBCStores.h"
+#include "DatabaseEnv.h"
+#include "Item.h"
+#include "ItemTemplate.h"
+#include "ObjectMgr.h"
+#include "Player.h"
+#include "SharedDefines.h"
+
+#include <sstream>
 
 /***
  * Represents an instance of an item in the game world.
@@ -19,10 +30,9 @@ namespace LuaItem
      *
      * @return bool isSoulBound
      */
-    int IsSoulBound(lua_State* L, Item* item)
+    bool IsSoulBound(Item* item)
     {
-        ALE::Push(L, item->IsSoulBound());
-        return 1;
+        return item->IsSoulBound();
     }
 
     /**
@@ -30,10 +40,9 @@ namespace LuaItem
      *
      * @return bool isAccountBound
      */
-    int IsBoundAccountWide(lua_State* L, Item* item)
+    bool IsBoundAccountWide(Item* item)
     {
-        ALE::Push(L, item->IsBoundAccountWide());
-        return 1;
+        return item->IsBoundAccountWide();
     }
 
     /**
@@ -41,10 +50,9 @@ namespace LuaItem
      *
      * @return bool isBoundByEnchant
      */
-    int IsBoundByEnchant(lua_State* L, Item* item)
+    bool IsBoundByEnchant(Item* item)
     {
-        ALE::Push(L, item->IsBoundByEnchant());
-        return 1;
+        return item->IsBoundByEnchant();
     }
 
     /**
@@ -53,12 +61,9 @@ namespace LuaItem
      * @param [Player] player : the [Player] object to check the item against
      * @return bool isNotBound
      */
-    int IsNotBoundToPlayer(lua_State* L, Item* item)
+    bool IsNotBoundToPlayer(Item* item, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-
-        ALE::Push(L, item->IsBindedNotWith(player));
-        return 1;
+        return item->IsBindedNotWith(player);
     }
 
     /**
@@ -66,10 +71,9 @@ namespace LuaItem
      *
      * @return bool isLocked
      */
-    int IsLocked(lua_State* L, Item* item)
+    bool IsLocked(Item* item)
     {
-        ALE::Push(L, item->IsLocked());
-        return 1;
+        return item->IsLocked();
     }
 
     /**
@@ -77,10 +81,9 @@ namespace LuaItem
      *
      * @return bool isBag
      */
-    int IsBag(lua_State* L, Item* item)
+    bool IsBag(Item* item)
     {
-        ALE::Push(L, item->IsBag());
-        return 1;
+        return item->IsBag();
     }
 
     /**
@@ -88,10 +91,9 @@ namespace LuaItem
      *
      * @return bool isCurrencyToken
      */
-    int IsCurrencyToken(lua_State* L, Item* item)
+    bool IsCurrencyToken(Item* item)
     {
-        ALE::Push(L, item->IsCurrencyToken());
-        return 1;
+        return item->IsCurrencyToken();
     }
 
     /**
@@ -99,10 +101,9 @@ namespace LuaItem
      *
      * @return bool isNotEmptyBag
      */
-    int IsNotEmptyBag(lua_State* L, Item* item)
+    bool IsNotEmptyBag(Item* item)
     {
-        ALE::Push(L, item->IsNotEmptyBag());
-        return 1;
+        return item->IsNotEmptyBag();
     }
 
     /**
@@ -110,10 +111,9 @@ namespace LuaItem
      *
      * @return bool isBroken
      */
-    int IsBroken(lua_State* L, Item* item)
+    bool IsBroken(Item* item)
     {
-        ALE::Push(L, item->IsBroken());
-        return 1;
+        return item->IsBroken();
     }
 
     /**
@@ -121,11 +121,9 @@ namespace LuaItem
      *
      * @return bool isTradeable
      */
-    int CanBeTraded(lua_State* L, Item* item)
+    bool CanBeTraded(Item* item, sol::optional<bool> mail)
     {
-        bool mail = ALE::CHECKVAL<bool>(L, 2, false);
-        ALE::Push(L, item->CanBeTraded(mail));
-        return 1;
+        return item->CanBeTraded(mail.value_or(false));
     }
 
     /**
@@ -133,10 +131,9 @@ namespace LuaItem
      *
      * @return bool isInTrade
      */
-    int IsInTrade(lua_State* L, Item* item)
+    bool IsInTrade(Item* item)
     {
-        ALE::Push(L, item->IsInTrade());
-        return 1;
+        return item->IsInTrade();
     }
 
     /**
@@ -144,10 +141,9 @@ namespace LuaItem
      *
      * @return bool isInBag
      */
-    int IsInBag(lua_State* L, Item* item)
+    bool IsInBag(Item* item)
     {
-        ALE::Push(L, item->IsInBag());
-        return 1;
+        return item->IsInBag();
     }
 
     /**
@@ -155,10 +151,9 @@ namespace LuaItem
      *
      * @return bool isEquipped
      */
-    int IsEquipped(lua_State* L, Item* item)
+    bool IsEquipped(Item* item)
     {
-        ALE::Push(L, item->IsEquipped());
-        return 1;
+        return item->IsEquipped();
     }
 
     /**
@@ -167,11 +162,9 @@ namespace LuaItem
      * @param uint32 questId : the [Quest] id to be checked
      * @return bool hasQuest
      */
-    int HasQuest(lua_State* L, Item* item)
+    bool HasQuest(Item* item, uint32 quest)
     {
-        uint32 quest = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, item->hasQuest(quest));
-        return 1;
+        return item->hasQuest(quest);
     }
 
     /**
@@ -179,10 +172,9 @@ namespace LuaItem
      *
      * @return bool isPotion
      */
-    int IsPotion(lua_State* L, Item* item)
+    bool IsPotion(Item* item)
     {
-        ALE::Push(L, item->IsPotion());
-        return 1;
+        return item->IsPotion();
     }
 
     /**
@@ -190,10 +182,9 @@ namespace LuaItem
      *
      * @return bool isWeaponVellum
      */
-    int IsWeaponVellum(lua_State* L, Item* item)
+    bool IsWeaponVellum(Item* item)
     {
-        ALE::Push(L, item->IsWeaponVellum());
-        return 1;
+        return item->IsWeaponVellum();
     }
 
     /**
@@ -201,10 +192,9 @@ namespace LuaItem
      *
      * @return bool isArmorVellum
      */
-    int IsArmorVellum(lua_State* L, Item* item)
+    bool IsArmorVellum(Item* item)
     {
-        ALE::Push(L, item->IsArmorVellum());
-        return 1;
+        return item->IsArmorVellum();
     }
 
     /**
@@ -212,16 +202,14 @@ namespace LuaItem
      *
      * @return bool isConjuredConsumable
      */
-    int IsConjuredConsumable(lua_State* L, Item* item)
+    bool IsConjuredConsumable(Item* item)
     {
-        ALE::Push(L, item->IsConjuredConsumable());
-        return 1;
+        return item->IsConjuredConsumable();
     }
 
-    /*int IsRefundExpired(lua_State* L, Item* item)// TODO: Implement core support
+    /*bool IsRefundExpired(Item* item)// TODO: Implement core support
     {
-        ALE::Push(L, item->IsRefundExpired());
-        return 1;
+        return item->IsRefundExpired();
     }*/
 
     /**
@@ -245,15 +233,15 @@ namespace LuaItem
      * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the [Item]'s name in
      * @return string itemLink
      */
-    int GetItemLink(lua_State* L, Item* item)
+    std::string GetItemLink(Item* item, sol::optional<uint8> localeArg)
     {
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 2, DEFAULT_LOCALE);
+        uint8 locale = localeArg.value_or(DEFAULT_LOCALE);
         if (locale >= TOTAL_LOCALES)
-            return luaL_argerror(L, 2, "valid LocaleConstant expected");
+            throw std::invalid_argument("valid LocaleConstant expected");
 
-        const ItemTemplate* temp = item->GetTemplate();
+        ItemTemplate const* temp = item->GetTemplate();
         std::string name = temp->Name1;
-        if (ItemLocale const* il = eObjectMgr->GetItemLocale(temp->ItemId))
+        if (ItemLocale const* il = sObjectMgr->GetItemLocale(temp->ItemId))
         {
             ObjectMgr::GetLocaleString(il->Name, static_cast<LocaleConstant>(locale), name);
         }
@@ -263,19 +251,19 @@ namespace LuaItem
             std::array<char const*, 16> const* suffix = NULL;
             if (itemRandPropId < 0)
             {
-                const ItemRandomSuffixEntry* itemRandEntry = sItemRandomSuffixStore.LookupEntry(-item->GetItemRandomPropertyId());
+                ItemRandomSuffixEntry const* itemRandEntry = sItemRandomSuffixStore.LookupEntry(-item->GetItemRandomPropertyId());
                 if (itemRandEntry)
                     suffix = &itemRandEntry->Name;
             }
             else
             {
-                const ItemRandomPropertiesEntry* itemRandEntry = sItemRandomPropertiesStore.LookupEntry(item->GetItemRandomPropertyId());
+                ItemRandomPropertiesEntry const* itemRandEntry = sItemRandomPropertiesStore.LookupEntry(item->GetItemRandomPropertyId());
                 if (itemRandEntry)
                     suffix = &itemRandEntry->Name;
             }
             if (suffix)
             {
-                const char* suffixName = (*suffix)[(name != temp->Name1) ? locale : uint8(DEFAULT_LOCALE)];
+                char const* suffixName = (*suffix)[(name != temp->Name1) ? locale : uint8(DEFAULT_LOCALE)];
                 if (strcmp(suffixName, "") != 0)
                 {
                     name += ' ';
@@ -296,8 +284,7 @@ namespace LuaItem
             item->GetItemRandomPropertyId() << ":" << item->GetItemSuffixFactor() << ":" <<
             (uint32)(owner ? owner->GetLevel() : 0) << "|h[" << name << "]|h|r";
 
-        ALE::Push(L, oss.str());
-        return 1;
+        return oss.str();
     }
 
     /**
@@ -306,10 +293,9 @@ namespace LuaItem
      * @param [Item] item
      * @return uint64 ownerGUID
      */
-    int GetOwnerGUID(lua_State* L, Item* item)
+    ObjectGuid GetOwnerGUID(Item* item)
     {
-        ALE::Push(L, item->GetOwnerGUID());
-        return 1;
+        return item->GetOwnerGUID();
     }
 
     /**
@@ -317,10 +303,9 @@ namespace LuaItem
      *
      * @return [Player] player : the [Player] who owns the [Item]
      */
-    int GetOwner(lua_State* L, Item* item)
+    Player* GetOwner(Item* item)
     {
-        ALE::Push(L, item->GetOwner());
-        return 1;
+        return item->GetOwner();
     }
 
     /**
@@ -328,10 +313,9 @@ namespace LuaItem
      *
      * @return uint32 count
      */
-    int GetCount(lua_State* L, Item* item)
+    uint32 GetCount(Item* item)
     {
-        ALE::Push(L, item->GetCount());
-        return 1;
+        return item->GetCount();
     }
 
     /**
@@ -339,10 +323,9 @@ namespace LuaItem
      *
      * @return uint32 maxCount
      */
-    int GetMaxStackCount(lua_State* L, Item* item)
+    uint32 GetMaxStackCount(Item* item)
     {
-        ALE::Push(L, item->GetMaxStackCount());
-        return 1;
+        return item->GetMaxStackCount();
     }
 
     /**
@@ -350,10 +333,9 @@ namespace LuaItem
      *
      * @return uint8 slot
      */
-    int GetSlot(lua_State* L, Item* item)
+    uint8 GetSlot(Item* item)
     {
-        ALE::Push(L, item->GetSlot());
-        return 1;
+        return item->GetSlot();
     }
 
     /**
@@ -361,10 +343,9 @@ namespace LuaItem
      *
      * @return uint8 bagSlot
      */
-    int GetBagSlot(lua_State* L, Item* item)
+    uint8 GetBagSlot(Item* item)
     {
-        ALE::Push(L, item->GetBagSlot());
-        return 1;
+        return item->GetBagSlot();
     }
 
     /**
@@ -373,15 +354,12 @@ namespace LuaItem
      * @param [EnchantmentSlot] enchantSlot : the enchant slot specified
      * @return uint32 enchantId : the id of the enchant slot specified
      */
-    int GetEnchantmentId(lua_State* L, Item* item)
+    uint32 GetEnchantmentId(Item* item, uint32 enchant_slot)
     {
-        uint32 enchant_slot = ALE::CHECKVAL<uint32>(L, 2);
-
         if (enchant_slot >= MAX_INSPECTED_ENCHANTMENT_SLOT)
-            return luaL_argerror(L, 2, "valid EnchantmentSlot expected");
+            throw std::invalid_argument("valid EnchantmentSlot expected");
 
-        ALE::Push(L, item->GetEnchantmentId(EnchantmentSlot(enchant_slot)));
-        return 1;
+        return item->GetEnchantmentId(EnchantmentSlot(enchant_slot));
     }
 
     /**
@@ -390,14 +368,12 @@ namespace LuaItem
      * @param uint32 spellIndex : the spell index specified
      * @return uint32 spellId : the id of the spell
      */
-    int GetSpellId(lua_State* L, Item* item)
+    int32 GetSpellId(Item* item, uint32 index)
     {
-        uint32 index = ALE::CHECKVAL<uint32>(L, 2);
         if (index >= MAX_ITEM_PROTO_SPELLS)
-            return luaL_argerror(L, 2, "valid SpellIndex expected");
+            throw std::invalid_argument("valid SpellIndex expected");
 
-        ALE::Push(L, item->GetTemplate()->Spells[index].SpellId);
-        return 1;
+        return item->GetTemplate()->Spells[index].SpellId;
     }
 
     /**
@@ -406,14 +382,12 @@ namespace LuaItem
      * @param uint32 spellIndex : the spell index specified
      * @return uint32 spellTrigger : the spell trigger of the specified index
      */
-    int GetSpellTrigger(lua_State* L, Item* item)
+    uint32 GetSpellTrigger(Item* item, uint32 index)
     {
-        uint32 index = ALE::CHECKVAL<uint32>(L, 2);
         if (index >= MAX_ITEM_PROTO_SPELLS)
-            return luaL_argerror(L, 2, "valid SpellIndex expected");
+            throw std::invalid_argument("valid SpellIndex expected");
 
-        ALE::Push(L, item->GetTemplate()->Spells[index].SpellTrigger);
-        return 1;
+        return item->GetTemplate()->Spells[index].SpellTrigger;
     }
 
     /**
@@ -421,10 +395,9 @@ namespace LuaItem
      *
      * @return uint32 class
      */
-    int GetClass(lua_State* L, Item* item)
+    uint32 GetClass(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->Class);
-        return 1;
+        return item->GetTemplate()->Class;
     }
 
     /**
@@ -432,10 +405,9 @@ namespace LuaItem
      *
      * @return uint32 subClass
      */
-    int GetSubClass(lua_State* L, Item* item)
+    uint32 GetSubClass(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->SubClass);
-        return 1;
+        return item->GetTemplate()->SubClass;
     }
 
     /**
@@ -443,10 +415,9 @@ namespace LuaItem
      *
      * @return string name
      */
-    int GetName(lua_State* L, Item* item)
+    std::string GetName(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->Name1);
-        return 1;
+        return item->GetTemplate()->Name1;
     }
 
     /**
@@ -454,10 +425,9 @@ namespace LuaItem
      *
      * @return uint32 displayId
      */
-    int GetDisplayId(lua_State* L, Item* item)
+    uint32 GetDisplayId(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->DisplayInfoID);
-        return 1;
+        return item->GetTemplate()->DisplayInfoID;
     }
 
     /**
@@ -465,10 +435,9 @@ namespace LuaItem
      *
      * @return uint32 quality
      */
-    int GetQuality(lua_State* L, Item* item)
+    uint32 GetQuality(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->Quality);
-        return 1;
+        return item->GetTemplate()->Quality;
     }
 
     /**
@@ -476,10 +445,9 @@ namespace LuaItem
      *
      * @return uint32 count
      */
-    int GetBuyCount(lua_State* L, Item* item)
+    uint32 GetBuyCount(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->BuyCount);
-        return 1;
+        return item->GetTemplate()->BuyCount;
     }
 
     /**
@@ -487,10 +455,9 @@ namespace LuaItem
      *
      * @return uint32 price
      */
-    int GetBuyPrice(lua_State* L, Item* item)
+    uint32 GetBuyPrice(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->BuyPrice);
-        return 1;
+        return item->GetTemplate()->BuyPrice;
     }
 
     /**
@@ -498,10 +465,9 @@ namespace LuaItem
      *
      * @return uint32 price
      */
-    int GetSellPrice(lua_State* L, Item* item)
+    uint32 GetSellPrice(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->SellPrice);
-        return 1;
+        return item->GetTemplate()->SellPrice;
     }
 
     /**
@@ -509,10 +475,9 @@ namespace LuaItem
      *
      * @return uint32 inventoryType
      */
-    int GetInventoryType(lua_State* L, Item* item)
+    uint32 GetInventoryType(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->InventoryType);
-        return 1;
+        return item->GetTemplate()->InventoryType;
     }
 
     /**
@@ -520,10 +485,9 @@ namespace LuaItem
      *
      * @return uint32 allowableClass
      */
-    int GetAllowableClass(lua_State* L, Item* item)
+    uint32 GetAllowableClass(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->AllowableClass);
-        return 1;
+        return item->GetTemplate()->AllowableClass;
     }
 
     /**
@@ -531,10 +495,9 @@ namespace LuaItem
      *
      * @return uint32 allowableRace
      */
-    int GetAllowableRace(lua_State* L, Item* item)
+    uint32 GetAllowableRace(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->AllowableRace);
-        return 1;
+        return item->GetTemplate()->AllowableRace;
     }
 
     /**
@@ -542,10 +505,9 @@ namespace LuaItem
      *
      * @return uint32 itemLevel
      */
-    int GetItemLevel(lua_State* L, Item* item)
+    uint32 GetItemLevel(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->ItemLevel);
-        return 1;
+        return item->GetTemplate()->ItemLevel;
     }
 
     /**
@@ -553,10 +515,9 @@ namespace LuaItem
      *
      * @return uint32 requiredLevel
      */
-    int GetRequiredLevel(lua_State* L, Item* item)
+    uint32 GetRequiredLevel(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->RequiredLevel);
-        return 1;
+        return item->GetTemplate()->RequiredLevel;
     }
 
     /**
@@ -565,10 +526,9 @@ namespace LuaItem
      * @param [Item] item
      * @return uint32 statsCount
      */
-    int GetStatsCount(lua_State* L, Item* item)
+    uint32 GetStatsCount(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->StatsCount);
-        return 1;
+        return item->GetTemplate()->StatsCount;
     }
 
     /**
@@ -576,10 +536,9 @@ namespace LuaItem
      *
      * @return uint32 randomPropertyId
      */
-    int GetRandomProperty(lua_State* L, Item* item)
+    uint32 GetRandomProperty(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->RandomProperty);
-        return 1;
+        return item->GetTemplate()->RandomProperty;
     }
 
     /**
@@ -588,10 +547,9 @@ namespace LuaItem
      * @param [Item] item
      * @return uint32 randomSuffixId
      */
-    int GetRandomSuffix(lua_State* L, Item* item)
+    uint32 GetRandomSuffix(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->RandomSuffix);
-        return 1;
+        return item->GetTemplate()->RandomSuffix;
     }
 
     /**
@@ -599,10 +557,9 @@ namespace LuaItem
      *
      * @return uint32 itemSetId
      */
-    int GetItemSet(lua_State* L, Item* item)
+    uint32 GetItemSet(Item* item)
     {
-        ALE::Push(L, item->GetTemplate()->ItemSet);
-        return 1;
+        return item->GetTemplate()->ItemSet;
     }
 
     /**
@@ -610,13 +567,12 @@ namespace LuaItem
      *
      * @return uint32 bagSize
      */
-    int GetBagSize(lua_State* L, Item* item)
+    uint32 GetBagSize(Item* item)
     {
         if (Bag* bag = item->ToBag())
-            ALE::Push(L, bag->GetBagSize());
-        else
-            ALE::Push(L, 0);
-        return 1;
+            return bag->GetBagSize();
+
+        return 0;
     }
 
     /**
@@ -624,10 +580,9 @@ namespace LuaItem
      *
      * @return [ItemTemplate] itemTemplate
      */
-    int GetItemTemplate(lua_State* L, Item* item)
+    ItemTemplate const* GetItemTemplate(Item* item)
     {
-        ALE::Push(L, item->GetTemplate());
-        return 1;
+        return item->GetTemplate();
     }
 
     /**
@@ -635,11 +590,9 @@ namespace LuaItem
      *
      * @param [Player] player : the [Player] specified
      */
-    int SetOwner(lua_State* L, Item* item)
+    void SetOwner(Item* item, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        item->SetOwnerGUID(player->GET_GUID());
-        return 0;
+        item->SetOwnerGUID(player->GetGUID());
     }
 
     /**
@@ -647,14 +600,10 @@ namespace LuaItem
      *
      * @param bool setBinding
      */
-    int SetBinding(lua_State* L, Item* item)
+    void SetBinding(Item* item, bool soulbound)
     {
-        bool soulbound = ALE::CHECKVAL<bool>(L, 2);
-
         item->SetBinding(soulbound);
         item->SetState(ITEM_CHANGED, item->GetOwner());
-
-        return 0;
     }
 
     /**
@@ -662,11 +611,9 @@ namespace LuaItem
      *
      * @param uint32 count
      */
-    int SetCount(lua_State* L, Item* item)
+    void SetCount(Item* item, uint32 count)
     {
-        uint32 count = ALE::CHECKVAL<uint32>(L, 2);
         item->SetCount(count);
-        return 0;
     }
 
     /**
@@ -676,31 +623,27 @@ namespace LuaItem
      * @param uint32 enchantSlot : the slot for the enchant to be applied to
      * @return bool enchantmentSuccess : if enchantment is successfully set to specified slot, returns 'true', otherwise 'false'
      */
-    int SetEnchantment(lua_State* L, Item* item)
+    bool SetEnchantment(Item* item, uint32 enchant, uint32 enchantSlot)
     {
         Player* owner = item->GetOwner();
         if (!owner)
         {
-            ALE::Push(L, false);
-            return 1;
+            return false;
         }
 
-        uint32 enchant = ALE::CHECKVAL<uint32>(L, 2);
         if (!sSpellItemEnchantmentStore.LookupEntry(enchant))
         {
-            ALE::Push(L, false);
-            return 1;
+            return false;
         }
 
-        EnchantmentSlot slot = (EnchantmentSlot)ALE::CHECKVAL<uint32>(L, 3);
+        EnchantmentSlot slot = (EnchantmentSlot)enchantSlot;
         if (slot >= MAX_INSPECTED_ENCHANTMENT_SLOT)
-            return luaL_argerror(L, 2, "valid EnchantmentSlot expected");
+            throw std::invalid_argument("valid EnchantmentSlot expected");
 
         owner->ApplyEnchantment(item, slot, false);
         item->SetEnchantment(slot, enchant, 0, 0);
         owner->ApplyEnchantment(item, slot, true);
-        ALE::Push(L, true);
-        return 1;
+        return true;
     }
 
 
@@ -709,11 +652,9 @@ namespace LuaItem
      *
      * @param uint32 randomPropId : The ID of the random property to be applied.
      */
-    int SetRandomProperty(lua_State* L, Item* item)
+    void SetRandomProperty(Item* item, uint32 randomPropId)
     {
-        uint32 randomPropId = ALE::CHECKVAL<uint32>(L, 2);
         item->SetItemRandomProperties(randomPropId);
-        return 0;
     }
 
     /**
@@ -721,11 +662,9 @@ namespace LuaItem
      *
      * @param uint32 randomSuffixId : The ID of the random suffix to be applied.
      */
-    int SetRandomSuffix(lua_State* L, Item* item)
+    void SetRandomSuffix(Item* item, uint32 randomPropId)
     {
-        uint32 randomPropId = ALE::CHECKVAL<uint32>(L, 2);
         item->SetItemRandomProperties(-randomPropId);
-        return 0;
     }
 
 
@@ -736,39 +675,95 @@ namespace LuaItem
      * @param uint32 enchantSlot : the slot for the enchant to be removed from
      * @return bool enchantmentRemoved : if enchantment is successfully removed from specified slot, returns 'true', otherwise 'false'
      */
-    int ClearEnchantment(lua_State* L, Item* item)
+    bool ClearEnchantment(Item* item, uint32 enchantSlot)
     {
         Player* owner = item->GetOwner();
         if (!owner)
         {
-            ALE::Push(L, false);
-            return 1;
+            return false;
         }
 
-        EnchantmentSlot slot = (EnchantmentSlot)ALE::CHECKVAL<uint32>(L, 2);
+        EnchantmentSlot slot = (EnchantmentSlot)enchantSlot;
         if (slot >= MAX_INSPECTED_ENCHANTMENT_SLOT)
-            return luaL_argerror(L, 2, "valid EnchantmentSlot expected");
+            throw std::invalid_argument("valid EnchantmentSlot expected");
 
         if (!item->GetEnchantmentId(slot))
         {
-            ALE::Push(L, false);
-            return 1;
+            return false;
         }
 
         owner->ApplyEnchantment(item, slot, false);
         item->ClearEnchantment(slot);
-        ALE::Push(L, true);
-        return 1;
+        return true;
     }
 
     /**
      * Saves the [Item] to the database
      */
-    int SaveToDB(lua_State* /*L*/, Item* item)
+    void SaveToDB(Item* item)
     {
         CharacterDatabaseTransaction trans = CharacterDatabaseTransaction(nullptr);
         item->SaveToDB(trans);
-        return 0;
     }
-};
-#endif
+}
+
+void RegisterItemMethods(sol::state& lua)
+{
+    sol::usertype<ItemRef> type = ALEBind::NewHandleType<ItemRef, ObjectRef>(lua, "Item");
+
+    type["IsSoulBound"]          = ALEBind::Method(&LuaItem::IsSoulBound);
+    type["IsBoundAccountWide"]   = ALEBind::Method(&LuaItem::IsBoundAccountWide);
+    type["IsBoundByEnchant"]     = ALEBind::Method(&LuaItem::IsBoundByEnchant);
+    type["IsNotBoundToPlayer"]   = ALEBind::Method(&LuaItem::IsNotBoundToPlayer);
+    type["IsLocked"]             = ALEBind::Method(&LuaItem::IsLocked);
+    type["IsBag"]                = ALEBind::Method(&LuaItem::IsBag);
+    type["IsCurrencyToken"]      = ALEBind::Method(&LuaItem::IsCurrencyToken);
+    type["IsNotEmptyBag"]        = ALEBind::Method(&LuaItem::IsNotEmptyBag);
+    type["IsBroken"]             = ALEBind::Method(&LuaItem::IsBroken);
+    type["CanBeTraded"]          = ALEBind::Method(&LuaItem::CanBeTraded);
+    type["IsInTrade"]            = ALEBind::Method(&LuaItem::IsInTrade);
+    type["IsInBag"]              = ALEBind::Method(&LuaItem::IsInBag);
+    type["IsEquipped"]           = ALEBind::Method(&LuaItem::IsEquipped);
+    type["HasQuest"]             = ALEBind::Method(&LuaItem::HasQuest);
+    type["IsPotion"]             = ALEBind::Method(&LuaItem::IsPotion);
+    type["IsWeaponVellum"]       = ALEBind::Method(&LuaItem::IsWeaponVellum);
+    type["IsArmorVellum"]        = ALEBind::Method(&LuaItem::IsArmorVellum);
+    type["IsConjuredConsumable"] = ALEBind::Method(&LuaItem::IsConjuredConsumable);
+    type["GetItemLink"]          = ALEBind::Method(&LuaItem::GetItemLink);
+    type["GetOwnerGUID"]         = ALEBind::Method(&LuaItem::GetOwnerGUID);
+    type["GetOwner"]             = ALEBind::Method(&LuaItem::GetOwner);
+    type["GetCount"]             = ALEBind::Method(&LuaItem::GetCount);
+    type["GetMaxStackCount"]     = ALEBind::Method(&LuaItem::GetMaxStackCount);
+    type["GetSlot"]              = ALEBind::Method(&LuaItem::GetSlot);
+    type["GetBagSlot"]           = ALEBind::Method(&LuaItem::GetBagSlot);
+    type["GetEnchantmentId"]     = ALEBind::Method(&LuaItem::GetEnchantmentId);
+    type["GetSpellId"]           = ALEBind::Method(&LuaItem::GetSpellId);
+    type["GetSpellTrigger"]      = ALEBind::Method(&LuaItem::GetSpellTrigger);
+    type["GetClass"]             = ALEBind::Method(&LuaItem::GetClass);
+    type["GetSubClass"]          = ALEBind::Method(&LuaItem::GetSubClass);
+    type["GetName"]              = ALEBind::Method(&LuaItem::GetName);
+    type["GetDisplayId"]         = ALEBind::Method(&LuaItem::GetDisplayId);
+    type["GetQuality"]           = ALEBind::Method(&LuaItem::GetQuality);
+    type["GetBuyCount"]          = ALEBind::Method(&LuaItem::GetBuyCount);
+    type["GetBuyPrice"]          = ALEBind::Method(&LuaItem::GetBuyPrice);
+    type["GetSellPrice"]         = ALEBind::Method(&LuaItem::GetSellPrice);
+    type["GetInventoryType"]     = ALEBind::Method(&LuaItem::GetInventoryType);
+    type["GetAllowableClass"]    = ALEBind::Method(&LuaItem::GetAllowableClass);
+    type["GetAllowableRace"]     = ALEBind::Method(&LuaItem::GetAllowableRace);
+    type["GetItemLevel"]         = ALEBind::Method(&LuaItem::GetItemLevel);
+    type["GetRequiredLevel"]     = ALEBind::Method(&LuaItem::GetRequiredLevel);
+    type["GetStatsCount"]        = ALEBind::Method(&LuaItem::GetStatsCount);
+    type["GetRandomProperty"]    = ALEBind::Method(&LuaItem::GetRandomProperty);
+    type["GetRandomSuffix"]      = ALEBind::Method(&LuaItem::GetRandomSuffix);
+    type["GetItemSet"]           = ALEBind::Method(&LuaItem::GetItemSet);
+    type["GetBagSize"]           = ALEBind::Method(&LuaItem::GetBagSize);
+    type["GetItemTemplate"]      = ALEBind::Method(&LuaItem::GetItemTemplate);
+    type["SetOwner"]             = ALEBind::Method(&LuaItem::SetOwner);
+    type["SetBinding"]           = ALEBind::Method(&LuaItem::SetBinding);
+    type["SetCount"]             = ALEBind::Method(&LuaItem::SetCount);
+    type["SetEnchantment"]       = ALEBind::Method(&LuaItem::SetEnchantment);
+    type["SetRandomProperty"]    = ALEBind::Method(&LuaItem::SetRandomProperty);
+    type["SetRandomSuffix"]      = ALEBind::Method(&LuaItem::SetRandomSuffix);
+    type["ClearEnchantment"]     = ALEBind::Method(&LuaItem::ClearEnchantment);
+    type["SaveToDB"]             = ALEBind::Method(&LuaItem::SaveToDB);
+}
diff --git a/src/LuaEngine/methods/ItemTemplateMethods.cpp b/src/LuaEngine/methods/ItemTemplateMethods.cpp
new file mode 100644
index 0000000000..fc77e473e9
--- /dev/null
+++ b/src/LuaEngine/methods/ItemTemplateMethods.cpp
@@ -0,0 +1,235 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#include "ALEBind.h"
+
+#include "DBCStores.h"
+#include "DBCStructure.h"
+#include "ItemTemplate.h"
+#include "ObjectMgr.h"
+#include "SharedDefines.h"
+
+/***
+ * Represents item data defined in the database and DBCs, such as stats, quality, class restrictions, and display info.
+ *
+ * Used to access read-only metadata about items (not specific item instances in bags or equipment).
+ *
+ * Inherits all methods from: none
+ */
+namespace LuaItemTemplate
+{
+    /**
+     * Returns the [ItemTemplate]'s ID.
+     *
+     * @return uint32 itemId
+     */
+    uint32 GetItemId(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->ItemId;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s class.
+     *
+     * @return uint32 class
+     */
+    uint32 GetClass(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->Class;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s subclass.
+     *
+     * @return uint32 subClass
+     */
+    uint32 GetSubClass(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->SubClass;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s name in the [Player]'s locale.
+     *
+     * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the [ItemTemplate] name in (it's optional default: LOCALE_enUS)
+     *
+     * @return string name
+     */
+    std::string GetName(ItemTemplate* itemTemplate, sol::optional<uint32> locale)
+    {
+        uint32 loc_idx = locale.value_or(LocaleConstant::LOCALE_enUS);
+        if (loc_idx >= TOTAL_LOCALES)
+            throw std::invalid_argument("locale index out of range");
+
+        ItemLocale const* itemLocale = sObjectMgr->GetItemLocale(itemTemplate->ItemId);
+        std::string name = itemTemplate->Name1;
+
+        if (itemLocale && !itemLocale->Name[loc_idx].empty())
+            name = itemLocale->Name[loc_idx];
+
+        return name;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s display ID.
+     *
+     * @return uint32 displayId
+     */
+    uint32 GetDisplayId(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->DisplayInfoID;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s quality.
+     *
+     * @return uint32 quality
+     */
+    uint32 GetQuality(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->Quality;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s flags.
+     *
+     * @return uint32 flags
+     */
+    uint32 GetFlags(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->Flags;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s extra flags.
+     *
+     * @return uint32 flags
+     */
+    uint32 GetExtraFlags(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->Flags2;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s default purchase count.
+     *
+     * @return uint32 buyCount
+     */
+    uint32 GetBuyCount(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->BuyCount;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s purchase price.
+     *
+     * @return int32 buyPrice
+     */
+    int32 GetBuyPrice(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->BuyPrice;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s sell price.
+     *
+     * @return uint32 sellPrice
+     */
+    uint32 GetSellPrice(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->SellPrice;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s inventory type.
+     *
+     * @return uint32 inventoryType
+     */
+    uint32 GetInventoryType(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->InventoryType;
+    }
+
+    /**
+     * Returns the [Player] classes allowed to use this [ItemTemplate].
+     *
+     * @return uint32 allowableClass
+     */
+    uint32 GetAllowableClass(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->AllowableClass;
+    }
+
+    /**
+     * Returns the [Player] races allowed to use this [ItemTemplate].
+     *
+     * @return uint32 allowableRace
+     */
+    uint32 GetAllowableRace(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->AllowableRace;
+    }
+
+    /**
+     * Returns the [ItemTemplate]'s item level.
+     *
+     * @return uint32 itemLevel
+     */
+    uint32 GetItemLevel(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->ItemLevel;
+    }
+
+    /**
+     * Returns the minimum level required to use this [ItemTemplate].
+     *
+     * @return uint32 requiredLevel
+     */
+    uint32 GetRequiredLevel(ItemTemplate* itemTemplate)
+    {
+        return itemTemplate->RequiredLevel;
+    }
+
+    /**
+     * Returns the icon is used by this [ItemTemplate].
+     *
+     * @return string itemIcon
+     */
+    sol::optional<std::string> GetIcon(ItemTemplate* itemTemplate)
+    {
+        uint32 display_id = itemTemplate->DisplayInfoID;
+
+        // Custom or broken items can carry a display id with no DBC entry.
+        ItemDisplayInfoEntry const* displayInfo = sItemDisplayInfoStore.LookupEntry(display_id);
+        if (!displayInfo)
+            return sol::nullopt;
+
+        return std::string(displayInfo->inventoryIcon);
+    }
+}
+
+void RegisterItemTemplateMethods(sol::state& lua)
+{
+    sol::usertype<ItemTemplate> type = lua.new_usertype<ItemTemplate>("ItemTemplate", sol::no_constructor);
+
+    type["GetItemId"]         = &LuaItemTemplate::GetItemId;
+    type["GetClass"]          = &LuaItemTemplate::GetClass;
+    type["GetSubClass"]       = &LuaItemTemplate::GetSubClass;
+    type["GetName"]           = &LuaItemTemplate::GetName;
+    type["GetDisplayId"]      = &LuaItemTemplate::GetDisplayId;
+    type["GetQuality"]        = &LuaItemTemplate::GetQuality;
+    type["GetFlags"]          = &LuaItemTemplate::GetFlags;
+    type["GetExtraFlags"]     = &LuaItemTemplate::GetExtraFlags;
+    type["GetBuyCount"]       = &LuaItemTemplate::GetBuyCount;
+    type["GetBuyPrice"]       = &LuaItemTemplate::GetBuyPrice;
+    type["GetSellPrice"]      = &LuaItemTemplate::GetSellPrice;
+    type["GetInventoryType"]  = &LuaItemTemplate::GetInventoryType;
+    type["GetAllowableClass"] = &LuaItemTemplate::GetAllowableClass;
+    type["GetAllowableRace"]  = &LuaItemTemplate::GetAllowableRace;
+    type["GetItemLevel"]      = &LuaItemTemplate::GetItemLevel;
+    type["GetRequiredLevel"]  = &LuaItemTemplate::GetRequiredLevel;
+    type["GetIcon"]           = &LuaItemTemplate::GetIcon;
+}
diff --git a/src/LuaEngine/methods/ItemTemplateMethods.h b/src/LuaEngine/methods/ItemTemplateMethods.h
deleted file mode 100644
index 317ae91224..0000000000
--- a/src/LuaEngine/methods/ItemTemplateMethods.h
+++ /dev/null
@@ -1,224 +0,0 @@
-/*
-* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
-* This program is free software licensed under GPL version 3
-* Please see the included DOCS/LICENSE.md for more information
-*/
-
-#ifndef ITEMTEMPLATEMETHODS_H
-#define ITEMTEMPLATEMETHODS_H
-
-#include "Chat.h"
-
-/***
- * Represents item data defined in the database and DBCs, such as stats, quality, class restrictions, and display info.
- *
- * Used to access read-only metadata about items (not specific item instances in bags or equipment).
- *
- * Inherits all methods from: none
- */
-namespace LuaItemTemplate
-{
-    /**
-     * Returns the [ItemTemplate]'s ID.
-     *
-     * @return uint32 itemId
-     */
-    int GetItemId(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->ItemId);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s class.
-     *
-     * @return uint32 class
-     */
-    int GetClass(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->Class);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s subclass.
-     *
-     * @return uint32 subClass
-     */
-    int GetSubClass(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->SubClass);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s name in the [Player]'s locale.
-     *
-     * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the [ItemTemplate] name in (it's optional default: LOCALE_enUS)
-     * 
-     * @return string name
-     */
-    int GetName(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        uint32 loc_idx = ALE::CHECKVAL<uint32>(L, 2, LocaleConstant::LOCALE_enUS);
-
-        const ItemLocale* itemLocale = eObjectMgr->GetItemLocale(itemTemplate->ItemId);
-        std::string name = itemTemplate->Name1;
-
-        if (itemLocale && !itemLocale->Name[loc_idx].empty())
-            name = itemLocale->Name[loc_idx];
-
-        ALE::Push(L, name);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s display ID.
-     *
-     * @return uint32 displayId
-     */
-    int GetDisplayId(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->DisplayInfoID);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s quality.
-     *
-     * @return uint32 quality
-     */
-    int GetQuality(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->Quality);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s flags.
-     *
-     * @return uint32 flags
-     */
-    int GetFlags(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->Flags);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s extra flags.
-     *
-     * @return uint32 flags
-     */
-    int GetExtraFlags(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->Flags2);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s default purchase count.
-     *
-     * @return uint32 buyCount
-     */
-    int GetBuyCount(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->BuyCount);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s purchase price.
-     *
-     * @return int32 buyPrice
-     */
-    int GetBuyPrice(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->BuyPrice);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s sell price.
-     *
-     * @return uint32 sellPrice
-     */
-    int GetSellPrice(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->SellPrice);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s inventory type.
-     *
-     * @return uint32 inventoryType
-     */
-    int GetInventoryType(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->InventoryType);
-        return 1;
-    }
-
-    /**
-     * Returns the [Player] classes allowed to use this [ItemTemplate].
-     *
-     * @return uint32 allowableClass
-     */
-    int GetAllowableClass(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->AllowableClass);
-        return 1;
-    }
-
-    /**
-     * Returns the [Player] races allowed to use this [ItemTemplate].
-     *
-     * @return uint32 allowableRace
-     */
-    int GetAllowableRace(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->AllowableRace);
-        return 1;
-    }
-
-    /**
-     * Returns the [ItemTemplate]'s item level.
-     *
-     * @return uint32 itemLevel
-     */
-    int GetItemLevel(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->ItemLevel);
-        return 1;
-    }
-
-    /**
-     * Returns the minimum level required to use this [ItemTemplate].
-     *
-     * @return uint32 requiredLevel
-     */
-    int GetRequiredLevel(lua_State* L, ItemTemplate* itemTemplate)
-    {
-        ALE::Push(L, itemTemplate->RequiredLevel);
-        return 1;
-    }
-
-    /**
-     * Returns the icon is used by this [ItemTemplate].
-     * 
-     * @return string itemIcon
-     */
-    int GetIcon(lua_State* L, ItemTemplate* itemTemplate)
-    {   
-        uint32 display_id = itemTemplate->DisplayInfoID;
-        
-        ItemDisplayInfoEntry const* displayInfo = sItemDisplayInfoStore.LookupEntry(display_id);       
-        const char* icon = displayInfo->inventoryIcon;
-
-        ALE::Push(L, icon);
-        return 1;
-    }
-}
-
-#endif
diff --git a/src/LuaEngine/methods/LootMethods.h b/src/LuaEngine/methods/LootMethods.cpp
similarity index 57%
rename from src/LuaEngine/methods/LootMethods.h
rename to src/LuaEngine/methods/LootMethods.cpp
index a48ff2d1a1..dbb8edd3b5 100644
--- a/src/LuaEngine/methods/LootMethods.h
+++ b/src/LuaEngine/methods/LootMethods.cpp
@@ -4,12 +4,14 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef LOOTMETHODS_H
-#define LOOTMETHODS_H
+#include "ALEBind.h"
+
+#include "LootMgr.h"
+#include "Player.h"
 
 /***
  * Represents loot that can be obtained from various sources like creatures, gameobjects, or items.
- * 
+ *
  * Contains information about items that can be looted, their quantities, money, and loot state.
  *
  * Inherits all methods from: none
@@ -21,10 +23,9 @@ namespace LuaLoot
      *
      * @return bool isLooted
      */
-    int IsLooted(lua_State* L, Loot* loot)
+    bool IsLooted(Loot* loot)
     {
-        ALE::Push(L, loot->isLooted());
-        return 1;
+        return loot->isLooted();
     }
 
     /**
@@ -40,15 +41,10 @@ namespace LuaLoot
      * @param bool needsQuest = false : if `true`, the item requires a quest to be looted
      * @param bool allowStacking = true : if `true`, allow items to stack in the loot window
      */
-    int AddItem(lua_State* L, Loot* loot)
+    void AddItem(Loot* loot, uint32 itemid, uint8 min_count, uint8 max_count, float chance, uint16 loot_mode, sol::optional<bool> needsQuest, sol::optional<bool> allowStacking)
     {
-        uint32 itemid = ALE::CHECKVAL<uint32>(L, 2);
-        uint8 min_count = ALE::CHECKVAL<uint8>(L, 3);
-        uint8 max_count = ALE::CHECKVAL<uint8>(L, 4);
-        float chance = ALE::CHECKVAL<float>(L, 5);
-        uint16 loot_mode = ALE::CHECKVAL<uint16>(L, 6);
-        bool needs_quest = ALE::CHECKVAL<bool>(L, 7, false);
-        bool allow_stacking = ALE::CHECKVAL<bool>(L, 8, true);
+        bool needs_quest = needsQuest.value_or(false);
+        bool allow_stacking = allowStacking.value_or(true);
 
         if (allow_stacking)
         {
@@ -61,15 +57,13 @@ namespace LuaLoot
                     uint32 add = std::max<uint32>(1u, min_count);
                     uint32 newCount = std::min<uint32>(255u, lootitem.count + add);
                     lootitem.count = static_cast<uint8>(newCount);
-                    return 0;
+                    return;
                 }
             }
         }
 
         LootStoreItem newLootStoreItem(itemid, 0, chance, needs_quest, loot_mode, 0, min_count, max_count);
         loot->AddItem(newLootStoreItem);
-
-        return 0;
     }
 
     /**
@@ -79,15 +73,15 @@ namespace LuaLoot
      * @param uint32 count = 0 : specific count to check for. If 0, ignores count
      * @return bool hasItem
      */
-    int HasItem(lua_State* L, Loot* loot)
+    bool HasItem(Loot* loot, sol::optional<uint32> itemId, sol::optional<uint32> countArg)
     {
-        uint32 itemid = ALE::CHECKVAL<uint32>(L, 2, false);
-        uint32 count = ALE::CHECKVAL<uint32>(L, 3, false);
+        uint32 itemid = itemId.value_or(0);
+        uint32 count = countArg.value_or(0);
         bool has_item = false;
 
         if (itemid)
         {
-            for (const LootItem &lootitem : loot->items)
+            for (LootItem const& lootitem : loot->items)
             {
                 if (lootitem.itemid == itemid && (count == 0 || lootitem.count == count))
                 {
@@ -98,7 +92,7 @@ namespace LuaLoot
         }
         else
         {
-            for (const LootItem &lootitem : loot->items)
+            for (LootItem const& lootitem : loot->items)
             {
                 if (lootitem.itemid != 0)
                 {
@@ -108,66 +102,70 @@ namespace LuaLoot
             }
         }
 
-        ALE::Push(L, has_item);
-        return 1;
+        return has_item;
     }
 
-    /**
-     * Removes the specified item from the [Loot].
-     *
-     * If count is specified, removes only that amount. Otherwise removes all items with the ID.
-     *
-     * @param uint32 itemId : the ID of the item to remove
-     * @param bool isCountSpecified = false : if `true`, only removes the specified count
-     * @param uint32 count = 0 : amount to remove when isCountSpecified is true
-     */
-    int RemoveItem(lua_State* L, Loot* loot)
+    // Helper for RemoveItem: erases (or decrements) matching items in one loot container.
+    void RemoveItemFromContainer(std::vector<LootItem>& container, uint32 itemid, bool isCountSpecified, uint32& remaining)
     {
-        uint32 itemid = ALE::CHECKVAL<uint32>(L, 2);
-        bool isCountSpecified = ALE::CHECKVAL<bool>(L, 3, false);
-        uint32 count = isCountSpecified ? ALE::CHECKVAL<uint32>(L, 4) : 0;
-
-        auto removeFromContainer = [&](auto& container, uint32& remaining)
+        for (auto it = container.begin(); it != container.end(); )
         {
-            for (auto it = container.begin(); it != container.end(); )
+            if (it->itemid == itemid)
             {
-                if (it->itemid == itemid)
+                if (isCountSpecified)
                 {
-                    if (isCountSpecified)
+                    if (it->count > remaining)
                     {
-                        if (it->count > remaining)
-                        {
-                            it->count -= static_cast<uint8>(remaining);
-                            remaining = 0;
-                            break;
-                        }
-                        else
-                        {
-                            remaining -= it->count;
-                            it = container.erase(it);
-                            if (remaining == 0)
-                                break;
-                            continue;
-                        }
+                        it->count -= static_cast<uint8>(remaining);
+                        remaining = 0;
+                        break;
                     }
                     else
                     {
+                        remaining -= it->count;
                         it = container.erase(it);
+                        if (remaining == 0)
+                            break;
                         continue;
                     }
                 }
-                ++it;
+                else
+                {
+                    it = container.erase(it);
+                    continue;
+                }
             }
-        };
+            ++it;
+        }
+    }
+
+    /**
+     * Removes the specified item from the [Loot].
+     *
+     * If count is specified, removes only that amount. Otherwise removes all items with the ID.
+     *
+     * @param uint32 itemId : the ID of the item to remove
+     * @param bool isCountSpecified = false : if `true`, only removes the specified count
+     * @param uint32 count = 0 : amount to remove when isCountSpecified is true
+     */
+    void RemoveItem(Loot* loot, uint32 itemid, sol::optional<bool> isCountSpecifiedArg, sol::optional<uint32> countArg)
+    {
+        bool isCountSpecified = isCountSpecifiedArg.value_or(false);
+        uint32 count = 0;
+        if (isCountSpecified)
+        {
+            if (!countArg)
+                throw std::invalid_argument("count expected when isCountSpecified is true");
+
+            count = *countArg;
+        }
 
         // Remove from regular items
-        removeFromContainer(loot->items, count);
+        RemoveItemFromContainer(loot->items, itemid, isCountSpecified, count);
 
         // Remove from quest items as well
         if (!isCountSpecified || count > 0)
-            removeFromContainer(loot->quest_items, count);
-
-        return 0;
+            RemoveItemFromContainer(loot->quest_items, itemid, isCountSpecified, count);
     }
 
     /**
@@ -175,10 +173,9 @@ namespace LuaLoot
      *
      * @return uint32 money : the amount of money in copper
      */
-    int GetMoney(lua_State* L, Loot* loot)
+    uint32 GetMoney(Loot* loot)
     {
-        ALE::Push(L, loot->gold);
-        return 1;
+        return loot->gold;
     }
 
     /**
@@ -186,12 +183,9 @@ namespace LuaLoot
      *
      * @param uint32 money : the amount of money to set in copper
      */
-    int SetMoney(lua_State* L, Loot* loot)
+    void SetMoney(Loot* loot, uint32 gold)
     {
-        uint32 gold = ALE::CHECKVAL<uint32>(L, 2);
-
         loot->gold = gold;
-        return 0;
     }
 
     /**
@@ -200,22 +194,17 @@ namespace LuaLoot
      * @param uint32 minGold : minimum amount of money in copper
      * @param uint32 maxGold : maximum amount of money in copper
      */
-    int GenerateMoney(lua_State* L, Loot* loot)
+    void GenerateMoney(Loot* loot, uint32 min_gold, uint32 max_gold)
     {
-        uint32 min_gold = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 max_gold = ALE::CHECKVAL<uint32>(L, 3);
-
         loot->generateMoneyLoot(min_gold, max_gold);
-        return 0;
     }
 
     /**
      * Clears all items and money from this [Loot].
      */
-    int Clear(lua_State* /*L*/, Loot* loot)
+    void Clear(Loot* loot)
     {
         loot->clear();
-        return 0;
     }
 
     /**
@@ -223,12 +212,9 @@ namespace LuaLoot
      *
      * @param uint32 count : the number of unlooted items
      */
-    int SetUnlootedCount(lua_State* L, Loot* loot)
+    void SetUnlootedCount(Loot* loot, uint32 count)
     {
-        uint32 count = ALE::CHECKVAL<uint32>(L, 2);
-
         loot->unlootedCount = count;
-        return 0;
     }
 
     /**
@@ -236,10 +222,9 @@ namespace LuaLoot
      *
      * @return uint32 unlootedCount
      */
-    int GetUnlootedCount(lua_State* L, Loot* loot)
+    uint32 GetUnlootedCount(Loot* loot)
     {
-        ALE::Push(L, loot->unlootedCount);
-        return 1;
+        return loot->unlootedCount;
     }
 
     /**
@@ -255,38 +240,26 @@ namespace LuaLoot
      *
      * @return table items : array of item tables
      */
-    int GetItems(lua_State* L, Loot* loot)
+    sol::table GetItems(Loot* loot, sol::this_state s)
     {
-        lua_createtable(L, loot->items.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table();
 
         for (unsigned int i = 0; i < loot->items.size(); i++)
         {
-            lua_newtable(L);
-
-            ALE::Push(L, loot->items[i].itemid);
-            lua_setfield(L, -2, "id");
+            sol::table item = lua.create_table();
 
-            ALE::Push(L, loot->items[i].itemIndex);
-            lua_setfield(L, -2, "index");
+            item["id"] = loot->items[i].itemid;
+            item["index"] = loot->items[i].itemIndex;
+            item["count"] = static_cast<uint8>(loot->items[i].count);
+            item["needs_quest"] = static_cast<bool>(loot->items[i].needs_quest);
+            item["is_looted"] = static_cast<bool>(loot->items[i].is_looted);
+            item["roll_winner_guid"] = loot->items[i].rollWinnerGUID;
 
-            ALE::Push(L, loot->items[i].count);
-            lua_setfield(L, -2, "count");
-
-            ALE::Push(L, loot->items[i].needs_quest);
-            lua_setfield(L, -2, "needs_quest");
-
-            ALE::Push(L, loot->items[i].is_looted);
-            lua_setfield(L, -2, "is_looted");
-
-            ALE::Push(L, loot->items[i].rollWinnerGUID);
-            lua_setfield(L, -2, "roll_winner_guid");
-
-            lua_rawseti(L, tbl, i + 1);
+            tbl[i + 1] = item;
         }
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -302,38 +275,26 @@ namespace LuaLoot
      *
      * @return table quest_items : array of quest item tables
      */
-    int GetQuestItems(lua_State* L, Loot* loot)
+    sol::table GetQuestItems(Loot* loot, sol::this_state s)
     {
-        lua_createtable(L, loot->quest_items.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table();
 
         for (unsigned int i = 0; i < loot->quest_items.size(); i++)
         {
-            lua_newtable(L);
-
-            ALE::Push(L, loot->quest_items[i].itemid);
-            lua_setfield(L, -2, "id");
-
-            ALE::Push(L, loot->quest_items[i].itemIndex);
-            lua_setfield(L, -2, "index");
+            sol::table item = lua.create_table();
 
-            ALE::Push(L, loot->quest_items[i].count);
-            lua_setfield(L, -2, "count");
+            item["id"] = loot->quest_items[i].itemid;
+            item["index"] = loot->quest_items[i].itemIndex;
+            item["count"] = static_cast<uint8>(loot->quest_items[i].count);
+            item["needs_quest"] = static_cast<bool>(loot->quest_items[i].needs_quest);
+            item["is_looted"] = static_cast<bool>(loot->quest_items[i].is_looted);
+            item["roll_winner_guid"] = loot->quest_items[i].rollWinnerGUID;
 
-            ALE::Push(L, loot->quest_items[i].needs_quest);
-            lua_setfield(L, -2, "needs_quest");
-
-            ALE::Push(L, loot->quest_items[i].is_looted);
-            lua_setfield(L, -2, "is_looted");
-
-            ALE::Push(L, loot->quest_items[i].rollWinnerGUID);
-            lua_setfield(L, -2, "roll_winner_guid");
-
-            lua_rawseti(L, tbl, i + 1);
+            tbl[i + 1] = item;
         }
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -341,7 +302,7 @@ namespace LuaLoot
      *
      * This should be called after removing items to ensure indices are sequential.
      */
-    int UpdateItemIndex(lua_State* /*L*/, Loot* loot)
+    void UpdateItemIndex(Loot* loot)
     {
         uint32 index = 0;
 
@@ -350,8 +311,6 @@ namespace LuaLoot
 
         for (unsigned int i = 0; i < loot->quest_items.size(); ++i)
             loot->quest_items[i].itemIndex = index++;
-
-        return 0;
     }
 
     /**
@@ -361,13 +320,11 @@ namespace LuaLoot
      * @param uint32 count : specific count to match. If 0, ignores count
      * @param bool looted = true : `true` to mark as looted, `false` to mark as unlooted
      */
-    int SetItemLooted(lua_State* L, Loot* loot)
+    void SetItemLooted(Loot* loot, uint32 itemid, uint32 count, sol::optional<bool> lootedArg)
     {
-        uint32 itemid = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 count = ALE::CHECKVAL<uint32>(L, 3);
-        bool looted = ALE::CHECKVAL<bool>(L, 4, true);
+        bool looted = lootedArg.value_or(true);
 
-        for (auto &lootItem : loot->items)
+        for (auto& lootItem : loot->items)
         {
             if (lootItem.itemid == itemid && (count == 0 || lootItem.count == count))
             {
@@ -375,7 +332,6 @@ namespace LuaLoot
                 break;
             }
         }
-        return 0;
     }
 
     /**
@@ -383,10 +339,9 @@ namespace LuaLoot
      *
      * @return bool isEmpty
      */
-    int IsEmpty(lua_State* L, Loot* loot)
+    bool IsEmpty(Loot* loot)
     {
-        ALE::Push(L, loot->empty());
-        return 1;
+        return loot->empty();
     }
 
     /**
@@ -394,10 +349,9 @@ namespace LuaLoot
      *
      * @return [LootType] lootType
      */
-    int GetLootType(lua_State* L, Loot* loot)
+    LootType GetLootType(Loot* loot)
     {
-        ALE::Push(L, loot->loot_type);
-        return 1;
+        return loot->loot_type;
     }
 
     /**
@@ -422,11 +376,9 @@ namespace LuaLoot
      *
      * @param [LootType] lootType : the loot type to set
      */
-    int SetLootType(lua_State* L, Loot* loot)
+    void SetLootType(Loot* loot, uint32 lootType)
     {
-        uint32 lootType = ALE::CHECKVAL<uint32>(L, 2);
         loot->loot_type = static_cast<LootType>(lootType);
-        return 0;
     }
 
     /**
@@ -434,10 +386,9 @@ namespace LuaLoot
      *
      * @return ObjectGuid roundRobinPlayer : the player GUID
      */
-    int GetRoundRobinPlayer(lua_State* L, Loot* loot)
+    ObjectGuid GetRoundRobinPlayer(Loot* loot)
     {
-        ALE::Push(L, loot->roundRobinPlayer);
-        return 1;
+        return loot->roundRobinPlayer;
     }
 
     /**
@@ -445,11 +396,9 @@ namespace LuaLoot
      *
      * @param ObjectGuid playerGUID : the player GUID
      */
-    int SetRoundRobinPlayer(lua_State* L, Loot* loot)
+    void SetRoundRobinPlayer(Loot* loot, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         loot->roundRobinPlayer = guid;
-        return 0;
     }
 
     /**
@@ -457,10 +406,9 @@ namespace LuaLoot
      *
      * @return ObjectGuid lootOwner : the player GUID
      */
-    int GetLootOwner(lua_State* L, Loot* loot)
+    ObjectGuid GetLootOwner(Loot* loot)
     {
-        ALE::Push(L, loot->lootOwnerGUID);
-        return 1;
+        return loot->lootOwnerGUID;
     }
 
     /**
@@ -468,11 +416,9 @@ namespace LuaLoot
      *
      * @param ObjectGuid playerGUID : the player GUID
      */
-    int SetLootOwner(lua_State* L, Loot* loot)
+    void SetLootOwner(Loot* loot, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         loot->lootOwnerGUID = guid;
-        return 0;
     }
 
     /**
@@ -480,10 +426,9 @@ namespace LuaLoot
      *
      * @return ObjectGuid containerGUID : the container GUID
      */
-    int GetContainer(lua_State* L, Loot* loot)
+    ObjectGuid GetContainer(Loot* loot)
     {
-        ALE::Push(L, loot->containerGUID);
-        return 1;
+        return loot->containerGUID;
     }
 
     /**
@@ -491,11 +436,9 @@ namespace LuaLoot
      *
      * @param ObjectGuid containerGUID : the container GUID
      */
-    int SetContainer(lua_State* L, Loot* loot)
+    void SetContainer(Loot* loot, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         loot->containerGUID = guid;
-        return 0;
     }
 
     /**
@@ -503,10 +446,9 @@ namespace LuaLoot
      *
      * @return ObjectGuid sourceGUID : the source [WorldObject] GUID
      */
-    int GetSourceWorldObject(lua_State* L, Loot* loot)
+    ObjectGuid GetSourceWorldObject(Loot* loot)
     {
-        ALE::Push(L, loot->sourceWorldObjectGUID);
-        return 1;
+        return loot->sourceWorldObjectGUID;
     }
 
     /**
@@ -514,11 +456,9 @@ namespace LuaLoot
      *
      * @param ObjectGuid sourceGUID : the source [WorldObject] GUID
      */
-    int SetSourceWorldObject(lua_State* L, Loot* loot)
+    void SetSourceWorldObject(Loot* loot, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         loot->sourceWorldObjectGUID = guid;
-        return 0;
     }
 
     /**
@@ -526,10 +466,9 @@ namespace LuaLoot
      *
      * @return bool hasQuestItems
      */
-    int HasQuestItems(lua_State* L, Loot* loot)
+    bool HasQuestItems(Loot* loot)
     {
-        ALE::Push(L, !loot->quest_items.empty());
-        return 1;
+        return !loot->quest_items.empty();
     }
 
     /**
@@ -537,10 +476,9 @@ namespace LuaLoot
      *
      * @return bool hasItemForAll
      */
-    int HasItemForAll(lua_State* L, Loot* loot)
+    bool HasItemForAll(Loot* loot)
     {
-        ALE::Push(L, loot->hasItemForAll());
-        return 1;
+        return loot->hasItemForAll();
     }
 
     /**
@@ -548,10 +486,9 @@ namespace LuaLoot
      *
      * @return bool hasOverThresholdItem
      */
-    int HasOverThresholdItem(lua_State* L, Loot* loot)
+    bool HasOverThresholdItem(Loot* loot)
     {
-        ALE::Push(L, loot->hasOverThresholdItem());
-        return 1;
+        return loot->hasOverThresholdItem();
     }
 
     /**
@@ -559,10 +496,9 @@ namespace LuaLoot
      *
      * @return uint32 itemCount
      */
-    int GetItemCount(lua_State* L, Loot* loot)
+    uint32 GetItemCount(Loot* loot)
     {
-        ALE::Push(L, static_cast<uint32>(loot->items.size() + loot->quest_items.size()));
-        return 1;
+        return static_cast<uint32>(loot->items.size() + loot->quest_items.size());
     }
 
     /**
@@ -571,11 +507,9 @@ namespace LuaLoot
      * @param [Player] player : the player to check slots for
      * @return uint32 maxSlot
      */
-    int GetMaxSlotForPlayer(lua_State* L, Loot* loot)
+    uint32 GetMaxSlotForPlayer(Loot* loot, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
-        ALE::Push(L, loot->GetMaxSlotInLootFor(player));
-        return 1;
+        return loot->GetMaxSlotInLootFor(player);
     }
 
     /**
@@ -583,11 +517,9 @@ namespace LuaLoot
      *
      * @param [Player] player : the player to add as a looter
      */
-    int AddLooter(lua_State* L, Loot* loot)
+    void AddLooter(Loot* loot, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
         loot->AddLooter(player->GetGUID());
-        return 0;
     }
 
     /**
@@ -595,11 +527,46 @@ namespace LuaLoot
      *
      * @param [Player] player : the player to remove from looters
      */
-    int RemoveLooter(lua_State* L, Loot* loot)
+    void RemoveLooter(Loot* loot, Player* player)
     {
-        Player* player = ALE::CHECKOBJ<Player>(L, 2);
         loot->RemoveLooter(player->GetGUID());
-        return 0;
     }
-};
-#endif // LOOTMETHODS_H
+}
+
+void RegisterLootMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<Loot>> type = ALEBind::NewHandleType<ScopedRef<Loot>>(lua, "Loot");
+
+    type["IsLooted"]             = ALEBind::Method(&LuaLoot::IsLooted);
+    type["AddItem"]              = ALEBind::Method(&LuaLoot::AddItem);
+    type["HasItem"]              = ALEBind::Method(&LuaLoot::HasItem);
+    type["RemoveItem"]           = ALEBind::Method(&LuaLoot::RemoveItem);
+    type["GetMoney"]             = ALEBind::Method(&LuaLoot::GetMoney);
+    type["SetMoney"]             = ALEBind::Method(&LuaLoot::SetMoney);
+    type["GenerateMoney"]        = ALEBind::Method(&LuaLoot::GenerateMoney);
+    type["Clear"]                = ALEBind::Method(&LuaLoot::Clear);
+    type["SetUnlootedCount"]     = ALEBind::Method(&LuaLoot::SetUnlootedCount);
+    type["GetUnlootedCount"]     = ALEBind::Method(&LuaLoot::GetUnlootedCount);
+    type["GetItems"]             = ALEBind::Method(&LuaLoot::GetItems);
+    type["GetQuestItems"]        = ALEBind::Method(&LuaLoot::GetQuestItems);
+    type["UpdateItemIndex"]      = ALEBind::Method(&LuaLoot::UpdateItemIndex);
+    type["SetItemLooted"]        = ALEBind::Method(&LuaLoot::SetItemLooted);
+    type["IsEmpty"]              = ALEBind::Method(&LuaLoot::IsEmpty);
+    type["GetLootType"]          = ALEBind::Method(&LuaLoot::GetLootType);
+    type["SetLootType"]          = ALEBind::Method(&LuaLoot::SetLootType);
+    type["GetRoundRobinPlayer"]  = ALEBind::Method(&LuaLoot::GetRoundRobinPlayer);
+    type["SetRoundRobinPlayer"]  = ALEBind::Method(&LuaLoot::SetRoundRobinPlayer);
+    type["GetLootOwner"]         = ALEBind::Method(&LuaLoot::GetLootOwner);
+    type["SetLootOwner"]         = ALEBind::Method(&LuaLoot::SetLootOwner);
+    type["GetContainer"]         = ALEBind::Method(&LuaLoot::GetContainer);
+    type["SetContainer"]         = ALEBind::Method(&LuaLoot::SetContainer);
+    type["GetSourceWorldObject"] = ALEBind::Method(&LuaLoot::GetSourceWorldObject);
+    type["SetSourceWorldObject"] = ALEBind::Method(&LuaLoot::SetSourceWorldObject);
+    type["HasQuestItems"]        = ALEBind::Method(&LuaLoot::HasQuestItems);
+    type["HasItemForAll"]        = ALEBind::Method(&LuaLoot::HasItemForAll);
+    type["HasOverThresholdItem"] = ALEBind::Method(&LuaLoot::HasOverThresholdItem);
+    type["GetItemCount"]         = ALEBind::Method(&LuaLoot::GetItemCount);
+    type["GetMaxSlotForPlayer"]  = ALEBind::Method(&LuaLoot::GetMaxSlotForPlayer);
+    type["AddLooter"]            = ALEBind::Method(&LuaLoot::AddLooter);
+    type["RemoveLooter"]         = ALEBind::Method(&LuaLoot::RemoveLooter);
+}
diff --git a/src/LuaEngine/methods/MapMethods.h b/src/LuaEngine/methods/MapMethods.cpp
similarity index 53%
rename from src/LuaEngine/methods/MapMethods.h
rename to src/LuaEngine/methods/MapMethods.cpp
index 79a1a087b5..c0af274727 100644
--- a/src/LuaEngine/methods/MapMethods.h
+++ b/src/LuaEngine/methods/MapMethods.cpp
@@ -4,11 +4,20 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef MAPMETHODS_H
-#define MAPMETHODS_H
-
+#include "ALEBind.h"
 #include "ALEInstanceAI.h"
 
+#include "Corpse.h"
+#include "Creature.h"
+#include "DynamicObject.h"
+#include "GameObject.h"
+#include "Map.h"
+#include "ObjectAccessor.h"
+#include "Pet.h"
+#include "Player.h"
+#include "SharedDefines.h"
+#include "Weather.h"
+
 /***
  * A game map, e.g. Azeroth, Eastern Kingdoms, the Molten Core, etc.
  *
@@ -22,10 +31,9 @@ namespace LuaMap
      *
      * @return bool isArena
      */
-    int IsArena(lua_State* L, Map* map)
+    bool IsArena(Map* map)
     {
-        ALE::Push(L, map->IsBattleArena());
-        return 1;
+        return map->IsBattleArena();
     }
 
     /**
@@ -33,10 +41,9 @@ namespace LuaMap
      *
      * @return bool isBattleGround
      */
-    int IsBattleground(lua_State* L, Map* map)
+    bool IsBattleground(Map* map)
     {
-        ALE::Push(L, map->IsBattleground());
-        return 1;
+        return map->IsBattleground();
     }
 
     /**
@@ -44,10 +51,9 @@ namespace LuaMap
      *
      * @return bool isDungeon
      */
-    int IsDungeon(lua_State* L, Map* map)
+    bool IsDungeon(Map* map)
     {
-        ALE::Push(L, map->IsDungeon());
-        return 1;
+        return map->IsDungeon();
     }
 
     /**
@@ -55,10 +61,9 @@ namespace LuaMap
      *
      * @return bool IsEmpty
      */
-    int IsEmpty(lua_State* L, Map* map)
+    bool IsEmpty(Map* map)
     {
-        ALE::Push(L, map->IsEmpty());
-        return 1;
+        return map->IsEmpty();
     }
 
     /**
@@ -66,10 +71,9 @@ namespace LuaMap
      *
      * @return bool isHeroic
      */
-    int IsHeroic(lua_State* L, Map* map)
+    bool IsHeroic(Map* map)
     {
-        ALE::Push(L, map->IsHeroic());
-        return 1;
+        return map->IsHeroic();
     }
 
     /**
@@ -77,10 +81,9 @@ namespace LuaMap
      *
      * @return bool isRaid
      */
-    int IsRaid(lua_State* L, Map* map)
+    bool IsRaid(Map* map)
     {
-        ALE::Push(L, map->IsRaid());
-        return 1;
+        return map->IsRaid();
     }
 
     /**
@@ -88,10 +91,9 @@ namespace LuaMap
      *
      * @return string mapName
      */
-    int GetName(lua_State* L, Map* map)
+    char const* GetName(Map* map)
     {
-        ALE::Push(L, map->GetMapName());
-        return 1;
+        return map->GetMapName();
     }
 
     /**
@@ -103,15 +105,13 @@ namespace LuaMap
      * @param float y
      * @return float z
      */
-    int GetHeight(lua_State* L, Map* map)
+    sol::optional<float> GetHeight(Map* map, float x, float y, sol::optional<uint32> phasemask)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        uint32 phasemask = ALE::CHECKVAL<uint32>(L, 4, 1);
-        float z = map->GetHeight(phasemask, x, y, MAX_HEIGHT);
+        float z = map->GetHeight(phasemask.value_or(1), x, y, MAX_HEIGHT);
         if (z != INVALID_HEIGHT)
-            ALE::Push(L, z);
-        return 1;
+            return z;
+
+        return sol::nullopt;
     }
 
     /**
@@ -121,10 +121,9 @@ namespace LuaMap
      *
      * @return int32 difficulty
      */
-    int GetDifficulty(lua_State* L, Map* map)
+    Difficulty GetDifficulty(Map* map)
     {
-        ALE::Push(L, map->GetDifficulty());
-        return 1;
+        return map->GetDifficulty();
     }
 
     /**
@@ -132,10 +131,9 @@ namespace LuaMap
      *
      * @return uint32 instanceId
      */
-    int GetInstanceId(lua_State* L, Map* map)
+    uint32 GetInstanceId(Map* map)
     {
-        ALE::Push(L, map->GetInstanceId());
-        return 1;
+        return map->GetInstanceId();
     }
 
     /**
@@ -143,10 +141,9 @@ namespace LuaMap
      *
      * @return uint32 playerCount
      */
-    int GetPlayerCount(lua_State* L, Map* map)
+    uint32 GetPlayerCount(Map* map)
     {
-        ALE::Push(L, map->GetPlayersCountExceptGMs());
-        return 1;
+        return map->GetPlayersCountExceptGMs();
     }
 
     /**
@@ -154,10 +151,9 @@ namespace LuaMap
      *
      * @return uint32 mapId
      */
-    int GetMapId(lua_State* L, Map* map)
+    uint32 GetMapId(Map* map)
     {
-        ALE::Push(L, map->GetId());
-        return 1;
+        return map->GetId();
     }
 
     /**
@@ -169,15 +165,9 @@ namespace LuaMap
      * @param uint32 phasemask = PHASEMASK_NORMAL
      * @return uint32 areaId
      */
-    int GetAreaId(lua_State* L, Map* map)
+    uint32 GetAreaId(Map* map, float x, float y, float z, sol::optional<uint32> phasemask)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float z = ALE::CHECKVAL<float>(L, 4);
-        float phasemask = ALE::CHECKVAL<uint32>(L, 5, PHASEMASK_NORMAL);
-
-        ALE::Push(L, map->GetAreaId(phasemask, x, y, z));
-        return 1;
+        return map->GetAreaId(phasemask.value_or(PHASEMASK_NORMAL), x, y, z);
     }
 
     /**
@@ -186,37 +176,38 @@ namespace LuaMap
      * @param ObjectGuid guid
      * @return [WorldObject] object
      */
-    int GetWorldObject(lua_State* L, Map* map)
+    sol::object GetWorldObject(Map* map, ObjectGuid guid, sol::this_state s)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
+        WorldObject* obj = nullptr;
 
         switch (guid.GetHigh())
         {
-            case HIGHGUID_PLAYER:
-                ALE::Push(L, eObjectAccessor()GetPlayer(map, guid));
+            case HighGuid::Player:
+                obj = ObjectAccessor::GetPlayer(map, guid);
                 break;
-            case HIGHGUID_TRANSPORT:
-            case HIGHGUID_MO_TRANSPORT:
-            case HIGHGUID_GAMEOBJECT:
-                ALE::Push(L, map->GetGameObject(guid));
+            case HighGuid::Transport:
+            case HighGuid::Mo_Transport:
+            case HighGuid::GameObject:
+                obj = map->GetGameObject(guid);
                 break;
-            case HIGHGUID_VEHICLE:
-            case HIGHGUID_UNIT:
-                ALE::Push(L, map->GetCreature(guid));
+            case HighGuid::Vehicle:
+            case HighGuid::Unit:
+                obj = map->GetCreature(guid);
                 break;
-            case HIGHGUID_PET:
-                ALE::Push(L, map->GetPet(guid));
+            case HighGuid::Pet:
+                obj = map->GetPet(guid);
                 break;
-            case HIGHGUID_DYNAMICOBJECT:
-                ALE::Push(L, map->GetDynamicObject(guid));
+            case HighGuid::DynamicObject:
+                obj = map->GetDynamicObject(guid);
                 break;
-            case HIGHGUID_CORPSE:
-                ALE::Push(L, map->GetCorpse(guid));
+            case HighGuid::Corpse:
+                obj = map->GetCorpse(guid);
                 break;
             default:
                 break;
         }
-        return 1;
+
+        return ALEBind::ToLuaDynamic(sol::state_view(s), obj);
     }
 
     /**
@@ -236,16 +227,11 @@ namespace LuaMap
      * @param [WeatherType] type : the [WeatherType], see above available weather types
      * @param float grade : the intensity/grade of the [Weather], ranges from 0 to 1
      */
-    int SetWeather(lua_State* L, Map* map)
+    void SetWeather(Map* map, uint32 zoneId, uint32 weatherType, float grade)
     {
-        uint32 zoneId = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 weatherType = ALE::CHECKVAL<uint32>(L, 3);
-        float grade = ALE::CHECKVAL<float>(L, 4);
-
         Weather* weather = map->GetOrGenerateZoneDefaultWeather(zoneId);
         if (weather)
             weather->SetWeather((WeatherType)weatherType, grade);
-        return 0;
     }
 
     /**
@@ -256,33 +242,30 @@ namespace LuaMap
      *
      * @return table instance_data : instance data table, or `nil`
      */
-    int GetInstanceData(lua_State* L, Map* map)
+    sol::object GetInstanceData(Map* map, sol::this_state s)
     {
-        ALEInstanceAI* iAI = NULL;
+        ALEInstanceAI* iAI = nullptr;
         if (InstanceMap* inst = map->ToInstanceMap())
             iAI = dynamic_cast<ALEInstanceAI*>(inst->GetInstanceScript());
 
+        sol::state_view lua(s);
         if (iAI)
-            ALE::GetALE(L)->PushInstanceData(L, iAI, false);
-        else
-            ALE::Push(L); // nil
+            return sol::make_object(lua, sALE->GetInstanceData(iAI));
 
-        return 1;
+        return sol::make_object(lua, sol::lua_nil);
     }
 
     /**
      * Saves the [Map]'s instance data to the database.
      */
-    int SaveInstanceData(lua_State* /*L*/, Map* map)
+    void SaveInstanceData(Map* map)
     {
-        ALEInstanceAI* iAI = NULL;
+        ALEInstanceAI* iAI = nullptr;
         if (InstanceMap* inst = map->ToInstanceMap())
             iAI = dynamic_cast<ALEInstanceAI*>(inst->GetInstanceScript());
 
         if (iAI)
             iAI->SaveToDB();
-
-        return 0;
     }
 
     /**
@@ -298,12 +281,11 @@ namespace LuaMap
     * @param [TeamId] team : optional check team of the [Player], Alliance, Horde or Neutral (All)
     * @return table mapPlayers
     */
-    int GetPlayers(lua_State* L, Map* map)
+    sol::table GetPlayers(Map* map, sol::optional<uint32> teamArg, sol::this_state s)
     {
-        uint32 team = ALE::CHECKVAL<uint32>(L, 2, TEAM_NEUTRAL);
+        uint32 team = teamArg.value_or(TEAM_NEUTRAL);
 
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         Map::PlayerList const& players = map->GetPlayers();
@@ -313,90 +295,100 @@ namespace LuaMap
             if (!player)
                 continue;
             if (player->GetSession() && (team >= TEAM_NEUTRAL || player->GetTeamId() == team))
-            {
-                ALE::Push(L, player);
-                lua_rawseti(L, tbl, ++i);
-            }
+                tbl[++i] = PlayerRef(player);
         }
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
      * Returns a table with all the current [Creature]s in the map
-     * 
+     *
      * @return table mapCreatures
      */
-    int GetCreatures(lua_State* L, Map* map)
+    sol::table GetCreatures(Map* map, sol::this_state s)
     {
-        const auto& creatures = map->GetCreatureBySpawnIdStore();
+        auto const& creatures = map->GetCreatureBySpawnIdStore();
 
-        lua_createtable(L, creatures.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
 
-        for (const auto& pair : creatures)
+        for (auto const& pair : creatures)
         {
             Creature* creature = pair.second;
-
-            ALE::Push(L, creature);
-            lua_rawseti(L, tbl, creature->GetSpawnId());
+            tbl[creature->GetSpawnId()] = CreatureRef(creature);
         }
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
      * Returns a table with all the current [Creature]s in the specific area id
-     * 
+     *
      * @param number areaId : specific area id
      * @return table mapCreatures
      */
-    int GetCreaturesByAreaId(lua_State* L, Map* map)
+    sol::table GetCreaturesByAreaId(Map* map, sol::optional<int32> areaIdArg, sol::this_state s)
     {
-        int32 areaId = ALE::CHECKVAL<int32>(L, 2, -1);
+        int32 areaId = areaIdArg.value_or(-1);
         std::vector<Creature*> filteredCreatures;
 
-        for (const auto& pair : map->GetCreatureBySpawnIdStore())
+        for (auto const& pair : map->GetCreatureBySpawnIdStore())
         {
             Creature* creature = pair.second;
             if (areaId == -1 || creature->GetAreaId() == (uint32)areaId)
-            {
                 filteredCreatures.push_back(creature);
-            }
         }
 
-        lua_createtable(L, filteredCreatures.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
 
         for (Creature* creature : filteredCreatures)
-        {
-            ALE::Push(L, creature);
-            lua_rawseti(L, tbl, creature->GetSpawnId());
-        }
+            tbl[creature->GetSpawnId()] = CreatureRef(creature);
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
-    
     /**
      * Returns a table of all [Transport]s on the [Map]
      *
      * @return table transports
      */
-    int GetTransports(lua_State* L, Map* map)
+    sol::table GetTransports(Map* map, sol::this_state s)
     {
         TransportsContainer const& transports = map->GetAllTransports();
-        lua_createtable(L, transports.size(), 0);
+
+        sol::table tbl = sol::state_view(s).create_table();
         int i = 1;
+
         for (Transport* transport : transports)
-        {
-            ALE::Push(L, transport);
-            lua_rawseti(L, -2, i++);
-        }
-        return 1;
+            tbl[i++] = TransportRef(transport);
+
+        return tbl;
     }
-};
-#endif
+}
+
+void RegisterMapMethods(sol::state& lua)
+{
+    sol::usertype<MapRef> type = ALEBind::NewHandleType<MapRef>(lua, "Map");
+
+    type["IsArena"]              = ALEBind::Method(&LuaMap::IsArena);
+    type["IsBattleground"]       = ALEBind::Method(&LuaMap::IsBattleground);
+    type["IsDungeon"]            = ALEBind::Method(&LuaMap::IsDungeon);
+    type["IsEmpty"]              = ALEBind::Method(&LuaMap::IsEmpty);
+    type["IsHeroic"]             = ALEBind::Method(&LuaMap::IsHeroic);
+    type["IsRaid"]               = ALEBind::Method(&LuaMap::IsRaid);
+    type["GetName"]              = ALEBind::Method(&LuaMap::GetName);
+    type["GetHeight"]            = ALEBind::Method(&LuaMap::GetHeight);
+    type["GetDifficulty"]        = ALEBind::Method(&LuaMap::GetDifficulty);
+    type["GetInstanceId"]        = ALEBind::Method(&LuaMap::GetInstanceId);
+    type["GetPlayerCount"]       = ALEBind::Method(&LuaMap::GetPlayerCount);
+    type["GetMapId"]             = ALEBind::Method(&LuaMap::GetMapId);
+    type["GetAreaId"]            = ALEBind::Method(&LuaMap::GetAreaId);
+    type["GetWorldObject"]       = ALEBind::Method(&LuaMap::GetWorldObject);
+    type["SetWeather"]           = ALEBind::Method(&LuaMap::SetWeather);
+    type["GetInstanceData"]      = ALEBind::Method(&LuaMap::GetInstanceData);
+    type["SaveInstanceData"]     = ALEBind::Method(&LuaMap::SaveInstanceData);
+    type["GetPlayers"]           = ALEBind::Method(&LuaMap::GetPlayers);
+    type["GetCreatures"]         = ALEBind::Method(&LuaMap::GetCreatures);
+    type["GetCreaturesByAreaId"] = ALEBind::Method(&LuaMap::GetCreaturesByAreaId);
+    type["GetTransports"]        = ALEBind::Method(&LuaMap::GetTransports);
+}
diff --git a/src/LuaEngine/methods/ObjectMethods.h b/src/LuaEngine/methods/ObjectMethods.cpp
similarity index 63%
rename from src/LuaEngine/methods/ObjectMethods.h
rename to src/LuaEngine/methods/ObjectMethods.cpp
index e99ce4f319..5f6253d153 100644
--- a/src/LuaEngine/methods/ObjectMethods.h
+++ b/src/LuaEngine/methods/ObjectMethods.cpp
@@ -4,8 +4,10 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef OBJECTMETHODS_H
-#define OBJECTMETHODS_H
+#include "ALEBind.h"
+
+#include "Object.h"
+#include "UpdateFields.h"
 
 /***
  * A basic game object (either an [Item] or a [WorldObject]).
@@ -31,13 +33,9 @@ namespace LuaObject
      * @param uint32 flag : the flag to check for in the flags data
      * @return bool hasFlag
      */
-    int HasFlag(lua_State* L, Object* obj)
+    bool HasFlag(Object* obj, uint16 index, uint32 flag)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 3);
-
-        ALE::Push(L, obj->HasFlag(index, flag));
-        return 1;
+        return obj->HasFlag(index, flag);
     }
 
     /**
@@ -45,21 +43,19 @@ namespace LuaObject
      *
      * @return bool inWorld
      */
-    int IsInWorld(lua_State* L, Object* obj)
+    bool IsInWorld(Object* obj)
     {
-        ALE::Push(L, obj->IsInWorld());
-        return 1;
+        return obj->IsInWorld();
     }
 
     /**
- * Returns 'true' if the [Object] is a player, 'false' otherwise.
- *
- * @return bool IsPlayer
- */
-    int IsPlayer(lua_State* L, Object* obj)
+     * Returns 'true' if the [Object] is a player, 'false' otherwise.
+     *
+     * @return bool IsPlayer
+     */
+    bool IsPlayer(Object* obj)
     {
-        ALE::Push(L, obj->IsPlayer());
-        return 1;
+        return obj->IsPlayer();
     }
 
     /**
@@ -68,11 +64,9 @@ namespace LuaObject
      * @param uint16 index
      * @return int32 value
      */
-    int GetInt32Value(lua_State* L, Object* obj)
+    int32 GetInt32Value(Object* obj, uint16 index)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        ALE::Push(L, obj->GetInt32Value(index));
-        return 1;
+        return obj->GetInt32Value(index);
     }
 
     /**
@@ -81,11 +75,9 @@ namespace LuaObject
      * @param uint16 index
      * @return uint32 value
      */
-    int GetUInt32Value(lua_State* L, Object* obj)
+    uint32 GetUInt32Value(Object* obj, uint16 index)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        ALE::Push(L, obj->GetUInt32Value(index));
-        return 1;
+        return obj->GetUInt32Value(index);
     }
 
     /**
@@ -94,11 +86,9 @@ namespace LuaObject
      * @param uint16 index
      * @return float value
      */
-    int GetFloatValue(lua_State* L, Object* obj)
+    float GetFloatValue(Object* obj, uint16 index)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        ALE::Push(L, obj->GetFloatValue(index));
-        return 1;
+        return obj->GetFloatValue(index);
     }
 
     /**
@@ -110,12 +100,9 @@ namespace LuaObject
      * @param uint8 offset : should be 0, 1, 2, or 3
      * @return uint8 value
      */
-    int GetByteValue(lua_State* L, Object* obj)
+    uint8 GetByteValue(Object* obj, uint16 index, uint8 offset)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint8 offset = ALE::CHECKVAL<uint8>(L, 3);
-        ALE::Push(L, obj->GetByteValue(index, offset));
-        return 1;
+        return obj->GetByteValue(index, offset);
     }
 
     /**
@@ -127,12 +114,9 @@ namespace LuaObject
      * @param uint8 offset : should be 0 or 1
      * @return uint16 value
      */
-    int GetUInt16Value(lua_State* L, Object* obj)
+    uint16 GetUInt16Value(Object* obj, uint16 index, uint8 offset)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint8 offset = ALE::CHECKVAL<uint8>(L, 3);
-        ALE::Push(L, obj->GetUInt16Value(index, offset));
-        return 1;
+        return obj->GetUInt16Value(index, offset);
     }
 
     /**
@@ -142,10 +126,9 @@ namespace LuaObject
      *
      * @return float scale
      */
-    int GetScale(lua_State* L, Object* obj)
+    float GetScale(Object* obj)
     {
-        ALE::Push(L, obj->GetFloatValue(OBJECT_FIELD_SCALE_X));
-        return 1;
+        return obj->GetFloatValue(OBJECT_FIELD_SCALE_X);
     }
 
     /**
@@ -155,10 +138,9 @@ namespace LuaObject
      *
      * @return uint32 entry
      */
-    int GetEntry(lua_State* L, Object* obj)
+    uint32 GetEntry(Object* obj)
     {
-        ALE::Push(L, obj->GetEntry());
-        return 1;
+        return obj->GetEntry();
     }
 
     /**
@@ -173,10 +155,9 @@ namespace LuaObject
      *
      * @return ObjectGuid guid
      */
-    int GetGUID(lua_State* L, Object* obj)
+    ObjectGuid GetGUID(Object* obj)
     {
-        ALE::Push(L, obj->GET_GUID());
-        return 1;
+        return obj->GetGUID();
     }
 
     /**
@@ -191,10 +172,9 @@ namespace LuaObject
      *
      * @return uint32 guidLow
      */
-    int GetGUIDLow(lua_State* L, Object* obj)
+    uint32 GetGUIDLow(Object* obj)
     {
-        ALE::Push(L, obj->GetGUID().GetCounter());
-        return 1;
+        return obj->GetGUID().GetCounter();
     }
 
     /**
@@ -214,10 +194,9 @@ namespace LuaObject
      *
      * @return uint8 typeID
      */
-    int GetTypeId(lua_State* L, Object* obj)
+    uint8 GetTypeId(Object* obj)
     {
-        ALE::Push(L, obj->GetTypeId());
-        return 1;
+        return obj->GetTypeId();
     }
 
     /**
@@ -226,11 +205,9 @@ namespace LuaObject
      * @param uint16 index
      * @return uint64 value
      */
-    int GetUInt64Value(lua_State* L, Object* obj)
+    uint64 GetUInt64Value(Object* obj, uint16 index)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        ALE::Push(L, obj->GetUInt64Value(index));
-        return 1;
+        return obj->GetUInt64Value(index);
     }
 
     /**
@@ -243,13 +220,9 @@ namespace LuaObject
      * @param uint16 index
      * @param uint32 value
      */
-    int SetFlag(lua_State* L, Object* obj)
+    void SetFlag(Object* obj, uint16 index, uint32 flag)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 3);
-
         obj->SetFlag(index, flag);
-        return 0;
     }
 
     /**
@@ -258,12 +231,9 @@ namespace LuaObject
      * @param uint16 index
      * @param int32 value
      */
-    int SetInt32Value(lua_State* L, Object* obj)
+    void SetInt32Value(Object* obj, uint16 index, int32 value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        int32 value = ALE::CHECKVAL<int32>(L, 3);
         obj->SetInt32Value(index, value);
-        return 0;
     }
 
     /**
@@ -272,12 +242,9 @@ namespace LuaObject
      * @param uint16 index
      * @param uint32 value
      */
-    int SetUInt32Value(lua_State* L, Object* obj)
+    void SetUInt32Value(Object* obj, uint16 index, uint32 value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint32 value = ALE::CHECKVAL<uint32>(L, 3);
         obj->SetUInt32Value(index, value);
-        return 0;
     }
 
     /**
@@ -286,12 +253,9 @@ namespace LuaObject
      * @param uint16 index
      * @param uint32 value
      */
-    int UpdateUInt32Value(lua_State* L, Object* obj)
+    void UpdateUInt32Value(Object* obj, uint16 index, uint32 value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint32 value = ALE::CHECKVAL<uint32>(L, 3);
         obj->UpdateUInt32Value(index, value);
-        return 0;
     }
 
     /**
@@ -300,13 +264,9 @@ namespace LuaObject
      * @param uint16 index
      * @param float value
      */
-    int SetFloatValue(lua_State* L, Object* obj)
+    void SetFloatValue(Object* obj, uint16 index, float value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        float value = ALE::CHECKVAL<float>(L, 3);
-
         obj->SetFloatValue(index, value);
-        return 0;
     }
 
     /**
@@ -316,13 +276,9 @@ namespace LuaObject
      * @param uint8 offset : should be 0, 1, 2, or 3
      * @param uint8 value
      */
-    int SetByteValue(lua_State* L, Object* obj)
+    void SetByteValue(Object* obj, uint16 index, uint8 offset, uint8 value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint8 offset = ALE::CHECKVAL<uint8>(L, 3);
-        uint8 value = ALE::CHECKVAL<uint8>(L, 4);
         obj->SetByteValue(index, offset, value);
-        return 0;
     }
 
     /**
@@ -332,13 +288,9 @@ namespace LuaObject
      * @param uint8 offset : should be 0 or 1
      * @param uint16 value
      */
-    int SetUInt16Value(lua_State* L, Object* obj)
+    void SetUInt16Value(Object* obj, uint16 index, uint8 offset, uint16 value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint8 offset = ALE::CHECKVAL<uint8>(L, 3);
-        uint16 value = ALE::CHECKVAL<uint16>(L, 4);
         obj->SetUInt16Value(index, offset, value);
-        return 0;
     }
 
     /**
@@ -348,13 +300,9 @@ namespace LuaObject
      * @param uint8 offset : should be 0 or 1
      * @param int16 value
      */
-    int SetInt16Value(lua_State* L, Object* obj)
+    void SetInt16Value(Object* obj, uint16 index, uint8 offset, int16 value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint8 offset = ALE::CHECKVAL<uint8>(L, 3);
-        int16 value = ALE::CHECKVAL<int16>(L, 4);
         obj->SetInt16Value(index, offset, value);
-        return 0;
     }
 
     /**
@@ -362,12 +310,9 @@ namespace LuaObject
      *
      * @param float scale
      */
-    int SetScale(lua_State* L, Object* obj)
+    void SetScale(Object* obj, float scale)
     {
-        float size = ALE::CHECKVAL<float>(L, 2);
-
-        obj->SetObjectScale(size);
-        return 0;
+        obj->SetObjectScale(scale);
     }
 
     /**
@@ -376,12 +321,9 @@ namespace LuaObject
      * @param uint16 index
      * @param uint64 value
      */
-    int SetUInt64Value(lua_State* L, Object* obj)
+    void SetUInt64Value(Object* obj, uint16 index, uint64 value)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint64 value = ALE::CHECKVAL<uint64>(L, 3);
         obj->SetUInt64Value(index, value);
-        return 0;
     }
 
     /**
@@ -390,13 +332,9 @@ namespace LuaObject
      * @param uint16 index
      * @param uint32 flag
      */
-    int RemoveFlag(lua_State* L, Object* obj)
+    void RemoveFlag(Object* obj, uint16 index, uint32 flag)
     {
-        uint16 index = ALE::CHECKVAL<uint16>(L, 2);
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 3);
-
         obj->RemoveFlag(index, flag);
-        return 0;
     }
 
     /**
@@ -406,10 +344,9 @@ namespace LuaObject
      *
      * @return [Corpse] corpse : the [Object] as a [Corpse], or `nil`
      */
-    int ToCorpse(lua_State* L, Object* obj)
+    Corpse* ToCorpse(Object* obj)
     {
-        ALE::Push(L, obj->ToCorpse());
-        return 1;
+        return obj->ToCorpse();
     }
 
     /**
@@ -419,10 +356,9 @@ namespace LuaObject
      *
      * @return [GameObject] gameObject : the [Object] as a [GameObject], or `nil`
      */
-    int ToGameObject(lua_State* L, Object* obj)
+    GameObject* ToGameObject(Object* obj)
     {
-        ALE::Push(L, obj->ToGameObject());
-        return 1;
+        return obj->ToGameObject();
     }
 
     /**
@@ -432,10 +368,9 @@ namespace LuaObject
      *
      * @return [Unit] unit : the [Object] as a [Unit], or `nil`
      */
-    int ToUnit(lua_State* L, Object* obj)
+    Unit* ToUnit(Object* obj)
     {
-        ALE::Push(L, obj->ToUnit());
-        return 1;
+        return obj->ToUnit();
     }
 
     /**
@@ -445,10 +380,9 @@ namespace LuaObject
      *
      * @return [Creature] creature : the [Object] as a [Creature], or `nil`
      */
-    int ToCreature(lua_State* L, Object* obj)
+    Creature* ToCreature(Object* obj)
     {
-        ALE::Push(L, obj->ToCreature());
-        return 1;
+        return obj->ToCreature();
     }
 
     /**
@@ -458,10 +392,44 @@ namespace LuaObject
      *
      * @return [Player] player : the [Object] as a [Player], or `nil`
      */
-    int ToPlayer(lua_State* L, Object* obj)
+    Player* ToPlayer(Object* obj)
     {
-        ALE::Push(L, obj->ToPlayer());
-        return 1;
+        return obj->ToPlayer();
     }
-};
-#endif
+}
+
+void RegisterObjectMethods(sol::state& lua)
+{
+    sol::usertype<ObjectRef> type = ALEBind::NewHandleType<ObjectRef>(lua, "Object");
+
+    type["HasFlag"]           = ALEBind::Method(&LuaObject::HasFlag);
+    type["IsInWorld"]         = ALEBind::Method(&LuaObject::IsInWorld);
+    type["IsPlayer"]          = ALEBind::Method(&LuaObject::IsPlayer);
+    type["GetInt32Value"]     = ALEBind::Method(&LuaObject::GetInt32Value);
+    type["GetUInt32Value"]    = ALEBind::Method(&LuaObject::GetUInt32Value);
+    type["GetFloatValue"]     = ALEBind::Method(&LuaObject::GetFloatValue);
+    type["GetByteValue"]      = ALEBind::Method(&LuaObject::GetByteValue);
+    type["GetUInt16Value"]    = ALEBind::Method(&LuaObject::GetUInt16Value);
+    type["GetScale"]          = ALEBind::Method(&LuaObject::GetScale);
+    type["GetEntry"]          = ALEBind::Method(&LuaObject::GetEntry);
+    type["GetGUID"]           = ALEBind::Method(&LuaObject::GetGUID);
+    type["GetGUIDLow"]        = ALEBind::Method(&LuaObject::GetGUIDLow);
+    type["GetTypeId"]         = ALEBind::Method(&LuaObject::GetTypeId);
+    type["GetUInt64Value"]    = ALEBind::Method(&LuaObject::GetUInt64Value);
+    type["SetFlag"]           = ALEBind::Method(&LuaObject::SetFlag);
+    type["SetInt32Value"]     = ALEBind::Method(&LuaObject::SetInt32Value);
+    type["SetUInt32Value"]    = ALEBind::Method(&LuaObject::SetUInt32Value);
+    type["UpdateUInt32Value"] = ALEBind::Method(&LuaObject::UpdateUInt32Value);
+    type["SetFloatValue"]     = ALEBind::Method(&LuaObject::SetFloatValue);
+    type["SetByteValue"]      = ALEBind::Method(&LuaObject::SetByteValue);
+    type["SetUInt16Value"]    = ALEBind::Method(&LuaObject::SetUInt16Value);
+    type["SetInt16Value"]     = ALEBind::Method(&LuaObject::SetInt16Value);
+    type["SetScale"]          = ALEBind::Method(&LuaObject::SetScale);
+    type["SetUInt64Value"]    = ALEBind::Method(&LuaObject::SetUInt64Value);
+    type["RemoveFlag"]        = ALEBind::Method(&LuaObject::RemoveFlag);
+    type["ToCorpse"]          = ALEBind::Method(&LuaObject::ToCorpse);
+    type["ToGameObject"]      = ALEBind::Method(&LuaObject::ToGameObject);
+    type["ToUnit"]            = ALEBind::Method(&LuaObject::ToUnit);
+    type["ToCreature"]        = ALEBind::Method(&LuaObject::ToCreature);
+    type["ToPlayer"]          = ALEBind::Method(&LuaObject::ToPlayer);
+}
diff --git a/src/LuaEngine/methods/PetMethods.h b/src/LuaEngine/methods/PetMethods.cpp
similarity index 61%
rename from src/LuaEngine/methods/PetMethods.h
rename to src/LuaEngine/methods/PetMethods.cpp
index 790da82379..5cbc809392 100644
--- a/src/LuaEngine/methods/PetMethods.h
+++ b/src/LuaEngine/methods/PetMethods.cpp
@@ -4,8 +4,11 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef PETMETHODS_H
-#define PETMETHODS_H
+#include "ALEBind.h"
+
+#include "Item.h"
+#include "Pet.h"
+#include "SpellMgr.h"
 
 /***
  * Non-[Player] controlled companions that fight alongside their owners.
@@ -31,10 +34,9 @@ namespace LuaPet
      *
      * @return [PetType] petType
      */
-    int GetPetType(lua_State* L, Pet* pet)
+    PetType GetPetType(Pet* pet)
     {
-        ALE::Push(L, pet->getPetType());
-        return 1;
+        return pet->getPetType();
     }
 
     /**
@@ -51,11 +53,9 @@ namespace LuaPet
      *
      * @param [PetType] petType : the pet type to set
      */
-    int SetPetType(lua_State* L, Pet* pet)
+    void SetPetType(Pet* pet, uint32 petType)
     {
-        uint32 petType = ALE::CHECKVAL<uint32>(L, 2);
         pet->setPetType(static_cast<PetType>(petType));
-        return 0;
     }
 
     /**
@@ -63,10 +63,9 @@ namespace LuaPet
      *
      * @return bool isControlled
      */
-    int IsControlled(lua_State* L, Pet* pet)
+    bool IsControlled(Pet* pet)
     {
-        ALE::Push(L, pet->isControlled());
-        return 1;
+        return pet->isControlled();
     }
 
     /**
@@ -74,10 +73,9 @@ namespace LuaPet
      *
      * @return bool isTemporary
      */
-    int IsTemporarySummoned(lua_State* L, Pet* pet)
+    bool IsTemporarySummoned(Pet* pet)
     {
-        ALE::Push(L, pet->isTemporarySummoned());
-        return 1;
+        return pet->isTemporarySummoned();
     }
 
     /**
@@ -86,11 +84,9 @@ namespace LuaPet
      * @param [Player] owner : the player to check ownership for
      * @return bool isPermanent
      */
-    int IsPermanentPetFor(lua_State* L, Pet* pet)
+    bool IsPermanentPetFor(Pet* pet, Player* owner)
     {
-        Player* owner = ALE::CHECKOBJ<Player>(L, 2);
-        ALE::Push(L, pet->IsPermanentPetFor(owner));
-        return 1;
+        return pet->IsPermanentPetFor(owner);
     }
 
     /**
@@ -99,11 +95,9 @@ namespace LuaPet
      * @param [Creature] creature : the creature to base the pet on
      * @return bool success : `true` if successful, `false` otherwise
      */
-    int CreateBaseAtCreature(lua_State* L, Pet* pet)
+    bool CreateBaseAtCreature(Pet* pet, Creature* creature)
     {
-        Creature* creature = ALE::CHECKOBJ<Creature>(L, 2);
-        ALE::Push(L, pet->CreateBaseAtCreature(creature));
-        return 1;
+        return pet->CreateBaseAtCreature(creature);
     }
 
     /**
@@ -111,10 +105,9 @@ namespace LuaPet
      *
      * @return uint32 duration : remaining time in milliseconds, 0 if permanent
      */
-    int GetDuration(lua_State* L, Pet* pet)
+    int64 GetDuration(Pet* pet)
     {
-        ALE::Push(L, pet->GetDuration().count());
-        return 1;
+        return pet->GetDuration().count();
     }
 
     /**
@@ -122,11 +115,9 @@ namespace LuaPet
      *
      * @param uint32 duration : duration in milliseconds, 0 for permanent
      */
-    int SetDuration(lua_State* L, Pet* pet)
+    void SetDuration(Pet* pet, uint32 duration)
     {
-        uint32 duration = ALE::CHECKVAL<uint32>(L, 2);
         pet->SetDuration(Milliseconds(duration));
-        return 0;
     }
 
     /**
@@ -143,10 +134,9 @@ namespace LuaPet
      *
      * @return [HappinessState] happinessState
      */
-    int GetHappinessState(lua_State* L, Pet* pet)
+    HappinessState GetHappinessState(Pet* pet)
     {
-        ALE::Push(L, pet->GetHappinessState());
-        return 1;
+        return pet->GetHappinessState();
     }
 
     /**
@@ -154,11 +144,9 @@ namespace LuaPet
      *
      * @param uint32 xp : amount of experience to give
      */
-    int GivePetXP(lua_State* L, Pet* pet)
+    void GivePetXP(Pet* pet, uint32 xp)
     {
-        uint32 xp = ALE::CHECKVAL<uint32>(L, 2);
         pet->GivePetXP(xp);
-        return 0;
     }
 
     /**
@@ -166,11 +154,9 @@ namespace LuaPet
      *
      * @param uint8 level : the level to set
      */
-    int GivePetLevel(lua_State* L, Pet* pet)
+    void GivePetLevel(Pet* pet, uint8 level)
     {
-        uint8 level = ALE::CHECKVAL<uint8>(L, 2);
         pet->GivePetLevel(level);
-        return 0;
     }
 
     /**
@@ -178,10 +164,9 @@ namespace LuaPet
      *
      * The pet's level will be adjusted based on the owner's level and pet scaling rules.
      */
-    int SynchronizeLevelWithOwner(lua_State* /*L*/, Pet* pet)
+    void SynchronizeLevelWithOwner(Pet* pet)
     {
         pet->SynchronizeLevelWithOwner();
-        return 0;
     }
 
     /**
@@ -190,11 +175,9 @@ namespace LuaPet
      * @param [Item] item : the item to check
      * @return bool canEat
      */
-    int HaveInDiet(lua_State* L, Pet* pet)
+    bool HaveInDiet(Pet* pet, Item* item)
     {
-        Item* item = ALE::CHECKOBJ<Item>(L, 2);
-        ALE::Push(L, pet->HaveInDiet(item->GetTemplate()));
-        return 1;
+        return pet->HaveInDiet(item->GetTemplate());
     }
 
     /**
@@ -203,11 +186,9 @@ namespace LuaPet
      * @param uint32 itemLevel : the level of the food item
      * @return uint32 benefitLevel
      */
-    int GetCurrentFoodBenefitLevel(lua_State* L, Pet* pet)
+    uint32 GetCurrentFoodBenefitLevel(Pet* pet, uint32 itemLevel)
     {
-        uint32 itemLevel = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, pet->GetCurrentFoodBenefitLevel(itemLevel));
-        return 1;
+        return pet->GetCurrentFoodBenefitLevel(itemLevel);
     }
 
     /**
@@ -216,16 +197,11 @@ namespace LuaPet
      * @param uint32 spellId : the spell ID to toggle autocast for
      * @param bool apply : `true` to enable autocast, `false` to disable
      */
-    int ToggleAutocast(lua_State* L, Pet* pet)
+    void ToggleAutocast(Pet* pet, uint32 spellId, bool apply)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        bool apply = ALE::CHECKVAL<bool>(L, 3);
-        
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
         if (spellInfo)
             pet->ToggleAutocast(spellInfo, apply);
-        
-        return 0;
     }
 
     /**
@@ -233,10 +209,9 @@ namespace LuaPet
      *
      * This includes racial passives and pet-specific passive abilities.
      */
-    int LearnPetPassives(lua_State* /*L*/, Pet* pet)
+    void LearnPetPassives(Pet* pet)
     {
         pet->LearnPetPassives();
-        return 0;
     }
 
     /**
@@ -246,24 +221,18 @@ namespace LuaPet
      * @param [Unit] target : the target for the spell
      * @param bool isPositive = false : whether the spell is beneficial
      */
-    int CastWhenWillAvailable(lua_State* L, Pet* pet)
+    void CastWhenWillAvailable(Pet* pet, uint32 spellId, Unit* target, sol::optional<bool> isPositive)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 3);
         ObjectGuid oldTarget = ObjectGuid::Empty;
-        bool isPositive = ALE::CHECKVAL<bool>(L, 4, false);
-        
-        pet->CastWhenWillAvailable(spellId, target, oldTarget, isPositive);
-        return 0;
+        pet->CastWhenWillAvailable(spellId, target, oldTarget, isPositive.value_or(false));
     }
 
     /**
      * Clears any queued spell that was set to cast when available.
      */
-    int ClearCastWhenWillAvailable(lua_State* /*L*/, Pet* pet)
+    void ClearCastWhenWillAvailable(Pet* pet)
     {
         pet->ClearCastWhenWillAvailable();
-        return 0;
     }
 
     /**
@@ -306,15 +275,13 @@ namespace LuaPet
      * @param [PetSpellType] type : the spell's type by default is PETSPELL_NORMAL
      * @return bool success : `true` if the spell was added successfully
      */
-    int AddSpell(lua_State* L, Pet* pet)
+    bool AddSpell(Pet* pet, uint32 spellId, sol::optional<uint32> active, sol::optional<uint32> state,
+        sol::optional<uint32> type)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 active = ALE::CHECKVAL<uint32>(L, 3, ACT_DECIDE);
-        uint32 state = ALE::CHECKVAL<uint32>(L, 4, PETSPELL_NEW);
-        uint32 type = ALE::CHECKVAL<uint32>(L, 5, PETSPELL_NORMAL);
-        
-        ALE::Push(L, pet->addSpell(spellId, static_cast<ActiveStates>(active), static_cast<PetSpellState>(state), static_cast<PetSpellType>(type)));
-        return 1;
+        return pet->addSpell(spellId,
+            static_cast<ActiveStates>(active.value_or(ACT_DECIDE)),
+            static_cast<PetSpellState>(state.value_or(PETSPELL_NEW)),
+            static_cast<PetSpellType>(type.value_or(PETSPELL_NORMAL)));
     }
 
     /**
@@ -323,11 +290,9 @@ namespace LuaPet
      * @param uint32 spellId : the spell ID to learn
      * @return bool success : `true` if the spell was learned successfully
      */
-    int LearnSpell(lua_State* L, Pet* pet)
+    bool LearnSpell(Pet* pet, uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, pet->learnSpell(spellId));
-        return 1;
+        return pet->learnSpell(spellId);
     }
 
     /**
@@ -335,11 +300,9 @@ namespace LuaPet
      *
      * @param uint32 spellId : the base spell ID
      */
-    int LearnSpellHighRank(lua_State* L, Pet* pet)
+    void LearnSpellHighRank(Pet* pet, uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
         pet->learnSpellHighRank(spellId);
-        return 0;
     }
 
     /**
@@ -347,10 +310,9 @@ namespace LuaPet
      *
      * This teaches the pet all spells it should know at its current level.
      */
-    int InitLevelupSpellsForLevel(lua_State* /*L*/, Pet* pet)
+    void InitLevelupSpellsForLevel(Pet* pet)
     {
         pet->InitLevelupSpellsForLevel();
-        return 0;
     }
 
     /**
@@ -361,14 +323,9 @@ namespace LuaPet
      * @param bool clearAb : if `true`, clears the spell from action bar by default is true
      * @return bool success : `true` if the spell was unlearned successfully
      */
-    int UnlearnSpell(lua_State* L, Pet* pet)
+    bool UnlearnSpell(Pet* pet, uint32 spellId, sol::optional<bool> learnPrev, sol::optional<bool> clearAb)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        bool learnPrev = ALE::CHECKVAL<bool>(L, 3, false);
-        bool clearAb = ALE::CHECKVAL<bool>(L, 4, true);
-        
-        ALE::Push(L, pet->unlearnSpell(spellId, learnPrev, clearAb));
-        return 1;
+        return pet->unlearnSpell(spellId, learnPrev.value_or(false), clearAb.value_or(true));
     }
 
     /**
@@ -379,23 +336,17 @@ namespace LuaPet
      * @param bool clearAb : if `true`, clears the spell from action bar by default is true
      * @return bool success : `true` if the spell was removed successfully
      */
-    int RemoveSpell(lua_State* L, Pet* pet)
+    bool RemoveSpell(Pet* pet, uint32 spellId, sol::optional<bool> learnPrev, sol::optional<bool> clearAb)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        bool learnPrev = ALE::CHECKVAL<bool>(L, 3, false);
-        bool clearAb = ALE::CHECKVAL<bool>(L, 4, true);
-        
-        ALE::Push(L, pet->removeSpell(spellId, learnPrev, clearAb));
-        return 1;
+        return pet->removeSpell(spellId, learnPrev.value_or(false), clearAb.value_or(true));
     }
 
     /**
      * Cleans up the [Pet]'s action bar, removing invalid spells.
      */
-    int CleanupActionBar(lua_State* /*L*/, Pet* pet)
+    void CleanupActionBar(Pet* pet)
     {
         pet->CleanupActionBar();
-        return 0;
     }
 
     /**
@@ -403,10 +354,9 @@ namespace LuaPet
      *
      * @return string actionBarData : the action bar data as a string
      */
-    int GenerateActionBarData(lua_State* L, Pet* pet)
+    std::string GenerateActionBarData(Pet* pet)
     {
-        ALE::Push(L, pet->GenerateActionBarData());
-        return 1;
+        return pet->GenerateActionBarData();
     }
 
     /**
@@ -414,10 +364,9 @@ namespace LuaPet
      *
      * This sets up the basic spells the pet should have when first created.
      */
-    int InitPetCreateSpells(lua_State* /*L*/, Pet* pet)
+    void InitPetCreateSpells(Pet* pet)
     {
         pet->InitPetCreateSpells();
-        return 0;
     }
 
     /**
@@ -425,10 +374,9 @@ namespace LuaPet
      *
      * @return bool success : `true` if talents were reset successfully
      */
-    int ResetTalents(lua_State* L, Pet* pet)
+    bool ResetTalents(Pet* pet)
     {
-        ALE::Push(L, pet->resetTalents());
-        return 1;
+        return pet->resetTalents();
     }
 
     /**
@@ -436,10 +384,9 @@ namespace LuaPet
      *
      * This assigns talent points based on the pet's level.
      */
-    int InitTalentForLevel(lua_State* /*L*/, Pet* pet)
+    void InitTalentForLevel(Pet* pet)
     {
         pet->InitTalentForLevel();
-        return 0;
     }
 
     /**
@@ -448,11 +395,9 @@ namespace LuaPet
      * @param uint8 level : the level to check
      * @return uint8 maxTalentPoints
      */
-    int GetMaxTalentPointsForLevel(lua_State* L, Pet* pet)
+    uint8 GetMaxTalentPointsForLevel(Pet* pet, uint8 level)
     {
-        uint8 level = ALE::CHECKVAL<uint8>(L, 2);
-        ALE::Push(L, pet->GetMaxTalentPointsForLevel(level));
-        return 1;
+        return pet->GetMaxTalentPointsForLevel(level);
     }
 
     /**
@@ -460,10 +405,9 @@ namespace LuaPet
      *
      * @return uint8 freeTalentPoints
      */
-    int GetFreeTalentPoints(lua_State* L, Pet* pet)
+    uint8 GetFreeTalentPoints(Pet* pet)
     {
-        ALE::Push(L, pet->GetFreeTalentPoints());
-        return 1;
+        return pet->GetFreeTalentPoints();
     }
 
     /**
@@ -471,11 +415,9 @@ namespace LuaPet
      *
      * @param uint8 points : the number of free talent points to set
      */
-    int SetFreeTalentPoints(lua_State* L, Pet* pet)
+    void SetFreeTalentPoints(Pet* pet, uint8 points)
     {
-        uint8 points = ALE::CHECKVAL<uint8>(L, 2);
         pet->SetFreeTalentPoints(points);
-        return 0;
     }
 
     /**
@@ -483,10 +425,9 @@ namespace LuaPet
      *
      * @return uint32 usedTalentCount
      */
-    int GetUsedTalentCount(lua_State* L, Pet* pet)
+    uint32 GetUsedTalentCount(Pet* pet)
     {
-        ALE::Push(L, pet->m_usedTalentCount);
-        return 1;
+        return pet->m_usedTalentCount;
     }
 
     /**
@@ -494,11 +435,9 @@ namespace LuaPet
      *
      * @param uint32 count : the number of used talents to set
      */
-    int SetUsedTalentCount(lua_State* L, Pet* pet)
+    void SetUsedTalentCount(Pet* pet, uint32 count)
     {
-        uint32 count = ALE::CHECKVAL<uint32>(L, 2);
         pet->m_usedTalentCount = count;
-        return 0;
     }
 
     /**
@@ -506,10 +445,9 @@ namespace LuaPet
      *
      * @return uint64 auraUpdateMask
      */
-    int GetAuraUpdateMaskForRaid(lua_State* L, Pet* pet)
+    uint64 GetAuraUpdateMaskForRaid(Pet* pet)
     {
-        ALE::Push(L, pet->GetAuraUpdateMaskForRaid());
-        return 1;
+        return pet->GetAuraUpdateMaskForRaid();
     }
 
     /**
@@ -517,20 +455,17 @@ namespace LuaPet
      *
      * @param uint8 slot : the aura slot to set
      */
-    int SetAuraUpdateMaskForRaid(lua_State* L, Pet* pet)
+    void SetAuraUpdateMaskForRaid(Pet* pet, uint8 slot)
     {
-        uint8 slot = ALE::CHECKVAL<uint8>(L, 2);
         pet->SetAuraUpdateMaskForRaid(slot);
-        return 0;
     }
 
     /**
      * Resets the aura update mask for raid members.
      */
-    int ResetAuraUpdateMaskForRaid(lua_State* /*L*/, Pet* pet)
+    void ResetAuraUpdateMaskForRaid(Pet* pet)
     {
         pet->ResetAuraUpdateMaskForRaid();
-        return 0;
     }
 
     /**
@@ -538,10 +473,9 @@ namespace LuaPet
      *
      * @return [Player] owner : the pet's owner
      */
-    int GetOwner(lua_State* L, Pet* pet)
+    Player* GetOwner(Pet* pet)
     {
-        ALE::Push(L, pet->GetOwner());
-        return 1;
+        return pet->GetOwner();
     }
 
     /**
@@ -549,10 +483,9 @@ namespace LuaPet
      *
      * @return bool hasTempSpell
      */
-    int HasTempSpell(lua_State* L, Pet* pet)
+    bool HasTempSpell(Pet* pet)
     {
-        ALE::Push(L, pet->HasTempSpell());
-        return 1;
+        return pet->HasTempSpell();
     }
 
     /**
@@ -560,10 +493,9 @@ namespace LuaPet
      *
      * @return bool isRemoved
      */
-    int IsRemoved(lua_State* L, Pet* pet)
+    bool IsRemoved(Pet* pet)
     {
-        ALE::Push(L, pet->m_removed);
-        return 1;
+        return pet->m_removed;
     }
 
     /**
@@ -571,11 +503,9 @@ namespace LuaPet
      *
      * @param bool removed : `true` to mark as removed, `false` otherwise
      */
-    int SetRemoved(lua_State* L, Pet* pet)
+    void SetRemoved(Pet* pet, bool removed)
     {
-        bool removed = ALE::CHECKVAL<bool>(L, 2);
         pet->m_removed = removed;
-        return 0;
     }
 
     /**
@@ -583,10 +513,9 @@ namespace LuaPet
      *
      * @return uint8 autoSpellCount
      */
-    int GetPetAutoSpellSize(lua_State* L, Pet* pet)
+    uint8 GetPetAutoSpellSize(Pet* pet)
     {
-        ALE::Push(L, pet->GetPetAutoSpellSize());
-        return 1;
+        return pet->GetPetAutoSpellSize();
     }
 
     /**
@@ -595,11 +524,9 @@ namespace LuaPet
      * @param uint8 pos : the position in the auto-spell list
      * @return uint32 spellId : the spell ID, or 0 if invalid position
      */
-    int GetPetAutoSpellOnPos(lua_State* L, Pet* pet)
+    uint32 GetPetAutoSpellOnPos(Pet* pet, uint8 pos)
     {
-        uint8 pos = ALE::CHECKVAL<uint8>(L, 2);
-        ALE::Push(L, pet->GetPetAutoSpellOnPos(pos));
-        return 1;
+        return pet->GetPetAutoSpellOnPos(pos);
     }
 
     /**
@@ -618,11 +545,9 @@ namespace LuaPet
      *
      * @param [PetSaveMode] mode : the save mode to use
      */
-    int SavePetToDB(lua_State* L, Pet* pet)
+    void SavePetToDB(Pet* pet, uint32 mode)
     {
-        uint32 mode = ALE::CHECKVAL<uint32>(L, 2);
         pet->SavePetToDB(static_cast<PetSaveMode>(mode));
-        return 0;
     }
 
     /**
@@ -642,12 +567,9 @@ namespace LuaPet
      * @param [PetSaveMode] mode : how to handle the removal
      * @param bool returnReagent = false : if `true`, returns reagents used to summon
      */
-    int Remove(lua_State* L, Pet* pet)
+    void Remove(Pet* pet, uint32 mode, sol::optional<bool> returnReagent)
     {
-        uint32 mode = ALE::CHECKVAL<uint32>(L, 2);
-        bool returnReagent = ALE::CHECKVAL<bool>(L, 3, false);
-        pet->Remove(static_cast<PetSaveMode>(mode), returnReagent);
-        return 0;
+        pet->Remove(static_cast<PetSaveMode>(mode), returnReagent.value_or(false));
     }
 
     /**
@@ -655,11 +577,60 @@ namespace LuaPet
      *
      * @return bool isBeingLoaded
      */
-    int IsBeingLoaded(lua_State* L, Pet* pet)
+    bool IsBeingLoaded(Pet* pet)
     {
-        ALE::Push(L, pet->isBeingLoaded());
-        return 1;
+        return pet->isBeingLoaded();
     }
-};
-#endif // PETMETHODS_H
+}
 
+void RegisterPetMethods(sol::state& lua)
+{
+    sol::usertype<PetRef> type = ALEBind::NewHandleType<PetRef, CreatureRef, UnitRef, WorldObjectRef, ObjectRef>(lua, "Pet");
+
+    type["GetPetType"]                 = ALEBind::Method(&LuaPet::GetPetType);
+    type["SetPetType"]                 = ALEBind::Method(&LuaPet::SetPetType);
+    type["IsControlled"]               = ALEBind::Method(&LuaPet::IsControlled);
+    type["IsTemporarySummoned"]        = ALEBind::Method(&LuaPet::IsTemporarySummoned);
+    type["IsPermanentPetFor"]          = ALEBind::Method(&LuaPet::IsPermanentPetFor);
+    type["CreateBaseAtCreature"]       = ALEBind::Method(&LuaPet::CreateBaseAtCreature);
+    type["GetDuration"]                = ALEBind::Method(&LuaPet::GetDuration);
+    type["SetDuration"]                = ALEBind::Method(&LuaPet::SetDuration);
+    type["GetHappinessState"]          = ALEBind::Method(&LuaPet::GetHappinessState);
+    type["GivePetXP"]                  = ALEBind::Method(&LuaPet::GivePetXP);
+    type["GivePetLevel"]               = ALEBind::Method(&LuaPet::GivePetLevel);
+    type["SynchronizeLevelWithOwner"]  = ALEBind::Method(&LuaPet::SynchronizeLevelWithOwner);
+    type["HaveInDiet"]                 = ALEBind::Method(&LuaPet::HaveInDiet);
+    type["GetCurrentFoodBenefitLevel"] = ALEBind::Method(&LuaPet::GetCurrentFoodBenefitLevel);
+    type["ToggleAutocast"]             = ALEBind::Method(&LuaPet::ToggleAutocast);
+    type["LearnPetPassives"]           = ALEBind::Method(&LuaPet::LearnPetPassives);
+    type["CastWhenWillAvailable"]      = ALEBind::Method(&LuaPet::CastWhenWillAvailable);
+    type["ClearCastWhenWillAvailable"] = ALEBind::Method(&LuaPet::ClearCastWhenWillAvailable);
+    type["AddSpell"]                   = ALEBind::Method(&LuaPet::AddSpell);
+    type["LearnSpell"]                 = ALEBind::Method(&LuaPet::LearnSpell);
+    type["LearnSpellHighRank"]         = ALEBind::Method(&LuaPet::LearnSpellHighRank);
+    type["InitLevelupSpellsForLevel"]  = ALEBind::Method(&LuaPet::InitLevelupSpellsForLevel);
+    type["UnlearnSpell"]               = ALEBind::Method(&LuaPet::UnlearnSpell);
+    type["RemoveSpell"]                = ALEBind::Method(&LuaPet::RemoveSpell);
+    type["CleanupActionBar"]           = ALEBind::Method(&LuaPet::CleanupActionBar);
+    type["GenerateActionBarData"]      = ALEBind::Method(&LuaPet::GenerateActionBarData);
+    type["InitPetCreateSpells"]        = ALEBind::Method(&LuaPet::InitPetCreateSpells);
+    type["ResetTalents"]               = ALEBind::Method(&LuaPet::ResetTalents);
+    type["InitTalentForLevel"]         = ALEBind::Method(&LuaPet::InitTalentForLevel);
+    type["GetMaxTalentPointsForLevel"] = ALEBind::Method(&LuaPet::GetMaxTalentPointsForLevel);
+    type["GetFreeTalentPoints"]        = ALEBind::Method(&LuaPet::GetFreeTalentPoints);
+    type["SetFreeTalentPoints"]        = ALEBind::Method(&LuaPet::SetFreeTalentPoints);
+    type["GetUsedTalentCount"]         = ALEBind::Method(&LuaPet::GetUsedTalentCount);
+    type["SetUsedTalentCount"]         = ALEBind::Method(&LuaPet::SetUsedTalentCount);
+    type["GetAuraUpdateMaskForRaid"]   = ALEBind::Method(&LuaPet::GetAuraUpdateMaskForRaid);
+    type["SetAuraUpdateMaskForRaid"]   = ALEBind::Method(&LuaPet::SetAuraUpdateMaskForRaid);
+    type["ResetAuraUpdateMaskForRaid"] = ALEBind::Method(&LuaPet::ResetAuraUpdateMaskForRaid);
+    type["GetOwner"]                   = ALEBind::Method(&LuaPet::GetOwner);
+    type["HasTempSpell"]               = ALEBind::Method(&LuaPet::HasTempSpell);
+    type["IsRemoved"]                  = ALEBind::Method(&LuaPet::IsRemoved);
+    type["SetRemoved"]                 = ALEBind::Method(&LuaPet::SetRemoved);
+    type["GetPetAutoSpellSize"]        = ALEBind::Method(&LuaPet::GetPetAutoSpellSize);
+    type["GetPetAutoSpellOnPos"]       = ALEBind::Method(&LuaPet::GetPetAutoSpellOnPos);
+    type["SavePetToDB"]                = ALEBind::Method(&LuaPet::SavePetToDB);
+    type["Remove"]                     = ALEBind::Method(&LuaPet::Remove);
+    type["IsBeingLoaded"]              = ALEBind::Method(&LuaPet::IsBeingLoaded);
+}
diff --git a/src/LuaEngine/methods/PlayerMethods.h b/src/LuaEngine/methods/PlayerMethods.cpp
similarity index 56%
rename from src/LuaEngine/methods/PlayerMethods.h
rename to src/LuaEngine/methods/PlayerMethods.cpp
index c39801fc98..cef549382d 100644
--- a/src/LuaEngine/methods/PlayerMethods.h
+++ b/src/LuaEngine/methods/PlayerMethods.cpp
@@ -4,12 +4,34 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef PLAYERMETHODS_H
-#define PLAYERMETHODS_H
+#include "ALEBind.h"
 
+#include "AccountMgr.h"
+#include "AchievementMgr.h"
+#include "AuctionHouseMgr.h"
+#include "Bag.h"
+#include "CharacterCache.h"
 #include "Chat.h"
+#include "DBCStores.h"
+#include "DatabaseEnv.h"
 #include "GameTime.h"
 #include "GossipDef.h"
+#include "Group.h"
+#include "GroupMgr.h"
+#include "Guild.h"
+#include "GuildMgr.h"
+#include "InstanceSaveMgr.h"
+#include "Item.h"
+#include "ObjectMgr.h"
+#include "Opcodes.h"
+#include "Pet.h"
+#include "Player.h"
+#include "QuestDef.h"
+#include "ReputationMgr.h"
+#include "SpellInfo.h"
+#include "SpellMgr.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
 
 /***
  * Inherits all methods from: [Object], [WorldObject], [Unit]
@@ -21,10 +43,9 @@ namespace LuaPlayer
      *
      * @return bool canTitanGrip
      */
-    int CanTitanGrip(lua_State* L, Player* player)
+    bool CanTitanGrip(Player* player)
     {
-        ALE::Push(L, player->CanTitanGrip());
-        return 1;
+        return player->CanTitanGrip();
     }
 
     /**
@@ -34,15 +55,13 @@ namespace LuaPlayer
      * @param uint8 spec : specified spec. 0 for primary, 1 for secondary.
      * @return bool hasTalent
      */
-    int HasTalent(lua_State* L, Player* player)
+    sol::optional<bool> HasTalent(Player* player, uint32 spellId, uint8 spec)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
         uint8 maxSpecs = MAX_TALENT_SPECS;
-        uint8 spec = ALE::CHECKVAL<uint8>(L, 3);
         if (spec >= maxSpecs)
-            return 1;
-        ALE::Push(L, player->HasTalent(spellId, spec));
-        return 1;
+            return sol::nullopt;
+
+        return player->HasTalent(spellId, spec);
     }
 
     /**
@@ -51,11 +70,9 @@ namespace LuaPlayer
      * @param uint32 achievementId
      * @return bool hasAchieved
      */
-    int HasAchieved(lua_State* L, Player* player)
+    bool HasAchieved(Player* player, uint32 achievementId)
     {
-        uint32 achievementId = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, player->HasAchieved(achievementId));
-        return 1;
+        return player->HasAchieved(achievementId);
     }
 
     /**
@@ -64,20 +81,14 @@ namespace LuaPlayer
      * @param uint32 criteriaId
      * @return uint32 progress : progress value or nil
      */
-    int GetAchievementCriteriaProgress(lua_State* L, Player* player)
+    sol::optional<uint32> GetAchievementCriteriaProgress(Player* player, uint32 criteriaId)
     {
-        uint32 criteriaId = ALE::CHECKVAL<uint32>(L, 2);
-        const AchievementCriteriaEntry* criteria = sAchievementCriteriaStore.LookupEntry(criteriaId);
+        AchievementCriteriaEntry const* criteria = sAchievementCriteriaStore.LookupEntry(criteriaId);
         CriteriaProgress* progress = player->GetAchievementMgr()->GetCriteriaProgress(criteria);
         if (progress)
-        {
-            ALE::Push(L, progress->counter);
-        }
-        else
-        {
-            ALE::Push(L, (void*)nullptr);
-        }
-        return 1;
+            return progress->counter;
+
+        return sol::nullopt;
     }
 
     /**
@@ -86,12 +97,9 @@ namespace LuaPlayer
      * @param uint32 questId
      * @return bool hasQuest
      */
-    int HasQuest(lua_State* L, Player* player)
+    bool HasQuest(Player* player, uint32 quest)
     {
-        uint32 quest = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->IsActiveQuest(quest));
-        return 1;
+        return player->IsActiveQuest(quest);
     }
 
     /**
@@ -100,12 +108,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @return bool hasSkill
      */
-    int HasSkill(lua_State* L, Player* player)
+    bool HasSkill(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->HasSkill(skill));
-        return 1;
+        return player->HasSkill(skill);
     }
 
     /**
@@ -114,12 +119,9 @@ namespace LuaPlayer
      * @param uint32 spellId
      * @return bool hasSpell
      */
-    int HasSpell(lua_State* L, Player* player)
+    bool HasSpell(Player* player, uint32 id)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->HasSpell(id));
-        return 1;
+        return player->HasSpell(id);
     }
 
     /**
@@ -128,12 +130,9 @@ namespace LuaPlayer
      * @param uint32 flag
      * @return bool hasLoginFlag
      */
-    int HasAtLoginFlag(lua_State* L, Player* player)
+    bool HasAtLoginFlag(Player* player, uint32 flag)
     {
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->HasAtLoginFlag((AtLoginFlags)flag));
-        return 1;
+        return player->HasAtLoginFlag((AtLoginFlags)flag);
     }
 
     /**
@@ -142,12 +141,9 @@ namespace LuaPlayer
      * @param int32 entry : entry of a [GameObject]
      * @return bool hasQuest
      */
-    int HasQuestForGO(lua_State* L, Player* player)
+    bool HasQuestForGO(Player* player, int32 entry)
     {
-        int32 entry = ALE::CHECKVAL<int32>(L, 2);
-
-        ALE::Push(L, player->HasQuestForGO(entry));
-        return 1;
+        return player->HasQuestForGO(entry);
     }
 
     /**
@@ -156,15 +152,15 @@ namespace LuaPlayer
      * @param uint32 titleId
      * @return bool hasTitle
      */
-    int HasTitle(lua_State* L, Player* player)
+    sol::optional<bool> HasTitle(Player* player, uint32 id)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
         CharTitlesEntry const* titleInfo = sCharTitlesStore.LookupEntry(id);
         if (titleInfo)
-            ALE::Push(L, player->HasTitle(titleInfo));
-        return 1;
+            return player->HasTitle(titleInfo);
+
+        return sol::nullopt;
     }
-    
+
     /**
      * Returns `true` if the [Player] has the given amount of item entry specified, `false` otherwise.
      *
@@ -173,29 +169,24 @@ namespace LuaPlayer
      * @param bool check_bank = false : determines if the item can be in player bank
      * @return bool hasItem
      */
-    int HasItem(lua_State* L, Player* player)
+    bool HasItem(Player* player, uint32 itemId, sol::optional<uint32> countArg, sol::optional<bool> checkBankArg)
     {
-        uint32 itemId = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 count = ALE::CHECKVAL<uint32>(L, 3, 1);
-        bool check_bank = ALE::CHECKVAL<bool>(L, 4, false);
-        ALE::Push(L, player->HasItemCount(itemId, count, check_bank));
-        return 1;
+        uint32 count = countArg.value_or(1);
+        bool check_bank = checkBankArg.value_or(false);
+        return player->HasItemCount(itemId, count, check_bank);
     }
-    
+
     /**
      * Returns `true` if the [Player] has a quest for the item entry specified, `false` otherwise.
      *
      * @param uint32 entry : entry of the item
      * @return bool hasQuest
      */
-    int HasQuestForItem(lua_State* L, Player* player)
+    bool HasQuestForItem(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->HasQuestForItem(entry));
-        return 1;
+        return player->HasQuestForItem(entry);
     }
-    
+
     /**
      * Returns `true` if the [Player] can use the item or item entry specified, `false` otherwise.
      *
@@ -205,21 +196,20 @@ namespace LuaPlayer
      * @param uint32 entry : entry of the item
      * @return bool canUse
      */
-    int CanUseItem(lua_State* L, Player* player)
+    bool CanUseItem(Player* player, sol::object itemOrEntry)
     {
-        Item* item = ALE::CHECKOBJ<Item>(L, 2, false);
-        if (item)
-            ALE::Push(L, player->CanUseItem(item) == EQUIP_ERR_OK);
-        else
+        if (itemOrEntry.is<ItemRef>())
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-            const ItemTemplate* temp = eObjectMgr->GetItemTemplate(entry);
-            if (temp)
-                ALE::Push(L, player->CanUseItem(temp) == EQUIP_ERR_OK);
-            else
-                ALE::Push(L, false);
+            Item* item = itemOrEntry.as<ItemRef>().Require();
+            return player->CanUseItem(item) == EQUIP_ERR_OK;
         }
-        return 1;
+
+        uint32 entry = itemOrEntry.as<uint32>();
+        ItemTemplate const* temp = sObjectMgr->GetItemTemplate(entry);
+        if (temp)
+            return player->CanUseItem(temp) == EQUIP_ERR_OK;
+
+        return false;
     }
 
     /**
@@ -228,12 +218,9 @@ namespace LuaPlayer
      * @param uint32 spellId
      * @return bool hasSpellCooldown
      */
-    int HasSpellCooldown(lua_State* L, Player* player)
+    bool HasSpellCooldown(Player* player, uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->HasSpellCooldown(spellId));
-        return 1;
+        return player->HasSpellCooldown(spellId);
     }
 
     /**
@@ -242,12 +229,9 @@ namespace LuaPlayer
      * @param uint32 entryId
      * @return bool hasSpellCooldown
      */
-    int CanShareQuest(lua_State* L, Player* player)
+    bool CanShareQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->CanShareQuest(entry));
-        return 1;
+        return player->CanShareQuest(entry);
     }
 
     /**
@@ -255,10 +239,9 @@ namespace LuaPlayer
      *
      * @return bool canSpeak
      */
-    int CanSpeak(lua_State* L, Player* player)
+    bool CanSpeak(Player* player)
     {
-        ALE::Push(L, player->CanSpeak());
-        return 1;
+        return player->CanSpeak();
     }
 
     /**
@@ -266,10 +249,9 @@ namespace LuaPlayer
      *
      * @return bool canUninviteFromGroup
      */
-    int CanUninviteFromGroup(lua_State* L, Player* player)
+    bool CanUninviteFromGroup(Player* player)
     {
-        ALE::Push(L, player->CanUninviteFromGroup() == ERR_PARTY_RESULT_OK);
-        return 1;
+        return player->CanUninviteFromGroup() == ERR_PARTY_RESULT_OK;
     }
 
     /**
@@ -277,10 +259,9 @@ namespace LuaPlayer
      *
      * @return bool canFly
      */
-    int CanFly(lua_State* L, Player* player)
+    bool CanFly(Player* player)
     {
-        ALE::Push(L, player->CanFly());
-        return 1;
+        return player->CanFly();
     }
 
     /**
@@ -288,10 +269,9 @@ namespace LuaPlayer
      *
      * @return bool isInWater
      */
-    int IsInWater(lua_State* L, Player* player)
+    bool IsInWater(Player* player)
     {
-        ALE::Push(L, player->IsInWater());
-        return 1;
+        return player->IsInWater();
     }
 
     /**
@@ -299,10 +279,9 @@ namespace LuaPlayer
      *
      * @return bool isMoving
      */
-    int IsMoving(lua_State* L, Player* player) // enable for unit when mangos support it
+    bool IsMoving(Player* player) // enable for unit when mangos support it
     {
-        ALE::Push(L, player->isMoving());
-        return 1;
+        return player->isMoving();
     }
 
     /**
@@ -310,10 +289,9 @@ namespace LuaPlayer
      *
      * @return bool isFlying
      */
-    int IsFlying(lua_State* L, Player* player) // enable for unit when mangos support it
+    bool IsFlying(Player* player) // enable for unit when mangos support it
     {
-        ALE::Push(L, player->IsFlying());
-        return 1;
+        return player->IsFlying();
     }
 
     /**
@@ -321,7 +299,7 @@ namespace LuaPlayer
      *
      * @return uint32 freeSlots
      */
-    int GetInventoryFreeSlots(lua_State* L, Player* player)
+    uint32 GetInventoryFreeSlots(Player* player)
     {
         uint32 freeSlots = 0;
 
@@ -345,8 +323,7 @@ namespace LuaPlayer
             }
         }
 
-        ALE::Push(L, freeSlots);
-        return 1;
+        return freeSlots;
     }
 
     /**
@@ -354,7 +331,7 @@ namespace LuaPlayer
      *
      * @return uint32 freeSlots
      */
-    int GetBankFreeSlots(lua_State* L, Player* player)
+    uint32 GetBankFreeSlots(Player* player)
     {
         uint32 freeSlots = 0;
 
@@ -378,53 +355,47 @@ namespace LuaPlayer
             }
         }
 
-        ALE::Push(L, freeSlots);
-        return 1;
+        return freeSlots;
     }
 
-
     /**
      * Returns `true` if the [Player] has a Tank Specialization, `false` otherwise.
      *
      * @return bool HasTankSpec
      */
-    int HasTankSpec(lua_State* L, Player* player)
+    bool HasTankSpec(Player* player)
     {
-        ALE::Push(L, player->HasTankSpec());
-        return 1;
+        return player->HasTankSpec();
     }
-    
+
     /**
      * Returns `true` if the [Player] has a Melee Specialization, `false` otherwise.
      *
      * @return bool HasMeleeSpec
      */
-    int HasMeleeSpec(lua_State* L, Player* player)
+    bool HasMeleeSpec(Player* player)
     {
-        ALE::Push(L, player->HasMeleeSpec());
-        return 1;
+        return player->HasMeleeSpec();
     }
-    
+
     /**
      * Returns `true` if the [Player] has a Caster Specialization, `false` otherwise.
      *
      * @return bool HasCasterSpec
      */
-    int HasCasterSpec(lua_State* L, Player* player)
+    bool HasCasterSpec(Player* player)
     {
-        ALE::Push(L, player->HasCasterSpec());
-        return 1;
+        return player->HasCasterSpec();
     }
-    
+
     /**
      * Returns `true` if the [Player] has a Heal Specialization, `false` otherwise.
      *
      * @return bool HasHealSpec
      */
-    int HasHealSpec(lua_State* L, Player* player)
+    bool HasHealSpec(Player* player)
     {
-        ALE::Push(L, player->HasHealSpec());
-        return 1;
+        return player->HasHealSpec();
     }
 
     /**
@@ -432,10 +403,9 @@ namespace LuaPlayer
      *
      * @return bool isInGroup
      */
-    int IsInGroup(lua_State* L, Player* player)
+    bool IsInGroup(Player* player)
     {
-        ALE::Push(L, (player->GetGroup() != NULL));
-        return 1;
+        return player->GetGroup() != nullptr;
     }
 
     /**
@@ -443,10 +413,9 @@ namespace LuaPlayer
      *
      * @return bool isInGuild
      */
-    int IsInGuild(lua_State* L, Player* player)
+    bool IsInGuild(Player* player)
     {
-        ALE::Push(L, (player->GetGuildId() != 0));
-        return 1;
+        return player->GetGuildId() != 0;
     }
 
     /**
@@ -456,10 +425,9 @@ namespace LuaPlayer
      *
      * @return bool isGM
      */
-    int IsGM(lua_State* L, Player* player)
+    bool IsGM(Player* player)
     {
-        ALE::Push(L, player->IsGameMaster());
-        return 1;
+        return player->IsGameMaster();
     }
 
     /**
@@ -468,14 +436,12 @@ namespace LuaPlayer
      * @param uint32 type
      * @return bool isInArenaTeam
      */
-    int IsInArenaTeam(lua_State* L, Player* player)
+    bool IsInArenaTeam(Player* player, uint32 type)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
         if (type < MAX_ARENA_SLOT && player->GetArenaTeamId(type))
-            ALE::Push(L, true);
-        else
-            ALE::Push(L, false);
-        return 1;
+            return true;
+
+        return false;
     }
 
     /**
@@ -483,10 +449,9 @@ namespace LuaPlayer
      *
      * @return bool isImmune
      */
-    int IsImmuneToDamage(lua_State* L, Player* player)
+    bool IsImmuneToDamage(Player* player)
     {
-        ALE::Push(L, player->isTotalImmune());
-        return 1;
+        return player->isTotalImmune();
     }
 
     /**
@@ -495,18 +460,13 @@ namespace LuaPlayer
      * @param uint32 questId
      * @return bool canCompleteRepeatableQuest
      */
-    int CanCompleteRepeatableQuest(lua_State* L, Player* player)
+    bool CanCompleteRepeatableQuest(Player* player, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-        const Quest* quest = sObjectMgr->GetQuestTemplate(questId); // Retrieve the Quest object
+        Quest const* quest = sObjectMgr->GetQuestTemplate(questId); // Retrieve the Quest object
         if (!quest)
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
+            return false;
 
-        ALE::Push(L, player->CanCompleteRepeatableQuest(quest));
-        return 1;
+        return player->CanCompleteRepeatableQuest(quest);
     }
 
     /**
@@ -515,18 +475,13 @@ namespace LuaPlayer
      * @param uint32 questId
      * @return bool canRewardQuest
      */
-    int CanRewardQuest(lua_State* L, Player* player)
+    bool CanRewardQuest(Player* player, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-        const Quest* quest = sObjectMgr->GetQuestTemplate(questId); // Retrieve the Quest object
+        Quest const* quest = sObjectMgr->GetQuestTemplate(questId); // Retrieve the Quest object
         if (!quest)
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
+            return false;
 
-        ALE::Push(L, player->CanRewardQuest(quest, true)); // Modify the second argument as needed
-        return 1;
+        return player->CanRewardQuest(quest, true); // Modify the second argument as needed
     }
 
     /**
@@ -535,12 +490,9 @@ namespace LuaPlayer
      * @param uint32 entry
      * @return bool canComplete
      */
-    int CanCompleteQuest(lua_State* L, Player* player)
+    bool CanCompleteQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->CanCompleteQuest(entry));
-        return 1;
+        return player->CanCompleteQuest(entry);
     }
 
     /**
@@ -548,10 +500,9 @@ namespace LuaPlayer
      *
      * @return bool isHorde
      */
-    int IsHorde(lua_State* L, Player* player)
+    bool IsHorde(Player* player)
     {
-        ALE::Push(L, (player->GetTeamId() == TEAM_HORDE));
-        return 1;
+        return player->GetTeamId() == TEAM_HORDE;
     }
 
     /**
@@ -559,10 +510,9 @@ namespace LuaPlayer
      *
      * @return bool isAlliance
      */
-    int IsAlliance(lua_State* L, Player* player)
+    bool IsAlliance(Player* player)
     {
-        ALE::Push(L, (player->GetTeamId() == TEAM_ALLIANCE));
-        return 1;
+        return player->GetTeamId() == TEAM_ALLIANCE;
     }
 
     /**
@@ -570,10 +520,9 @@ namespace LuaPlayer
      *
      * @return bool isDND
      */
-    int IsDND(lua_State* L, Player* player)
+    bool IsDND(Player* player)
     {
-        ALE::Push(L, player->isDND());
-        return 1;
+        return player->isDND();
     }
 
     /**
@@ -581,10 +530,9 @@ namespace LuaPlayer
      *
      * @return bool isAFK
      */
-    int IsAFK(lua_State* L, Player* player)
+    bool IsAFK(Player* player)
     {
-        ALE::Push(L, player->isAFK());
-        return 1;
+        return player->isAFK();
     }
 
     /**
@@ -592,10 +540,9 @@ namespace LuaPlayer
      *
      * @return bool isFalling
      */
-    int IsFalling(lua_State* L, Player* player)
+    bool IsFalling(Player* player)
     {
-        ALE::Push(L, player->IsFalling());
-        return 1;
+        return player->IsFalling();
     }
 
     /**
@@ -605,11 +552,9 @@ namespace LuaPlayer
      * @param [Player] target : the player to check visibility from
      * @return bool isGroupVisible
      */
-    int IsGroupVisibleFor(lua_State* L, Player* player)
+    bool IsGroupVisibleFor(Player* player, Player* target)
     {
-        Player* target = ALE::CHECKOBJ<Player>(L, 2);
-        ALE::Push(L, player->IsGroupVisibleFor(target));
-        return 1;
+        return player->IsGroupVisibleFor(target);
     }
 
     /**
@@ -618,11 +563,9 @@ namespace LuaPlayer
      * @param [Player] player
      * @return bool isInSameRaidWith
      */
-    int IsInSameRaidWith(lua_State* L, Player* player)
+    bool IsInSameRaidWith(Player* player, Player* target)
     {
-        Player* target = ALE::CHECKOBJ<Player>(L, 2);
-        ALE::Push(L, player->IsInSameRaidWith(target));
-        return 1;
+        return player->IsInSameRaidWith(target);
     }
 
     /**
@@ -631,11 +574,9 @@ namespace LuaPlayer
      * @param [Player] player
      * @return bool isInSameGroupWith
      */
-    int IsInSameGroupWith(lua_State* L, Player* player)
+    bool IsInSameGroupWith(Player* player, Player* target)
     {
-        Player* target = ALE::CHECKOBJ<Player>(L, 2);
-        ALE::Push(L, player->IsInSameGroupWith(target));
-        return 1;
+        return player->IsInSameGroupWith(target);
     }
 
     /**
@@ -644,12 +585,9 @@ namespace LuaPlayer
      * @param [Unit] unit
      * @return bool isHonorOrXPTarget
      */
-    int IsHonorOrXPTarget(lua_State* L, Player* player)
+    bool IsHonorOrXPTarget(Player* player, Unit* victim)
     {
-        Unit* victim = ALE::CHECKOBJ<Unit>(L, 2);
-
-        ALE::Push(L, player->isHonorOrXPTarget(victim));
-        return 1;
+        return player->isHonorOrXPTarget(victim);
     }
 
     /**
@@ -658,12 +596,9 @@ namespace LuaPlayer
      * @param [Player] player
      * @return bool isVisibleForPlayer
      */
-    int IsVisibleForPlayer(lua_State* L, Player* player)
+    bool IsVisibleForPlayer(Player* player, Player* target)
     {
-        Player* target = ALE::CHECKOBJ<Player>(L, 2);
-
-        ALE::Push(L, player->IsVisibleGloballyFor(target));
-        return 1;
+        return player->IsVisibleGloballyFor(target);
     }
 
     /**
@@ -672,10 +607,9 @@ namespace LuaPlayer
      * @param [Player] player
      * @return bool isVisible
      */
-    int IsGMVisible(lua_State* L, Player* player)
+    bool IsGMVisible(Player* player)
     {
-        ALE::Push(L, player->isGMVisible());
-        return 1;
+        return player->isGMVisible();
     }
 
     /**
@@ -683,10 +617,9 @@ namespace LuaPlayer
      *
      * @return bool isTaxiCheater
      */
-    int IsTaxiCheater(lua_State* L, Player* player)
+    bool IsTaxiCheater(Player* player)
     {
-        ALE::Push(L, player->isTaxiCheater());
-        return 1;
+        return player->isTaxiCheater();
     }
 
     /**
@@ -695,10 +628,9 @@ namespace LuaPlayer
      * @param [Player] player
      * @return bool isGMChat
      */
-    int IsGMChat(lua_State* L, Player* player)
+    bool IsGMChat(Player* player)
     {
-        ALE::Push(L, player->isGMChat());
-        return 1;
+        return player->isGMChat();
     }
 
     /**
@@ -706,10 +638,9 @@ namespace LuaPlayer
      *
      * @return bool isAcceptingWhispers
      */
-    int IsAcceptingWhispers(lua_State* L, Player* player)
+    bool IsAcceptingWhispers(Player* player)
     {
-        ALE::Push(L, player->isAcceptWhispers());
-        return 1;
+        return player->isAcceptWhispers();
     }
 
     /**
@@ -717,10 +648,9 @@ namespace LuaPlayer
      *
      * @return bool isRested
      */
-    int IsRested(lua_State* L, Player* player)
+    bool IsRested(Player* player)
     {
-        ALE::Push(L, player->GetRestBonus() > 0.0f);
-        return 1;
+        return player->GetRestBonus() > 0.0f;
     }
 
     /**
@@ -728,10 +658,9 @@ namespace LuaPlayer
      *
      * @return bool inBattlegroundQueue
      */
-    int InBattlegroundQueue(lua_State* L, Player* player)
+    bool InBattlegroundQueue(Player* player)
     {
-        ALE::Push(L, player->InBattlegroundQueue());
-        return 1;
+        return player->InBattlegroundQueue();
     }
 
     /**
@@ -739,10 +668,9 @@ namespace LuaPlayer
      *
      * @return bool inArena
      */
-    int InArena(lua_State* L, Player* player)
+    bool InArena(Player* player)
     {
-        ALE::Push(L, player->InArena());
-        return 1;
+        return player->InArena();
     }
 
     /**
@@ -750,10 +678,9 @@ namespace LuaPlayer
      *
      * @return bool inBattleGround
      */
-    int InBattleground(lua_State* L, Player* player)
+    bool InBattleground(Player* player)
     {
-        ALE::Push(L, player->InBattleground());
-        return 1;
+        return player->InBattleground();
     }
 
     /**
@@ -761,10 +688,9 @@ namespace LuaPlayer
      *
      * @return bool canBlock
      */
-    int CanBlock(lua_State* L, Player* player)
+    bool CanBlock(Player* player)
     {
-        ALE::Push(L, player->CanBlock());
-        return 1;
+        return player->CanBlock();
     }
 
     /**
@@ -772,10 +698,9 @@ namespace LuaPlayer
      *
      * @return bool canParry
      */
-    int CanParry(lua_State* L, Player* player)
+    bool CanParry(Player* player)
     {
-        ALE::Push(L, player->CanParry());
-        return 1;
+        return player->CanParry();
     }
 
     /**
@@ -783,10 +708,9 @@ namespace LuaPlayer
      *
      * @return uint8 specCount
      */
-    int GetSpecsCount(lua_State* L, Player* player)
+    uint8 GetSpecsCount(Player* player)
     {
-        ALE::Push(L, player->GetSpecsCount());
-        return 1;
+        return player->GetSpecsCount();
     }
 
     /**
@@ -794,10 +718,9 @@ namespace LuaPlayer
      *
      * @return uint32 specId
      */
-    int GetActiveSpec(lua_State* L, Player* player)
+    uint8 GetActiveSpec(Player* player)
     {
-        ALE::Push(L, player->GetActiveSpec());
-        return 1;
+        return player->GetActiveSpec();
     }
 
     /**
@@ -805,10 +728,9 @@ namespace LuaPlayer
      *
      * @return uint32 phasemask
      */
-    int GetPhaseMaskForSpawn(lua_State* L, Player* player)
+    uint32 GetPhaseMaskForSpawn(Player* player)
     {
-        ALE::Push(L, player->GetPhaseMaskForSpawn());
-        return 1;
+        return player->GetPhaseMaskForSpawn();
     }
 
     /**
@@ -816,10 +738,10 @@ namespace LuaPlayer
      *
      * @return uint32 achievementPoints
      */
-    int GetAchievementPoints(lua_State* L, Player* player)
+    uint32 GetAchievementPoints(Player* player)
     {
         uint32 count = 0;
-        const CompletedAchievementMap& completedAchievements = player->GetAchievementMgr()->GetCompletedAchievements();
+        CompletedAchievementMap const& completedAchievements = player->GetAchievementMgr()->GetCompletedAchievements();
         for (auto& pair : completedAchievements)
         {
             AchievementEntry const* achievement = sAchievementStore.LookupEntry(pair.first);
@@ -829,8 +751,7 @@ namespace LuaPlayer
             }
         }
 
-        ALE::Push(L, count);
-        return 1;
+        return count;
     }
 
     /**
@@ -838,22 +759,21 @@ namespace LuaPlayer
      *
      * @return uint32 achievementsCount
      */
-    int GetCompletedAchievementsCount(lua_State* L, Player* player)
+    uint32 GetCompletedAchievementsCount(Player* player, sol::optional<bool> countFeatsOfStrengthArg)
     {
         uint32 count = 0;
-        bool countFeatsOfStrength = ALE::CHECKVAL<bool>(L, 2, false);
-        const CompletedAchievementMap& completedAchievements = player->GetAchievementMgr()->GetCompletedAchievements();
+        bool countFeatsOfStrength = countFeatsOfStrengthArg.value_or(false);
+        CompletedAchievementMap const& completedAchievements = player->GetAchievementMgr()->GetCompletedAchievements();
         for (auto& pair : completedAchievements)
         {
             AchievementEntry const* achievement = sAchievementStore.LookupEntry(pair.first);
             if (achievement && (achievement->categoryId != 81 || countFeatsOfStrength))
-            {               
-                    count++;             
+            {
+                count++;
             }
         }
 
-        ALE::Push(L, count);
-        return 1;
+        return count;
     }
 
     /**
@@ -861,10 +781,9 @@ namespace LuaPlayer
      *
      * @return uint32 arenaPoints
      */
-    int GetArenaPoints(lua_State* L, Player* player)
+    uint32 GetArenaPoints(Player* player)
     {
-        ALE::Push(L, player->GetArenaPoints());
-        return 1;
+        return player->GetArenaPoints();
     }
 
     /**
@@ -872,10 +791,9 @@ namespace LuaPlayer
      *
      * @return uint32 honorPoints
      */
-    int GetHonorPoints(lua_State* L, Player* player)
+    uint32 GetHonorPoints(Player* player)
     {
-        ALE::Push(L, player->GetHonorPoints());
-        return 1;
+        return player->GetHonorPoints();
     }
 
     /**
@@ -883,10 +801,9 @@ namespace LuaPlayer
      *
      * @return uint32 todayHonorPoints
      */
-    int GetTodayHonorPoints(lua_State* L, Player* player)
+    uint32 GetTodayHonorPoints(Player* player)
     {
-        ALE::Push(L, player->GetUInt32Value(PLAYER_FIELD_TODAY_CONTRIBUTION));
-        return 1;
+        return player->GetUInt32Value(PLAYER_FIELD_TODAY_CONTRIBUTION);
     }
 
     /**
@@ -894,10 +811,9 @@ namespace LuaPlayer
      *
      * @return uint32 yesterdayHonorPoints
      */
-    int GetYesterdayHonorPoints(lua_State* L, Player* player)
+    uint32 GetYesterdayHonorPoints(Player* player)
     {
-        ALE::Push(L, player->GetUInt32Value(PLAYER_FIELD_YESTERDAY_CONTRIBUTION));
-        return 1;
+        return player->GetUInt32Value(PLAYER_FIELD_YESTERDAY_CONTRIBUTION);
     }
 
     /**
@@ -905,10 +821,9 @@ namespace LuaPlayer
      *
      * @return uint32 blockValue
      */
-    int GetShieldBlockValue(lua_State* L, Player* player)
+    uint32 GetShieldBlockValue(Player* player)
     {
-        ALE::Push(L, player->GetShieldBlockValue());
-        return 1;
+        return player->GetShieldBlockValue();
     }
 
     /**
@@ -917,12 +832,9 @@ namespace LuaPlayer
      * @param uint32 spellId
      * @return uint32 spellCooldownDelay
      */
-    int GetSpellCooldownDelay(lua_State* L, Player* player)
+    uint32 GetSpellCooldownDelay(Player* player, uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, uint32(player->GetSpellCooldownDelay(spellId)));
-        return 1;
+        return uint32(player->GetSpellCooldownDelay(spellId));
     }
 
     /**
@@ -930,10 +842,9 @@ namespace LuaPlayer
      *
      * @return uint32 latency
      */
-    int GetLatency(lua_State* L, Player* player)
+    uint32 GetLatency(Player* player)
     {
-        ALE::Push(L, player->GetSession()->GetLatency());
-        return 1;
+        return player->GetSession()->GetLatency();
     }
 
     /**
@@ -941,10 +852,9 @@ namespace LuaPlayer
      *
      * @return uint32 championingFaction
      */
-    int GetChampioningFaction(lua_State* L, Player* player)
+    uint32 GetChampioningFaction(Player* player)
     {
-        ALE::Push(L, player->GetChampioningFaction());
-        return 1;
+        return player->GetChampioningFaction();
     }
 
     /**
@@ -952,10 +862,9 @@ namespace LuaPlayer
      *
      * @return uint8 subGroup
      */
-    int GetOriginalSubGroup(lua_State* L, Player* player)
+    uint8 GetOriginalSubGroup(Player* player)
     {
-        ALE::Push(L, player->GetOriginalSubGroup());
-        return 1;
+        return player->GetOriginalSubGroup();
     }
 
     /**
@@ -963,10 +872,9 @@ namespace LuaPlayer
      *
      * @return [Group] group
      */
-    int GetOriginalGroup(lua_State* L, Player* player)
+    Group* GetOriginalGroup(Player* player)
     {
-        ALE::Push(L, player->GetOriginalGroup());
-        return 1;
+        return player->GetOriginalGroup();
     }
 
     /**
@@ -975,12 +883,9 @@ namespace LuaPlayer
      * @param float radius
      * @return [Player] player
      */
-    int GetNextRandomRaidMember(lua_State* L, Player* player)
+    Player* GetNextRandomRaidMember(Player* player, float radius)
     {
-        float radius = ALE::CHECKVAL<float>(L, 2);
-
-        ALE::Push(L, player->GetNextRandomRaidMember(radius));
-        return 1;
+        return player->GetNextRandomRaidMember(radius);
     }
 
     /**
@@ -988,10 +893,9 @@ namespace LuaPlayer
      *
      * @return uint8 subGroup
      */
-    int GetSubGroup(lua_State* L, Player* player)
+    uint8 GetSubGroup(Player* player)
     {
-        ALE::Push(L, player->GetSubGroup());
-        return 1;
+        return player->GetSubGroup();
     }
 
     /**
@@ -999,10 +903,9 @@ namespace LuaPlayer
      *
      * @return [Group] group
      */
-    int GetGroupInvite(lua_State* L, Player* player)
+    Group* GetGroupInvite(Player* player)
     {
-        ALE::Push(L, player->GetGroupInvite());
-        return 1;
+        return player->GetGroupInvite();
     }
 
     /**
@@ -1010,10 +913,9 @@ namespace LuaPlayer
      *
      * @return uint32 xp
      */
-    int GetXP(lua_State* L, Player* player)
+    uint32 GetXP(Player* player)
     {
-        ALE::Push(L, player->GetUInt32Value(PLAYER_XP));
-        return 1;
+        return player->GetUInt32Value(PLAYER_XP);
     }
 
     /**
@@ -1022,12 +924,9 @@ namespace LuaPlayer
      * @param uint32 xp
      * @return uint32 xpBonus
      */
-    int GetXPRestBonus(lua_State* L, Player* player)
+    uint32 GetXPRestBonus(Player* player, uint32 xp)
     {
-        uint32 xp = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetXPRestBonus(xp));
-        return 1;
+        return player->GetXPRestBonus(xp);
     }
 
     /**
@@ -1035,10 +934,9 @@ namespace LuaPlayer
      *
      * @return [BattleGroundTypeId] typeId
      */
-    int GetBattlegroundTypeId(lua_State* L, Player* player)
+    BattlegroundTypeId GetBattlegroundTypeId(Player* player)
     {
-        ALE::Push(L, player->GetBattlegroundTypeId());
-        return 1;
+        return player->GetBattlegroundTypeId();
     }
 
     /**
@@ -1046,10 +944,9 @@ namespace LuaPlayer
      *
      * @return uint32 battleGroundId
      */
-    int GetBattlegroundId(lua_State* L, Player* player)
+    uint32 GetBattlegroundId(Player* player)
     {
-        ALE::Push(L, player->GetBattlegroundId());
-        return 1;
+        return player->GetBattlegroundId();
     }
 
     /**
@@ -1058,12 +955,9 @@ namespace LuaPlayer
      * @param uint32 faction
      * @return [ReputationRank] rank
      */
-    int GetReputationRank(lua_State* L, Player* player)
+    ReputationRank GetReputationRank(Player* player, uint32 faction)
     {
-        uint32 faction = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetReputationRank(faction));
-        return 1;
+        return player->GetReputationRank(faction);
     }
 
     /**
@@ -1071,10 +965,9 @@ namespace LuaPlayer
      *
      * @return uint16 drunkValue
      */
-    int GetDrunkValue(lua_State* L, Player* player)
+    uint16 GetDrunkValue(Player* player)
     {
-        ALE::Push(L, player->GetDrunkValue());
-        return 1;
+        return player->GetDrunkValue();
     }
 
     /**
@@ -1083,12 +976,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @param int16 bonusVal
      */
-    int GetSkillTempBonusValue(lua_State* L, Player* player)
+    int16 GetSkillTempBonusValue(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetSkillTempBonusValue(skill));
-        return 1;
+        return player->GetSkillTempBonusValue(skill);
     }
 
     /**
@@ -1097,12 +987,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @param int16 bonusVal
      */
-    int GetSkillPermBonusValue(lua_State* L, Player* player)
+    int16 GetSkillPermBonusValue(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetSkillPermBonusValue(skill));
-        return 1;
+        return player->GetSkillPermBonusValue(skill);
     }
 
     /**
@@ -1111,12 +998,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @return uint16 pureVal
      */
-    int GetPureSkillValue(lua_State* L, Player* player)
+    uint16 GetPureSkillValue(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetPureSkillValue(skill));
-        return 1;
+        return player->GetPureSkillValue(skill);
     }
 
     /**
@@ -1125,12 +1009,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @return uint16 baseVal
      */
-    int GetBaseSkillValue(lua_State* L, Player* player)
+    uint16 GetBaseSkillValue(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetBaseSkillValue(skill));
-        return 1;
+        return player->GetBaseSkillValue(skill);
     }
 
     /**
@@ -1139,12 +1020,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @return uint16 val
      */
-    int GetSkillValue(lua_State* L, Player* player)
+    uint16 GetSkillValue(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetSkillValue(skill));
-        return 1;
+        return player->GetSkillValue(skill);
     }
 
     /**
@@ -1153,12 +1031,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @return uint16 pureVal
      */
-    int GetPureMaxSkillValue(lua_State* L, Player* player)
+    uint16 GetPureMaxSkillValue(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetPureMaxSkillValue(skill));
-        return 1;
+        return player->GetPureMaxSkillValue(skill);
     }
 
     /**
@@ -1167,12 +1042,9 @@ namespace LuaPlayer
      * @param uint32 skill
      * @return uint16 val
      */
-    int GetMaxSkillValue(lua_State* L, Player* player)
+    uint16 GetMaxSkillValue(Player* player, uint32 skill)
     {
-        uint32 skill = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetMaxSkillValue(skill));
-        return 1;
+        return player->GetMaxSkillValue(skill);
     }
 
     /**
@@ -1180,10 +1052,9 @@ namespace LuaPlayer
      *
      * @return float bonus
      */
-    int GetManaBonusFromIntellect(lua_State* L, Player* player)
+    float GetManaBonusFromIntellect(Player* player)
     {
-        ALE::Push(L, player->GetManaBonusFromIntellect());
-        return 1;
+        return player->GetManaBonusFromIntellect();
     }
 
     /**
@@ -1191,10 +1062,9 @@ namespace LuaPlayer
      *
      * @return float bonus
      */
-    int GetHealthBonusFromStamina(lua_State* L, Player* player)
+    float GetHealthBonusFromStamina(Player* player)
     {
-        ALE::Push(L, player->GetHealthBonusFromStamina());
-        return 1;
+        return player->GetHealthBonusFromStamina();
     }
 
     /**
@@ -1203,11 +1073,10 @@ namespace LuaPlayer
      * @param bool isRaid = true : argument is TrinityCore only
      * @return int32 difficulty
      */
-    int GetDifficulty(lua_State* L, Player* player)
+    Difficulty GetDifficulty(Player* player, sol::optional<bool> isRaidArg)
     {
-        bool isRaid = ALE::CHECKVAL<bool>(L, 2, true);
-        ALE::Push(L, player->GetDifficulty(isRaid));
-        return 1;
+        bool isRaid = isRaidArg.value_or(true);
+        return player->GetDifficulty(isRaid);
     }
 
     /**
@@ -1215,10 +1084,9 @@ namespace LuaPlayer
      *
      * @return uint32 guildRank
      */
-    int GetGuildRank(lua_State* L, Player* player) // TODO: Move to Guild Methods
+    uint8 GetGuildRank(Player* player) // TODO: Move to Guild Methods
     {
-        ALE::Push(L, player->GetRank());
-        return 1;
+        return player->GetRank();
     }
 
     /**
@@ -1226,10 +1094,9 @@ namespace LuaPlayer
      *
      * @return uint32 freeTalentPointAmt
      */
-    int GetFreeTalentPoints(lua_State* L, Player* player)
+    uint32 GetFreeTalentPoints(Player* player)
     {
-        ALE::Push(L, player->GetFreeTalentPoints());
-        return 1;
+        return player->GetFreeTalentPoints();
     }
 
     /**
@@ -1237,12 +1104,12 @@ namespace LuaPlayer
      *
      * @return string guildName
      */
-    int GetGuildName(lua_State* L, Player* player)
+    sol::optional<std::string> GetGuildName(Player* player)
     {
         if (!player->GetGuildId())
-            return 1;
-        ALE::Push(L, eGuildMgr->GetGuildNameById(player->GetGuildId()));
-        return 1;
+            return sol::nullopt;
+
+        return sGuildMgr->GetGuildNameById(player->GetGuildId());
     }
 
     /**
@@ -1251,12 +1118,9 @@ namespace LuaPlayer
      * @param uint32 faction
      * @return int32 reputationAmt
      */
-    int GetReputation(lua_State* L, Player* player)
+    int32 GetReputation(Player* player, uint32 faction)
     {
-        uint32 faction = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetReputationMgr().GetReputation(faction));
-        return 1;
+        return player->GetReputationMgr().GetReputation(faction);
     }
 
     /**
@@ -1264,10 +1128,9 @@ namespace LuaPlayer
      *
      * @return [Unit] target
      */
-    int GetComboTarget(lua_State* L, Player* player)
+    Unit* GetComboTarget(Player* player)
     {
-        ALE::Push(L, player->GetComboTarget());
-        return 1;
+        return player->GetComboTarget();
     }
 
     /**
@@ -1275,10 +1138,9 @@ namespace LuaPlayer
      *
      * @return uint8 comboPoints
      */
-    int GetComboPoints(lua_State* L, Player* player)
+    uint8 GetComboPoints(Player* player)
     {
-        ALE::Push(L, player->GetComboPoints());
-        return 1;
+        return player->GetComboPoints();
     }
 
     /**
@@ -1286,10 +1148,9 @@ namespace LuaPlayer
      *
      * @return uint32 inGameTime
      */
-    int GetInGameTime(lua_State* L, Player* player)
+    uint32 GetInGameTime(Player* player)
     {
-        ALE::Push(L, player->GetInGameTime());
-        return 1;
+        return player->GetInGameTime();
     }
 
     /**
@@ -1298,12 +1159,9 @@ namespace LuaPlayer
      * @param uint32 questId
      * @return [QuestStatus] questStatus
      */
-    int GetQuestStatus(lua_State* L, Player* player)
+    QuestStatus GetQuestStatus(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetQuestStatus(entry));
-        return 1;
+        return player->GetQuestStatus(entry);
     }
 
     /**
@@ -1312,12 +1170,9 @@ namespace LuaPlayer
      * @param uint32 questId
      * @return bool questRewardStatus
      */
-    int GetQuestRewardStatus(lua_State* L, Player* player)
+    bool GetQuestRewardStatus(Player* player, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetQuestRewardStatus(questId));
-        return 1;
+        return player->GetQuestRewardStatus(questId);
     }
 
     /**
@@ -1327,13 +1182,9 @@ namespace LuaPlayer
      * @param int32 entry : entry of required [Creature]
      * @return uint16 count
      */
-    int GetReqKillOrCastCurrentCount(lua_State* L, Player* player)
+    uint16 GetReqKillOrCastCurrentCount(Player* player, uint32 questId, int32 entry)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-        int32 entry = ALE::CHECKVAL<int32>(L, 3);
-
-        ALE::Push(L, player->GetReqKillOrCastCurrentCount(questId, entry));
-        return 1;
+        return player->GetReqKillOrCastCurrentCount(questId, entry);
     }
 
     /**
@@ -1342,12 +1193,9 @@ namespace LuaPlayer
      * @param uint32 questId
      * @return [QuestStatus] questRewardStatus
      */
-    int GetQuestLevel(lua_State* L, Player* player)
+    int32 GetQuestLevel(Player* player, Quest* quest)
     {
-        Quest* quest = ALE::CHECKOBJ<Quest>(L, 2);
-
-        ALE::Push(L, player->GetQuestLevel(quest));
-        return 1;
+        return player->GetQuestLevel(quest);
     }
 
     /**
@@ -1356,15 +1204,13 @@ namespace LuaPlayer
      * @param uint8 slot
      * @return [Item] item
      */
-    int GetEquippedItemBySlot(lua_State* L, Player* player)
+    Item* GetEquippedItemBySlot(Player* player, uint8 slot)
     {
-        uint8 slot = ALE::CHECKVAL<uint8>(L, 2);
         if (slot >= EQUIPMENT_SLOT_END)
-            return 1;
+            return nullptr;
 
         Item* item = player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot);
-        ALE::Push(L, item);
-        return 1;
+        return item;
     }
 
     /**
@@ -1372,10 +1218,9 @@ namespace LuaPlayer
      *
      * @return float restBonus
      */
-    int GetRestBonus(lua_State* L, Player* player)
+    float GetRestBonus(Player* player)
     {
-        ALE::Push(L, player->GetRestBonus());
-        return 1;
+        return player->GetRestBonus();
     }
 
     /**
@@ -1383,10 +1228,9 @@ namespace LuaPlayer
      *
      * @return uint8 tag
      */
-    int GetChatTag(lua_State* L, Player* player)
+    uint8 GetChatTag(Player* player)
     {
-        ALE::Push(L, player->GetChatTag());
-        return 1;
+        return player->GetChatTag();
     }
 
     /**
@@ -1414,13 +1258,9 @@ namespace LuaPlayer
      * @param uint8 slot : the slot the [Item] is in within the bag, you can get this with [Item:GetSlot]
      * @return [Item] item : [Item] or nil
      */
-    int GetItemByPos(lua_State* L, Player* player)
+    Item* GetItemByPos(Player* player, uint8 bag, uint8 slot)
     {
-        uint8 bag = ALE::CHECKVAL<uint8>(L, 2);
-        uint8 slot = ALE::CHECKVAL<uint8>(L, 3);
-
-        ALE::Push(L, player->GetItemByPos(bag, slot));
-        return 1;
+        return player->GetItemByPos(bag, slot);
     }
 
     /**
@@ -1431,12 +1271,9 @@ namespace LuaPlayer
      * @param ObjectGuid guid : an item guid
      * @return [Item] item
      */
-    int GetItemByGUID(lua_State* L, Player* player)
+    Item* GetItemByGUID(Player* player, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-
-        ALE::Push(L, player->GetItemByGuid(guid));
-        return 1;
+        return player->GetItemByGuid(guid);
     }
 
     /**
@@ -1444,19 +1281,13 @@ namespace LuaPlayer
      *
      * @return uint32 mailCount
      */
-    int GetMailCount(lua_State* L, Player* player)
+    uint32 GetMailCount(Player* player)
     {
-        const CharacterCacheEntry* cache = sCharacterCache->GetCharacterCacheByGuid(player->GetGUID());
+        CharacterCacheEntry const* cache = sCharacterCache->GetCharacterCacheByGuid(player->GetGUID());
         if (cache)
-        {
-            ALE::Push(L, static_cast<uint32>(cache->MailCount));
-        }
-        else
-        {
-            ALE::Push(L, player->GetMailSize());
-        }
+            return static_cast<uint32>(cache->MailCount);
 
-        return 1;
+        return player->GetMailSize();
     }
 
     /**
@@ -1465,12 +1296,9 @@ namespace LuaPlayer
      * @param ObjectGuid guid : an item guid
      * @return [Item] item
      */
-    int GetMailItem(lua_State* L, Player* player)
+    Item* GetMailItem(Player* player, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-
-        ALE::Push(L, player->GetMItem(guid.GetCounter()));
-        return 1;
+        return player->GetMItem(guid.GetCounter());
     }
 
     /**
@@ -1481,25 +1309,20 @@ namespace LuaPlayer
      * @param uint32 entryId
      * @return [Item] item
      */
-    int GetItemByEntry(lua_State* L, Player* player)
+    Item* GetItemByEntry(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, player->GetItemByEntry(entry));
-        return 1;
+        return player->GetItemByEntry(entry);
     }
-    
+
     /**
      * Returns the database textID of the [WorldObject]'s gossip header text for the [Player]
      *
      * @param [WorldObject] object
      * @return uint32 textId : key to npc_text database table
      */
-    int GetGossipTextId(lua_State* L, Player* player)
+    uint32 GetGossipTextId(Player* player, WorldObject* obj)
     {
-        WorldObject* obj = ALE::CHECKOBJ<WorldObject>(L, 2);
-        ALE::Push(L, player->GetGossipTextId(obj));
-        return 1;
+        return player->GetGossipTextId(obj);
     }
 
     /**
@@ -1507,10 +1330,9 @@ namespace LuaPlayer
      *
      * @return [Unit] unit
      */
-    int GetSelection(lua_State* L, Player* player)
+    Unit* GetSelection(Player* player)
     {
-        ALE::Push(L, player->GetSelectedUnit());
-        return 1;
+        return player->GetSelectedUnit();
     }
 
     /**
@@ -1518,10 +1340,9 @@ namespace LuaPlayer
      *
      * @return [AccountTypes] gmRank
      */
-    int GetGMRank(lua_State* L, Player* player)
+    AccountTypes GetGMRank(Player* player)
     {
-        ALE::Push(L, player->GetSession()->GetSecurity());
-        return 1;
+        return player->GetSession()->GetSecurity();
     }
 
     /**
@@ -1529,10 +1350,9 @@ namespace LuaPlayer
      *
      * @return uint32 coinage
      */
-    int GetCoinage(lua_State* L, Player* player)
+    uint32 GetCoinage(Player* player)
     {
-        ALE::Push(L, player->GetMoney());
-        return 1;
+        return player->GetMoney();
     }
 
     /**
@@ -1540,10 +1360,9 @@ namespace LuaPlayer
      *
      * @return uint32 guildId
      */
-    int GetGuildId(lua_State* L, Player* player)
+    uint32 GetGuildId(Player* player)
     {
-        ALE::Push(L, player->GetGuildId());
-        return 1;
+        return player->GetGuildId();
     }
 
     /**
@@ -1551,12 +1370,11 @@ namespace LuaPlayer
      *
      * @return [TeamId] teamId
      */
-    int GetTeam(lua_State* L, Player* player)
+    TeamId GetTeam(Player* player)
     {
-        ALE::Push(L, player->GetTeamId());
-        return 1;
+        return player->GetTeamId();
     }
-    
+
     /**
      * Returns amount of the specified [Item] the [Player] has.
      *
@@ -1564,12 +1382,10 @@ namespace LuaPlayer
      * @param bool checkinBank = false : also counts the items in player's bank if true
      * @return uint32 itemamount
      */
-    int GetItemCount(lua_State* L, Player* player)
+    uint32 GetItemCount(Player* player, uint32 entry, sol::optional<bool> checkinBankArg)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        bool checkinBank = ALE::CHECKVAL<bool>(L, 3, false);
-        ALE::Push(L, player->GetItemCount(entry, checkinBank));
-        return 1;
+        bool checkinBank = checkinBankArg.value_or(false);
+        return player->GetItemCount(entry, checkinBank);
     }
 
     /**
@@ -1577,10 +1393,9 @@ namespace LuaPlayer
      *
      * @return uint32 lifeTimeKils
      */
-    int GetLifetimeKills(lua_State* L, Player* player)
+    uint32 GetLifetimeKills(Player* player)
     {
-        ALE::Push(L, player->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS));
-        return 1;
+        return player->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS);
     }
 
     /**
@@ -1588,10 +1403,9 @@ namespace LuaPlayer
      *
      * @return uint32 todayKills
      */
-    int GetTodayKills(lua_State* L, Player* player)
+    uint32 GetTodayKills(Player* player)
     {
-        ALE::Push(L, uint32(player->GetUInt16Value(PLAYER_FIELD_KILLS, 0)));
-        return 1;
+        return uint32(player->GetUInt16Value(PLAYER_FIELD_KILLS, 0));
     }
 
     /**
@@ -1599,10 +1413,9 @@ namespace LuaPlayer
      *
      * @return uint32 yesterdayKills
      */
-    int GetYesterdayKills(lua_State* L, Player* player)
+    uint32 GetYesterdayKills(Player* player)
     {
-        ALE::Push(L, uint32(player->GetUInt16Value(PLAYER_FIELD_KILLS, 1)));
-        return 1;
+        return uint32(player->GetUInt16Value(PLAYER_FIELD_KILLS, 1));
     }
 
     /**
@@ -1610,10 +1423,9 @@ namespace LuaPlayer
      *
      * @return string ip
      */
-    int GetPlayerIP(lua_State* L, Player* player)
+    std::string GetPlayerIP(Player* player)
     {
-        ALE::Push(L, player->GetSession()->GetRemoteAddress());
-        return 1;
+        return player->GetSession()->GetRemoteAddress();
     }
 
     /**
@@ -1621,10 +1433,9 @@ namespace LuaPlayer
      *
      * @return uint32 currLevelPlayTime
      */
-    int GetLevelPlayedTime(lua_State* L, Player* player)
+    uint32 GetLevelPlayedTime(Player* player)
     {
-        ALE::Push(L, player->GetLevelPlayedTime());
-        return 1;
+        return player->GetLevelPlayedTime();
     }
 
     /**
@@ -1632,10 +1443,9 @@ namespace LuaPlayer
      *
      * @return uint32 totalPlayTime
      */
-    int GetTotalPlayedTime(lua_State* L, Player* player)
+    uint32 GetTotalPlayedTime(Player* player)
     {
-        ALE::Push(L, player->GetTotalPlayedTime());
-        return 1;
+        return player->GetTotalPlayedTime();
     }
 
     /**
@@ -1643,10 +1453,9 @@ namespace LuaPlayer
      *
      * @return [Guild] guild
      */
-    int GetGuild(lua_State* L, Player* player)
+    Guild* GetGuild(Player* player)
     {
-        ALE::Push(L, eGuildMgr->GetGuildById(player->GetGuildId()));
-        return 1;
+        return sGuildMgr->GetGuildById(player->GetGuildId());
     }
 
     /**
@@ -1654,10 +1463,9 @@ namespace LuaPlayer
      *
      * @return [Group] group
      */
-    int GetGroup(lua_State* L, Player* player)
+    Group* GetGroup(Player* player)
     {
-        ALE::Push(L, player->GetGroup());
-        return 1;
+        return player->GetGroup();
     }
 
     /**
@@ -1665,10 +1473,9 @@ namespace LuaPlayer
      *
      * @return uint32 accountId
      */
-    int GetAccountId(lua_State* L, Player* player)
+    uint32 GetAccountId(Player* player)
     {
-        ALE::Push(L, player->GetSession()->GetAccountId());
-        return 1;
+        return player->GetSession()->GetAccountId();
     }
 
     /**
@@ -1676,12 +1483,13 @@ namespace LuaPlayer
      *
      * @return string accountName
      */
-    int GetAccountName(lua_State* L, Player* player)
+    sol::optional<std::string> GetAccountName(Player* player)
     {
         std::string accName;
         if (AccountMgr::GetName(player->GetSession()->GetAccountId(), accName))
-            ALE::Push(L, accName);
-        return 1;
+            return accName;
+
+        return sol::nullopt;
     }
 
     /**
@@ -1689,12 +1497,11 @@ namespace LuaPlayer
      *
      * @return int32 questcount
      */
-    int GetCompletedQuestsCount(lua_State* L, Player* player)
+    uint32 GetCompletedQuestsCount(Player* player)
     {
         uint32 count = player->GetRewardedQuestCount();
 
-        ALE::Push(L, count);
-        return 1;
+        return count;
     }
 
     /**
@@ -1702,10 +1509,9 @@ namespace LuaPlayer
      *
      * @return [Corpse] corpse
      */
-    int GetCorpse(lua_State* L, Player* player)
+    Corpse* GetCorpse(Player* player)
     {
-        ALE::Push(L, player->GetCorpse());
-        return 1;
+        return player->GetCorpse();
     }
 
     /**
@@ -1713,10 +1519,9 @@ namespace LuaPlayer
      *
      * @return int localeIndex
      */
-    int GetDbLocaleIndex(lua_State* L, Player* player)
+    LocaleConstant GetDbLocaleIndex(Player* player)
     {
-        ALE::Push(L, player->GetSession()->GetSessionDbLocaleIndex());
-        return 1;
+        return player->GetSession()->GetSessionDbLocaleIndex();
     }
 
     /**
@@ -1724,10 +1529,9 @@ namespace LuaPlayer
      *
      * @return [LocaleConstant] locale
      */
-    int GetDbcLocale(lua_State* L, Player* player)
+    LocaleConstant GetDbcLocale(Player* player)
     {
-        ALE::Push(L, player->GetSession()->GetSessionDbcLocale());
-        return 1;
+        return player->GetSession()->GetSessionDbcLocale();
     }
 
     /**
@@ -1735,12 +1539,9 @@ namespace LuaPlayer
      *
      * @return table nodes : A table containing the IDs of the known taxi nodes
      */
-    int GetKnownTaxiNodes(lua_State* L, Player* player)
+    sol::table GetKnownTaxiNodes(Player* player, sol::this_state s)
     {
-        if (!player)
-            return 0;
-
-        lua_newtable(L);
+        sol::table tbl = sol::state_view(s).create_table();
 
         ByteBuffer data;
         player->m_taxi.AppendTaximaskTo(data, false);
@@ -1757,47 +1558,22 @@ namespace LuaPlayer
                 if (mask & (1u << bit))
                 {
                     uint32 nodeId = (i * 32) + bit + 1;
-                    lua_pushinteger(L, nodeId);
-                    lua_rawseti(L, -2, idx++);
+                    tbl[idx++] = nodeId;
                 }
             }
         }
 
-        return 1;
+        return tbl;
     }
 
-    /*int GetRecruiterId(lua_State* L, Player* player)
-    {
-        ALE::Push(L, player->GetSession()->GetRecruiterId());
-        return 1;
-    }*/
-
-    /*int GetSelectedPlayer(lua_State* L, Player* player)
-    {
-        ALE::Push(L, player->GetSelectedPlayer());
-        return 1;
-    }*/
-
-    /*int GetSelectedUnit(lua_State* L, Player* player)
-    {
-        ALE::Push(L, player->GetSelectedUnit());
-        return 1;
-    }*/
-
-    /*int GetNearbyGameObject(lua_State* L, Player* player)
-    {
-        ALE::Push(L, ChatHandler(player->GetSession()).GetNearbyGameObject());
-        return 1;
-    }*/
-    
     /**
      * Locks the player controls and disallows all movement and casting.
      *
      * @param bool apply = true : lock if true and unlock if false
      */
-    int SetPlayerLock(lua_State* L, Player* player)
+    void SetPlayerLock(Player* player, sol::optional<bool> applyArg)
     {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
+        bool apply = applyArg.value_or(true);
 
         if (apply)
         {
@@ -1809,7 +1585,6 @@ namespace LuaPlayer
             player->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED | UNIT_FLAG_SILENCED);
             player->SetClientControl(player, 1);
         }
-        return 0;
     }
 
     /**
@@ -1817,12 +1592,9 @@ namespace LuaPlayer
      *
      * @param uint32 flag
      */
-    int SetAtLoginFlag(lua_State* L, Player* player)
+    void SetAtLoginFlag(Player* player, uint32 flag)
     {
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 2);
-
         player->SetAtLoginFlag((AtLoginFlags)flag);
-        return 0;
     }
 
     /**
@@ -1830,14 +1602,12 @@ namespace LuaPlayer
      *
      * @param uint32 sheatheState
      */
-    int SetSheath(lua_State* L, Player* player)
+    void SetSheath(Player* player, uint32 sheathed)
     {
-        uint32 sheathed = ALE::CHECKVAL<uint32>(L, 2);
         if (sheathed >= MAX_SHEATH_STATE)
-            return 0;
+            return;
 
         player->SetSheath((SheathState)sheathed);
-        return 0;
     }
 
     /**
@@ -1845,12 +1615,9 @@ namespace LuaPlayer
      *
      * @param uint8 drunkValue
      */
-    int SetDrunkValue(lua_State* L, Player* player)
+    void SetDrunkValue(Player* player, uint8 newDrunkValue)
     {
-        uint8 newDrunkValue = ALE::CHECKVAL<uint8>(L, 2);
-
         player->SetDrunkValue(newDrunkValue);
-        return 0;
     }
 
     /**
@@ -1858,12 +1625,9 @@ namespace LuaPlayer
      *
      * @param uint8 raceId
      */
-    int SetFactionForRace(lua_State* L, Player* player)
+    void SetFactionForRace(Player* player, uint8 race)
     {
-        uint8 race = ALE::CHECKVAL<uint8>(L, 2);
-
         player->SetFactionForRace(race);
-        return 0;
     }
 
     /**
@@ -1874,15 +1638,9 @@ namespace LuaPlayer
      * @param uint16 currVal
      * @param uint16 maxVal
      */
-    int SetSkill(lua_State* L, Player* player)
+    void SetSkill(Player* player, uint16 id, uint16 step, uint16 currVal, uint16 maxVal)
     {
-        uint16 id = ALE::CHECKVAL<uint16>(L, 2);
-        uint16 step = ALE::CHECKVAL<uint16>(L, 3);
-        uint16 currVal = ALE::CHECKVAL<uint16>(L, 4);
-        uint16 maxVal = ALE::CHECKVAL<uint16>(L, 5);
-
         player->SetSkill(id, currVal, maxVal, step);
-        return 0;
     }
 
     /**
@@ -1890,15 +1648,12 @@ namespace LuaPlayer
      *
      * @param uint8 rank
      */
-    int SetGuildRank(lua_State* L, Player* player) // TODO: Move to Guild Methods
+    void SetGuildRank(Player* player, uint8 rank) // TODO: Move to Guild Methods
     {
-        uint8 rank = ALE::CHECKVAL<uint8>(L, 2);
-
         if (!player->GetGuildId())
-            return 0;
+            return;
 
         player->SetRank(rank);
-        return 0;
     }
 
     /**
@@ -1906,13 +1661,10 @@ namespace LuaPlayer
      *
      * @param uint32 talentPointAmt
      */
-    int SetFreeTalentPoints(lua_State* L, Player* player)
+    void SetFreeTalentPoints(Player* player, uint32 points)
     {
-        uint32 points = ALE::CHECKVAL<uint32>(L, 2);
-
         player->SetFreeTalentPoints(points);
         player->SendTalentsInfoData(false);
-        return 0;
     }
 
     /**
@@ -1921,14 +1673,10 @@ namespace LuaPlayer
      * @param uint32 factionId
      * @param int32 reputationValue
      */
-    int SetReputation(lua_State* L, Player* player)
+    void SetReputation(Player* player, uint32 faction, int32 value)
     {
-        uint32 faction = ALE::CHECKVAL<uint32>(L, 2);
-        int32 value = ALE::CHECKVAL<int32>(L, 3);
-
         FactionEntry const* factionEntry = sFactionStore.LookupEntry(faction);
         player->GetReputationMgr().SetReputation(factionEntry, value);
-        return 0;
     }
 
     /**
@@ -1937,15 +1685,12 @@ namespace LuaPlayer
      * @param uint32 entry : entry of a quest
      * @param uint32 status
      */
-    int SetQuestStatus(lua_State* L, Player* player)
+    void SetQuestStatus(Player* player, uint32 entry, uint32 status)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 status = ALE::CHECKVAL<uint32>(L, 3);
         if (status >= MAX_QUEST_STATUS)
-            return 0;
+            return;
 
         player->SetQuestStatus(entry, (QuestStatus)status);
-        return 0;
     }
 
     /**
@@ -1953,12 +1698,9 @@ namespace LuaPlayer
      *
      * @param float restBonus
      */
-    int SetRestBonus(lua_State* L, Player* player)
+    void SetRestBonus(Player* player, float bonus)
     {
-        float bonus = ALE::CHECKVAL<float>(L, 2);
-
         player->SetRestBonus(bonus);
-        return 0;
     }
 
     /**
@@ -1966,12 +1708,11 @@ namespace LuaPlayer
      *
      * @param bool acceptWhispers = true
      */
-    int SetAcceptWhispers(lua_State* L, Player* player)
+    void SetAcceptWhispers(Player* player, sol::optional<bool> onArg)
     {
-        bool on = ALE::CHECKVAL<bool>(L, 2, true);
+        bool on = onArg.value_or(true);
 
         player->SetAcceptWhispers(on);
-        return 0;
     }
 
     /**
@@ -1979,12 +1720,11 @@ namespace LuaPlayer
      *
      * @param bool on = true
      */
-    int SetPvPDeath(lua_State* L, Player* player)
+    void SetPvPDeath(Player* player, sol::optional<bool> onArg)
     {
-        bool on = ALE::CHECKVAL<bool>(L, 2, true);
+        bool on = onArg.value_or(true);
 
         player->SetPvPDeath(on);
-        return 0;
     }
 
     /**
@@ -1992,12 +1732,11 @@ namespace LuaPlayer
      *
      * @param bool gmVisible = true
      */
-    int SetGMVisible(lua_State* L, Player* player)
+    void SetGMVisible(Player* player, sol::optional<bool> onArg)
     {
-        bool on = ALE::CHECKVAL<bool>(L, 2, true);
+        bool on = onArg.value_or(true);
 
         player->SetGMVisible(on);
-        return 0;
     }
 
     /**
@@ -2005,27 +1744,15 @@ namespace LuaPlayer
      *
      * @param table nodes : A table containing the taxi node IDs to set as known
      */
-    int SetKnownTaxiNodes(lua_State* L, Player* player)
-    {
-        if (!player)
-            return 0;
-    
-        if (!lua_istable(L, 2))
-            return 0;
-    
-        lua_pushnil(L);
-    
-        while (lua_next(L, 2) != 0)
+    void SetKnownTaxiNodes(Player* player, sol::table nodes)
+    {
+        for (auto const& kv : nodes)
         {
-            uint32 nodeId = luaL_checkinteger(L, -1);
-    
-            if (nodeId > 0) 
+            uint32 nodeId = kv.second.as<uint32>();
+
+            if (nodeId > 0)
                 player->m_taxi.SetTaximaskNode(nodeId);
-    
-            lua_pop(L, 1);
         }
-    
-        return 0;
     }
 
     /**
@@ -2033,12 +1760,11 @@ namespace LuaPlayer
      *
      * @param bool taxiCheat = true
      */
-    int SetTaxiCheat(lua_State* L, Player* player)
+    void SetTaxiCheat(Player* player, sol::optional<bool> onArg)
     {
-        bool on = ALE::CHECKVAL<bool>(L, 2, true);
+        bool on = onArg.value_or(true);
 
         player->SetTaxiCheater(on);
-        return 0;
     }
 
     /**
@@ -2046,12 +1772,11 @@ namespace LuaPlayer
      *
      * @param bool on = true
      */
-    int SetGMChat(lua_State* L, Player* player)
+    void SetGMChat(Player* player, sol::optional<bool> onArg)
     {
-        bool on = ALE::CHECKVAL<bool>(L, 2, true);
+        bool on = onArg.value_or(true);
 
         player->SetGMChat(on);
-        return 0;
     }
 
     /**
@@ -2059,12 +1784,11 @@ namespace LuaPlayer
      *
      * @param bool setGmMode = true
      */
-    int SetGameMaster(lua_State* L, Player* player)
+    void SetGameMaster(Player* player, sol::optional<bool> onArg)
     {
-        bool on = ALE::CHECKVAL<bool>(L, 2, true);
+        bool on = onArg.value_or(true);
 
         player->SetGameMaster(on);
-        return 0;
     }
 
     /**
@@ -2075,10 +1799,8 @@ namespace LuaPlayer
      *
      * @param [Gender] gender
      */
-    int SetGender(lua_State* L, Player* player)
+    void SetGender(Player* player, uint32 _gender)
     {
-        uint32 _gender = ALE::CHECKVAL<uint32>(L, 2);
-
         Gender gender;
         switch (_gender)
         {
@@ -2089,13 +1811,12 @@ namespace LuaPlayer
                 gender = GENDER_FEMALE;
                 break;
             default:
-                return luaL_argerror(L, 2, "valid Gender expected");
+                throw std::invalid_argument("valid Gender expected");
         }
 
         player->SetByteValue(UNIT_FIELD_BYTES_0, 2, gender);
         player->SetByteValue(PLAYER_BYTES_3, 0, gender);
         player->InitDisplayIds();
-        return 0;
     }
 
     /**
@@ -2103,11 +1824,9 @@ namespace LuaPlayer
      *
      * @param uint32 arenaPoints
      */
-    int SetArenaPoints(lua_State* L, Player* player)
+    void SetArenaPoints(Player* player, uint32 arenaP)
     {
-        uint32 arenaP = ALE::CHECKVAL<uint32>(L, 2);
         player->SetArenaPoints(arenaP);
-        return 0;
     }
 
     /**
@@ -2115,11 +1834,9 @@ namespace LuaPlayer
      *
      * @param uint32 honorPoints
      */
-    int SetHonorPoints(lua_State* L, Player* player)
+    void SetHonorPoints(Player* player, uint32 honorP)
     {
-        uint32 honorP = ALE::CHECKVAL<uint32>(L, 2);
         player->SetHonorPoints(honorP);
-        return 0;
     }
 
     /**
@@ -2127,11 +1844,9 @@ namespace LuaPlayer
      *
      * @param uint32 honorableKills
      */
-    int SetLifetimeKills(lua_State* L, Player* player)
+    void SetLifetimeKills(Player* player, uint32 val)
     {
-        uint32 val = ALE::CHECKVAL<uint32>(L, 2);
         player->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, val);
-        return 0;
     }
 
     /**
@@ -2139,11 +1854,9 @@ namespace LuaPlayer
      *
      * @param uint32 copperAmt
      */
-    int SetCoinage(lua_State* L, Player* player)
+    void SetCoinage(Player* player, uint32 amt)
     {
-        uint32 amt = ALE::CHECKVAL<uint32>(L, 2);
         player->SetMoney(amt);
-        return 0;
     }
 
     /**
@@ -2155,17 +1868,10 @@ namespace LuaPlayer
      * @param uint32 mapId : Map ID
      * @param uint32 areaId : Area ID
      */
-    int SetBindPoint(lua_State* L, Player* player)
+    void SetBindPoint(Player* player, float x, float y, float z, uint32 mapId, uint32 areaId)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float z = ALE::CHECKVAL<float>(L, 4);
-        uint32 mapId = ALE::CHECKVAL<uint32>(L, 5);
-        uint32 areaId = ALE::CHECKVAL<uint32>(L, 6);
-
         WorldLocation loc(mapId, x, y, z);
         player->SetHomebind(loc, areaId);
-        return 0;
     }
 
     /**
@@ -2173,13 +1879,11 @@ namespace LuaPlayer
      *
      * @param uint32 titleId
      */
-    int SetKnownTitle(lua_State* L, Player* player)
+    void SetKnownTitle(Player* player, uint32 id)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
         CharTitlesEntry const* t = sCharTitlesStore.LookupEntry(id);
         if (t)
             player->SetTitle(t, false);
-        return 0;
     }
 
     /**
@@ -2187,43 +1891,31 @@ namespace LuaPlayer
      *
      * @param uint32 achievementid
      */
-    int SetAchievement(lua_State* L, Player* player)
+    void SetAchievement(Player* player, uint32 id)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
         AchievementEntry const* t = sAchievementStore.LookupEntry(id);
         if (t)
             player->CompletedAchievement(t);
-        return 0;
     }
 
-    /*int SetMovement(lua_State* L, Player* player)
-    {
-        int32 pType = ALE::CHECKVAL<int32>(L, 2);
-
-        player->SetMovement((PlayerMovementType)pType);
-        return 0;
-    }*/
-
     /**
      * Reset the [Player]s completed achievements
      */
-    int ResetAchievements(lua_State* /*L*/, Player* player)
+    void ResetAchievements(Player* player)
     {
         player->ResetAchievements();
-        return 0;
     }
-    
+
     /**
      * Shows the mailbox window to the player from specified guid.
      *
      * @param ObjectGuid guid = playerguid : guid of the mailbox window sender
      */
-    int SendShowMailBox(lua_State* L, Player* player)
+    void SendShowMailBox(Player* player, sol::optional<ObjectGuid> guidArg)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2, player->GET_GUID());
+        ObjectGuid guid = guidArg.value_or(player->GetGUID());
 
         player->GetSession()->SendShowMailBox(guid);
-        return 0;
     }
 
     /**
@@ -2231,12 +1923,9 @@ namespace LuaPlayer
      *
      * @param int32 amount
      */
-    int ModifyArenaPoints(lua_State* L, Player* player)
+    void ModifyArenaPoints(Player* player, int32 amount)
     {
-        int32 amount = ALE::CHECKVAL<int32>(L, 2);
-
         player->ModifyArenaPoints(amount);
-        return 0;
     }
 
     /**
@@ -2244,21 +1933,17 @@ namespace LuaPlayer
      *
      * @param int32 amount
      */
-    int ModifyHonorPoints(lua_State* L, Player* player)
+    void ModifyHonorPoints(Player* player, int32 amount)
     {
-        int32 amount = ALE::CHECKVAL<int32>(L, 2);
-
         player->ModifyHonorPoints(amount);
-        return 0;
     }
 
     /**
      * Saves the [Player] to the database
      */
-    int SaveToDB(lua_State* /*L*/, Player* player)
+    void SaveToDB(Player* player)
     {
         player->SaveToDB(false, false);
-        return 0;
     }
 
     /**
@@ -2266,20 +1951,17 @@ namespace LuaPlayer
      *
      * @param [Unit] summoner
      */
-    int SummonPlayer(lua_State* L, Player* player)
+    void SummonPlayer(Player* player, Unit* summoner)
     {
-        Unit* summoner = ALE::CHECKOBJ<Unit>(L, 2);
-
         float x, y, z;
         summoner->GetPosition(x,y,z);
         player->SetSummonPoint(summoner->GetMapId(), x, y, z);
 
         WorldPacket data(SMSG_SUMMON_REQUEST, 8 + 4 + 4);
-        data << summoner->GET_GUID();
+        data << summoner->GetGUID();
         data << uint32(summoner->GetZoneId());
         data << uint32(MAX_PLAYER_SUMMON_DELAY * IN_MILLISECONDS);
         player->GetSession()->SendPacket(&data);
-        return 0;
     }
 
     /**
@@ -2287,15 +1969,13 @@ namespace LuaPlayer
      *
      * @param uint32 muteTime
      */
-    int Mute(lua_State* L, Player* player)
+    void Mute(Player* player, uint32 muteseconds)
     {
-        uint32 muteseconds = ALE::CHECKVAL<uint32>(L, 2);
         /*const char* reason = luaL_checkstring(E, 2);*/ // Mangos does not have a reason field in database.
 
         time_t muteTime = GameTime::GetGameTime().count() + muteseconds;
         player->GetSession()->m_muteTime = muteTime;
         LoginDatabase.Execute("UPDATE account SET mutetime = {} WHERE id = {}", muteTime, player->GetSession()->GetAccountId());
-        return 0;
     }
 
     /**
@@ -2303,18 +1983,15 @@ namespace LuaPlayer
      *
      * @param uint32 entry : quest entry
      */
-    int RewardQuest(lua_State* L, Player* player)
+    void RewardQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        Quest const* quest = eObjectMgr->GetQuestTemplate(entry);
+        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
 
         // If player doesn't have the quest
         if (!quest || player->GetQuestStatus(entry) != QUEST_STATUS_COMPLETE)
-            return 0;
+            return;
 
         player->RewardQuest(quest, 0, player);
-        return 0;
     }
 
     /**
@@ -2322,20 +1999,17 @@ namespace LuaPlayer
      *
      * @param [Unit] sender
      */
-    int SendAuctionMenu(lua_State* L, Player* player)
+    void SendAuctionMenu(Player* player, Unit* unit)
     {
-        Unit* unit = ALE::CHECKOBJ<Unit>(L, 2);
-
         AuctionHouseEntry const* ahEntry = AuctionHouseMgr::GetAuctionHouseEntryFromFactionTemplate(unit->GetFaction());
         if (!ahEntry)
-            return 0;
+            return;
 
         WorldPacket data(MSG_AUCTION_HELLO, 12);
-        data << unit->GET_GUID();
+        data << unit->GetGUID();
         data << uint32(ahEntry->houseId);
         data << uint8(1);
         player->GetSession()->SendPacket(&data);
-        return 0;
     }
 
     /**
@@ -2343,21 +2017,17 @@ namespace LuaPlayer
      *
      * @param [Creature] sender
      */
-    int SendTaxiMenu(lua_State* L, Player* player)
+    void SendTaxiMenu(Player* player, Creature* creature)
     {
-        Creature* creature = ALE::CHECKOBJ<Creature>(L, 2);
-
         player->GetSession()->SendTaxiMenu(creature);
-        return 0;
     }
 
     /**
      * Sends a spirit resurrection request to the [Player]
      */
-    int SendSpiritResurrect(lua_State* /*L*/, Player* player)
+    void SendSpiritResurrect(Player* player)
     {
         player->GetSession()->SendSpiritResurrect();
-        return 0;
     }
 
     /**
@@ -2365,12 +2035,9 @@ namespace LuaPlayer
      *
      * @param [WorldObject] sender
      */
-    int SendTabardVendorActivate(lua_State* L, Player* player)
+    void SendTabardVendorActivate(Player* player, WorldObject* obj)
     {
-        WorldObject* obj = ALE::CHECKOBJ<WorldObject>(L, 2);
-
-        player->GetSession()->SendTabardVendorActivate(obj->GET_GUID());
-        return 0;
+        player->GetSession()->SendTabardVendorActivate(obj->GetGUID());
     }
 
     /**
@@ -2378,24 +2045,20 @@ namespace LuaPlayer
      *
      * @param [WorldObject] sender
      */
-    int SendShowBank(lua_State* L, Player* player)
+    void SendShowBank(Player* player, WorldObject* obj)
     {
-        WorldObject* obj = ALE::CHECKOBJ<WorldObject>(L, 2);
-
-        player->GetSession()->SendShowBank(obj->GET_GUID());
-        return 0;
+        player->GetSession()->SendShowBank(obj->GetGUID());
     }
-    
+
     /**
      * Sends a vendor window to the [Player] from the [WorldObject] specified.
      *
      * @param [WorldObject] sender
      * @param uint32 vendorId = 0 : optional entry ID to use for the vendor item list, overriding the sender's default inventory
      */
-    int SendListInventory(lua_State* L, Player* player)
+    void SendListInventory(Player* player, WorldObject* obj, sol::optional<uint32> vendorIdArg)
     {
-        WorldObject* obj = ALE::CHECKOBJ<WorldObject>(L, 2);
-        uint32 vendorId = ALE::CHECKVAL<uint32>(L, 3, 0);
+        uint32 vendorId = vendorIdArg.value_or(0);
 
         Creature* creature = obj->ToCreature();
         bool addedVendorFlag = false;
@@ -2405,12 +2068,10 @@ namespace LuaPlayer
             addedVendorFlag = true;
         }
 
-        player->GetSession()->SendListInventory(obj->GET_GUID(), vendorId);
+        player->GetSession()->SendListInventory(obj->GetGUID(), vendorId);
 
         if (addedVendorFlag)
             creature->RemoveNpcFlag(UNIT_NPC_FLAG_VENDOR);
-
-        return 0;
     }
 
     /**
@@ -2418,12 +2079,9 @@ namespace LuaPlayer
      *
      * @param [Creature] sender
      */
-    int SendTrainerList(lua_State* L, Player* player)
+    void SendTrainerList(Player* player, Creature* obj)
     {
-        Creature* obj = ALE::CHECKOBJ<Creature>(L, 2);
-
         player->GetSession()->SendTrainerList(obj);
-        return 0;
     }
 
     /**
@@ -2431,13 +2089,10 @@ namespace LuaPlayer
      *
      * @param [Player] invitee
      */
-    int SendGuildInvite(lua_State* L, Player* player)
+    void SendGuildInvite(Player* player, Player* plr)
     {
-        Player* plr = ALE::CHECKOBJ<Player>(L, 2);
-
         if (Guild* guild = player->GetGuild())
             guild->HandleInviteMember(player->GetSession(), plr->GetName());
-        return 0;
     }
 
     /**
@@ -2446,13 +2101,9 @@ namespace LuaPlayer
      * @param uint32 field
      * @param uint32 value
      */
-    int SendUpdateWorldState(lua_State* L, Player* player)
+    void SendUpdateWorldState(Player* player, uint32 field, uint32 value)
     {
-        uint32 field = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 value = ALE::CHECKVAL<uint32>(L, 3);
-
         player->SendUpdateWorldState(field, value);
-        return 0;
     }
 
     /**
@@ -2460,21 +2111,19 @@ namespace LuaPlayer
      *
      * @param bool saveToDb = true
      */
-    int LogoutPlayer(lua_State* L, Player* player)
+    void LogoutPlayer(Player* player, sol::optional<bool> saveArg)
     {
-        bool save = ALE::CHECKVAL<bool>(L, 2, true);
+        bool save = saveArg.value_or(true);
 
         player->GetSession()->LogoutPlayer(save);
-        return 0;
     }
 
     /**
      * Forcefully removes the [Player] from a [BattleGround] raid group
      */
-    int RemoveFromBattlegroundRaid(lua_State* /*L*/, Player* player)
+    void RemoveFromBattlegroundRaid(Player* player)
     {
         player->RemoveFromBattlegroundOrBattlefieldRaid();
-        return 0;
     }
 
     /**
@@ -2485,24 +2134,22 @@ namespace LuaPlayer
      * @param uint32 map = true
      * @param uint32 difficulty = 0
      */
-    int UnbindInstance(lua_State* L, Player* player)
+    void UnbindInstance(Player* player, uint32 map, sol::optional<uint32> difficultyArg)
     {
-        uint32 map = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 difficulty = ALE::CHECKVAL<uint32>(L, 3, 0);
+        uint32 difficulty = difficultyArg.value_or(0);
 
         if (difficulty < MAX_DIFFICULTY)
             sInstanceSaveMgr->PlayerUnbindInstance(player->GetGUID(), map, Difficulty(difficulty), true, player);
-        return 0;
     }
 
     /**
      * Unbinds the [Player] from his instances except the one he currently is in.
      */
-    int UnbindAllInstances(lua_State* /*L*/, Player* player)
+    void UnbindAllInstances(Player* player)
     {
         for (uint8 i = 0; i < MAX_DIFFICULTY; ++i)
         {
-            const BoundInstancesMap& binds = sInstanceSaveMgr->PlayerGetBoundInstances(player->GetGUID(), Difficulty(i));
+            BoundInstancesMap const& binds = sInstanceSaveMgr->PlayerGetBoundInstances(player->GetGUID(), Difficulty(i));
             for (BoundInstancesMap::const_iterator itr = binds.begin(); itr != binds.end();)
             {
                 if (itr->first != player->GetMapId())
@@ -2516,8 +2163,6 @@ namespace LuaPlayer
                 }
             }
         }
-
-        return 0;
     }
 
     /**
@@ -2525,11 +2170,9 @@ namespace LuaPlayer
      *
      * @param bool teleToEntry = true
      */
-    int LeaveBattleground(lua_State* L, Player* player)
+    void LeaveBattleground(Player* player)
     {
-        (void)L; // ensure that the variable is referenced in order to pass compiler checks
         player->LeaveBattleground();
-        return 0;
     }
 
     /**
@@ -2539,14 +2182,12 @@ namespace LuaPlayer
      * @param bool cost = true
      * @param float discountMod = 1.0
      */
-    int DurabilityRepair(lua_State* L, Player* player)
+    void DurabilityRepair(Player* player, uint16 position, sol::optional<bool> takeCostArg, sol::optional<float> discountModArg)
     {
-        uint16 position = ALE::CHECKVAL<uint16>(L, 2);
-        bool takeCost = ALE::CHECKVAL<bool>(L, 3, true);
-        float discountMod = ALE::CHECKVAL<float>(L, 4, 1.0f);
+        bool takeCost = takeCostArg.value_or(true);
+        float discountMod = discountModArg.value_or(1.0f);
 
         player->DurabilityRepair(position, takeCost, discountMod, false);
-        return 0;
     }
 
     /**
@@ -2556,14 +2197,13 @@ namespace LuaPlayer
      * @param float discountMod = 1.0
      * @param bool guidBank = false
      */
-    int DurabilityRepairAll(lua_State* L, Player* player)
+    void DurabilityRepairAll(Player* player, sol::optional<bool> takeCostArg, sol::optional<float> discountModArg, sol::optional<bool> guildBankArg)
     {
-        bool takeCost = ALE::CHECKVAL<bool>(L, 2, true);
-        float discountMod = ALE::CHECKVAL<float>(L, 3, 1.0f);
-        bool guildBank = ALE::CHECKVAL<bool>(L, 4, false);
+        bool takeCost = takeCostArg.value_or(true);
+        float discountMod = discountModArg.value_or(1.0f);
+        bool guildBank = guildBankArg.value_or(false);
 
         player->DurabilityRepairAll(takeCost, discountMod, guildBank);
-        return 0;
     }
 
     /**
@@ -2571,13 +2211,10 @@ namespace LuaPlayer
      *
      * @param int32 slot
      */
-    int DurabilityPointLossForEquipSlot(lua_State* L, Player* player)
+    void DurabilityPointLossForEquipSlot(Player* player, int32 slot)
     {
-        int32 slot = ALE::CHECKVAL<int32>(L, 2);
-
         if (slot >= EQUIPMENT_SLOT_START && slot < EQUIPMENT_SLOT_END)
             player->DurabilityPointLossForEquipSlot((EquipmentSlots)slot);
-        return 0;
     }
 
     /**
@@ -2588,13 +2225,11 @@ namespace LuaPlayer
      * @param int32 points
      * @param bool inventory = true
      */
-    int DurabilityPointsLossAll(lua_State* L, Player* player)
+    void DurabilityPointsLossAll(Player* player, int32 points, sol::optional<bool> inventoryArg)
     {
-        int32 points = ALE::CHECKVAL<int32>(L, 2);
-        bool inventory = ALE::CHECKVAL<bool>(L, 3, true);
+        bool inventory = inventoryArg.value_or(true);
 
         player->DurabilityPointsLossAll(points, inventory);
-        return 0;
     }
 
     /**
@@ -2603,13 +2238,9 @@ namespace LuaPlayer
      * @param [Item] item
      * @param int32 points
      */
-    int DurabilityPointsLoss(lua_State* L, Player* player)
+    void DurabilityPointsLoss(Player* player, Item* item, int32 points)
     {
-        Item* item = ALE::CHECKOBJ<Item>(L, 2);
-        int32 points = ALE::CHECKVAL<int32>(L, 3);
-
         player->DurabilityPointsLoss(item, points);
-        return 0;
     }
 
     /**
@@ -2618,13 +2249,9 @@ namespace LuaPlayer
      * @param [Item] item
      * @param double percent
      */
-    int DurabilityLoss(lua_State* L, Player* player)
+    void DurabilityLoss(Player* player, Item* item, double percent)
     {
-        Item* item = ALE::CHECKOBJ<Item>(L, 2);
-        double percent = ALE::CHECKVAL<double>(L, 3);
-
         player->DurabilityLoss(item, percent);
-        return 0;
     }
 
     /**
@@ -2633,34 +2260,30 @@ namespace LuaPlayer
      * @param double percent
      * @param bool inventory = true
      */
-    int DurabilityLossAll(lua_State* L, Player* player)
+    void DurabilityLossAll(Player* player, double percent, sol::optional<bool> inventoryArg)
     {
-        double percent = ALE::CHECKVAL<double>(L, 2);
-        bool inventory = ALE::CHECKVAL<bool>(L, 3, true);
+        bool inventory = inventoryArg.value_or(true);
 
         player->DurabilityLossAll(percent, inventory);
-        return 0;
     }
 
     /**
      * Kills the [Player]
      */
-    int KillPlayer(lua_State* /*L*/, Player* player)
+    void KillPlayer(Player* player)
     {
         player->KillPlayer();
-        return 0;
     }
 
     /**
      * Forces the [Player] to leave a [Group]
      */
-    int RemoveFromGroup(lua_State* /*L*/, Player* player)
+    void RemoveFromGroup(Player* player)
     {
         if (!player->GetGroup())
-            return 0;
+            return;
 
         player->RemoveFromGroup();
-        return 0;
     }
 
     /**
@@ -2668,10 +2291,9 @@ namespace LuaPlayer
      *
      * @return uint32 resetCost
      */
-    int ResetTalentsCost(lua_State* L, Player* player)
+    uint32 ResetTalentsCost(Player* player)
     {
-        ALE::Push(L, player->resetTalentsCost());
-        return 1;
+        return player->resetTalentsCost();
     }
 
     /**
@@ -2679,13 +2301,12 @@ namespace LuaPlayer
      *
      * @param bool noCost = true
      */
-    int ResetTalents(lua_State* L, Player* player)
+    void ResetTalents(Player* player, sol::optional<bool> noCostArg)
     {
-        bool no_cost = ALE::CHECKVAL<bool>(L, 2, true);
+        bool no_cost = noCostArg.value_or(true);
 
         player->resetTalents(no_cost);
         player->SendTalentsInfoData(false);
-        return 0;
     }
 
     /**
@@ -2693,21 +2314,17 @@ namespace LuaPlayer
      *
      * @param uint32 entry : entry of a [Spell]
      */
-    int RemoveSpell(lua_State* L, Player* player)
+    void RemoveSpell(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
         player->removeSpell(entry, SPEC_MASK_ALL, false);
-        return 0;
     }
 
     /**
      * Clears the [Player]s combo points
      */
-    int ClearComboPoints(lua_State* /*L*/, Player* player)
+    void ClearComboPoints(Player* player)
     {
         player->ClearComboPoints();
-        return 0;
     }
 
     /**
@@ -2716,13 +2333,9 @@ namespace LuaPlayer
      * @param [Unit] target
      * @param int8 count
      */
-    int AddComboPoints(lua_State* L, Player* player)
+    void AddComboPoints(Player* player, Unit* target, int8 count)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-        int8 count = ALE::CHECKVAL<int8>(L, 3);
-
         player->AddComboPoints(target, count);
-        return 0;
     }
 
     /**
@@ -2731,13 +2344,9 @@ namespace LuaPlayer
      * @param uint32 entry : entry of a [Creature]
      * @param [Creature] creature
      */
-    int TalkedToCreature(lua_State* L, Player* player)
+    void TalkedToCreature(Player* player, uint32 entry, Creature* creature)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        Creature* creature = ALE::CHECKOBJ<Creature>(L, 3);
-
-        player->TalkedToCreature(entry, creature->GET_GUID());
-        return 0;
+        player->TalkedToCreature(entry, creature->GetGUID());
     }
 
     /**
@@ -2745,12 +2354,9 @@ namespace LuaPlayer
      *
      * @param uint32 entry : entry of a [Creature]
      */
-    int KilledMonsterCredit(lua_State* L, Player* player)
+    void KilledMonsterCredit(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        player->KilledMonsterCredit(entry, player->GET_GUID());
-        return 0;
+        player->KilledMonsterCredit(entry, player->GetGUID());
     }
 
     /**
@@ -2759,13 +2365,9 @@ namespace LuaPlayer
      * @param uint32 quest : entry of a quest
      * @param [WorldObject] obj
      */
-    int GroupEventHappens(lua_State* L, Player* player)
+    void GroupEventHappens(Player* player, uint32 questId, WorldObject* obj)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-        WorldObject* obj = ALE::CHECKOBJ<WorldObject>(L, 3);
-
         player->GroupEventHappens(questId, obj);
-        return 0;
     }
 
     /**
@@ -2773,12 +2375,9 @@ namespace LuaPlayer
      *
      * @param uint32 quest : entry of a [Quest]
      */
-    int AreaExploredOrEventHappens(lua_State* L, Player* player)
+    void AreaExploredOrEventHappens(Player* player, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-
         player->AreaExploredOrEventHappens(questId);
-        return 0;
     }
 
     /**
@@ -2786,12 +2385,9 @@ namespace LuaPlayer
      *
      * @param uint32 entry : entry of a [Quest]
      */
-    int FailQuest(lua_State* L, Player* player)
+    void FailQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
         player->FailQuest(entry);
-        return 0;
     }
 
     /**
@@ -2799,12 +2395,9 @@ namespace LuaPlayer
      *
      * @param uint32 entry : quest entry
      */
-    int IncompleteQuest(lua_State* L, Player* player)
+    void IncompleteQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
         player->IncompleteQuest(entry);
-        return 0;
     }
 
     /**
@@ -2814,15 +2407,13 @@ namespace LuaPlayer
      *
      * @param uint32 entry : quest entry
      */
-    int CompleteQuest(lua_State* L, Player* player)
+    void CompleteQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        Quest const* quest = eObjectMgr->GetQuestTemplate(entry);
+        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
 
         // If player doesn't have the quest
         if (!quest || player->GetQuestStatus(entry) == QUEST_STATUS_NONE)
-            return 0;
+            return;
 
         // Add quest items for quests that require items
         for (uint8 x = 0; x < QUEST_ITEM_OBJECTIVES_COUNT; ++x)
@@ -2888,7 +2479,6 @@ namespace LuaPlayer
             player->ModifyMoney(-ReqOrRewMoney);
 
         player->CompleteQuest(entry);
-        return 0;
     }
 
     /**
@@ -2896,26 +2486,23 @@ namespace LuaPlayer
      *
      * @param uint32 entry : quest entry
      */
-    int AddQuest(lua_State* L, Player* player)
+    void AddQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        Quest const* quest = eObjectMgr->GetQuestTemplate(entry);
+        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
         if (!quest)
-            return 0;
+            return;
 
         // check item starting quest (it can work incorrectly if added without item in inventory)
         ItemTemplateContainer const* itc = sObjectMgr->GetItemTemplateStore();
-        ItemTemplateContainer::const_iterator result = find_if(itc->begin(), itc->end(), Finder<uint32, ItemTemplate>(entry, &ItemTemplate::StartQuest));
-
-        if (result != itc->end())
-            return 0;
+        for (auto const& pair : *itc)
+        {
+            if (pair.second.StartQuest == entry)
+                return;
+        }
 
         // ok, normal (creature/GO starting) quest
         if (player->CanAddQuest(quest, true))
-            player->AddQuestAndCheckCompletion(quest, NULL);
-
-        return 0;
+            player->AddQuestAndCheckCompletion(quest, nullptr);
     }
 
     /**
@@ -2923,14 +2510,12 @@ namespace LuaPlayer
      *
      * @param uint32 entry : quest entry
      */
-    int RemoveQuest(lua_State* L, Player* player)
+    void RemoveQuest(Player* player, uint32 entry)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-        Quest const* quest = eObjectMgr->GetQuestTemplate(entry);
+        Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
 
         if (!quest)
-            return 0;
+            return;
 
         // remove all quest entries for 'entry' from quest log
         for (uint8 slot = 0; slot < MAX_QUEST_LOG_SIZE; ++slot)
@@ -2953,7 +2538,6 @@ namespace LuaPlayer
 
         player->RemoveActiveQuest(entry, false);
         player->RemoveRewardedQuest(entry);
-        return 0;
     }
 
     /**
@@ -2964,13 +2548,9 @@ namespace LuaPlayer
      * @param [Player] receiver : is the [Player] that will receive the whisper, if TrinityCore
      * @param ObjectGuid guid : is the GUID of a [Player] that will receive the whisper, not TrinityCore
      */
-    int Whisper(lua_State* L, Player* player)
+    void Whisper(Player* player, std::string const& text, uint32 lang, Player* receiver)
     {
-        std::string text = ALE::CHECKVAL<std::string>(L, 2);
-        uint32 lang = ALE::CHECKVAL<uint32>(L, 3);
-        Player* receiver = ALE::CHECKOBJ<Player>(L, 4);
         player->Whisper(text, (Language)lang, receiver);
-        return 0;
     }
 
     /**
@@ -2978,12 +2558,9 @@ namespace LuaPlayer
      *
      * @param string emoteText
      */
-    int TextEmote(lua_State* L, Player* player)
+    void TextEmote(Player* player, std::string const& text)
     {
-        std::string text = ALE::CHECKVAL<std::string>(L, 2);
-
         player->TextEmote(text);
-        return 0;
     }
 
     /**
@@ -2992,12 +2569,9 @@ namespace LuaPlayer
      * @param string text : text for the [Player] to yells
      * @param uint32 lang : language the [Player] will speak
      */
-    int Yell(lua_State* L, Player* player)
+    void Yell(Player* player, std::string const& text, uint32 lang)
     {
-        std::string text = ALE::CHECKVAL<std::string>(L, 2);
-        uint32 lang = ALE::CHECKVAL<uint32>(L, 3);
         player->Yell(text, (Language)lang);
-        return 0;
     }
 
     /**
@@ -3006,12 +2580,9 @@ namespace LuaPlayer
      * @param string text : text for the [Player] to say
      * @param uint32 lang : language the [Player] will speak
      */
-    int Say(lua_State* L, Player* player)
+    void Say(Player* player, std::string const& text, uint32 lang)
     {
-        std::string text = ALE::CHECKVAL<std::string>(L, 2);
-        uint32 lang = ALE::CHECKVAL<uint32>(L, 3);
         player->Say(text, (Language)lang);
-        return 0;
     }
 
     /**
@@ -3020,31 +2591,27 @@ namespace LuaPlayer
      * @param uint32 xp : experience to give
      * @param [Unit] victim = nil
      */
-    int GiveXP(lua_State* L, Player* player)
+    void GiveXP(Player* player, uint32 xp, sol::optional<UnitRef> victimArg)
     {
-        uint32 xp = ALE::CHECKVAL<uint32>(L, 2);
-        Unit* victim = ALE::CHECKOBJ<Unit>(L, 3, false);
+        Unit* victim = victimArg ? victimArg->Resolve() : nullptr;
 
         player->GiveXP(xp, victim);
-        return 0;
     }
 
     /**
      * Toggle the [Player]s 'Do Not Disturb' flag
      */
-    int ToggleDND(lua_State* /*L*/, Player* player)
+    void ToggleDND(Player* player)
     {
         player->ToggleDND();
-        return 0;
     }
 
     /**
      * Toggle the [Player]s 'Away From Keyboard' flag
      */
-    int ToggleAFK(lua_State* /*L*/, Player* player)
+    void ToggleAFK(Player* player)
     {
         player->ToggleAFK();
-        return 0;
     }
 
     /**
@@ -3088,27 +2655,26 @@ namespace LuaPlayer
      * @param uint32 slot : equipment slot to equip the item to The slot can be [EquipmentSlots] or [InventorySlots]
      * @return [Item] equippedItem : item or nil if equipping failed
      */
-    int EquipItem(lua_State* L, Player* player)
+    Item* EquipItem(Player* player, sol::object itemOrEntry, uint32 slot)
     {
         uint16 dest = 0;
-        Item* item = ALE::CHECKOBJ<Item>(L, 2, false);
-        uint32 slot = ALE::CHECKVAL<uint32>(L, 3);
+        Item* item = itemOrEntry.is<ItemRef>() ? itemOrEntry.as<ItemRef>().Require() : nullptr;
 
         if (slot >= INVENTORY_SLOT_BAG_END)
-            return 1;
+            return nullptr;
 
         if (!item)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
+            uint32 entry = itemOrEntry.as<uint32>();
             item = Item::CreateItem(entry, 1, player);
             if (!item)
-                return 1;
+                return nullptr;
 
             InventoryResult result = player->CanEquipItem(slot, dest, item, false);
             if (result != EQUIP_ERR_OK)
             {
                 delete item;
-                return 1;
+                return nullptr;
             }
             player->ItemAddedQuestCheck(entry, 1);
             player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_RECEIVE_EPIC_ITEM, entry, 1);
@@ -3117,15 +2683,15 @@ namespace LuaPlayer
         {
             InventoryResult result = player->CanEquipItem(slot, dest, item, false);
             if (result != EQUIP_ERR_OK)
-                return 1;
+                return nullptr;
             player->RemoveItem(item->GetBagSlot(), item->GetSlot(), true);
         }
 
-        ALE::Push(L, player->EquipItem(dest, item, true));
+        Item* equippedItem = player->EquipItem(dest, item, true);
         player->AutoUnequipOffhandIfNeed();
-        return 1;
+        return equippedItem;
     }
-    
+
     /**
      * Returns true if the player can equip the given [Item] or item entry to the given slot, false otherwise.
      *
@@ -3136,39 +2702,28 @@ namespace LuaPlayer
      * @param uint32 slot : equipment slot to test
      * @return bool canEquip
      */
-    int CanEquipItem(lua_State* L, Player* player)
+    bool CanEquipItem(Player* player, sol::object itemOrEntry, uint32 slot)
     {
-        Item* item = ALE::CHECKOBJ<Item>(L, 2, false);
-        uint32 slot = ALE::CHECKVAL<uint32>(L, 3);
+        Item* item = itemOrEntry.is<ItemRef>() ? itemOrEntry.as<ItemRef>().Require() : nullptr;
         if (slot >= EQUIPMENT_SLOT_END)
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
+            return false;
 
         if (!item)
         {
-            uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
+            uint32 entry = itemOrEntry.as<uint32>();
             uint16 dest;
             InventoryResult msg = player->CanEquipNewItem(slot, dest, entry, false);
             if (msg != EQUIP_ERR_OK)
-            {
-                ALE::Push(L, false);
-                return 1;
-            }
+                return false;
         }
         else
         {
             uint16 dest;
             InventoryResult msg = player->CanEquipItem(slot, dest, item, false);
             if (msg != EQUIP_ERR_OK)
-            {
-                ALE::Push(L, false);
-                return 1;
-            }
+                return false;
         }
-        ALE::Push(L, true);
-        return 1;
+        return true;
     }
 
     /**
@@ -3176,22 +2731,19 @@ namespace LuaPlayer
      *
      * @param uint32 titleId
      */
-    int UnsetKnownTitle(lua_State* L, Player* player)
+    void UnsetKnownTitle(Player* player, uint32 id)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
         CharTitlesEntry const* t = sCharTitlesStore.LookupEntry(id);
         if (t)
             player->SetTitle(t, true);
-        return 0;
     }
 
     /**
      * Advances all of the [Player]s weapon skills to the maximum amount available
      */
-    int AdvanceSkillsToMax(lua_State* /*L*/, Player* player)
+    void AdvanceSkillsToMax(Player* player)
     {
         player->UpdateSkillsToMaxSkillsForLevel();
-        return 0;
     }
 
     /**
@@ -3199,12 +2751,10 @@ namespace LuaPlayer
      *
      * @param uint32 skillStep
      */
-    int AdvanceAllSkills(lua_State* L, Player* player)
+    void AdvanceAllSkills(Player* player, uint32 step)
     {
-        uint32 step = ALE::CHECKVAL<uint32>(L, 2);
-
         if (!step)
-            return 0;
+            return;
 
         for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
         {
@@ -3217,8 +2767,6 @@ namespace LuaPlayer
                     player->UpdateSkill(entry->id, step);
             }
         }
-
-        return 0;
     }
 
     /**
@@ -3228,17 +2776,14 @@ namespace LuaPlayer
      * @param uint32 step : the step to advance the skill by
      * @return bool success : true if the skill was updated successfully
      */
-    int AdvanceSkill(lua_State* L, Player* player)
+    bool AdvanceSkill(Player* player, uint32 _skillId, uint32 _step)
     {
-        uint32 _skillId = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 _step = ALE::CHECKVAL<uint32>(L, 3);
         bool success = false;
         if (_skillId && _step && player->HasSkill(_skillId))
         {
             success = player->UpdateSkill(_skillId, _step);
         }
-        ALE::Push(L, success);
-        return 1;
+        return success;
     }
 
     /**
@@ -3250,22 +2795,15 @@ namespace LuaPlayer
      * @param float zCoord
      * @param float orientation
      */
-    int Teleport(lua_State* L, Player* player)
+    bool Teleport(Player* player, uint32 mapId, float x, float y, float z, float o)
     {
-        uint32 mapId = ALE::CHECKVAL<uint32>(L, 2);
-        float x = ALE::CHECKVAL<float>(L, 3);
-        float y = ALE::CHECKVAL<float>(L, 4);
-        float z = ALE::CHECKVAL<float>(L, 5);
-        float o = ALE::CHECKVAL<float>(L, 6);
-
         if (player->IsInFlight())
         {
             player->GetMotionMaster()->MovementExpired();
             player->m_taxi.ClearTaxiDestinations();
         }
 
-        ALE::Push(L, player->TeleportTo(mapId, x, y, z, o));
-        return 1;
+        return player->TeleportTo(mapId, x, y, z, o);
     }
 
     /**
@@ -3274,14 +2812,12 @@ namespace LuaPlayer
      * @param [Player] player
      * @param uint32 kills
      */
-    int AddLifetimeKills(lua_State* L, Player* player)
+    void AddLifetimeKills(Player* player, uint32 val)
     {
-        uint32 val = ALE::CHECKVAL<uint32>(L, 2);
         uint32 currentKills = player->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS);
         player->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, currentKills + val);
-        return 0;
     }
-    
+
     /**
      * Adds the given amount of the specified item entry to the player.
      *
@@ -3289,10 +2825,9 @@ namespace LuaPlayer
      * @param uint32 itemCount = 1 : amount of the item to add
      * @return [Item] item : the item that was added or nil
      */
-    int AddItem(lua_State* L, Player* player)
+    Item* AddItem(Player* player, uint32 itemId, sol::optional<uint32> itemCountArg)
     {
-        uint32 itemId = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 itemCount = ALE::CHECKVAL<uint32>(L, 3, 1);
+        uint32 itemCount = itemCountArg.value_or(1);
 
         uint32 noSpaceForCount = 0;
         ItemPosCountVec dest;
@@ -3301,16 +2836,15 @@ namespace LuaPlayer
             itemCount -= noSpaceForCount;
 
         if (itemCount == 0 || dest.empty())
-            return 1;
+            return nullptr;
 
         Item* item = player->StoreNewItem(dest, itemId, true, Item::GenerateItemRandomPropertyId(itemId));
         if (item)
             player->SendNewItem(item, itemCount, true, false);
-        ALE::Push(L, item);
 
-        return 1;
+        return item;
     }
-    
+
     /**
      * Removes the given amount of the specified [Item] from the player.
      *
@@ -3320,23 +2854,18 @@ namespace LuaPlayer
      * @param uint32 entry : entry of the item to remove
      * @param uint32 itemCount = 1 : amount of the item to remove
      */
-    int RemoveItem(lua_State* L, Player* player)
+    void RemoveItem(Player* player, sol::object itemOrEntry, uint32 itemCount)
     {
-        Item* item = ALE::CHECKOBJ<Item>(L, 2, false);
-        uint32 itemCount = ALE::CHECKVAL<uint32>(L, 3);
+        Item* item = itemOrEntry.is<ItemRef>() ? itemOrEntry.as<ItemRef>().Require() : nullptr;
         if (!item)
         {
-            uint32 itemId = ALE::CHECKVAL<uint32>(L, 2);
+            uint32 itemId = itemOrEntry.as<uint32>();
             player->DestroyItemCount(itemId, itemCount, true);
         }
         else
         {
-            bool all = itemCount >= item->GetCount();
             player->DestroyItemCount(item, itemCount, true);
-            if (all)
-                ALE::CHECKOBJ<ALEObject>(L, 2)->Invalidate();
         }
-        return 0;
     }
 
     /**
@@ -3344,14 +2873,12 @@ namespace LuaPlayer
      *
      * @param uint32 val : kills to remove
      */
-    int RemoveLifetimeKills(lua_State* L, Player* player)
+    void RemoveLifetimeKills(Player* player, uint32 val)
     {
-        uint32 val = ALE::CHECKVAL<uint32>(L, 2);
         uint32 currentKills = player->GetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS);
         if (val > currentKills)
             val = currentKills;
         player->SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, currentKills - val);
-        return 0;
     }
 
     /**
@@ -3360,12 +2887,10 @@ namespace LuaPlayer
      * @param uint32 spellId
      * @param bool update = true
      */
-    int ResetSpellCooldown(lua_State* L, Player* player)
+    void ResetSpellCooldown(Player* player, uint32 spellId, sol::optional<bool> updateArg)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        bool update = ALE::CHECKVAL<bool>(L, 3, true);
+        bool update = updateArg.value_or(true);
         player->RemoveSpellCooldown(spellId, update);
-        return 0;
     }
 
     /**
@@ -3374,23 +2899,20 @@ namespace LuaPlayer
      * @param uint32 category
      * @param bool update = true
      */
-    int ResetTypeCooldowns(lua_State* L, Player* player)
+    void ResetTypeCooldowns(Player* player, uint32 category, sol::optional<bool> updateArg)
     {
-        uint32 category = ALE::CHECKVAL<uint32>(L, 2);
-        bool update = ALE::CHECKVAL<bool>(L, 3, true);
+        bool update = updateArg.value_or(true);
         (void)update; // ensure that the variable is referenced in order to pass compiler checks
 
         player->RemoveCategoryCooldown(category);
-        return 0;
     }
 
     /**
      * Resets all of the [Player]'s cooldowns
      */
-    int ResetAllCooldowns(lua_State* /*L*/, Player* player)
+    void ResetAllCooldowns(Player* player)
     {
         player->RemoveAllSpellCooldown();
-        return 0;
     }
 
     /**
@@ -3398,12 +2920,10 @@ namespace LuaPlayer
      *
      * @param string message
      */
-    int SendBroadcastMessage(lua_State* L, Player* player)
+    void SendBroadcastMessage(Player* player, std::string const& message)
     {
-        const char* message = ALE::CHECKVAL<const char*>(L, 2);
-        if (std::string(message).length() > 0)
+        if (message.length() > 0)
             ChatHandler(player->GetSession()).SendSysMessage(message);
-        return 0;
     }
 
     /**
@@ -3411,12 +2931,10 @@ namespace LuaPlayer
      *
      * @param string message
      */
-    int SendAreaTriggerMessage(lua_State* L, Player* player)
+    void SendAreaTriggerMessage(Player* player, std::string const& msg)
     {
-        std::string msg = ALE::CHECKVAL<std::string>(L, 2);
         if (msg.length() > 0)
             player->GetSession()->SendAreaTriggerMessage("{}", msg.c_str());
-        return 0;
     }
 
     /**
@@ -3424,12 +2942,10 @@ namespace LuaPlayer
      *
      * @param string message
      */
-    int SendNotification(lua_State* L, Player* player)
+    void SendNotification(Player* player, std::string const& msg)
     {
-        std::string msg = ALE::CHECKVAL<std::string>(L, 2);
         if (msg.length() > 0)
             ChatHandler(player->GetSession()).SendNotification("{}", msg);
-        return 0;
     }
 
     /**
@@ -3438,15 +2954,13 @@ namespace LuaPlayer
      * @param [WorldPacket] packet
      * @param bool selfOnly = true
      */
-    int SendPacket(lua_State* L, Player* player)
+    void SendPacket(Player* player, WorldPacket* data, sol::optional<bool> selfOnlyArg)
     {
-        WorldPacket* data = ALE::CHECKOBJ<WorldPacket>(L, 2);
-        bool selfOnly = ALE::CHECKVAL<bool>(L, 3, true);
+        bool selfOnly = selfOnlyArg.value_or(true);
         if (selfOnly)
             player->GetSession()->SendPacket(data);
         else
             player->SendMessageToSet(data, true);
-        return 0;
     }
 
     /**
@@ -3458,35 +2972,28 @@ namespace LuaPlayer
      * @param [Player] receiver
      *
      */
-    int SendAddonMessage(lua_State* L, Player* player)
+    void SendAddonMessage(Player* player, std::string const& prefix, std::string const& message, uint8 channel, Player* receiver)
     {
-        std::string prefix = ALE::CHECKVAL<std::string>(L, 2);
-        std::string message = ALE::CHECKVAL<std::string>(L, 3);
-        uint8 channel = ALE::CHECKVAL<uint8>(L, 4);
-        Player* receiver = ALE::CHECKOBJ<Player>(L, 5);
-
         std::string fullmsg = prefix + "\t" + message;
 
         WorldPacket data(SMSG_MESSAGECHAT, 100);
         data << uint8(channel);
         data << int32(LANG_ADDON);
-        data << player->GET_GUID();
+        data << player->GetGUID();
         data << uint32(0);
-        data << receiver->GET_GUID();
+        data << receiver->GetGUID();
         data << uint32(fullmsg.length() + 1);
         data << fullmsg;
         data << uint8(0);
         receiver->GetSession()->SendPacket(&data);
-        return 0;
     }
 
     /**
      * Kicks the [Player] from the server
      */
-    int KickPlayer(lua_State* /*L*/, Player* player)
+    void KickPlayer(Player* player)
     {
         player->GetSession()->KickPlayer();
-        return 0;
     }
 
     /**
@@ -3494,12 +3001,9 @@ namespace LuaPlayer
      *
      * @param int32 copperAmt : negative to remove, positive to add
      */
-    int ModifyMoney(lua_State* L, Player* player)
+    void ModifyMoney(Player* player, int32 amt)
     {
-        int32 amt = ALE::CHECKVAL<int32>(L, 2);
-
         player->ModifyMoney(amt);
-        return 1;
     }
 
     /**
@@ -3507,11 +3011,9 @@ namespace LuaPlayer
      *
      * @param uint32 spellId
      */
-    int LearnSpell(lua_State* L, Player* player)
+    void LearnSpell(Player* player, uint32 id)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
         player->learnSpell(id);
-        return 0;
     }
 
     /**
@@ -3520,25 +3022,19 @@ namespace LuaPlayer
      * @param uint32 talent_id
      * @param uint32 talentRank
      */
-    int LearnTalent(lua_State* L, Player* player)
+    void LearnTalent(Player* player, uint32 id, uint32 rank)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 rank = ALE::CHECKVAL<uint32>(L, 3);
-
         player->LearnTalent(id, rank);
         player->SendTalentsInfoData(false);
-
-        return 0;
     }
+
     /**
     * Run a chat command as if the player typed it into the chat
     *
     * @param string command: text to display in chat or console
     */
-    int RunCommand(lua_State* L, Player* player)
+    void RunCommand(Player* player, std::string command)
     {
-        auto command = ALE::CHECKVAL<std::string>(L, 2);
-
         // In _ParseCommands which is used below no leading . or ! is allowed for the command string.
         if (command[0] == '.' || command[0] == '!') {
             command = command.substr(1);
@@ -3546,8 +3042,6 @@ namespace LuaPlayer
 
         auto handler = ChatHandler(player->GetSession());
         handler._ParseCommands(command);
-
-        return 0;
     }
 
     /**
@@ -3556,15 +3050,10 @@ namespace LuaPlayer
     * @param uint32 glyphId
     * @param uint32 slotIndex
     */
-    int SetGlyph(lua_State* L, Player* player)
+    void SetGlyph(Player* player, uint32 glyphId, uint32 slotIndex)
     {
-        uint32 glyphId = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 slotIndex = ALE::CHECKVAL<uint32>(L, 3);
-
         player->SetGlyph(slotIndex, glyphId, true);
         player->SendTalentsInfoData(false); // Also handles GlyphData
-
-        return 0;
     }
 
     /**
@@ -3573,20 +3062,17 @@ namespace LuaPlayer
     * @param [uint32] slotIndex
     * @return [uint32] glyphId
     */
-    int GetGlyph(lua_State* L, Player* player)
+    uint32 GetGlyph(Player* player, uint32 slotIndex)
     {
-        auto slotIndex = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L,player->GetGlyph(slotIndex));
-        return 1;
+        return player->GetGlyph(slotIndex);
     }
 
     /**
      * Remove cooldowns on spells that have less than 10 minutes of cooldown from the [Player], similarly to when you enter an arena.
      */
-    int RemoveArenaSpellCooldowns(lua_State* /*L*/, Player* player)
+    void RemoveArenaSpellCooldowns(Player* player)
     {
         player->RemoveArenaSpellCooldowns();
-        return 0;
     }
 
     /**
@@ -3595,21 +3081,20 @@ namespace LuaPlayer
      * @param float healthPercent = 100.0f
      * @param bool ressSickness = false
      */
-    int ResurrectPlayer(lua_State* L, Player* player)
+    void ResurrectPlayer(Player* player, sol::optional<float> percentArg, sol::optional<bool> sicknessArg)
     {
-        float percent = ALE::CHECKVAL<float>(L, 2, 100.0f);
-        bool sickness = ALE::CHECKVAL<bool>(L, 3, false);
+        float percent = percentArg.value_or(100.0f);
+        bool sickness = sicknessArg.value_or(false);
         player->ResurrectPlayer(percent, sickness);
         player->SpawnCorpseBones();
-        return 0;
     }
 
     /**
      * Adds a new item to the gossip menu shown to the [Player] on next call to [Player:GossipSendMenu].
      *
-     * sender and intid are numbers which are passed directly to the gossip selection handler. Internally they are partly used for the database gossip handling.  
-     * code specifies whether to show a box to insert text to. The player inserted text is passed to the gossip selection handler.  
-     * money specifies an amount of money the player needs to have to click the option. An error message is shown if the player doesn't have enough money.  
+     * sender and intid are numbers which are passed directly to the gossip selection handler. Internally they are partly used for the database gossip handling.
+     * code specifies whether to show a box to insert text to. The player inserted text is passed to the gossip selection handler.
+     * money specifies an amount of money the player needs to have to click the option. An error message is shown if the player doesn't have enough money.
      * Note that the money amount is only checked client side and is not removed from the player either. You will need to check again in your code before taking action.
      *
      * See also: [Player:GossipSendMenu], [Player:GossipAddQuests], [Player:GossipComplete], [Player:GossipClearMenu]
@@ -3622,15 +3107,11 @@ namespace LuaPlayer
      * @param string popup = nil : if non empty string, a popup with given text shown on click
      * @param uint32 money = 0 : required money in copper
      */
-    int GossipMenuAddItem(lua_State* L, Player* player)
+    void GossipMenuAddItem(Player* player, uint32 _icon, std::string const& msg, uint32 _sender, uint32 _intid, sol::optional<bool> codeArg, sol::optional<std::string> promptMsgArg, sol::optional<uint32> moneyArg)
     {
-        uint32 _icon = ALE::CHECKVAL<uint32>(L, 2);
-        const char* msg = ALE::CHECKVAL<const char*>(L, 3);
-        uint32 _sender = ALE::CHECKVAL<uint32>(L, 4);
-        uint32 _intid = ALE::CHECKVAL<uint32>(L, 5);
-        bool _code = ALE::CHECKVAL<bool>(L, 6, false);
-        const char* _promptMsg = ALE::CHECKVAL<const char*>(L, 7, "");
-        uint32 _money = ALE::CHECKVAL<uint32>(L, 8, 0);
+        bool _code = codeArg.value_or(false);
+        std::string _promptMsg = promptMsgArg.value_or("");
+        uint32 _money = moneyArg.value_or(0);
         if (player->PlayerTalkClass->GetGossipMenu().GetMenuItemCount() < GOSSIP_MAX_MENU_ITEMS)
         {
             player->PlayerTalkClass->GetGossipMenu().AddMenuItem(-1, _icon, msg, _sender, _intid, _promptMsg, _money,
@@ -3638,9 +3119,8 @@ namespace LuaPlayer
         }
         else
         {
-            return luaL_error(L, "GossipMenuItem not added. Reached Max amount of possible GossipMenuItems in this GossipMenu");
+            throw std::runtime_error("GossipMenuItem not added. Reached Max amount of possible GossipMenuItems in this GossipMenu");
         }
-        return 0;
     }
 
     /**
@@ -3648,10 +3128,9 @@ namespace LuaPlayer
      *
      * See also: [Player:GossipMenuAddItem], [Player:GossipAddQuests], [Player:GossipSendMenu], [Player:GossipClearMenu]
      */
-    int GossipComplete(lua_State* /*L*/, Player* player)
+    void GossipComplete(Player* player)
     {
         player->PlayerTalkClass->SendCloseGossip();
-        return 0;
     }
 
     /**
@@ -3668,31 +3147,30 @@ namespace LuaPlayer
      * @param [Object] sender : object acting as the source of the sent gossip menu
      * @param uint32 menu_id : if sender is a [Player] then menu_id is mandatory
      */
-    int GossipSendMenu(lua_State* L, Player* player)
+    void GossipSendMenu(Player* player, uint32 npc_text, Object* sender, sol::optional<uint32> menuIdArg)
     {
-        uint32 npc_text = ALE::CHECKVAL<uint32>(L, 2);
-        Object* sender = ALE::CHECKOBJ<Object>(L, 3);
         if (sender->GetTypeId() == TYPEID_PLAYER)
         {
-            uint32 menu_id = ALE::CHECKVAL<uint32>(L, 4);
+            if (!menuIdArg)
+                throw std::invalid_argument("menu_id is mandatory when the sender is a Player");
+
+            uint32 menu_id = *menuIdArg;
             player->PlayerTalkClass->GetGossipMenu().SetMenuId(menu_id);
         }
-        player->PlayerTalkClass->SendGossipMenu(npc_text, sender->GET_GUID());
-        return 0;
+        player->PlayerTalkClass->SendGossipMenu(npc_text, sender->GetGUID());
     }
 
     /**
      * Clears the [Player]s current gossip item list.
      *
      * See also: [Player:GossipMenuAddItem], [Player:GossipSendMenu], [Player:GossipAddQuests], [Player:GossipComplete]
-     * 
+     *
      *     Note: This is needed when you show a gossip menu without using gossip hello or select hooks which do this automatically.
      *     Usually this is needed when using [Player] is the sender of a Gossip Menu.
      */
-    int GossipClearMenu(lua_State* /*L*/, Player* player)
+    void GossipClearMenu(Player* player)
     {
         player->PlayerTalkClass->ClearMenus();
-        return 0;
     }
 
     /**
@@ -3700,12 +3178,9 @@ namespace LuaPlayer
      *
      * @param uint32 pathId : pathId from DBC or [Global:AddTaxiPath]
      */
-    int StartTaxi(lua_State* L, Player* player)
+    void StartTaxi(Player* player, uint32 pathId)
     {
-        uint32 pathId = ALE::CHECKVAL<uint32>(L, 2);
-
         player->ActivateTaxiPathTo(pathId);
-        return 0;
     }
 
     /**
@@ -3718,15 +3193,8 @@ namespace LuaPlayer
      * @param uint32 data
      * @param string iconText
      */
-    int GossipSendPOI(lua_State* L, Player* player)
+    void GossipSendPOI(Player* player, float x, float y, uint32 icon, uint32 flags, uint32 data, std::string const& iconText)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        uint32 icon = ALE::CHECKVAL<uint32>(L, 4);
-        uint32 flags = ALE::CHECKVAL<uint32>(L, 5);
-        uint32 data = ALE::CHECKVAL<uint32>(L, 6);
-        std::string iconText = ALE::CHECKVAL<std::string>(L, 7);
-
         WorldPacket packet(SMSG_GOSSIP_POI, 4 + 4 + 4 + 4 + 4 + 10);
         packet << flags;
         packet << x;
@@ -3735,7 +3203,6 @@ namespace LuaPlayer
         packet << data;
         packet << iconText;
         player->GetSession()->SendPacket(&packet);
-        return 0;
     }
 
     /**
@@ -3743,21 +3210,18 @@ namespace LuaPlayer
      *
      * @param [WorldObject] source : a questgiver with quests
      */
-    int GossipAddQuests(lua_State* L, Player* player)
+    void GossipAddQuests(Player* player, WorldObject* source)
     {
-        WorldObject* source = ALE::CHECKOBJ<WorldObject>(L, 2);
-
         if (source->GetTypeId() == TYPEID_UNIT)
         {
             if (source->GetUInt32Value(UNIT_NPC_FLAGS) & UNIT_NPC_FLAG_QUESTGIVER)
-                player->PrepareQuestMenu(source->GET_GUID());
+                player->PrepareQuestMenu(source->GetGUID());
         }
         else if (source->GetTypeId() == TYPEID_GAMEOBJECT)
         {
             if (source->ToGameObject()->GetGoType() == GAMEOBJECT_TYPE_QUESTGIVER)
-                player->PrepareQuestMenu(source->GET_GUID());
+                player->PrepareQuestMenu(source->GetGUID());
         }
-        return 0;
     }
 
     /**
@@ -3766,26 +3230,23 @@ namespace LuaPlayer
      * @param uint32 questId : entry of a quest
      * @param bool activateAccept = true : auto finish the quest
      */
-    int SendQuestTemplate(lua_State* L, Player* player)
+    void SendQuestTemplate(Player* player, uint32 questId, sol::optional<bool> activateAcceptArg)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-        bool activateAccept = ALE::CHECKVAL<bool>(L, 3, true);
+        bool activateAccept = activateAcceptArg.value_or(true);
 
-        Quest const* quest = eObjectMgr->GetQuestTemplate(questId);
+        Quest const* quest = sObjectMgr->GetQuestTemplate(questId);
         if (!quest)
-            return 0;
+            return;
 
-        player->PlayerTalkClass->SendQuestGiverQuestDetails(quest, player->GET_GUID(), activateAccept);
-        return 0;
+        player->PlayerTalkClass->SendQuestGiverQuestDetails(quest, player->GetGUID(), activateAccept);
     }
 
     /**
      * Converts [Player]'s corpse to bones
      */
-    int SpawnBones(lua_State* /*L*/, Player* player)
+    void SpawnBones(Player* player)
     {
         player->SpawnCorpseBones();
-        return 0;
     }
 
     /**
@@ -3793,11 +3254,9 @@ namespace LuaPlayer
      *
      * @param [Player] looter
      */
-    int RemovedInsignia(lua_State* L, Player* player)
+    void RemovedInsignia(Player* player, Player* looter)
     {
-        Player* looter = ALE::CHECKOBJ<Player>(L, 2);
         player->RemovedInsignia(looter);
-        return 0;
     }
 
     /**
@@ -3806,15 +3265,10 @@ namespace LuaPlayer
      * @param [Player] invited : player to invite to group
      * @return bool success : true if the player was invited to a group
      */
-    int GroupInvite(lua_State* L, Player* player)
+    bool GroupInvite(Player* player, Player* invited)
     {
-        Player* invited = ALE::CHECKOBJ<Player>(L, 2);
-
         if (invited->GetGroup() || invited->GetGroupInvite())
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
+            return false;
 
         // Get correct existing group if any
         Group* group = player->GetGroup();
@@ -3846,8 +3300,7 @@ namespace LuaPlayer
             invited->GetSession()->SendPacket(&data);
         }
 
-        ALE::Push(L, success);
-        return 1;
+        return success;
     }
 
     /**
@@ -3856,12 +3309,10 @@ namespace LuaPlayer
      * @param [Player] invited : player to add to group
      * @return [Group] createdGroup : the created group or nil
      */
-    int GroupCreate(lua_State* L, Player* player)
+    Group* GroupCreate(Player* player, Player* invited)
     {
-        Player* invited = ALE::CHECKOBJ<Player>(L, 2);
-
         if (player->GetGroup() || invited->GetGroup())
-            return 0;
+            return nullptr;
 
         if (player->GetGroupInvite())
             player->UninviteFromGroup();
@@ -3873,7 +3324,7 @@ namespace LuaPlayer
         if (!group->AddLeaderInvite(player))
         {
             delete group;
-            return 0;
+            return nullptr;
         }
 
         // Forming a new group, create it
@@ -3885,10 +3336,9 @@ namespace LuaPlayer
         }
 
         if (!group->AddMember(invited))
-            return 0;
+            return nullptr;
         group->BroadcastGroupUpdate();
-        ALE::Push(L, group);
-        return 1;
+        return group;
     }
 
     /**
@@ -3896,12 +3346,9 @@ namespace LuaPlayer
      *
      * @param uint32 CinematicSequenceId : entry of a cinematic
      */
-    int SendCinematicStart(lua_State* L, Player* player)
+    void SendCinematicStart(Player* player, uint32 CinematicSequenceId)
     {
-        uint32 CinematicSequenceId = ALE::CHECKVAL<uint32>(L, 2);
-
         player->SendCinematicStart(CinematicSequenceId);
-        return 0;
     }
 
     /**
@@ -3909,12 +3356,9 @@ namespace LuaPlayer
      *
      * @param uint32 MovieId : entry of a movie
      */
-    int SendMovieStart(lua_State* L, Player* player)
+    void SendMovieStart(Player* player, uint32 MovieId)
     {
-        uint32 MovieId = ALE::CHECKVAL<uint32>(L, 2);
-
         player->SendMovieStart(MovieId);
-        return 0;
     }
 
     /**
@@ -3924,13 +3368,9 @@ namespace LuaPlayer
      * @param uint32 index
      * @param uint32 value
      */
-    int UpdatePlayerSetting(lua_State* L, Player* player)
+    void UpdatePlayerSetting(Player* player, std::string const& source, uint32 index, uint32 value)
     {
-        std::string source = ALE::CHECKVAL<std::string>(L, 2);
-        uint32 index = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 value = ALE::CHECKVAL<uint32>(L, 4);
         player->UpdatePlayerSetting(source, index, value);
-        return 0;
     }
 
     /**
@@ -3939,13 +3379,10 @@ namespace LuaPlayer
      * @param string source
      * @param uint32 index
      */
-    int GetPlayerSettingValue(lua_State* L, Player* player)
+    uint32 GetPlayerSettingValue(Player* player, std::string const& source, uint32 index)
     {
-        std::string source = ALE::CHECKVAL<std::string>(L, 2);
-        uint32 index = ALE::CHECKVAL<uint32>(L, 3);
         uint32 value = player->GetPlayerSetting(source, index).value;
-        ALE::Push(L, value);
-        return 1;
+        return value;
     }
 
     /**
@@ -3953,10 +3390,9 @@ namespace LuaPlayer
      *
      * @return [Player] trader : the player trading, or nil
      */
-    int GetTrader(lua_State* L, Player* player)
+    Player* GetTrader(Player* player)
     {
-        ALE::Push(L, player->GetTrader());
-        return 1;
+        return player->GetTrader();
     }
 
     /**
@@ -3965,111 +3401,21 @@ namespace LuaPlayer
      * @param int value : The spell power value to set
      * @param bool apply = false : Whether the spell power should be applied or removed
      */
-    int SetSpellPower(lua_State* L, Player* player)
+    void SetSpellPower(Player* player, int value, sol::optional<bool> applyArg)
     {
-        int value  = ALE::CHECKVAL<int>(L, 2);
-        bool apply = ALE::CHECKVAL<bool>(L, 3, false);
+        bool apply = applyArg.value_or(false);
 
         player->ApplySpellPowerBonus(value, apply);
-        return 0;
     }
 
-    /*int BindToInstance(lua_State* L, Player* player)
-    {
-    player->BindToInstance();
-    return 0;
-    }*/
-
-    /*int AddTalent(lua_State* L, Player* player)
-    {
-    uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-    uint8 spec = ALE::CHECKVAL<uint8>(L, 3);
-    bool learning = ALE::CHECKVAL<bool>(L, 4, true);
-    if (spec >= MAX_TALENT_SPECS)
-    ALE::Push(L, false);
-    else
-    ALE::Push(L, player->AddTalent(spellId, spec, learning));
-    return 1;
-    }*/
-
-    /*int GainSpellComboPoints(lua_State* L, Player* player)
-    {
-    int8 count = ALE::CHECKVAL<int8>(L, 2);
-
-    player->GainSpellComboPoints(count);
-    return 0;
-    }*/
-
-    /*int KillGOCredit(lua_State* L, Player* player)
-    {
-    uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-    ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 3);
-    player->KillCreditGO(entry, guid);
-    return 0;
-    }*/
-
-    /*int KilledPlayerCredit(lua_State* L, Player* player)
-    {
-    player->KilledPlayerCredit();
-    return 0;
-    }*/
-
-    /*int RemoveRewardedQuest(lua_State* L, Player* player)
-    {
-    uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-    player->RemoveRewardedQuest(entry);
-    return 0;
-    }*/
-
-    /*int RemoveActiveQuest(lua_State* L, Player* player)
-    {
-    uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-
-    player->RemoveActiveQuest(entry);
-    return 0;
-    }*/
-
-    /*int SummonPet(lua_State* L, Player* player)
-    {
-    uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-    float x = ALE::CHECKVAL<float>(L, 3);
-    float y = ALE::CHECKVAL<float>(L, 4);
-    float z = ALE::CHECKVAL<float>(L, 5);
-    float o = ALE::CHECKVAL<float>(L, 6);
-    uint32 petType = ALE::CHECKVAL<uint32>(L, 7);
-    uint32 despwtime = ALE::CHECKVAL<uint32>(L, 8);
-
-    if (petType >= MAX_PET_TYPE)
-    return 0;
-
-    player->SummonPet(entry, x, y, z, o, (PetType)petType, despwtime);
-    return 0;
-    }*/
-
-    /*int RemovePet(lua_State* L, Player* player)
-    {
-    int mode = ALE::CHECKVAL<int>(L, 2, PET_SAVE_AS_DELETED);
-    bool returnreagent = ALE::CHECKVAL<bool>(L, 2, false);
-
-    if (!player->GetPet())
-    return 0;
-
-    player->RemovePet(player->GetPet(), (PetSaveMode)mode, returnreagent);
-    return 0;
-    }*/
-
     /**
      * Set bonus talent count to a specific count for the [Player]
      *
      * @param uint32 value : bonus talent points
      */
-    int SetBonusTalentCount(lua_State* L, Player* player)
+    void SetBonusTalentCount(Player* player, uint32 value)
     {
-        uint32 value = ALE::CHECKVAL<uint32>(L, 2);
-
         player->SetBonusTalentCount(value);
-        return 0;
     }
 
     /**
@@ -4077,34 +3423,29 @@ namespace LuaPlayer
      *
      * @return uint32 bonusTalent
      */
-    int GetBonusTalentCount(lua_State* L, Player* player)
+    uint32 GetBonusTalentCount(Player* player)
     {
-        ALE::Push(L, player->GetBonusTalentCount());
-        return 1;
+        return player->GetBonusTalentCount();
     }
-  
+
     /**
      *  Returns the [Player] spells list
      *
      * @return table playerSpells
      */
-    int GetSpells(lua_State* L, Player* player)
+    sol::table GetSpells(Player* player, sol::this_state s)
     {
-        std::list<uint32> list;
-        lua_createtable(L, list.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         PlayerSpellMap spellMap = player->GetSpellMap();
         for (PlayerSpellMap::const_iterator itr = spellMap.begin(); itr != spellMap.end(); ++itr)
         {
             SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(itr->first);
-            ALE::Push(L, spellInfo->Id);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = spellInfo->Id;
         }
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -4112,12 +3453,9 @@ namespace LuaPlayer
      *
      * @param uint32 count = count of bonus talent
      */
-    int AddBonusTalent(lua_State* L, Player* player)
+    void AddBonusTalent(Player* player, uint32 count)
     {
-        uint32 count = ALE::CHECKVAL<uint32>(L, 2);
-
         player->AddBonusTalent(count);
-        return 0;
     }
 
     /**
@@ -4125,14 +3463,11 @@ namespace LuaPlayer
      *
      * @param uint32 count = count of bonus talent
      */
-    int RemoveBonusTalent(lua_State* L, Player* player)
+    void RemoveBonusTalent(Player* player, uint32 count)
     {
-        uint32 count = ALE::CHECKVAL<uint32>(L, 2);
-
         player->RemoveBonusTalent(count);
-        return 0;
     }
-  
+
     /**
      *  Returns the [Player] homebind location.
      *
@@ -4142,22 +3477,16 @@ namespace LuaPlayer
      *      - float y: The Y coordinate of the homebind location.
      *      - float z: The Z coordinate of the homebind location.
      */
-    int GetHomebind(lua_State* L, Player* player)
+    sol::table GetHomebind(Player* player, sol::this_state s)
     {
-        lua_newtable(L);
-        lua_pushinteger(L, player->m_homebindMapId);
-        lua_setfield(L, -2, "mapId");
-
-        lua_pushnumber(L, player->m_homebindX);
-        lua_setfield(L, -2, "x");
+        sol::table tbl = sol::state_view(s).create_table();
 
-        lua_pushnumber(L, player->m_homebindY);
-        lua_setfield(L, -2, "y");
+        tbl["mapId"] = player->m_homebindMapId;
+        tbl["x"] = player->m_homebindX;
+        tbl["y"] = player->m_homebindY;
+        tbl["z"] = player->m_homebindZ;
 
-        lua_pushnumber(L, player->m_homebindZ);
-        lua_setfield(L, -2, "z");
-
-        return 1;
+        return tbl;
     }
 
     /**
@@ -4165,10 +3494,9 @@ namespace LuaPlayer
      *
      *  @param string tele : The name of the predefined teleport location.
      */
-    int TeleportTo(lua_State* L, Player* player)
+    void TeleportTo(Player* player, std::string const& tele)
     {
-        std::string tele = ALE::CHECKVAL<std::string>(L, 2);
-        const GameTele* game_tele = sObjectMgr->GetGameTele(tele);
+        GameTele const* game_tele = sObjectMgr->GetGameTele(tele);
 
         if (player->IsInFlight())
         {
@@ -4177,7 +3505,6 @@ namespace LuaPlayer
         }
 
         player->TeleportTo(game_tele->mapId, game_tele->position_x, game_tele->position_y, game_tele->position_z, game_tele->orientation);
-        return 0;
     }
 
     /**
@@ -4185,10 +3512,9 @@ namespace LuaPlayer
      *
      * @return [Pet] pet : the player's pet, or `nil` if no pet
      */
-    int GetPet(lua_State* L, Player* player)
+    Pet* GetPet(Player* player)
     {
-        ALE::Push(L, player->GetPet());
-        return 1;
+        return player->GetPet();
     }
 
     /**
@@ -4196,10 +3522,9 @@ namespace LuaPlayer
      *
      * @return bool isMaxLevel
      */
-    int IsMaxLevel(lua_State* L, Player* player)
+    bool IsMaxLevel(Player* player)
     {
-        ALE::Push(L, player->IsMaxLevel());
-        return 1;
+        return player->IsMaxLevel();
     }
 
     /**
@@ -4215,20 +3540,13 @@ namespace LuaPlayer
      * @param uint32 healthPct = 0 : initial health percentage
      * @return [Pet] pet : the summoned pet, or `nil` if failed
      */
-    int SummonPet(lua_State* L, Player* player)
+    Pet* SummonPet(Player* player, uint32 entry, float x, float y, float z, float ang, uint32 petType, sol::optional<uint32> durationArg, sol::optional<uint32> healthPctArg)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        float x = ALE::CHECKVAL<float>(L, 3);
-        float y = ALE::CHECKVAL<float>(L, 4);
-        float z = ALE::CHECKVAL<float>(L, 5);
-        float ang = ALE::CHECKVAL<float>(L, 6);
-        uint32 petType = ALE::CHECKVAL<uint32>(L, 7);
-        uint32 duration = ALE::CHECKVAL<uint32>(L, 8, 0);
-        uint32 healthPct = ALE::CHECKVAL<uint32>(L, 9, 0);
+        uint32 duration = durationArg.value_or(0);
+        uint32 healthPct = healthPctArg.value_or(0);
 
         Pet* pet = player->SummonPet(entry, x, y, z, ang, static_cast<PetType>(petType), Milliseconds(duration), healthPct);
-        ALE::Push(L, pet);
-        return 1;
+        return pet;
     }
 
     /**
@@ -4236,10 +3554,9 @@ namespace LuaPlayer
      *
      * @return float averageItemLevel
      */
-    int GetAverageItemLevel(lua_State* L, Player* player)
+    float GetAverageItemLevel(Player* player)
     {
-        ALE::Push(L, player->GetAverageItemLevel());
-        return 1;
+        return player->GetAverageItemLevel();
     }
 
     /**
@@ -4254,22 +3571,19 @@ namespace LuaPlayer
      * @param uint32 spellID = 0 : spell used for taming (second form)
      * @return [Pet] pet : the created pet, or `nil` if failed
      */
-    int CreatePet(lua_State* L, Player* player)
+    Pet* CreatePet(Player* player, sol::object creatureOrEntry, sol::optional<uint32> spellIDArg)
     {
-        if (lua_gettop(L) == 2)
-        {
-            uint32 creatureEntry = ALE::CHECKVAL<uint32>(L, 2);
-            Pet* pet = player->CreatePet(creatureEntry);
-            ALE::Push(L, pet);
-        }
-        else
+        if (creatureOrEntry.is<CreatureRef>())
         {
-            Creature* creatureTarget = ALE::CHECKOBJ<Creature>(L, 2);
-            uint32 spellID = ALE::CHECKVAL<uint32>(L, 3, 0);
+            Creature* creatureTarget = creatureOrEntry.as<CreatureRef>().Require();
+            uint32 spellID = spellIDArg.value_or(0);
             Pet* pet = player->CreatePet(creatureTarget, spellID);
-            ALE::Push(L, pet);
+            return pet;
         }
-        return 1;
+
+        uint32 creatureEntry = creatureOrEntry.as<uint32>();
+        Pet* pet = player->CreatePet(creatureEntry);
+        return pet;
     }
 
     /**
@@ -4278,11 +3592,9 @@ namespace LuaPlayer
      * @param uint32 questId
      * @return bool isDailyQuestDone
      */
-    int IsDailyQuestDone(lua_State* L, Player* player)
+    bool IsDailyQuestDone(Player* player, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, player->IsDailyQuestDone(questId));
-        return 1;
+        return player->IsDailyQuestDone(questId);
     }
 
     /**
@@ -4290,10 +3602,9 @@ namespace LuaPlayer
      *
      * The pet can be resummoned later. Used during teleportation, mounting, etc.
      */
-    int UnsummonPetTemporarily(lua_State* /*L*/, Player* player)
+    void UnsummonPetTemporarily(Player* player)
     {
         player->UnsummonPetTemporaryIfAny();
-        return 0;
     }
 
     /**
@@ -4301,11 +3612,9 @@ namespace LuaPlayer
      *
      * @param uint32 flag : the player flag to set
      */
-    int SetPlayerFlag(lua_State* L, Player* player)
+    void SetPlayerFlag(Player* player, uint32 flag)
     {
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 2);
         player->SetPlayerFlag((PlayerFlags)flag);
-        return 0;
     }
 
     /**
@@ -4315,13 +3624,10 @@ namespace LuaPlayer
      * @param [PetSaveMode] mode : how to handle pet removal
      * @param bool returnReagent = false : if `true`, returns reagents used to summon
      */
-    int RemovePet(lua_State* L, Player* player)
+    void RemovePet(Player* player, Pet* pet, uint32 mode, sol::optional<bool> returnReagentArg)
     {
-        Pet* pet = ALE::CHECKOBJ<Pet>(L, 2);
-        uint32 mode = ALE::CHECKVAL<uint32>(L, 3);
-        bool returnReagent = ALE::CHECKVAL<bool>(L, 4, false);
+        bool returnReagent = returnReagentArg.value_or(false);
         player->RemovePet(pet, static_cast<PetSaveMode>(mode), returnReagent);
-        return 1;
     }
 
     /**
@@ -4329,11 +3635,9 @@ namespace LuaPlayer
      *
      * @param uint32 flag : the player flag to remove
      */
-    int RemovePlayerFlag(lua_State* L, Player* player)
+    void RemovePlayerFlag(Player* player, uint32 flag)
     {
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 2);
         player->RemovePlayerFlag((PlayerFlags)flag);
-        return 0;
     }
 
     /**
@@ -4341,10 +3645,9 @@ namespace LuaPlayer
      *
      * @return bool canResurrect
      */
-    int CanPetResurrect(lua_State* L, Player* player)
+    bool CanPetResurrect(Player* player)
     {
-        ALE::Push(L, player->CanPetResurrect());
-        return 1;
+        return player->CanPetResurrect();
     }
 
     /**
@@ -4354,12 +3657,9 @@ namespace LuaPlayer
      * @param uint32 maximum : the maximum value
      * @return uint32 randomValue : a random number between min and max
      */
-    int DoRandomRoll(lua_State* L, Player* player)
+    uint32 DoRandomRoll(Player* player, uint32 minimum, uint32 maximum)
     {
-        uint32 minimum = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 maximum = ALE::CHECKVAL<uint32>(L, 3);
-        ALE::Push(L, player->DoRandomRoll(minimum, maximum));
-        return 1;
+        return player->DoRandomRoll(minimum, maximum);
     }
 
     /**
@@ -4367,10 +3667,9 @@ namespace LuaPlayer
      *
      * @return bool isPvP
      */
-    int IsPvP(lua_State* L, Player* player)
+    bool IsPvP(Player* player)
     {
-        ALE::Push(L, player->IsPvP());
-        return 1;
+        return player->IsPvP();
     }
 
     /**
@@ -4378,10 +3677,9 @@ namespace LuaPlayer
      *
      * @return bool isFFAPvP
      */
-    int IsFFAPvP(lua_State* L, Player* player)
+    bool IsFFAPvP(Player* player)
     {
-        ALE::Push(L, player->IsFFAPvP());
-        return 1;
+        return player->IsFFAPvP();
     }
 
     /**
@@ -4389,10 +3687,9 @@ namespace LuaPlayer
      *
      * @return bool isUsingLfg
      */
-    int IsUsingLfg(lua_State* L, Player* player)
+    bool IsUsingLfg(Player* player)
     {
-        ALE::Push(L, player->IsUsingLfg());
-        return 1;
+        return player->IsUsingLfg();
     }
 
     /**
@@ -4400,10 +3697,9 @@ namespace LuaPlayer
      *
      * @return bool inRandomLfgDungeon
      */
-    int InRandomLfgDungeon(lua_State* L, Player* player)
+    bool InRandomLfgDungeon(Player* player)
     {
-        ALE::Push(L, player->inRandomLfgDungeon());
-        return 1;
+        return player->inRandomLfgDungeon();
     }
 
     /**
@@ -4412,11 +3708,9 @@ namespace LuaPlayer
      * @param [Object] questGiver : the quest giver object
      * @return bool canInteract
      */
-    int CanInteractWithQuestGiver(lua_State* L, Player* player)
+    bool CanInteractWithQuestGiver(Player* player, Object* questGiver)
     {
-        Object* questGiver = ALE::CHECKOBJ<Object>(L, 2);
-        ALE::Push(L, player->CanInteractWithQuestGiver(questGiver));
-        return 1;
+        return player->CanInteractWithQuestGiver(questGiver);
     }
 
     /**
@@ -4425,11 +3719,9 @@ namespace LuaPlayer
      * @param [Quest] quest : the quest to check
      * @return bool canSeeStartQuest
      */
-    int CanSeeStartQuest(lua_State* L, Player* player)
+    bool CanSeeStartQuest(Player* player, Quest const* quest)
     {
-        Quest const* quest = ALE::CHECKOBJ<Quest>(L, 2);
-        ALE::Push(L, player->CanSeeStartQuest(quest));
-        return 1;
+        return player->CanSeeStartQuest(quest);
     }
 
     /**
@@ -4437,10 +3729,9 @@ namespace LuaPlayer
      *
      * @return bool hasExistingPet
      */
-    int IsExistPet(lua_State* L, Player* player)
+    bool IsExistPet(Player* player)
     {
-        ALE::Push(L, player->IsExistPet());
-        return 1;
+        return player->IsExistPet();
     }
 
     /**
@@ -4450,22 +3741,19 @@ namespace LuaPlayer
      * @param bool msg : whether to send error messages
      * @return bool canTakeQuest
      */
-    int CanTakeQuest(lua_State* L, Player* player)
+    bool CanTakeQuest(Player* player, Quest const* quest, sol::optional<bool> msgArg)
     {
-        Quest const* quest = ALE::CHECKOBJ<Quest>(L, 2);
-        bool msg = ALE::CHECKVAL<bool>(L, 3, true);
-        ALE::Push(L, player->CanTakeQuest(quest, msg));
-        return 1;
+        bool msg = msgArg.value_or(true);
+        return player->CanTakeQuest(quest, msg);
     }
 
     /**
      * Resets the [Player]'s pet talents.
      *
      */
-    int ResetPetTalents(lua_State* /*L*/, Player* player)
+    void ResetPetTalents(Player* player)
     {
         player->ResetPetTalents();
-        return 0;
     }
 
     /**
@@ -4475,12 +3763,10 @@ namespace LuaPlayer
      * @param bool msg : whether to send error messages
      * @return bool canAddQuest
      */
-    int CanAddQuest(lua_State* L, Player* player)
+    bool CanAddQuest(Player* player, Quest const* quest, sol::optional<bool> msgArg)
     {
-        Quest const* quest = ALE::CHECKOBJ<Quest>(L, 2);
-        bool msg = ALE::CHECKVAL<bool>(L, 3, true);
-        ALE::Push(L, player->CanAddQuest(quest, msg));
-        return 1;
+        bool msg = msgArg.value_or(true);
+        return player->CanAddQuest(quest, msg);
     }
 
     /**
@@ -4491,13 +3777,9 @@ namespace LuaPlayer
      * @param uint8 newfacialhair : the new facial hair
      * @return uint32 cost : the cost in copper
      */
-    int GetBarberShopCost(lua_State* L, Player* player)
+    uint32 GetBarberShopCost(Player* player, uint8 newhairstyle, uint8 newhaircolor, uint8 newfacialhair)
     {
-        uint8 newhairstyle = ALE::CHECKVAL<uint8>(L, 2);
-        uint8 newhaircolor = ALE::CHECKVAL<uint8>(L, 3);
-        uint8 newfacialhair = ALE::CHECKVAL<uint8>(L, 4);
-        ALE::Push(L, player->GetBarberShopCost(newhairstyle, newhaircolor, newfacialhair));
-        return 1;
+        return player->GetBarberShopCost(newhairstyle, newhaircolor, newfacialhair);
     }
 
     /**
@@ -4506,11 +3788,10 @@ namespace LuaPlayer
      * @param [WorldObject] target : the target to check sight range for (optional)
      * @return float sightRange
      */
-    int GetSightRange(lua_State* L, Player* player)
+    float GetSightRange(Player* player, sol::optional<WorldObjectRef> targetArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, false);
-        ALE::Push(L, player->GetSightRange(target));
-        return 1;
+        WorldObject* target = targetArg ? targetArg->Resolve() : nullptr;
+        return player->GetSightRange(target);
     }
 
     /**
@@ -4523,16 +3804,11 @@ namespace LuaPlayer
      * @param bool noQuestBonus : whether to skip quest bonus
      * @return float reputationGain
      */
-    int CalculateReputationGain(lua_State* L, Player* player)
+    float CalculateReputationGain(Player* player, uint32 source, uint32 creatureOrQuestLevel, float rep, uint32 faction, sol::optional<bool> noQuestBonusArg)
     {
-        uint32 source = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 creatureOrQuestLevel = ALE::CHECKVAL<uint32>(L, 3);
-        float rep = ALE::CHECKVAL<float>(L, 4);
-        uint32 faction = ALE::CHECKVAL<uint32>(L, 5);
-        bool noQuestBonus = ALE::CHECKVAL<bool>(L, 6, false);
-        
-        ALE::Push(L, player->CalculateReputationGain((ReputationSource)source, creatureOrQuestLevel, rep, faction, noQuestBonus));
-        return 1;
+        bool noQuestBonus = noQuestBonusArg.value_or(false);
+
+        return player->CalculateReputationGain((ReputationSource)source, creatureOrQuestLevel, rep, faction, noQuestBonus);
     }
 
     /**
@@ -4542,21 +3818,17 @@ namespace LuaPlayer
      * @param uint32 damage : damage amount
      * @return uint32 actualDamage : the actual damage dealt
      */
-    int EnvironmentalDamage(lua_State* L, Player* player)
+    uint32 EnvironmentalDamage(Player* player, uint32 type, uint32 damage)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 damage = ALE::CHECKVAL<uint32>(L, 3);
-        ALE::Push(L, player->EnvironmentalDamage((EnviromentalDamage)type, damage));
-        return 1;
+        return player->EnvironmentalDamage((EnviromentalDamage)type, damage);
     }
 
     /**
      * Initializes taxi nodes for the [Player]'s current level.
      */
-    int InitTaxiNodesForLevel(lua_State* /*L*/, Player* player)
+    void InitTaxiNodesForLevel(Player* player)
     {
         player->InitTaxiNodesForLevel();
-        return 0;
     }
 
     /**
@@ -4566,13 +3838,9 @@ namespace LuaPlayer
      * @param uint32 talentId : ID of the talent to learn
      * @param uint32 talentRank : rank of the talent to learn
      */
-    int LearnPetTalent(lua_State* L, Player* player)
+    void LearnPetTalent(Player* player, ObjectGuid petGuid, uint32 talentId, uint32 talentRank)
     {
-        ObjectGuid petGuid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        uint32 talentId = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 talentRank = ALE::CHECKVAL<uint32>(L, 4);
         player->LearnPetTalent(petGuid, talentId, talentRank);
-        return 0;
     }
 
     /**
@@ -4581,11 +3849,9 @@ namespace LuaPlayer
      * @param uint32 bitIndex : the title bit index to check
      * @return bool hasTitle
      */
-    int HasTitleByIndex(lua_State* L, Player* player)
+    bool HasTitleByIndex(Player* player, uint32 bitIndex)
     {
-        uint32 bitIndex = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, player->HasTitle(bitIndex));
-        return 1;
+        return player->HasTitle(bitIndex);
     }
 
     /**
@@ -4594,11 +3860,9 @@ namespace LuaPlayer
      * @param [WorldObject] target : the target to check distance to
      * @return bool isAtGroupRewardDistance
      */
-    int IsAtGroupRewardDistance(lua_State* L, Player* player)
+    bool IsAtGroupRewardDistance(Player* player, WorldObject const* target)
     {
-        WorldObject const* target = ALE::CHECKOBJ<WorldObject>(L, 2);
-        ALE::Push(L, player->IsAtGroupRewardDistance(target));
-        return 1;
+        return player->IsAtGroupRewardDistance(target);
     }
 
     /**
@@ -4607,11 +3871,9 @@ namespace LuaPlayer
      * @param [WorldObject] target : the target to check distance to
      * @return bool isAtLootRewardDistance
      */
-    int IsAtLootRewardDistance(lua_State* L, Player* player)
+    bool IsAtLootRewardDistance(Player* player, WorldObject const* target)
     {
-        WorldObject const* target = ALE::CHECKOBJ<WorldObject>(L, 2);
-        ALE::Push(L, player->IsAtLootRewardDistance(target));
-        return 1;
+        return player->IsAtLootRewardDistance(target);
     }
 
     /**
@@ -4619,11 +3881,9 @@ namespace LuaPlayer
      *
      * @param uint32 questId : the quest entry ID to abandon
      */
-    int AbandonQuest(lua_State* L, Player* player)
+    void AbandonQuest(Player* player, uint32 questId)
     {
-        uint32 questId = ALE::CHECKVAL<uint32>(L, 2);
         player->AbandonQuest(questId);
-        return 0;
     }
 
     /**
@@ -4631,10 +3891,9 @@ namespace LuaPlayer
      *
      * @return bool canTameExoticPets : `true` if the player can tame exotic pets, `false` otherwise
      */
-    int CanTameExoticPets(lua_State* L, Player* player)
+    bool CanTameExoticPets(Player* player)
     {
-        ALE::Push(L, player->CanTameExoticPets());
-        return 1;
+        return player->CanTameExoticPets();
     }
 
     /**
@@ -4642,10 +3901,9 @@ namespace LuaPlayer
      *
      * @return uint32 proficiencyFlags : bitmask of weapon proficiencies
      */
-    int GetWeaponProficiency(lua_State* L, Player* player)
+    uint32 GetWeaponProficiency(Player* player)
     {
-        ALE::Push(L, player->GetWeaponProficiency());
-        return 1;
+        return player->GetWeaponProficiency();
     }
 
     /**
@@ -4653,10 +3911,9 @@ namespace LuaPlayer
      *
      * @return uint32 petNumber : the temporary unsummoned pet number
      */
-    int GetTemporaryUnsummonedPetNumber(lua_State* L, Player* player)
+    uint32 GetTemporaryUnsummonedPetNumber(Player* player)
     {
-        ALE::Push(L, player->GetTemporaryUnsummonedPetNumber());
-        return 1;
+        return player->GetTemporaryUnsummonedPetNumber();
     }
 
     /**
@@ -4664,10 +3921,9 @@ namespace LuaPlayer
      *
      * @return uint32 proficiencyFlags : bitmask of armor proficiencies
      */
-    int GetArmorProficiency(lua_State* L, Player* player)
+    uint32 GetArmorProficiency(Player* player)
     {
-        ALE::Push(L, player->GetArmorProficiency());
-        return 1;
+        return player->GetArmorProficiency();
     }
 
     /**
@@ -4675,11 +3931,9 @@ namespace LuaPlayer
      *
      * @param uint32 petNumber : the pet number to set
      */
-    int SetTemporaryUnsummonedPetNumber(lua_State* L, Player* player)
+    void SetTemporaryUnsummonedPetNumber(Player* player, uint32 petNumber)
     {
-        uint32 petNumber = ALE::CHECKVAL<uint32>(L, 2);
         player->SetTemporaryUnsummonedPetNumber(petNumber);
-        return 0;
     }
 
     /**
@@ -4687,21 +3941,18 @@ namespace LuaPlayer
      *
      * @param uint32 flag : weapon proficiency flag to add
      */
-    int AddWeaponProficiency(lua_State* L, Player* player)
+    void AddWeaponProficiency(Player* player, uint32 flag)
     {
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 2);
         player->AddWeaponProficiency(flag);
-        return 0;
     }
 
     /**
      * Resummons the [Player]'s pet if it was temporarily unsummoned.
      *
      */
-    int ResummonPetTemporaryUnSummonedIfAny(lua_State* /*L*/, Player* player)
+    void ResummonPetTemporaryUnSummonedIfAny(Player* player)
     {
         player->ResummonPetTemporaryUnSummonedIfAny();
-        return 0;
     }
 
     /**
@@ -4709,11 +3960,9 @@ namespace LuaPlayer
      *
      * @param uint32 flag : armor proficiency flag to add
      */
-    int AddArmorProficiency(lua_State* L, Player* player)
+    void AddArmorProficiency(Player* player, uint32 flag)
     {
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 2);
         player->AddArmorProficiency(flag);
-        return 0;
     }
 
     /**
@@ -4722,10 +3971,9 @@ namespace LuaPlayer
      *
      * @return bool isPetNeedBeTemporaryUnsummoned : `true` if the pet needs to be temporarily unsummoned, `false` otherwise
      */
-    int IsPetNeedBeTemporaryUnsummoned(lua_State* L, Player* player)
+    bool IsPetNeedBeTemporaryUnsummoned(Player* player)
     {
-        ALE::Push(L, player->IsPetNeedBeTemporaryUnsummoned());
-        return 1;
+        return player->IsPetNeedBeTemporaryUnsummoned();
     }
 
     /**
@@ -4733,20 +3981,17 @@ namespace LuaPlayer
      *
      * @param uint32 itemEntry : ammo item entry ID
      */
-    int SetAmmo(lua_State* L, Player* player)
+    void SetAmmo(Player* player, uint32 itemEntry)
     {
-        uint32 itemEntry = ALE::CHECKVAL<uint32>(L, 2);
         player->SetAmmo(itemEntry);
-        return 0;
     }
 
     /**
      * Removes the [Player]'s ammo.
      */
-    int RemoveAmmo(lua_State* /*L*/, Player* player)
+    void RemoveAmmo(Player* player)
     {
         player->RemoveAmmo();
-        return 0;
     }
 
     /**
@@ -4754,10 +3999,9 @@ namespace LuaPlayer
      *
      * @return float ammoDPS : damage per second from ammo
      */
-    int GetAmmoDPS(lua_State* L, Player* player)
+    float GetAmmoDPS(Player* player)
     {
-        ALE::Push(L, player->GetAmmoDPS());
-        return 1;
+        return player->GetAmmoDPS();
     }
 
     /**
@@ -4766,11 +4010,9 @@ namespace LuaPlayer
      * @param uint32 spellId : the spell ID to check
      * @return bool canResummon : `true` if the player can resummon the pet, `false` otherwise
      */
-    int CanResummonPet(lua_State* L, Player* player)
+    bool CanResummonPet(Player* player, uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, player->CanResummonPet(spellId));
-        return 1;
+        return player->CanResummonPet(spellId);
     }
 
     /**
@@ -4778,10 +4020,9 @@ namespace LuaPlayer
      *
      * @return [Item] shield : the equipped shield or nil
      */
-    int GetShield(lua_State* L, Player* player)
+    Item* GetShield(Player* player)
     {
-        ALE::Push(L, player->GetShield());
-        return 1;
+        return player->GetShield();
     }
 
     /**
@@ -4789,10 +4030,9 @@ namespace LuaPlayer
      *
      * @return uint32 petNumber : the last pet number
      */
-    int GetLastPetNumber(lua_State* L, Player* player)
+    uint32 GetLastPetNumber(Player* player)
     {
-        ALE::Push(L, player->GetLastPetNumber());
-        return 1;
+        return player->GetLastPetNumber();
     }
 
     /**
@@ -4800,10 +4040,9 @@ namespace LuaPlayer
      *
      * @return bool canTeleport
      */
-    int CanTeleport(lua_State* L, Player* player)
+    bool CanTeleport(Player* player)
     {
-        ALE::Push(L, player->CanTeleport());
-        return 1;
+        return player->CanTeleport();
     }
 
     /**
@@ -4811,11 +4050,9 @@ namespace LuaPlayer
      *
      * @param uint32 petNumber : the pet number to set
      */
-    int SetLastPetNumber(lua_State* L, Player* player)
+    void SetLastPetNumber(Player* player, uint32 petNumber)
     {
-        uint32 petNumber = ALE::CHECKVAL<uint32>(L, 2);
         player->SetLastPetNumber(petNumber);
-        return 0;
     }
 
     /**
@@ -4823,11 +4060,9 @@ namespace LuaPlayer
      *
      * @param bool canTeleport : true to allow teleportation, false to disallow
      */
-    int SetCanTeleport(lua_State* L, Player* player)
+    void SetCanTeleport(Player* player, bool canTeleport)
     {
-        bool canTeleport = ALE::CHECKVAL<bool>(L, 2);
         player->SetCanTeleport(canTeleport);
-        return 0;
     }
 
     /**
@@ -4835,10 +4070,9 @@ namespace LuaPlayer
      *
      * @return uint32 petSpell : the pet spell ID
      */
-    int GetLastPetSpell(lua_State* L, Player* player)
+    uint32 GetLastPetSpell(Player* player)
     {
-        ALE::Push(L, player->GetLastPetSpell());
-        return 1;
+        return player->GetLastPetSpell();
     }
 
     /**
@@ -4846,10 +4080,9 @@ namespace LuaPlayer
      *
      * @return uint32 runesState : current runes state bitmask
      */
-    int GetRunesState(lua_State* L, Player* player)
+    uint8 GetRunesState(Player* player)
     {
-        ALE::Push(L, player->GetRunesState());
-        return 1;
+        return player->GetRunesState();
     }
 
     /**
@@ -4857,11 +4090,9 @@ namespace LuaPlayer
      *
      * @param uint32 petSpell : the pet spell ID to set
      */
-    int SetLastPetSpell(lua_State* L, Player* player)
+    void SetLastPetSpell(Player* player, uint32 petSpell)
     {
-        uint32 petSpell = ALE::CHECKVAL<uint32>(L, 2);
         player->SetLastPetSpell(petSpell);
-        return 0;
     }
 
     /**
@@ -4869,10 +4100,9 @@ namespace LuaPlayer
      *
      * @return bool isSpectator
      */
-    int IsSpectator(lua_State* L, Player* player)
+    bool IsSpectator(Player* player)
     {
-        ALE::Push(L, player->IsSpectator());
-        return 1;
+        return player->IsSpectator();
     }
 
     /**
@@ -4880,11 +4110,9 @@ namespace LuaPlayer
      *
      * @param bool isSpectator : true to set as spectator, false otherwise
      */
-    int SetIsSpectator(lua_State* L, Player* player)
+    void SetIsSpectator(Player* player, bool isSpectator)
     {
-        bool isSpectator = ALE::CHECKVAL<bool>(L, 2);
         player->SetIsSpectator(isSpectator);
-        return 0;
     }
 
     /**
@@ -4892,10 +4120,9 @@ namespace LuaPlayer
      *
      * @return bool canSeeDKPet
      */
-    int CanSeeDKPet(lua_State* L, Player* player)
+    bool CanSeeDKPet(Player* player)
     {
-        ALE::Push(L, player->CanSeeDKPet());
-        return 1;
+        return player->CanSeeDKPet();
     }
 
     /**
@@ -4903,10 +4130,9 @@ namespace LuaPlayer
      *
      * @return [WorldObject] viewpoint : the object the player is viewing from
      */
-    int GetViewpoint(lua_State* L, Player* player)
+    WorldObject* GetViewpoint(Player* player)
     {
-        ALE::Push(L, player->GetViewpoint());
-        return 1;
+        return player->GetViewpoint();
     }
 
     /**
@@ -4914,11 +4140,9 @@ namespace LuaPlayer
      *
      * @param bool show : `true` to show DK pets, `false` to hide them
      */
-    int SetShowDKPet(lua_State* L, Player* player)
+    void SetShowDKPet(Player* player, bool show)
     {
-        bool show = ALE::CHECKVAL<bool>(L, 2);
         player->SetShowDKPet(show);
-        return 0;
     }
 
     /**
@@ -4926,21 +4150,18 @@ namespace LuaPlayer
      *
      * @param [WorldObject] target : the object to view from
      */
-    int SetViewpoint(lua_State* L, Player* player)
+    void SetViewpoint(Player* player, WorldObject* target, sol::optional<bool> applyArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2);
-        bool apply = ALE::CHECKVAL<bool>(L, 3, false);
+        bool apply = applyArg.value_or(false);
         player->SetViewpoint(target, apply);
-        return 0;
     }
 
     /**
      * Toggles instant flight mode for the [Player].
      */
-    int ToggleInstantFlight(lua_State* /*L*/, Player* player)
+    void ToggleInstantFlight(Player* player)
     {
         player->ToggleInstantFlight();
-        return 0;
     }
 
     /**
@@ -4948,10 +4169,9 @@ namespace LuaPlayer
      *
      * @return uint32 creationTime : Unix timestamp of character creation
      */
-    int GetCreationTime(lua_State* L, Player* player)
+    uint32 GetCreationTime(Player* player)
     {
-        ALE::Push(L, static_cast<uint32>(player->GetCreationTime().count()));
-        return 1;
+        return static_cast<uint32>(player->GetCreationTime().count());
     }
 
     /**
@@ -4959,11 +4179,9 @@ namespace LuaPlayer
      *
      * @param uint32 creationTime : Unix timestamp to set as creation time
      */
-    int SetCreationTime(lua_State* L, Player* player)
+    void SetCreationTime(Player* player, uint32 creationTime)
     {
-        uint32 creationTime = ALE::CHECKVAL<uint32>(L, 2);
         player->SetCreationTime(Seconds(creationTime));
-        return 0;
     }
 
     /**
@@ -4971,12 +4189,11 @@ namespace LuaPlayer
      *
      * @return float dodgeChance : dodge percentage from agility stat
      */
-    int GetDodgeFromAgility(lua_State* L, Player* player)
+    float GetDodgeFromAgility(Player* player)
     {
         float diminishing, nondiminishing;
         player->GetDodgeFromAgility(diminishing, nondiminishing);
-        ALE::Push(L, diminishing + nondiminishing);
-        return 1;
+        return diminishing + nondiminishing;
     }
 
     /**
@@ -4984,10 +4201,9 @@ namespace LuaPlayer
      *
      * @return float critChance : melee crit percentage from agility stat
      */
-    int GetMeleeCritFromAgility(lua_State* L, Player* player)
+    float GetMeleeCritFromAgility(Player* player)
     {
-        ALE::Push(L, player->GetMeleeCritFromAgility());
-        return 1;
+        return player->GetMeleeCritFromAgility();
     }
 
     /**
@@ -4995,10 +4211,9 @@ namespace LuaPlayer
      *
      * @return float critChance : spell crit percentage from intellect stat
      */
-    int GetSpellCritFromIntellect(lua_State* L, Player* player)
+    float GetSpellCritFromIntellect(Player* player)
     {
-        ALE::Push(L, player->GetSpellCritFromIntellect());
-        return 1;
+        return player->GetSpellCritFromIntellect();
     }
 
     /**
@@ -5007,13 +4222,12 @@ namespace LuaPlayer
      * @param uint32 slot : inventory slot number
      * @return [Item] item : the item in the specified slot or nil
      */
-    int GetInventoryItem(lua_State* L, Player* player)
+    Item* GetInventoryItem(Player* player, uint32 slot)
     {
-        uint32 slot = ALE::CHECKVAL<uint32>(L, 2);
         if (slot >= INVENTORY_SLOT_ITEM_END)
-            return 1;
-        ALE::Push(L, player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot));
-        return 1;
+            return nullptr;
+
+        return player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot);
     }
 
     /**
@@ -5022,13 +4236,12 @@ namespace LuaPlayer
      * @param uint32 slot : bank slot number
      * @return [Item] item : the item in the specified bank slot or nil
      */
-    int GetBankItem(lua_State* L, Player* player)
+    Item* GetBankItem(Player* player, uint32 slot)
     {
-        uint32 slot = ALE::CHECKVAL<uint32>(L, 2);
         if (slot >= BANK_SLOT_ITEM_END)
-            return 1;
-        ALE::Push(L, player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot + BANK_SLOT_ITEM_START));
-        return 1;
+            return nullptr;
+
+        return player->GetItemByPos(INVENTORY_SLOT_BAG_0, slot + BANK_SLOT_ITEM_START);
     }
 
     /**
@@ -5037,14 +4250,12 @@ namespace LuaPlayer
      * @param uint16 slot : quest log slot
      * @return uint32 questId : quest ID or 0 if slot is invalid
      */
-    int GetQuestSlotQuestId(lua_State* L, Player* player)
+    sol::optional<uint32> GetQuestSlotQuestId(Player* player, uint16 slot)
     {
-        uint16 slot = ALE::CHECKVAL<uint16>(L, 2);
         if (slot > MAX_QUEST_LOG_SIZE)
-            return 0;
+            return sol::nullopt;
 
-        ALE::Push(L, player->GetQuestSlotQuestId(slot));
-        return 1;
+        return player->GetQuestSlotQuestId(slot);
     }
 
     /**
@@ -5052,11 +4263,10 @@ namespace LuaPlayer
      *
      * @param bool activate = false : true to enable flying, false to disable
      */
-    int SetCanFly(lua_State* L, Player* player)
+    void SetCanFly(Player* player, sol::optional<bool> activateArg)
     {
-        bool activate = ALE::CHECKVAL<bool>(L, 2, false);
+        bool activate = activateArg.value_or(false);
         player->SetCanFly(activate);
-        return 0;
     }
 
     /**
@@ -5097,15 +4307,11 @@ namespace LuaPlayer
      *
      */
 
-    int ApplyRatingMod(lua_State* L, Player* player)
+    void ApplyRatingMod(Player* player, int32 stat, float value, sol::optional<bool> applyArg)
     {
-        int32 stat = ALE::CHECKVAL<int32>(L, 2);
-
-        float value = ALE::CHECKVAL<float>(L, 3);
-        bool apply = ALE::CHECKVAL<bool>(L, 4, false);
+        bool apply = applyArg.value_or(false);
 
         player->ApplyRatingMod(CombatRating(stat), value, apply);
-        return 0;
     }
 
     /**
@@ -5114,24 +4320,12 @@ namespace LuaPlayer
      * @param uint32 nodeId
      * @return bool known
      */
-    int HasKnownTaxiNode(lua_State* L, Player* player)
+    bool HasKnownTaxiNode(Player* player, uint32 nodeId)
     {
-        if (!player)
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
-
-        uint32 nodeId = ALE::CHECKVAL<uint32>(L, 2);
-
         if (nodeId == 0)
-        {
-            ALE::Push(L, false);
-            return 1;
-        }
+            return false;
 
-        ALE::Push(L, player->m_taxi.IsTaximaskNodeKnown(nodeId));
-        return 1;
+        return player->m_taxi.IsTaximaskNodeKnown(nodeId);
     }
 
     /**
@@ -5139,30 +4333,26 @@ namespace LuaPlayer
      *
      * @return bool isBot
      */
-    int IsBot(lua_State* L, Player* player)
+    bool IsBot(Player* player)
     {
     #if defined(MOD_PLAYERBOTS)
-        ALE::Push(L, player->GetSession()->IsBot());
+        return player->GetSession()->IsBot();
     #else
         (void)player;
-        ALE::Push(L, false);
+        return false;
     #endif
-        return 1;
     }
-    
+
     /**
      * Returns the [Player]s spent talent points in each talent tree for the active spec
      *
      * @return uint8 tree1, uint8 tree2, uint8 tree3
      */
-    int GetTalentTreePoints(lua_State* L, Player* player)
+    std::tuple<uint8, uint8, uint8> GetTalentTreePoints(Player* player)
     {
         uint8 specPoints[3] = {0, 0, 0};
         player->GetTalentTreePoints(specPoints);
-        ALE::Push(L, specPoints[0]);
-        ALE::Push(L, specPoints[1]);
-        ALE::Push(L, specPoints[2]);
-        return 3;
+        return std::tuple<uint8, uint8, uint8>(specPoints[0], specPoints[1], specPoints[2]);
     }
 
     /**
@@ -5170,11 +4360,348 @@ namespace LuaPlayer
      *
      * @return uint8 treeIndex
      */
-    int GetMostPointsTalentTree(lua_State* L, Player* player)
+    uint8 GetMostPointsTalentTree(Player* player)
     {
-        ALE::Push(L, player->GetMostPointsTalentTree());
-        return 1;
+        return player->GetMostPointsTalentTree();
     }
-};
-#endif
-
+}
+void RegisterPlayerMethods(sol::state& lua)
+{
+    sol::usertype<PlayerRef> type = ALEBind::NewHandleType<PlayerRef, UnitRef, WorldObjectRef, ObjectRef>(lua, "Player");
+
+    type["GetInventoryFreeSlots"              ] = ALEBind::Method(&LuaPlayer::GetInventoryFreeSlots);
+    type["GetBankFreeSlots"                   ] = ALEBind::Method(&LuaPlayer::GetBankFreeSlots);
+    type["GetSelection"                       ] = ALEBind::Method(&LuaPlayer::GetSelection);
+    type["GetGMRank"                          ] = ALEBind::Method(&LuaPlayer::GetGMRank);
+    type["GetGuildId"                         ] = ALEBind::Method(&LuaPlayer::GetGuildId);
+    type["GetCoinage"                         ] = ALEBind::Method(&LuaPlayer::GetCoinage);
+    type["GetTeam"                            ] = ALEBind::Method(&LuaPlayer::GetTeam);
+    type["GetItemCount"                       ] = ALEBind::Method(&LuaPlayer::GetItemCount);
+    type["GetGroup"                           ] = ALEBind::Method(&LuaPlayer::GetGroup);
+    type["GetGuild"                           ] = ALEBind::Method(&LuaPlayer::GetGuild);
+    type["GetAccountId"                       ] = ALEBind::Method(&LuaPlayer::GetAccountId);
+    type["GetAccountName"                     ] = ALEBind::Method(&LuaPlayer::GetAccountName);
+    type["GetCompletedQuestsCount"            ] = ALEBind::Method(&LuaPlayer::GetCompletedQuestsCount);
+    type["GetArenaPoints"                     ] = ALEBind::Method(&LuaPlayer::GetArenaPoints);
+    type["GetHonorPoints"                     ] = ALEBind::Method(&LuaPlayer::GetHonorPoints);
+    type["GetTodayHonorPoints"                ] = ALEBind::Method(&LuaPlayer::GetTodayHonorPoints);
+    type["GetYesterdayHonorPoints"            ] = ALEBind::Method(&LuaPlayer::GetYesterdayHonorPoints);
+    type["GetLifetimeKills"                   ] = ALEBind::Method(&LuaPlayer::GetLifetimeKills);
+    type["GetTodayKills"                      ] = ALEBind::Method(&LuaPlayer::GetTodayKills);
+    type["GetYesterdayKills"                  ] = ALEBind::Method(&LuaPlayer::GetYesterdayKills);
+    type["GetPlayerIP"                        ] = ALEBind::Method(&LuaPlayer::GetPlayerIP);
+    type["GetLevelPlayedTime"                 ] = ALEBind::Method(&LuaPlayer::GetLevelPlayedTime);
+    type["GetTotalPlayedTime"                 ] = ALEBind::Method(&LuaPlayer::GetTotalPlayedTime);
+    type["GetItemByPos"                       ] = ALEBind::Method(&LuaPlayer::GetItemByPos);
+    type["GetItemByEntry"                     ] = ALEBind::Method(&LuaPlayer::GetItemByEntry);
+    type["GetItemByGUID"                      ] = ALEBind::Method(&LuaPlayer::GetItemByGUID);
+    type["GetMailCount"                       ] = ALEBind::Method(&LuaPlayer::GetMailCount);
+    type["GetMailItem"                        ] = ALEBind::Method(&LuaPlayer::GetMailItem);
+    type["GetReputation"                      ] = ALEBind::Method(&LuaPlayer::GetReputation);
+    type["GetEquippedItemBySlot"              ] = ALEBind::Method(&LuaPlayer::GetEquippedItemBySlot);
+    type["GetQuestLevel"                      ] = ALEBind::Method(&LuaPlayer::GetQuestLevel);
+    type["GetChatTag"                         ] = ALEBind::Method(&LuaPlayer::GetChatTag);
+    type["GetRestBonus"                       ] = ALEBind::Method(&LuaPlayer::GetRestBonus);
+    type["GetPhaseMaskForSpawn"               ] = ALEBind::Method(&LuaPlayer::GetPhaseMaskForSpawn);
+    type["GetAchievementPoints"               ] = ALEBind::Method(&LuaPlayer::GetAchievementPoints);
+    type["GetCompletedAchievementsCount"      ] = ALEBind::Method(&LuaPlayer::GetCompletedAchievementsCount);
+    type["GetReqKillOrCastCurrentCount"       ] = ALEBind::Method(&LuaPlayer::GetReqKillOrCastCurrentCount);
+    type["GetQuestStatus"                     ] = ALEBind::Method(&LuaPlayer::GetQuestStatus);
+    type["GetInGameTime"                      ] = ALEBind::Method(&LuaPlayer::GetInGameTime);
+    type["GetComboPoints"                     ] = ALEBind::Method(&LuaPlayer::GetComboPoints);
+    type["GetComboTarget"                     ] = ALEBind::Method(&LuaPlayer::GetComboTarget);
+    type["GetGuildName"                       ] = ALEBind::Method(&LuaPlayer::GetGuildName);
+    type["GetFreeTalentPoints"                ] = ALEBind::Method(&LuaPlayer::GetFreeTalentPoints);
+    type["GetActiveSpec"                      ] = ALEBind::Method(&LuaPlayer::GetActiveSpec);
+    type["GetSpecsCount"                      ] = ALEBind::Method(&LuaPlayer::GetSpecsCount);
+    type["GetSpellCooldownDelay"              ] = ALEBind::Method(&LuaPlayer::GetSpellCooldownDelay);
+    type["GetGuildRank"                       ] = ALEBind::Method(&LuaPlayer::GetGuildRank);
+    type["GetDifficulty"                      ] = ALEBind::Method(&LuaPlayer::GetDifficulty);
+    type["GetHealthBonusFromStamina"          ] = ALEBind::Method(&LuaPlayer::GetHealthBonusFromStamina);
+    type["GetManaBonusFromIntellect"          ] = ALEBind::Method(&LuaPlayer::GetManaBonusFromIntellect);
+    type["GetMaxSkillValue"                   ] = ALEBind::Method(&LuaPlayer::GetMaxSkillValue);
+    type["GetPureMaxSkillValue"               ] = ALEBind::Method(&LuaPlayer::GetPureMaxSkillValue);
+    type["GetSkillValue"                      ] = ALEBind::Method(&LuaPlayer::GetSkillValue);
+    type["GetBaseSkillValue"                  ] = ALEBind::Method(&LuaPlayer::GetBaseSkillValue);
+    type["GetPureSkillValue"                  ] = ALEBind::Method(&LuaPlayer::GetPureSkillValue);
+    type["GetSkillPermBonusValue"             ] = ALEBind::Method(&LuaPlayer::GetSkillPermBonusValue);
+    type["GetSkillTempBonusValue"             ] = ALEBind::Method(&LuaPlayer::GetSkillTempBonusValue);
+    type["GetReputationRank"                  ] = ALEBind::Method(&LuaPlayer::GetReputationRank);
+    type["GetDrunkValue"                      ] = ALEBind::Method(&LuaPlayer::GetDrunkValue);
+    type["GetBattlegroundId"                  ] = ALEBind::Method(&LuaPlayer::GetBattlegroundId);
+    type["GetBattlegroundTypeId"              ] = ALEBind::Method(&LuaPlayer::GetBattlegroundTypeId);
+    type["GetXP"                              ] = ALEBind::Method(&LuaPlayer::GetXP);
+    type["GetXPRestBonus"                     ] = ALEBind::Method(&LuaPlayer::GetXPRestBonus);
+    type["GetGroupInvite"                     ] = ALEBind::Method(&LuaPlayer::GetGroupInvite);
+    type["GetSubGroup"                        ] = ALEBind::Method(&LuaPlayer::GetSubGroup);
+    type["GetNextRandomRaidMember"            ] = ALEBind::Method(&LuaPlayer::GetNextRandomRaidMember);
+    type["GetOriginalGroup"                   ] = ALEBind::Method(&LuaPlayer::GetOriginalGroup);
+    type["GetOriginalSubGroup"                ] = ALEBind::Method(&LuaPlayer::GetOriginalSubGroup);
+    type["GetChampioningFaction"              ] = ALEBind::Method(&LuaPlayer::GetChampioningFaction);
+    type["GetLatency"                         ] = ALEBind::Method(&LuaPlayer::GetLatency);
+    type["GetDbLocaleIndex"                   ] = ALEBind::Method(&LuaPlayer::GetDbLocaleIndex);
+    type["GetDbcLocale"                       ] = ALEBind::Method(&LuaPlayer::GetDbcLocale);
+    type["GetCorpse"                          ] = ALEBind::Method(&LuaPlayer::GetCorpse);
+    type["GetGossipTextId"                    ] = ALEBind::Method(&LuaPlayer::GetGossipTextId);
+    type["GetQuestRewardStatus"               ] = ALEBind::Method(&LuaPlayer::GetQuestRewardStatus);
+    type["GetShieldBlockValue"                ] = ALEBind::Method(&LuaPlayer::GetShieldBlockValue);
+    type["GetPlayerSettingValue"              ] = ALEBind::Method(&LuaPlayer::GetPlayerSettingValue);
+    type["GetTrader"                          ] = ALEBind::Method(&LuaPlayer::GetTrader);
+    type["GetBonusTalentCount"                ] = ALEBind::Method(&LuaPlayer::GetBonusTalentCount);
+    type["GetKnownTaxiNodes"                  ] = ALEBind::Method(&LuaPlayer::GetKnownTaxiNodes);
+    type["GetPet"                             ] = ALEBind::Method(&LuaPlayer::GetPet);
+    type["GetTemporaryUnsummonedPetNumber"    ] = ALEBind::Method(&LuaPlayer::GetTemporaryUnsummonedPetNumber);
+    type["GetLastPetNumber"                   ] = ALEBind::Method(&LuaPlayer::GetLastPetNumber);
+    type["GetLastPetSpell"                    ] = ALEBind::Method(&LuaPlayer::GetLastPetSpell);
+    type["GetQuestSlotQuestId"                ] = ALEBind::Method(&LuaPlayer::GetQuestSlotQuestId);
+    type["GetTalentTreePoints"                ] = ALEBind::Method(&LuaPlayer::GetTalentTreePoints);
+    type["GetMostPointsTalentTree"            ] = ALEBind::Method(&LuaPlayer::GetMostPointsTalentTree);
+    type["SetTemporaryUnsummonedPetNumber"    ] = ALEBind::Method(&LuaPlayer::SetTemporaryUnsummonedPetNumber);
+    type["SetLastPetNumber"                   ] = ALEBind::Method(&LuaPlayer::SetLastPetNumber);
+    type["SetLastPetSpell"                    ] = ALEBind::Method(&LuaPlayer::SetLastPetSpell);
+    type["SetShowDKPet"                       ] = ALEBind::Method(&LuaPlayer::SetShowDKPet);
+    type["AdvanceSkillsToMax"                 ] = ALEBind::Method(&LuaPlayer::AdvanceSkillsToMax);
+    type["AdvanceSkill"                       ] = ALEBind::Method(&LuaPlayer::AdvanceSkill);
+    type["AdvanceAllSkills"                   ] = ALEBind::Method(&LuaPlayer::AdvanceAllSkills);
+    type["AddLifetimeKills"                   ] = ALEBind::Method(&LuaPlayer::AddLifetimeKills);
+    type["SetCoinage"                         ] = ALEBind::Method(&LuaPlayer::SetCoinage);
+    type["SetKnownTitle"                      ] = ALEBind::Method(&LuaPlayer::SetKnownTitle);
+    type["UnsetKnownTitle"                    ] = ALEBind::Method(&LuaPlayer::UnsetKnownTitle);
+    type["SetBindPoint"                       ] = ALEBind::Method(&LuaPlayer::SetBindPoint);
+    type["SetArenaPoints"                     ] = ALEBind::Method(&LuaPlayer::SetArenaPoints);
+    type["SetHonorPoints"                     ] = ALEBind::Method(&LuaPlayer::SetHonorPoints);
+    type["SetSpellPower"                      ] = ALEBind::Method(&LuaPlayer::SetSpellPower);
+    type["SetLifetimeKills"                   ] = ALEBind::Method(&LuaPlayer::SetLifetimeKills);
+    type["SetGameMaster"                      ] = ALEBind::Method(&LuaPlayer::SetGameMaster);
+    type["SetGMChat"                          ] = ALEBind::Method(&LuaPlayer::SetGMChat);
+    type["SetKnownTaxiNodes"                  ] = ALEBind::Method(&LuaPlayer::SetKnownTaxiNodes);
+    type["SetTaxiCheat"                       ] = ALEBind::Method(&LuaPlayer::SetTaxiCheat);
+    type["SetGMVisible"                       ] = ALEBind::Method(&LuaPlayer::SetGMVisible);
+    type["SetPvPDeath"                        ] = ALEBind::Method(&LuaPlayer::SetPvPDeath);
+    type["SetAcceptWhispers"                  ] = ALEBind::Method(&LuaPlayer::SetAcceptWhispers);
+    type["SetRestBonus"                       ] = ALEBind::Method(&LuaPlayer::SetRestBonus);
+    type["SetQuestStatus"                     ] = ALEBind::Method(&LuaPlayer::SetQuestStatus);
+    type["SetReputation"                      ] = ALEBind::Method(&LuaPlayer::SetReputation);
+    type["SetFreeTalentPoints"                ] = ALEBind::Method(&LuaPlayer::SetFreeTalentPoints);
+    type["SetGuildRank"                       ] = ALEBind::Method(&LuaPlayer::SetGuildRank);
+    type["SetSkill"                           ] = ALEBind::Method(&LuaPlayer::SetSkill);
+    type["SetFactionForRace"                  ] = ALEBind::Method(&LuaPlayer::SetFactionForRace);
+    type["SetDrunkValue"                      ] = ALEBind::Method(&LuaPlayer::SetDrunkValue);
+    type["SetAtLoginFlag"                     ] = ALEBind::Method(&LuaPlayer::SetAtLoginFlag);
+    type["SetPlayerLock"                      ] = ALEBind::Method(&LuaPlayer::SetPlayerLock);
+    type["SetGender"                          ] = ALEBind::Method(&LuaPlayer::SetGender);
+    type["SetSheath"                          ] = ALEBind::Method(&LuaPlayer::SetSheath);
+    type["SetBonusTalentCount"                ] = ALEBind::Method(&LuaPlayer::SetBonusTalentCount);
+    type["AddBonusTalent"                     ] = ALEBind::Method(&LuaPlayer::AddBonusTalent);
+    type["RemoveBonusTalent"                  ] = ALEBind::Method(&LuaPlayer::RemoveBonusTalent);
+    type["GetHomebind"                        ] = ALEBind::Method(&LuaPlayer::GetHomebind);
+    type["GetSpells"                          ] = ALEBind::Method(&LuaPlayer::GetSpells);
+    type["GetAverageItemLevel"                ] = ALEBind::Method(&LuaPlayer::GetAverageItemLevel);
+    type["GetBarberShopCost"                  ] = ALEBind::Method(&LuaPlayer::GetBarberShopCost);
+    type["GetSightRange"                      ] = ALEBind::Method(&LuaPlayer::GetSightRange);
+    type["GetWeaponProficiency"               ] = ALEBind::Method(&LuaPlayer::GetWeaponProficiency);
+    type["GetArmorProficiency"                ] = ALEBind::Method(&LuaPlayer::GetArmorProficiency);
+    type["GetAmmoDPS"                         ] = ALEBind::Method(&LuaPlayer::GetAmmoDPS);
+    type["GetShield"                          ] = ALEBind::Method(&LuaPlayer::GetShield);
+    type["GetRunesState"                      ] = ALEBind::Method(&LuaPlayer::GetRunesState);
+    type["GetViewpoint"                       ] = ALEBind::Method(&LuaPlayer::GetViewpoint);
+    type["GetDodgeFromAgility"                ] = ALEBind::Method(&LuaPlayer::GetDodgeFromAgility);
+    type["GetMeleeCritFromAgility"            ] = ALEBind::Method(&LuaPlayer::GetMeleeCritFromAgility);
+    type["GetSpellCritFromIntellect"          ] = ALEBind::Method(&LuaPlayer::GetSpellCritFromIntellect);
+    type["GetInventoryItem"                   ] = ALEBind::Method(&LuaPlayer::GetInventoryItem);
+    type["GetBankItem"                        ] = ALEBind::Method(&LuaPlayer::GetBankItem);
+    type["GetCreationTime"                    ] = ALEBind::Method(&LuaPlayer::GetCreationTime);
+    type["SetCanFly"                          ] = ALEBind::Method(&LuaPlayer::SetCanFly);
+    type["HasTankSpec"                        ] = ALEBind::Method(&LuaPlayer::HasTankSpec);
+    type["HasMeleeSpec"                       ] = ALEBind::Method(&LuaPlayer::HasMeleeSpec);
+    type["HasCasterSpec"                      ] = ALEBind::Method(&LuaPlayer::HasCasterSpec);
+    type["HasHealSpec"                        ] = ALEBind::Method(&LuaPlayer::HasHealSpec);
+    type["IsInGroup"                          ] = ALEBind::Method(&LuaPlayer::IsInGroup);
+    type["IsInGuild"                          ] = ALEBind::Method(&LuaPlayer::IsInGuild);
+    type["IsGM"                               ] = ALEBind::Method(&LuaPlayer::IsGM);
+    type["IsImmuneToDamage"                   ] = ALEBind::Method(&LuaPlayer::IsImmuneToDamage);
+    type["IsAlliance"                         ] = ALEBind::Method(&LuaPlayer::IsAlliance);
+    type["IsHorde"                            ] = ALEBind::Method(&LuaPlayer::IsHorde);
+    type["HasTitle"                           ] = ALEBind::Method(&LuaPlayer::HasTitle);
+    type["HasItem"                            ] = ALEBind::Method(&LuaPlayer::HasItem);
+    type["Teleport"                           ] = ALEBind::Method(&LuaPlayer::Teleport);
+    type["AddItem"                            ] = ALEBind::Method(&LuaPlayer::AddItem);
+    type["IsInArenaTeam"                      ] = ALEBind::Method(&LuaPlayer::IsInArenaTeam);
+    type["CanRewardQuest"                     ] = ALEBind::Method(&LuaPlayer::CanRewardQuest);
+    type["CanCompleteRepeatableQuest"         ] = ALEBind::Method(&LuaPlayer::CanCompleteRepeatableQuest);
+    type["CanCompleteQuest"                   ] = ALEBind::Method(&LuaPlayer::CanCompleteQuest);
+    type["CanEquipItem"                       ] = ALEBind::Method(&LuaPlayer::CanEquipItem);
+    type["IsFalling"                          ] = ALEBind::Method(&LuaPlayer::IsFalling);
+    type["ToggleAFK"                          ] = ALEBind::Method(&LuaPlayer::ToggleAFK);
+    type["ToggleDND"                          ] = ALEBind::Method(&LuaPlayer::ToggleDND);
+    type["IsAFK"                              ] = ALEBind::Method(&LuaPlayer::IsAFK);
+    type["IsDND"                              ] = ALEBind::Method(&LuaPlayer::IsDND);
+    type["IsAcceptingWhispers"                ] = ALEBind::Method(&LuaPlayer::IsAcceptingWhispers);
+    type["IsGMChat"                           ] = ALEBind::Method(&LuaPlayer::IsGMChat);
+    type["IsTaxiCheater"                      ] = ALEBind::Method(&LuaPlayer::IsTaxiCheater);
+    type["IsGMVisible"                        ] = ALEBind::Method(&LuaPlayer::IsGMVisible);
+    type["HasQuest"                           ] = ALEBind::Method(&LuaPlayer::HasQuest);
+    type["InBattlegroundQueue"                ] = ALEBind::Method(&LuaPlayer::InBattlegroundQueue);
+    type["CanSpeak"                           ] = ALEBind::Method(&LuaPlayer::CanSpeak);
+    type["HasAtLoginFlag"                     ] = ALEBind::Method(&LuaPlayer::HasAtLoginFlag);
+    type["HasAchieved"                        ] = ALEBind::Method(&LuaPlayer::HasAchieved);
+    type["GetAchievementCriteriaProgress"     ] = ALEBind::Method(&LuaPlayer::GetAchievementCriteriaProgress);
+    type["SetAchievement"                     ] = ALEBind::Method(&LuaPlayer::SetAchievement);
+    type["CanUninviteFromGroup"               ] = ALEBind::Method(&LuaPlayer::CanUninviteFromGroup);
+    type["IsRested"                           ] = ALEBind::Method(&LuaPlayer::IsRested);
+    type["IsVisibleForPlayer"                 ] = ALEBind::Method(&LuaPlayer::IsVisibleForPlayer);
+    type["HasQuestForItem"                    ] = ALEBind::Method(&LuaPlayer::HasQuestForItem);
+    type["HasQuestForGO"                      ] = ALEBind::Method(&LuaPlayer::HasQuestForGO);
+    type["CanShareQuest"                      ] = ALEBind::Method(&LuaPlayer::CanShareQuest);
+    type["HasTalent"                          ] = ALEBind::Method(&LuaPlayer::HasTalent);
+    type["IsInSameGroupWith"                  ] = ALEBind::Method(&LuaPlayer::IsInSameGroupWith);
+    type["IsInSameRaidWith"                   ] = ALEBind::Method(&LuaPlayer::IsInSameRaidWith);
+    type["IsGroupVisibleFor"                  ] = ALEBind::Method(&LuaPlayer::IsGroupVisibleFor);
+    type["HasSkill"                           ] = ALEBind::Method(&LuaPlayer::HasSkill);
+    type["IsHonorOrXPTarget"                  ] = ALEBind::Method(&LuaPlayer::IsHonorOrXPTarget);
+    type["CanParry"                           ] = ALEBind::Method(&LuaPlayer::CanParry);
+    type["CanBlock"                           ] = ALEBind::Method(&LuaPlayer::CanBlock);
+    type["CanTitanGrip"                       ] = ALEBind::Method(&LuaPlayer::CanTitanGrip);
+    type["InBattleground"                     ] = ALEBind::Method(&LuaPlayer::InBattleground);
+    type["InArena"                            ] = ALEBind::Method(&LuaPlayer::InArena);
+    type["CanUseItem"                         ] = ALEBind::Method(&LuaPlayer::CanUseItem);
+    type["HasSpell"                           ] = ALEBind::Method(&LuaPlayer::HasSpell);
+    type["HasSpellCooldown"                   ] = ALEBind::Method(&LuaPlayer::HasSpellCooldown);
+    type["IsInWater"                          ] = ALEBind::Method(&LuaPlayer::IsInWater);
+    type["CanFly"                             ] = ALEBind::Method(&LuaPlayer::CanFly);
+    type["IsMoving"                           ] = ALEBind::Method(&LuaPlayer::IsMoving);
+    type["IsFlying"                           ] = ALEBind::Method(&LuaPlayer::IsFlying);
+    type["CanPetResurrect"                    ] = ALEBind::Method(&LuaPlayer::CanPetResurrect);
+    type["IsExistPet"                         ] = ALEBind::Method(&LuaPlayer::IsExistPet);
+    type["CanTameExoticPets"                  ] = ALEBind::Method(&LuaPlayer::CanTameExoticPets);
+    type["IsPetNeedBeTemporaryUnsummoned"     ] = ALEBind::Method(&LuaPlayer::IsPetNeedBeTemporaryUnsummoned);
+    type["CanResummonPet"                     ] = ALEBind::Method(&LuaPlayer::CanResummonPet);
+    type["CanSeeDKPet"                        ] = ALEBind::Method(&LuaPlayer::CanSeeDKPet);
+    type["IsMaxLevel"                         ] = ALEBind::Method(&LuaPlayer::IsMaxLevel);
+    type["IsDailyQuestDone"                   ] = ALEBind::Method(&LuaPlayer::IsDailyQuestDone);
+    type["IsPvP"                              ] = ALEBind::Method(&LuaPlayer::IsPvP);
+    type["IsFFAPvP"                           ] = ALEBind::Method(&LuaPlayer::IsFFAPvP);
+    type["IsUsingLfg"                         ] = ALEBind::Method(&LuaPlayer::IsUsingLfg);
+    type["InRandomLfgDungeon"                 ] = ALEBind::Method(&LuaPlayer::InRandomLfgDungeon);
+    type["CanInteractWithQuestGiver"          ] = ALEBind::Method(&LuaPlayer::CanInteractWithQuestGiver);
+    type["CanSeeStartQuest"                   ] = ALEBind::Method(&LuaPlayer::CanSeeStartQuest);
+    type["CanTakeQuest"                       ] = ALEBind::Method(&LuaPlayer::CanTakeQuest);
+    type["CanAddQuest"                        ] = ALEBind::Method(&LuaPlayer::CanAddQuest);
+    type["CalculateReputationGain"            ] = ALEBind::Method(&LuaPlayer::CalculateReputationGain);
+    type["HasTitleByIndex"                    ] = ALEBind::Method(&LuaPlayer::HasTitleByIndex);
+    type["IsAtGroupRewardDistance"            ] = ALEBind::Method(&LuaPlayer::IsAtGroupRewardDistance);
+    type["IsAtLootRewardDistance"             ] = ALEBind::Method(&LuaPlayer::IsAtLootRewardDistance);
+    type["CanTeleport"                        ] = ALEBind::Method(&LuaPlayer::CanTeleport);
+    type["IsSpectator"                        ] = ALEBind::Method(&LuaPlayer::IsSpectator);
+    type["HasKnownTaxiNode"                   ] = ALEBind::Method(&LuaPlayer::HasKnownTaxiNode);
+    type["IsBot"                              ] = ALEBind::Method(&LuaPlayer::IsBot);
+    type["GossipMenuAddItem"                  ] = ALEBind::Method(&LuaPlayer::GossipMenuAddItem);
+    type["GossipSendMenu"                     ] = ALEBind::Method(&LuaPlayer::GossipSendMenu);
+    type["GossipComplete"                     ] = ALEBind::Method(&LuaPlayer::GossipComplete);
+    type["GossipClearMenu"                    ] = ALEBind::Method(&LuaPlayer::GossipClearMenu);
+    type["SendBroadcastMessage"               ] = ALEBind::Method(&LuaPlayer::SendBroadcastMessage);
+    type["SendAreaTriggerMessage"             ] = ALEBind::Method(&LuaPlayer::SendAreaTriggerMessage);
+    type["SendNotification"                   ] = ALEBind::Method(&LuaPlayer::SendNotification);
+    type["SendPacket"                         ] = ALEBind::Method(&LuaPlayer::SendPacket);
+    type["SendAddonMessage"                   ] = ALEBind::Method(&LuaPlayer::SendAddonMessage);
+    type["ModifyMoney"                        ] = ALEBind::Method(&LuaPlayer::ModifyMoney);
+    type["LearnSpell"                         ] = ALEBind::Method(&LuaPlayer::LearnSpell);
+    type["LearnTalent"                        ] = ALEBind::Method(&LuaPlayer::LearnTalent);
+    type["RunCommand"                         ] = ALEBind::Method(&LuaPlayer::RunCommand);
+    type["SetGlyph"                           ] = ALEBind::Method(&LuaPlayer::SetGlyph);
+    type["GetGlyph"                           ] = ALEBind::Method(&LuaPlayer::GetGlyph);
+    type["RemoveArenaSpellCooldowns"          ] = ALEBind::Method(&LuaPlayer::RemoveArenaSpellCooldowns);
+    type["RemoveItem"                         ] = ALEBind::Method(&LuaPlayer::RemoveItem);
+    type["RemoveLifetimeKills"                ] = ALEBind::Method(&LuaPlayer::RemoveLifetimeKills);
+    type["ResurrectPlayer"                    ] = ALEBind::Method(&LuaPlayer::ResurrectPlayer);
+    type["EquipItem"                          ] = ALEBind::Method(&LuaPlayer::EquipItem);
+    type["ResetSpellCooldown"                 ] = ALEBind::Method(&LuaPlayer::ResetSpellCooldown);
+    type["ResetTypeCooldowns"                 ] = ALEBind::Method(&LuaPlayer::ResetTypeCooldowns);
+    type["ResetAllCooldowns"                  ] = ALEBind::Method(&LuaPlayer::ResetAllCooldowns);
+    type["GiveXP"                             ] = ALEBind::Method(&LuaPlayer::GiveXP);
+    type["Say"                                ] = ALEBind::Method(&LuaPlayer::Say);
+    type["Yell"                               ] = ALEBind::Method(&LuaPlayer::Yell);
+    type["TextEmote"                          ] = ALEBind::Method(&LuaPlayer::TextEmote);
+    type["Whisper"                            ] = ALEBind::Method(&LuaPlayer::Whisper);
+    type["CompleteQuest"                      ] = ALEBind::Method(&LuaPlayer::CompleteQuest);
+    type["IncompleteQuest"                    ] = ALEBind::Method(&LuaPlayer::IncompleteQuest);
+    type["FailQuest"                          ] = ALEBind::Method(&LuaPlayer::FailQuest);
+    type["AddQuest"                           ] = ALEBind::Method(&LuaPlayer::AddQuest);
+    type["RemoveQuest"                        ] = ALEBind::Method(&LuaPlayer::RemoveQuest);
+    type["AreaExploredOrEventHappens"         ] = ALEBind::Method(&LuaPlayer::AreaExploredOrEventHappens);
+    type["GroupEventHappens"                  ] = ALEBind::Method(&LuaPlayer::GroupEventHappens);
+    type["KilledMonsterCredit"                ] = ALEBind::Method(&LuaPlayer::KilledMonsterCredit);
+    type["TalkedToCreature"                   ] = ALEBind::Method(&LuaPlayer::TalkedToCreature);
+    type["ResetPetTalents"                    ] = ALEBind::Method(&LuaPlayer::ResetPetTalents);
+    type["AddComboPoints"                     ] = ALEBind::Method(&LuaPlayer::AddComboPoints);
+    type["ClearComboPoints"                   ] = ALEBind::Method(&LuaPlayer::ClearComboPoints);
+    type["RemoveSpell"                        ] = ALEBind::Method(&LuaPlayer::RemoveSpell);
+    type["ResetTalents"                       ] = ALEBind::Method(&LuaPlayer::ResetTalents);
+    type["ResetTalentsCost"                   ] = ALEBind::Method(&LuaPlayer::ResetTalentsCost);
+    type["RemoveFromGroup"                    ] = ALEBind::Method(&LuaPlayer::RemoveFromGroup);
+    type["KillPlayer"                         ] = ALEBind::Method(&LuaPlayer::KillPlayer);
+    type["DurabilityLossAll"                  ] = ALEBind::Method(&LuaPlayer::DurabilityLossAll);
+    type["DurabilityLoss"                     ] = ALEBind::Method(&LuaPlayer::DurabilityLoss);
+    type["DurabilityPointsLoss"               ] = ALEBind::Method(&LuaPlayer::DurabilityPointsLoss);
+    type["DurabilityPointsLossAll"            ] = ALEBind::Method(&LuaPlayer::DurabilityPointsLossAll);
+    type["DurabilityPointLossForEquipSlot"    ] = ALEBind::Method(&LuaPlayer::DurabilityPointLossForEquipSlot);
+    type["DurabilityRepairAll"                ] = ALEBind::Method(&LuaPlayer::DurabilityRepairAll);
+    type["DurabilityRepair"                   ] = ALEBind::Method(&LuaPlayer::DurabilityRepair);
+    type["ModifyHonorPoints"                  ] = ALEBind::Method(&LuaPlayer::ModifyHonorPoints);
+    type["ModifyArenaPoints"                  ] = ALEBind::Method(&LuaPlayer::ModifyArenaPoints);
+    type["LeaveBattleground"                  ] = ALEBind::Method(&LuaPlayer::LeaveBattleground);
+    type["UnbindInstance"                     ] = ALEBind::Method(&LuaPlayer::UnbindInstance);
+    type["UnbindAllInstances"                 ] = ALEBind::Method(&LuaPlayer::UnbindAllInstances);
+    type["RemoveFromBattlegroundRaid"         ] = ALEBind::Method(&LuaPlayer::RemoveFromBattlegroundRaid);
+    type["ResetAchievements"                  ] = ALEBind::Method(&LuaPlayer::ResetAchievements);
+    type["KickPlayer"                         ] = ALEBind::Method(&LuaPlayer::KickPlayer);
+    type["LogoutPlayer"                       ] = ALEBind::Method(&LuaPlayer::LogoutPlayer);
+    type["SendTrainerList"                    ] = ALEBind::Method(&LuaPlayer::SendTrainerList);
+    type["SendListInventory"                  ] = ALEBind::Method(&LuaPlayer::SendListInventory);
+    type["SendShowBank"                       ] = ALEBind::Method(&LuaPlayer::SendShowBank);
+    type["SendTabardVendorActivate"           ] = ALEBind::Method(&LuaPlayer::SendTabardVendorActivate);
+    type["SendSpiritResurrect"                ] = ALEBind::Method(&LuaPlayer::SendSpiritResurrect);
+    type["SendTaxiMenu"                       ] = ALEBind::Method(&LuaPlayer::SendTaxiMenu);
+    type["SendUpdateWorldState"               ] = ALEBind::Method(&LuaPlayer::SendUpdateWorldState);
+    type["RewardQuest"                        ] = ALEBind::Method(&LuaPlayer::RewardQuest);
+    type["SendAuctionMenu"                    ] = ALEBind::Method(&LuaPlayer::SendAuctionMenu);
+    type["SendShowMailBox"                    ] = ALEBind::Method(&LuaPlayer::SendShowMailBox);
+    type["StartTaxi"                          ] = ALEBind::Method(&LuaPlayer::StartTaxi);
+    type["GossipSendPOI"                      ] = ALEBind::Method(&LuaPlayer::GossipSendPOI);
+    type["GossipAddQuests"                    ] = ALEBind::Method(&LuaPlayer::GossipAddQuests);
+    type["SendQuestTemplate"                  ] = ALEBind::Method(&LuaPlayer::SendQuestTemplate);
+    type["SpawnBones"                         ] = ALEBind::Method(&LuaPlayer::SpawnBones);
+    type["RemovedInsignia"                    ] = ALEBind::Method(&LuaPlayer::RemovedInsignia);
+    type["SendGuildInvite"                    ] = ALEBind::Method(&LuaPlayer::SendGuildInvite);
+    type["Mute"                               ] = ALEBind::Method(&LuaPlayer::Mute);
+    type["SummonPlayer"                       ] = ALEBind::Method(&LuaPlayer::SummonPlayer);
+    type["SaveToDB"                           ] = ALEBind::Method(&LuaPlayer::SaveToDB);
+    type["GroupInvite"                        ] = ALEBind::Method(&LuaPlayer::GroupInvite);
+    type["GroupCreate"                        ] = ALEBind::Method(&LuaPlayer::GroupCreate);
+    type["SendCinematicStart"                 ] = ALEBind::Method(&LuaPlayer::SendCinematicStart);
+    type["SendMovieStart"                     ] = ALEBind::Method(&LuaPlayer::SendMovieStart);
+    type["UpdatePlayerSetting"                ] = ALEBind::Method(&LuaPlayer::UpdatePlayerSetting);
+    type["TeleportTo"                         ] = ALEBind::Method(&LuaPlayer::TeleportTo);
+    type["SummonPet"                          ] = ALEBind::Method(&LuaPlayer::SummonPet);
+    type["CreatePet"                          ] = ALEBind::Method(&LuaPlayer::CreatePet);
+    type["UnsummonPetTemporarily"             ] = ALEBind::Method(&LuaPlayer::UnsummonPetTemporarily);
+    type["RemovePet"                          ] = ALEBind::Method(&LuaPlayer::RemovePet);
+    type["LearnPetTalent"                     ] = ALEBind::Method(&LuaPlayer::LearnPetTalent);
+    type["ResummonPetTemporaryUnSummonedIfAny"] = ALEBind::Method(&LuaPlayer::ResummonPetTemporaryUnSummonedIfAny);
+    type["SetPlayerFlag"                      ] = ALEBind::Method(&LuaPlayer::SetPlayerFlag);
+    type["RemovePlayerFlag"                   ] = ALEBind::Method(&LuaPlayer::RemovePlayerFlag);
+    type["DoRandomRoll"                       ] = ALEBind::Method(&LuaPlayer::DoRandomRoll);
+    type["EnvironmentalDamage"                ] = ALEBind::Method(&LuaPlayer::EnvironmentalDamage);
+    type["InitTaxiNodesForLevel"              ] = ALEBind::Method(&LuaPlayer::InitTaxiNodesForLevel);
+    type["AbandonQuest"                       ] = ALEBind::Method(&LuaPlayer::AbandonQuest);
+    type["AddWeaponProficiency"               ] = ALEBind::Method(&LuaPlayer::AddWeaponProficiency);
+    type["AddArmorProficiency"                ] = ALEBind::Method(&LuaPlayer::AddArmorProficiency);
+    type["SetAmmo"                            ] = ALEBind::Method(&LuaPlayer::SetAmmo);
+    type["RemoveAmmo"                         ] = ALEBind::Method(&LuaPlayer::RemoveAmmo);
+    type["SetCanTeleport"                     ] = ALEBind::Method(&LuaPlayer::SetCanTeleport);
+    type["SetIsSpectator"                     ] = ALEBind::Method(&LuaPlayer::SetIsSpectator);
+    type["SetViewpoint"                       ] = ALEBind::Method(&LuaPlayer::SetViewpoint);
+    type["ToggleInstantFlight"                ] = ALEBind::Method(&LuaPlayer::ToggleInstantFlight);
+    type["SetCreationTime"                    ] = ALEBind::Method(&LuaPlayer::SetCreationTime);
+    type["ApplyRatingMod"                     ] = ALEBind::Method(&LuaPlayer::ApplyRatingMod);
+}
diff --git a/src/LuaEngine/methods/QuestMethods.h b/src/LuaEngine/methods/QuestMethods.cpp
similarity index 72%
rename from src/LuaEngine/methods/QuestMethods.h
rename to src/LuaEngine/methods/QuestMethods.cpp
index 7969cad751..28023654e0 100644
--- a/src/LuaEngine/methods/QuestMethods.h
+++ b/src/LuaEngine/methods/QuestMethods.cpp
@@ -4,8 +4,9 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef QUESTMETHODS_H
-#define QUESTMETHODS_H
+#include "ALEBind.h"
+
+#include "QuestDef.h"
 
 /***
  * Represents a quest in the game, including its objectives, rewards, and conditions.
@@ -51,11 +52,9 @@ namespace LuaQuest
      * @param [QuestFlags] flag : all available flags can be seen above
      * @return bool hasFlag
      */
-    int HasFlag(lua_State* L, Quest* quest)
+    bool HasFlag(Quest* quest, uint32 flag)
     {
-        uint32 flag = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, quest->HasFlag(flag));
-        return 1;
+        return quest->HasFlag(flag);
     }
 
     /**
@@ -63,10 +62,9 @@ namespace LuaQuest
      *
      * @return bool isDaily
      */
-    int IsDaily(lua_State* L, Quest* quest)
+    bool IsDaily(Quest* quest)
     {
-        ALE::Push(L, quest->IsDaily());
-        return 1;
+        return quest->IsDaily();
     }
 
     /**
@@ -74,10 +72,9 @@ namespace LuaQuest
      *
      * @return bool isRepeatable
      */
-    int IsRepeatable(lua_State* L, Quest* quest)
+    bool IsRepeatable(Quest* quest)
     {
-        ALE::Push(L, quest->IsRepeatable());
-        return 1;
+        return quest->IsRepeatable();
     }
 
     /**
@@ -85,10 +82,9 @@ namespace LuaQuest
      *
      * @return uint32 entryId
      */
-    int GetId(lua_State* L, Quest* quest)
+    uint32 GetId(Quest* quest)
     {
-        ALE::Push(L, quest->GetQuestId());
-        return 1;
+        return quest->GetQuestId();
     }
 
     /**
@@ -96,10 +92,9 @@ namespace LuaQuest
      *
      * @return uint32 level
      */
-    int GetLevel(lua_State* L, Quest* quest)
+    int32 GetLevel(Quest* quest)
     {
-        ALE::Push(L, quest->GetQuestLevel());
-        return 1;
+        return quest->GetQuestLevel();
     }
 
     /**
@@ -107,10 +102,9 @@ namespace LuaQuest
      *
      * @return uint32 minLevel
      */
-    int GetMinLevel(lua_State* L, Quest* quest)
+    uint32 GetMinLevel(Quest* quest)
     {
-        ALE::Push(L, quest->GetMinLevel());
-        return 1;
+        return quest->GetMinLevel();
     }
 
     /**
@@ -118,10 +112,9 @@ namespace LuaQuest
      *
      * @return int32 entryId
      */
-    int GetNextQuestId(lua_State* L, Quest* quest)
+    uint32 GetNextQuestId(Quest* quest)
     {
-        ALE::Push(L, quest->GetNextQuestId());
-        return 1;
+        return quest->GetNextQuestId();
     }
 
     /**
@@ -129,10 +122,9 @@ namespace LuaQuest
      *
      * @return int32 entryId
      */
-    int GetPrevQuestId(lua_State* L, Quest* quest)
+    int32 GetPrevQuestId(Quest* quest)
     {
-        ALE::Push(L, quest->GetPrevQuestId());
-        return 1;
+        return quest->GetPrevQuestId();
     }
 
     /**
@@ -140,10 +132,9 @@ namespace LuaQuest
      *
      * @return int32 entryId
      */
-    int GetNextQuestInChain(lua_State* L, Quest* quest)
+    uint32 GetNextQuestInChain(Quest* quest)
     {
-        ALE::Push(L, quest->GetNextQuestInChain());
-        return 1;
+        return quest->GetNextQuestInChain();
     }
 
     /**
@@ -151,10 +142,9 @@ namespace LuaQuest
      *
      * @return [QuestFlags] flags
      */
-    int GetFlags(lua_State* L, Quest* quest)
+    uint32 GetFlags(Quest* quest)
     {
-        ALE::Push(L, quest->GetFlags());
-        return 1;
+        return quest->GetFlags();
     }
 
     /**
@@ -164,16 +154,30 @@ namespace LuaQuest
      *
      * @return uint32 type
      */
-    int GetType(lua_State* L, Quest* quest)
+    uint32 GetType(Quest* quest)
     {
-        ALE::Push(L, quest->GetType());
-        return 1;
+        return quest->GetType();
     }
 
-    /*int GetMaxLevel(lua_State* L, Quest* quest)
+    /*uint32 GetMaxLevel(Quest* quest)
     {
-        ALE::Push(L, quest->GetMaxLevel());
-        return 1;
+        return quest->GetMaxLevel();
     }*/
-};
-#endif
+}
+
+void RegisterQuestMethods(sol::state& lua)
+{
+    sol::usertype<Quest> type = lua.new_usertype<Quest>("Quest", sol::no_constructor);
+
+    type["HasFlag"]             = &LuaQuest::HasFlag;
+    type["IsDaily"]             = &LuaQuest::IsDaily;
+    type["IsRepeatable"]        = &LuaQuest::IsRepeatable;
+    type["GetId"]               = &LuaQuest::GetId;
+    type["GetLevel"]            = &LuaQuest::GetLevel;
+    type["GetMinLevel"]         = &LuaQuest::GetMinLevel;
+    type["GetNextQuestId"]      = &LuaQuest::GetNextQuestId;
+    type["GetPrevQuestId"]      = &LuaQuest::GetPrevQuestId;
+    type["GetNextQuestInChain"] = &LuaQuest::GetNextQuestInChain;
+    type["GetFlags"]            = &LuaQuest::GetFlags;
+    type["GetType"]             = &LuaQuest::GetType;
+}
diff --git a/src/LuaEngine/methods/RollMethods.h b/src/LuaEngine/methods/RollMethods.cpp
similarity index 57%
rename from src/LuaEngine/methods/RollMethods.h
rename to src/LuaEngine/methods/RollMethods.cpp
index fdcbd0bb36..47e0b96b02 100644
--- a/src/LuaEngine/methods/RollMethods.h
+++ b/src/LuaEngine/methods/RollMethods.cpp
@@ -4,8 +4,7 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef ROLLMETHODS_H
-#define ROLLMETHODS_H
+#include "ALEBind.h"
 
 #include "Group.h"
 
@@ -23,10 +22,9 @@ namespace LuaRoll
      *
      * @return ObjectGuid guid
      */
-    int GetItemGUID(lua_State* L, Roll* roll)
+    uint32 GetItemGUID(Roll* roll)
     {
-        ALE::Push(L, roll->itemGUID.GetCounter());
-        return 1;
+        return roll->itemGUID.GetCounter();
     }
 
     /**
@@ -34,10 +32,9 @@ namespace LuaRoll
      *
      * @return uint32 entry
      */
-    int GetItemId(lua_State* L, Roll* roll)
+    uint32 GetItemId(Roll* roll)
     {
-        ALE::Push(L, roll->itemid);
-        return 1;
+        return roll->itemid;
     }
 
     /**
@@ -45,10 +42,9 @@ namespace LuaRoll
      *
      * @return int32 randomPropId
      */
-    int GetItemRandomPropId(lua_State* L, Roll* roll)
+    int32 GetItemRandomPropId(Roll* roll)
     {
-        ALE::Push(L, roll->itemRandomPropId);
-        return 1;
+        return roll->itemRandomPropId;
     }
 
     /**
@@ -56,10 +52,9 @@ namespace LuaRoll
      *
      * @return uint32 randomSuffix
      */
-    int GetItemRandomSuffix(lua_State* L, Roll* roll)
+    uint32 GetItemRandomSuffix(Roll* roll)
     {
-        ALE::Push(L, roll->itemRandomSuffix);
-        return 1;
+        return roll->itemRandomSuffix;
     }
 
     /**
@@ -67,10 +62,9 @@ namespace LuaRoll
      *
      * @return uint8 count
      */
-    int GetItemCount(lua_State* L, Roll* roll)
+    uint8 GetItemCount(Roll* roll)
     {
-        ALE::Push(L, roll->itemCount);
-        return 1;
+        return roll->itemCount;
     }
 
     /**
@@ -92,26 +86,18 @@ namespace LuaRoll
      * @param ObjectGuid guid
      * @return [RollVote] vote
      */
-    int GetPlayerVote(lua_State* L, Roll* roll)
+    sol::optional<RollVote> GetPlayerVote(Roll* roll, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-
-        bool found = false;
+        sol::optional<RollVote> vote;
         for (std::pair<const ObjectGuid, RollVote>& pair : roll->playerVote)
         {
             if (pair.first == guid)
             {
-                ALE::Push(L, pair.second);
-                found = true;
+                vote = pair.second;
             }
         }
 
-        if (!found)
-        {
-            ALE::Push(L);
-        }
-
-        return 1;
+        return vote;
     }
 
     /**
@@ -120,20 +106,17 @@ namespace LuaRoll
      *
      * @return table guids
      */
-    int GetPlayerVoteGUIDs(lua_State* L, Roll* roll)
+    sol::table GetPlayerVoteGUIDs(Roll* roll, sol::this_state s)
     {
-        lua_newtable(L);
-        int table = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 1;
         for (std::pair<const ObjectGuid, RollVote>& pair : roll->playerVote)
         {
-            ALE::Push(L, pair.first);
-            lua_rawseti(L, table, i);
+            tbl[i] = pair.first;
             ++i;
         }
 
-        lua_settop(L, table); // push table to top of stack
-        return 1;
+        return tbl;
     }
 
     /**
@@ -141,10 +124,9 @@ namespace LuaRoll
      *
      * @return uint8 playersCount
      */
-    int GetTotalPlayersRolling(lua_State* L, Roll* roll)
+    uint8 GetTotalPlayersRolling(Roll* roll)
     {
-        ALE::Push(L, roll->totalPlayersRolling);
-        return 1;
+        return roll->totalPlayersRolling;
     }
 
     /**
@@ -152,10 +134,9 @@ namespace LuaRoll
      *
      * @return uint8 playersCount
      */
-    int GetTotalNeed(lua_State* L, Roll* roll)
+    uint8 GetTotalNeed(Roll* roll)
     {
-        ALE::Push(L, roll->totalNeed);
-        return 1;
+        return roll->totalNeed;
     }
 
     /**
@@ -163,10 +144,9 @@ namespace LuaRoll
      *
      * @return uint8 playersCount
      */
-    int GetTotalGreed(lua_State* L, Roll* roll)
+    uint8 GetTotalGreed(Roll* roll)
     {
-        ALE::Push(L, roll->totalGreed);
-        return 1;
+        return roll->totalGreed;
     }
 
     /**
@@ -174,10 +154,9 @@ namespace LuaRoll
      *
      * @return uint8 playersCount
      */
-    int GetTotalPass(lua_State* L, Roll* roll)
+    uint8 GetTotalPass(Roll* roll)
     {
-        ALE::Push(L, roll->totalPass);
-        return 1;
+        return roll->totalPass;
     }
 
     /**
@@ -185,10 +164,9 @@ namespace LuaRoll
      *
      * @return uint8 slot
      */
-    int GetItemSlot(lua_State* L, Roll* roll)
+    uint8 GetItemSlot(Roll* roll)
     {
-        ALE::Push(L, roll->itemSlot);
-        return 1;
+        return roll->itemSlot;
     }
 
     /**
@@ -201,7 +179,7 @@ namespace LuaRoll
      *     ROLL_FLAG_TYPE_NEED                 = 0x02,
      *     ROLL_FLAG_TYPE_GREED                = 0x04,
      *     ROLL_FLAG_TYPE_DISENCHANT           = 0x08,
-     * 
+     *
      *     ROLL_ALL_TYPE_NO_DISENCHANT         = 0x07,
      *     ROLL_ALL_TYPE_MASK                  = 0x0F
      * };
@@ -209,11 +187,27 @@ namespace LuaRoll
      *
      * @return [RollMask] rollMask
      */
-    int GetRollVoteMask(lua_State* L, Roll* roll)
+    uint8 GetRollVoteMask(Roll* roll)
     {
-        ALE::Push(L, roll->rollVoteMask);
-        return 1;
+        return roll->rollVoteMask;
     }
 }
 
-#endif
+void RegisterRollMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<Roll>> type = ALEBind::NewHandleType<ScopedRef<Roll>>(lua, "Roll");
+
+    type["GetItemGUID"]            = ALEBind::Method(&LuaRoll::GetItemGUID);
+    type["GetItemId"]              = ALEBind::Method(&LuaRoll::GetItemId);
+    type["GetItemRandomPropId"]    = ALEBind::Method(&LuaRoll::GetItemRandomPropId);
+    type["GetItemRandomSuffix"]    = ALEBind::Method(&LuaRoll::GetItemRandomSuffix);
+    type["GetItemCount"]           = ALEBind::Method(&LuaRoll::GetItemCount);
+    type["GetPlayerVote"]          = ALEBind::Method(&LuaRoll::GetPlayerVote);
+    type["GetPlayerVoteGUIDs"]     = ALEBind::Method(&LuaRoll::GetPlayerVoteGUIDs);
+    type["GetTotalPlayersRolling"] = ALEBind::Method(&LuaRoll::GetTotalPlayersRolling);
+    type["GetTotalNeed"]           = ALEBind::Method(&LuaRoll::GetTotalNeed);
+    type["GetTotalGreed"]          = ALEBind::Method(&LuaRoll::GetTotalGreed);
+    type["GetTotalPass"]           = ALEBind::Method(&LuaRoll::GetTotalPass);
+    type["GetItemSlot"]            = ALEBind::Method(&LuaRoll::GetItemSlot);
+    type["GetRollVoteMask"]        = ALEBind::Method(&LuaRoll::GetRollVoteMask);
+}
diff --git a/src/LuaEngine/methods/SpellEntryMethods.h b/src/LuaEngine/methods/SpellEntryMethods.cpp
similarity index 60%
rename from src/LuaEngine/methods/SpellEntryMethods.h
rename to src/LuaEngine/methods/SpellEntryMethods.cpp
index 615c2e50e4..07c52ab054 100644
--- a/src/LuaEngine/methods/SpellEntryMethods.h
+++ b/src/LuaEngine/methods/SpellEntryMethods.cpp
@@ -4,8 +4,12 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef SPELLENTRYMETHODS_H
-#define SPELLENTRYMETHODS_H
+#include "ALEBind.h"
+
+#include "DBCStores.h"
+#include "DBCStructure.h"
+#include "SpellInfo.h"
+#include "SpellMgr.h"
 
 /***
  * Represents spell data loaded from the DBCs, including effects, costs, attributes, and requirements.
@@ -21,10 +25,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 id
      */
-    int GetId(lua_State* L, SpellEntry* entry)
+    uint32 GetId(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Id);
-        return 1;
+        return entry->Id;
     }
 
     /**
@@ -32,10 +35,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 categoryId
      */
-    int GetCategory(lua_State* L, SpellEntry* entry)
+    uint32 GetCategory(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Category);
-        return 1;
+        return entry->Category;
     }
 
     /**
@@ -43,10 +45,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 dispelId
      */
-    int GetDispel(lua_State* L, SpellEntry* entry)
+    uint32 GetDispel(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Dispel);
-        return 1;
+        return entry->Dispel;
     }
 
     /**
@@ -54,10 +55,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 mechanicId
      */
-    int GetMechanic(lua_State* L, SpellEntry* entry)
+    uint32 GetMechanic(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Mechanic);
-        return 1;
+        return entry->Mechanic;
     }
 
     /**
@@ -65,10 +65,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attribute : bitmask, but returned as uint32
      */
-    int GetAttributes(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributes(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Attributes);
-        return 1;
+        return entry->Attributes;
     }
 
     /**
@@ -76,10 +75,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attributeEx : bitmask, but returned as uint32
      */
-    int GetAttributesEx(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributesEx(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AttributesEx);
-        return 1;
+        return entry->AttributesEx;
     }
 
     /**
@@ -87,10 +85,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attributeEx2 : bitmask, but returned as uint32
      */
-    int GetAttributesEx2(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributesEx2(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AttributesEx2);
-        return 1;
+        return entry->AttributesEx2;
     }
 
     /**
@@ -98,10 +95,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attributeEx3 : bitmask, but returned as uint32
      */
-    int GetAttributesEx3(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributesEx3(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AttributesEx3);
-        return 1;
+        return entry->AttributesEx3;
     }
 
     /**
@@ -109,10 +105,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attributeEx4 : bitmask, but returned as uint32
      */
-    int GetAttributesEx4(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributesEx4(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AttributesEx4);
-        return 1;
+        return entry->AttributesEx4;
     }
 
     /**
@@ -120,10 +115,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attributeEx5 : bitmask, but returned as uint32
      */
-    int GetAttributesEx5(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributesEx5(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AttributesEx5);
-        return 1;
+        return entry->AttributesEx5;
     }
 
     /**
@@ -131,10 +125,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attributeEx6 : bitmask, but returned as uint32
      */
-    int GetAttributesEx6(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributesEx6(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AttributesEx6);
-        return 1;
+        return entry->AttributesEx6;
     }
 
     /**
@@ -142,10 +135,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 attributeEx7 : bitmask, but returned as uint32
      */
-    int GetAttributesEx7(lua_State* L, SpellEntry* entry)
+    uint32 GetAttributesEx7(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AttributesEx7);
-        return 1;
+        return entry->AttributesEx7;
     }
 
     /**
@@ -153,10 +145,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 stance : bitmask, but returned as uint32
      */
-    int GetStances(lua_State* L, SpellEntry* entry)
+    uint32 GetStances(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Stances);
-        return 1;
+        return entry->Stances;
     }
 
     /**
@@ -166,10 +157,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 stancesNotMask
      */
-    int GetStancesNot(lua_State* L, SpellEntry* entry)
+    uint32 GetStancesNot(SpellEntry* entry)
     {
-        ALE::Push(L, entry->StancesNot);
-        return 1;
+        return entry->StancesNot;
     }
 
     /**
@@ -177,10 +167,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 target : bitmasks, but returned as uint32.
      */
-    int GetTargets(lua_State* L, SpellEntry* entry)
+    uint32 GetTargets(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Targets);
-        return 1;
+        return entry->Targets;
     }
 
     /**
@@ -188,10 +177,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 targetCreatureType : bitmasks, but returned as uint32.
      */
-    int GetTargetCreatureType(lua_State* L, SpellEntry* entry)
+    uint32 GetTargetCreatureType(SpellEntry* entry)
     {
-        ALE::Push(L, entry->TargetCreatureType);
-        return 1;
+        return entry->TargetCreatureType;
     }
 
     /**
@@ -201,10 +189,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 spellFocusId
      */
-    int GetRequiresSpellFocus(lua_State* L, SpellEntry* entry)
+    uint32 GetRequiresSpellFocus(SpellEntry* entry)
     {
-        ALE::Push(L, entry->RequiresSpellFocus);
-        return 1;
+        return entry->RequiresSpellFocus;
     }
 
     /**
@@ -214,10 +201,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 facingFlags
      */
-    int GetFacingCasterFlags(lua_State* L, SpellEntry* entry)
+    uint32 GetFacingCasterFlags(SpellEntry* entry)
     {
-        ALE::Push(L, entry->FacingCasterFlags);
-        return 1;
+        return entry->FacingCasterFlags;
     }
 
     /**
@@ -227,10 +213,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 casterAuraState
      */
-    int GetCasterAuraState(lua_State* L, SpellEntry* entry)
+    uint32 GetCasterAuraState(SpellEntry* entry)
     {
-        ALE::Push(L, entry->CasterAuraState);
-        return 1;
+        return entry->CasterAuraState;
     }
 
     /**
@@ -240,10 +225,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 targetAuraState
      */
-    int GetTargetAuraState(lua_State* L, SpellEntry* entry)
+    uint32 GetTargetAuraState(SpellEntry* entry)
     {
-        ALE::Push(L, entry->TargetAuraState);
-        return 1;
+        return entry->TargetAuraState;
     }
 
     /**
@@ -253,10 +237,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 casterAuraStateNot
      */
-    int GetCasterAuraStateNot(lua_State* L, SpellEntry* entry)
+    uint32 GetCasterAuraStateNot(SpellEntry* entry)
     {
-        ALE::Push(L, entry->CasterAuraStateNot);
-        return 1;
+        return entry->CasterAuraStateNot;
     }
 
     /**
@@ -266,10 +249,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 targetAuraStateNot
      */
-    int GetTargetAuraStateNot(lua_State* L, SpellEntry* entry)
+    uint32 GetTargetAuraStateNot(SpellEntry* entry)
     {
-        ALE::Push(L, entry->TargetAuraStateNot);
-        return 1;
+        return entry->TargetAuraStateNot;
     }
 
     /**
@@ -279,10 +261,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 casterAuraSpellId
      */
-    int GetCasterAuraSpell(lua_State* L, SpellEntry* entry)
+    uint32 GetCasterAuraSpell(SpellEntry* entry)
     {
-        ALE::Push(L, entry->CasterAuraSpell);
-        return 1;
+        return entry->CasterAuraSpell;
     }
 
     /**
@@ -292,10 +273,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 targetAuraSpellId
      */
-    int GetTargetAuraSpell(lua_State* L, SpellEntry* entry)
+    uint32 GetTargetAuraSpell(SpellEntry* entry)
     {
-        ALE::Push(L, entry->TargetAuraSpell);
-        return 1;
+        return entry->TargetAuraSpell;
     }
 
     /**
@@ -305,10 +285,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 excludeCasterAuraSpellId
      */
-    int GetExcludeCasterAuraSpell(lua_State* L, SpellEntry* entry)
+    uint32 GetExcludeCasterAuraSpell(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ExcludeCasterAuraSpell);
-        return 1;
+        return entry->ExcludeCasterAuraSpell;
     }
 
     /**
@@ -318,10 +297,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 excludeTargetAuraSpellId
      */
-    int GetExcludeTargetAuraSpell(lua_State* L, SpellEntry* entry)
+    uint32 GetExcludeTargetAuraSpell(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ExcludeTargetAuraSpell);
-        return 1;
+        return entry->ExcludeTargetAuraSpell;
     }
 
     /**
@@ -331,10 +309,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 castingTimeIndex
      */
-    int GetCastingTimeIndex(lua_State* L, SpellEntry* entry)
+    uint32 GetCastingTimeIndex(SpellEntry* entry)
     {
-        ALE::Push(L, entry->CastingTimeIndex);
-        return 1;
+        return entry->CastingTimeIndex;
     }
 
     /**
@@ -342,10 +319,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 recoveryTime
      */
-    int GetRecoveryTime(lua_State* L, SpellEntry* entry)
+    uint32 GetRecoveryTime(SpellEntry* entry)
     {
-        ALE::Push(L, entry->RecoveryTime);
-        return 1;
+        return entry->RecoveryTime;
     }
 
     /**
@@ -353,10 +329,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 categoryRecoveryTime : in milliseconds, returned as uint32
      */
-    int GetCategoryRecoveryTime(lua_State* L, SpellEntry* entry)
+    uint32 GetCategoryRecoveryTime(SpellEntry* entry)
     {
-        ALE::Push(L, entry->CategoryRecoveryTime);
-        return 1;
+        return entry->CategoryRecoveryTime;
     }
 
     /**
@@ -366,10 +341,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 interruptFlags
      */
-    int GetInterruptFlags(lua_State* L, SpellEntry* entry)
+    uint32 GetInterruptFlags(SpellEntry* entry)
     {
-        ALE::Push(L, entry->InterruptFlags);
-        return 1;
+        return entry->InterruptFlags;
     }
 
     /**
@@ -379,10 +353,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 auraInterruptFlags
      */
-    int GetAuraInterruptFlags(lua_State* L, SpellEntry* entry)
+    uint32 GetAuraInterruptFlags(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AuraInterruptFlags);
-        return 1;
+        return entry->AuraInterruptFlags;
     }
 
     /**
@@ -392,10 +365,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 channelInterruptFlags
      */
-    int GetChannelInterruptFlags(lua_State* L, SpellEntry* entry)
+    uint32 GetChannelInterruptFlags(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ChannelInterruptFlags);
-        return 1;
+        return entry->ChannelInterruptFlags;
     }
 
     /**
@@ -405,10 +377,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 procFlags
      */
-    int GetProcFlags(lua_State* L, SpellEntry* entry)
+    uint32 GetProcFlags(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ProcFlags);
-        return 1;
+        return entry->ProcFlags;
     }
 
     /**
@@ -416,10 +387,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 procChance
      */
-    int GetProcChance(lua_State* L, SpellEntry* entry)
+    uint32 GetProcChance(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ProcChance);
-        return 1;
+        return entry->ProcChance;
     }
 
     /**
@@ -427,10 +397,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 procCharges
      */
-    int GetProcCharges(lua_State* L, SpellEntry* entry)
+    uint32 GetProcCharges(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ProcCharges);
-        return 1;
+        return entry->ProcCharges;
     }
 
     /**
@@ -438,10 +407,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 maxLevel : the [SpellEntry] max level.
      */
-    int GetMaxLevel(lua_State* L, SpellEntry* entry)
+    uint32 GetMaxLevel(SpellEntry* entry)
     {
-        ALE::Push(L, entry->MaxLevel);
-        return 1;
+        return entry->MaxLevel;
     }
 
     /**
@@ -449,10 +417,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 baseLevel
      */
-    int GetBaseLevel(lua_State* L, SpellEntry* entry)
+    uint32 GetBaseLevel(SpellEntry* entry)
     {
-        ALE::Push(L, entry->BaseLevel);
-        return 1;
+        return entry->BaseLevel;
     }
 
     /**
@@ -460,10 +427,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 spellLevel
      */
-    int GetSpellLevel(lua_State* L, SpellEntry* entry)
+    uint32 GetSpellLevel(SpellEntry* entry)
     {
-        ALE::Push(L, entry->SpellLevel);
-        return 1;
+        return entry->SpellLevel;
     }
 
     /**
@@ -471,10 +437,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 durationIndex
      */
-    int GetDurationIndex(lua_State* L, SpellEntry* entry)
+    uint32 GetDurationIndex(SpellEntry* entry)
     {
-        ALE::Push(L, entry->DurationIndex);
-        return 1;
+        return entry->DurationIndex;
     }
 
     /**
@@ -482,10 +447,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 powerTypeId
      */
-    int GetPowerType(lua_State* L, SpellEntry* entry)
+    uint32 GetPowerType(SpellEntry* entry)
     {
-        ALE::Push(L, entry->PowerType);
-        return 1;
+        return entry->PowerType;
     }
 
     /**
@@ -493,10 +457,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 manaCost
      */
-    int GetManaCost(lua_State* L, SpellEntry* entry)
+    uint32 GetManaCost(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ManaCost);
-        return 1;
+        return entry->ManaCost;
     }
 
     /**
@@ -504,10 +467,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 manaCostPerLevel
      */
-    int GetManaCostPerlevel(lua_State* L, SpellEntry* entry)
+    uint32 GetManaCostPerlevel(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ManaCostPerlevel);
-        return 1;
+        return entry->ManaCostPerlevel;
     }
 
     /**
@@ -515,10 +477,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 manaPerSecond
      */
-    int GetManaPerSecond(lua_State* L, SpellEntry* entry)
+    uint32 GetManaPerSecond(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ManaPerSecond);
-        return 1;
+        return entry->ManaPerSecond;
     }
 
     /**
@@ -526,10 +487,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 manaPerSecondPerLevel
      */
-    int GetManaPerSecondPerLevel(lua_State* L, SpellEntry* entry)
+    uint32 GetManaPerSecondPerLevel(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ManaPerSecondPerLevel);
-        return 1;
+        return entry->ManaPerSecondPerLevel;
     }
 
     /**
@@ -537,10 +497,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 rangeIndex
      */
-    int GetRangeIndex(lua_State* L, SpellEntry* entry)
+    uint32 GetRangeIndex(SpellEntry* entry)
     {
-        ALE::Push(L, entry->RangeIndex);
-        return 1;
+        return entry->RangeIndex;
     }
 
     /**
@@ -548,10 +507,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 speed
      */
-    int GetSpeed(lua_State* L, SpellEntry* entry)
+    float GetSpeed(SpellEntry* entry)
     {
-        ALE::Push(L, entry->Speed);
-        return 1;
+        return entry->Speed;
     }
 
     /**
@@ -559,10 +517,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 stackAmount
      */
-    int GetStackAmount(lua_State* L, SpellEntry* entry)
+    uint32 GetStackAmount(SpellEntry* entry)
     {
-        ALE::Push(L, entry->StackAmount);
-        return 1;
+        return entry->StackAmount;
     }
 
     /**
@@ -570,20 +527,17 @@ namespace LuaSpellEntry
      *
      * @return table totem
      */
-    int GetTotem(lua_State* L, SpellEntry* entry)
+    sol::table GetTotem(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->Totem.size(); ++index)
         {
-            ALE::Push(L, entry->Totem[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->Totem[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -591,20 +545,17 @@ namespace LuaSpellEntry
      *
      * @return table reagent
      */
-    int GetReagent(lua_State* L, SpellEntry* entry)
+    sol::table GetReagent(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->Reagent.size(); ++index)
         {
-            ALE::Push(L, entry->Reagent[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->Reagent[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -612,20 +563,17 @@ namespace LuaSpellEntry
      *
      * @return table reagentCount
      */
-    int GetReagentCount(lua_State* L, SpellEntry* entry)
+    sol::table GetReagentCount(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->ReagentCount.size(); ++index)
         {
-            ALE::Push(L, entry->ReagentCount[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->ReagentCount[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -633,10 +581,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 equippedItemClassId
      */
-    int GetEquippedItemClass(lua_State* L, SpellEntry* entry)
+    int32 GetEquippedItemClass(SpellEntry* entry)
     {
-        ALE::Push(L, entry->EquippedItemClass);
-        return 1;
+        return entry->EquippedItemClass;
     }
 
     /**
@@ -644,10 +591,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 equippedItemSubClassMasks : bitmasks, returned as uint32.
      */
-    int GetEquippedItemSubClassMask(lua_State* L, SpellEntry* entry)
+    int32 GetEquippedItemSubClassMask(SpellEntry* entry)
     {
-        ALE::Push(L, entry->EquippedItemSubClassMask);
-        return 1;
+        return entry->EquippedItemSubClassMask;
     }
 
     /**
@@ -655,10 +601,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 equippedItemInventoryTypeMasks : bitmasks, returned as uint32.
      */
-    int GetEquippedItemInventoryTypeMask(lua_State* L, SpellEntry* entry)
+    int32 GetEquippedItemInventoryTypeMask(SpellEntry* entry)
     {
-        ALE::Push(L, entry->EquippedItemInventoryTypeMask);
-        return 1;
+        return entry->EquippedItemInventoryTypeMask;
     }
 
     /**
@@ -666,20 +611,17 @@ namespace LuaSpellEntry
      *
      * @return table effect
      */
-    int GetEffect(lua_State* L, SpellEntry* entry)
+    sol::table GetEffect(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->Effect.size(); ++index)
         {
-            ALE::Push(L, entry->Effect[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->Effect[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -687,20 +629,17 @@ namespace LuaSpellEntry
      *
      * @return table effectDieSides
      */
-    int GetEffectDieSides(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectDieSides(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectDieSides.size(); ++index)
         {
-            ALE::Push(L, entry->EffectDieSides[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectDieSides[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -708,20 +647,17 @@ namespace LuaSpellEntry
      *
      * @return table effectRealPointsPerLevel
      */
-    int GetEffectRealPointsPerLevel(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectRealPointsPerLevel(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectRealPointsPerLevel.size(); ++index)
         {
-            ALE::Push(L, entry->EffectRealPointsPerLevel[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectRealPointsPerLevel[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -729,20 +665,17 @@ namespace LuaSpellEntry
      *
      * @return table effectBasePoints
      */
-    int GetEffectBasePoints(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectBasePoints(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectBasePoints.size(); ++index)
         {
-            ALE::Push(L, entry->EffectBasePoints[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectBasePoints[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -750,20 +683,17 @@ namespace LuaSpellEntry
      *
      * @return table effectMechanic
      */
-    int GetEffectMechanic(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectMechanic(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectMechanic.size(); ++index)
         {
-            ALE::Push(L, entry->EffectMechanic[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectMechanic[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -771,20 +701,17 @@ namespace LuaSpellEntry
      *
      * @return table effectImplicitTargetA
      */
-    int GetEffectImplicitTargetA(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectImplicitTargetA(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectImplicitTargetA.size(); ++index)
         {
-            ALE::Push(L, entry->EffectImplicitTargetA[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectImplicitTargetA[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -792,20 +719,17 @@ namespace LuaSpellEntry
      *
      * @return table effectImplicitTargetB
      */
-    int GetEffectImplicitTargetB(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectImplicitTargetB(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectImplicitTargetB.size(); ++index)
         {
-            ALE::Push(L, entry->EffectImplicitTargetB[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectImplicitTargetB[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -813,20 +737,17 @@ namespace LuaSpellEntry
      *
      * @return table effectRadiusIndex
      */
-    int GetEffectRadiusIndex(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectRadiusIndex(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectRadiusIndex.size(); ++index)
         {
-            ALE::Push(L, entry->EffectRadiusIndex[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectRadiusIndex[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -834,20 +755,17 @@ namespace LuaSpellEntry
      *
      * @return table effectApplyAura
      */
-    int GetEffectApplyAuraName(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectApplyAuraName(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectApplyAuraName.size(); ++index)
         {
-            ALE::Push(L, entry->EffectApplyAuraName[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectApplyAuraName[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -855,20 +773,17 @@ namespace LuaSpellEntry
      *
      * @return table effectAmplitude
      */
-    int GetEffectAmplitude(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectAmplitude(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectAmplitude.size(); ++index)
         {
-            ALE::Push(L, entry->EffectAmplitude[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectAmplitude[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -876,20 +791,17 @@ namespace LuaSpellEntry
      *
      * @return table effectValueMultiplier
      */
-    int GetEffectValueMultiplier(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectValueMultiplier(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectValueMultiplier.size(); ++index)
         {
-            ALE::Push(L, entry->EffectValueMultiplier[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectValueMultiplier[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -897,20 +809,17 @@ namespace LuaSpellEntry
      *
      * @return table effectChainTarget
      */
-    int GetEffectChainTarget(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectChainTarget(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectChainTarget.size(); ++index)
         {
-            ALE::Push(L, entry->EffectChainTarget[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectChainTarget[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -918,20 +827,17 @@ namespace LuaSpellEntry
      *
      * @return table effectItemType
      */
-    int GetEffectItemType(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectItemType(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectItemType.size(); ++index)
         {
-            ALE::Push(L, entry->EffectItemType[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectItemType[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -939,20 +845,17 @@ namespace LuaSpellEntry
      *
      * @return table effectMiscValueA
      */
-    int GetEffectMiscValue(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectMiscValue(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectMiscValue.size(); ++index)
         {
-            ALE::Push(L, entry->EffectMiscValue[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectMiscValue[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -960,20 +863,17 @@ namespace LuaSpellEntry
      *
      * @return table effectMiscValueB
      */
-    int GetEffectMiscValueB(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectMiscValueB(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectMiscValueB.size(); ++index)
         {
-            ALE::Push(L, entry->EffectMiscValueB[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectMiscValueB[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -981,20 +881,17 @@ namespace LuaSpellEntry
      *
      * @return table effectTriggerSpell
      */
-    int GetEffectTriggerSpell(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectTriggerSpell(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectTriggerSpell.size(); ++index)
         {
-            ALE::Push(L, entry->EffectTriggerSpell[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectTriggerSpell[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1002,20 +899,17 @@ namespace LuaSpellEntry
      *
      * @return table effectPointsPerComboPoint : returns a table containing all the effect points per combo point values of [SpellEntry]
      */
-    int GetEffectPointsPerComboPoint(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectPointsPerComboPoint(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectPointsPerComboPoint.size(); ++index)
         {
-            ALE::Push(L, entry->EffectPointsPerComboPoint[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectPointsPerComboPoint[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1026,20 +920,17 @@ namespace LuaSpellEntry
      *
      * @return table effectSpellClassMask : table of [SpellFamilyFlags] per effect
      */
-    int GetEffectSpellClassMask(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectSpellClassMask(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectSpellClassMask.size(); ++index)
         {
-            ALE::Push(L, entry->EffectSpellClassMask[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = static_cast<bool>(entry->EffectSpellClassMask[index]);
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1047,20 +938,17 @@ namespace LuaSpellEntry
      *
      * @return table spellVisuals : returns a table containing both spellVisuals for [SpellEntry].
      */
-    int GetSpellVisual(lua_State* L, SpellEntry* entry)
+    sol::table GetSpellVisual(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->SpellVisual.size(); ++index)
         {
-            ALE::Push(L, entry->SpellVisual[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->SpellVisual[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1068,10 +956,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 spellIconId
      */
-    int GetSpellIconID(lua_State* L, SpellEntry* entry)
+    uint32 GetSpellIconID(SpellEntry* entry)
     {
-        ALE::Push(L, entry->SpellIconID);
-        return 1;
+        return entry->SpellIconID;
     }
 
     /**
@@ -1079,10 +966,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 activeIconId
      */
-    int GetActiveIconID(lua_State* L, SpellEntry* entry)
+    uint32 GetActiveIconID(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ActiveIconID);
-        return 1;
+        return entry->ActiveIconID;
     }
 
     /**
@@ -1090,10 +976,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 spellPriority
      */
-    int GetSpellPriority(lua_State* L, SpellEntry* entry)
+    uint32 GetSpellPriority(SpellEntry* entry)
     {
-        ALE::Push(L, entry->SpellPriority);
-        return 1;
+        return entry->SpellPriority;
     }
 
     /**
@@ -1101,20 +986,17 @@ namespace LuaSpellEntry
      *
      * @return table spellNames
      */
-    int GetSpellName(lua_State* L, SpellEntry* entry)
+    sol::table GetSpellName(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->SpellName.size(); ++index)
         {
-            ALE::Push(L, entry->SpellName[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->SpellName[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1122,20 +1004,17 @@ namespace LuaSpellEntry
      *
      * @return table spellRanks
      */
-    int GetRank(lua_State* L, SpellEntry* entry)
+    sol::table GetRank(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->Rank.size(); ++index)
         {
-            ALE::Push(L, entry->Rank[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->Rank[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1143,10 +1022,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 manaCostPercentage : the mana cost in percentage, returned as uint32.
      */
-    int GetManaCostPercentage(lua_State* L, SpellEntry* entry)
+    uint32 GetManaCostPercentage(SpellEntry* entry)
     {
-        ALE::Push(L, entry->ManaCostPercentage);
-        return 1;
+        return entry->ManaCostPercentage;
     }
 
     /**
@@ -1154,10 +1032,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 globalCooldownTime
      */
-    int GetStartRecoveryCategory(lua_State* L, SpellEntry* entry)
+    uint32 GetStartRecoveryCategory(SpellEntry* entry)
     {
-        ALE::Push(L, entry->StartRecoveryCategory);
-        return 1;
+        return entry->StartRecoveryCategory;
     }
 
     /**
@@ -1165,10 +1042,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 globalCooldownCategory
      */
-    int GetStartRecoveryTime(lua_State* L, SpellEntry* entry)
+    uint32 GetStartRecoveryTime(SpellEntry* entry)
     {
-        ALE::Push(L, entry->StartRecoveryTime);
-        return 1;
+        return entry->StartRecoveryTime;
     }
 
     /**
@@ -1176,10 +1052,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 maxTargetLevel
      */
-    int GetMaxTargetLevel(lua_State* L, SpellEntry* entry)
+    uint32 GetMaxTargetLevel(SpellEntry* entry)
     {
-        ALE::Push(L, entry->MaxTargetLevel);
-        return 1;
+        return entry->MaxTargetLevel;
     }
 
     /**
@@ -1189,10 +1064,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 spellFamilyName
      */
-    int GetSpellFamilyName(lua_State* L, SpellEntry* entry)
+    uint32 GetSpellFamilyName(SpellEntry* entry)
     {
-        ALE::Push(L, entry->SpellFamilyName);
-        return 1;
+        return entry->SpellFamilyName;
     }
 
     /**
@@ -1202,10 +1076,9 @@ namespace LuaSpellEntry
      *
      * @return uint64 spellFamilyFlags
      */
-    int GetSpellFamilyFlags(lua_State* L, SpellEntry* entry)
+    bool GetSpellFamilyFlags(SpellEntry* entry)
     {
-        ALE::Push(L, entry->SpellFamilyFlags);
-        return 1;
+        return entry->SpellFamilyFlags;
     }
 
     /**
@@ -1213,10 +1086,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 maxAffectedTargets
      */
-    int GetMaxAffectedTargets(lua_State* L, SpellEntry* entry)
+    uint32 GetMaxAffectedTargets(SpellEntry* entry)
     {
-        ALE::Push(L, entry->MaxAffectedTargets);
-        return 1;
+        return entry->MaxAffectedTargets;
     }
 
     /**
@@ -1224,10 +1096,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 spellDamageTypeId
      */
-    int GetDmgClass(lua_State* L, SpellEntry* entry)
+    uint32 GetDmgClass(SpellEntry* entry)
     {
-        ALE::Push(L, entry->DmgClass);
-        return 1;
+        return entry->DmgClass;
     }
 
     /**
@@ -1235,10 +1106,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 preventionTypeId
      */
-    int GetPreventionType(lua_State* L, SpellEntry* entry)
+    uint32 GetPreventionType(SpellEntry* entry)
     {
-        ALE::Push(L, entry->PreventionType);
-        return 1;
+        return entry->PreventionType;
     }
 
     /**
@@ -1246,20 +1116,17 @@ namespace LuaSpellEntry
      *
      * @return table effectDamageMultipliers
      */
-    int GetEffectDamageMultiplier(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectDamageMultiplier(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectDamageMultiplier.size(); ++index)
         {
-            ALE::Push(L, entry->EffectDamageMultiplier[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectDamageMultiplier[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1267,20 +1134,17 @@ namespace LuaSpellEntry
      *
      * @return table totemCategory
      */
-    int GetTotemCategory(lua_State* L, SpellEntry* entry)
+    sol::table GetTotemCategory(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->TotemCategory.size(); ++index)
         {
-            ALE::Push(L, entry->TotemCategory[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->TotemCategory[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1290,10 +1154,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 areaGroupId
      */
-    int GetAreaGroupId(lua_State* L, SpellEntry* entry)
+    int32 GetAreaGroupId(SpellEntry* entry)
     {
-        ALE::Push(L, entry->AreaGroupId);
-        return 1;
+        return entry->AreaGroupId;
     }
 
     /**
@@ -1301,10 +1164,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 schoolMask : bitmask, returned as uint32.
      */
-    int GetSchoolMask(lua_State* L, SpellEntry* entry)
+    uint32 GetSchoolMask(SpellEntry* entry)
     {
-        ALE::Push(L, entry->SchoolMask);
-        return 1;
+        return entry->SchoolMask;
     }
 
     /**
@@ -1312,10 +1174,9 @@ namespace LuaSpellEntry
      *
      * @return uint32 runeCostId
      */
-    int GetRuneCostID(lua_State* L, SpellEntry* entry)
+    uint32 GetRuneCostID(SpellEntry* entry)
     {
-        ALE::Push(L, entry->RuneCostID);
-        return 1;
+        return entry->RuneCostID;
     }
 
     /**
@@ -1323,20 +1184,17 @@ namespace LuaSpellEntry
      *
      * @return table effectBonusMultipliers
      */
-    int GetEffectBonusMultiplier(lua_State* L, SpellEntry* entry)
+    sol::table GetEffectBonusMultiplier(SpellEntry* entry, sol::this_state s)
     {
-        lua_newtable(L);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (size_t index = 0; index < entry->EffectBonusMultiplier.size(); ++index)
         {
-            ALE::Push(L, entry->EffectBonusMultiplier[index]);
-            lua_rawseti(L, tbl, ++i);
+            tbl[++i] = entry->EffectBonusMultiplier[index];
         }
-        
-        lua_settop(L, tbl); // push table to top of stack
-        return 1;
+
+        return tbl;
     }
 
     /**
@@ -1344,17 +1202,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 category : the new category value
      */
-    int SetCategory(lua_State* L, SpellEntry* entry)
+    void SetCategory(SpellEntry* entry, uint32 category)
     {
-        uint32 category = ALE::CHECKVAL<uint32>(L, 2);
         entry->Category = category;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->CategoryEntry = category ? sSpellCategoryStore.LookupEntry(category) : nullptr;
         }
-        
-        return 0;
     }
 
     /**
@@ -1362,17 +1217,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 dispel : the new dispel type value
      */
-    int SetDispel(lua_State* L, SpellEntry* entry)
+    void SetDispel(SpellEntry* entry, uint32 dispel)
     {
-        uint32 dispel = ALE::CHECKVAL<uint32>(L, 2);
         entry->Dispel = dispel;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->Dispel = dispel;
         }
-        
-        return 0;
     }
 
     /**
@@ -1380,17 +1232,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 mechanic : the new mechanic value
      */
-    int SetMechanic(lua_State* L, SpellEntry* entry)
+    void SetMechanic(SpellEntry* entry, uint32 mechanic)
     {
-        uint32 mechanic = ALE::CHECKVAL<uint32>(L, 2);
         entry->Mechanic = mechanic;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->Mechanic = mechanic;
         }
-        
-        return 0;
     }
 
     /**
@@ -1398,17 +1247,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributes : the new attributes bitmask
      */
-    int SetAttributes(lua_State* L, SpellEntry* entry)
+    void SetAttributes(SpellEntry* entry, uint32 attributes)
     {
-        uint32 attributes = ALE::CHECKVAL<uint32>(L, 2);
         entry->Attributes = attributes;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->Attributes = attributes;
         }
-        
-        return 0;
     }
 
     /**
@@ -1416,17 +1262,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributesEx : the new attributesEx bitmask
      */
-    int SetAttributesEx(lua_State* L, SpellEntry* entry)
+    void SetAttributesEx(SpellEntry* entry, uint32 attributesEx)
     {
-        uint32 attributesEx = ALE::CHECKVAL<uint32>(L, 2);
         entry->AttributesEx = attributesEx;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AttributesEx = attributesEx;
         }
-        
-        return 0;
     }
 
     /**
@@ -1434,17 +1277,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributesEx2 : the new attributesEx2 bitmask
      */
-    int SetAttributesEx2(lua_State* L, SpellEntry* entry)
+    void SetAttributesEx2(SpellEntry* entry, uint32 attributesEx2)
     {
-        uint32 attributesEx2 = ALE::CHECKVAL<uint32>(L, 2);
         entry->AttributesEx2 = attributesEx2;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AttributesEx2 = attributesEx2;
         }
-        
-        return 0;
     }
 
     /**
@@ -1452,17 +1292,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributesEx3 : the new attributesEx3 bitmask
      */
-    int SetAttributesEx3(lua_State* L, SpellEntry* entry)
+    void SetAttributesEx3(SpellEntry* entry, uint32 attributesEx3)
     {
-        uint32 attributesEx3 = ALE::CHECKVAL<uint32>(L, 2);
         entry->AttributesEx3 = attributesEx3;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AttributesEx3 = attributesEx3;
         }
-        
-        return 0;
     }
 
     /**
@@ -1470,17 +1307,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributesEx4 : the new attributesEx4 bitmask
      */
-    int SetAttributesEx4(lua_State* L, SpellEntry* entry)
+    void SetAttributesEx4(SpellEntry* entry, uint32 attributesEx4)
     {
-        uint32 attributesEx4 = ALE::CHECKVAL<uint32>(L, 2);
         entry->AttributesEx4 = attributesEx4;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AttributesEx4 = attributesEx4;
         }
-        
-        return 0;
     }
 
     /**
@@ -1488,17 +1322,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributesEx5 : the new attributesEx5 bitmask
      */
-    int SetAttributesEx5(lua_State* L, SpellEntry* entry)
+    void SetAttributesEx5(SpellEntry* entry, uint32 attributesEx5)
     {
-        uint32 attributesEx5 = ALE::CHECKVAL<uint32>(L, 2);
         entry->AttributesEx5 = attributesEx5;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AttributesEx5 = attributesEx5;
         }
-        
-        return 0;
     }
 
     /**
@@ -1506,17 +1337,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributesEx6 : the new attributesEx6 bitmask
      */
-    int SetAttributesEx6(lua_State* L, SpellEntry* entry)
+    void SetAttributesEx6(SpellEntry* entry, uint32 attributesEx6)
     {
-        uint32 attributesEx6 = ALE::CHECKVAL<uint32>(L, 2);
         entry->AttributesEx6 = attributesEx6;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AttributesEx6 = attributesEx6;
         }
-        
-        return 0;
     }
 
     /**
@@ -1524,17 +1352,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 attributesEx7 : the new attributesEx7 bitmask
      */
-    int SetAttributesEx7(lua_State* L, SpellEntry* entry)
+    void SetAttributesEx7(SpellEntry* entry, uint32 attributesEx7)
     {
-        uint32 attributesEx7 = ALE::CHECKVAL<uint32>(L, 2);
         entry->AttributesEx7 = attributesEx7;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AttributesEx7 = attributesEx7;
         }
-        
-        return 0;
     }
 
     /**
@@ -1542,17 +1367,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 stances : the new stances bitmask
      */
-    int SetStances(lua_State* L, SpellEntry* entry)
+    void SetStances(SpellEntry* entry, uint32 stances)
     {
-        uint32 stances = ALE::CHECKVAL<uint32>(L, 2);
         entry->Stances = stances;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->Stances = stances;
         }
-
-        return 0;
     }
 
     /**
@@ -1560,17 +1382,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 stancesNot : the new stancesNot bitmask
      */
-    int SetStancesNot(lua_State* L, SpellEntry* entry)
+    void SetStancesNot(SpellEntry* entry, uint32 stancesNot)
     {
-        uint32 stancesNot = ALE::CHECKVAL<uint32>(L, 2);
         entry->StancesNot = stancesNot;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->StancesNot = stancesNot;
         }
-
-        return 0;
     }
 
     /**
@@ -1578,17 +1397,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 targets : the new targets bitmask
      */
-    int SetTargets(lua_State* L, SpellEntry* entry)
+    void SetTargets(SpellEntry* entry, uint32 targets)
     {
-        uint32 targets = ALE::CHECKVAL<uint32>(L, 2);
         entry->Targets = targets;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->Targets = targets;
         }
-
-        return 0;
     }
 
     /**
@@ -1596,17 +1412,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 targetCreatureType : the new target creature type bitmask
      */
-    int SetTargetCreatureType(lua_State* L, SpellEntry* entry)
+    void SetTargetCreatureType(SpellEntry* entry, uint32 targetCreatureType)
     {
-        uint32 targetCreatureType = ALE::CHECKVAL<uint32>(L, 2);
         entry->TargetCreatureType = targetCreatureType;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->TargetCreatureType = targetCreatureType;
         }
-
-        return 0;
     }
 
     /**
@@ -1614,17 +1427,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 requiresSpellFocus : the new requires spell focus value
      */
-    int SetRequiresSpellFocus(lua_State* L, SpellEntry* entry)
+    void SetRequiresSpellFocus(SpellEntry* entry, uint32 requiresSpellFocus)
     {
-        uint32 requiresSpellFocus = ALE::CHECKVAL<uint32>(L, 2);
         entry->RequiresSpellFocus = requiresSpellFocus;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->RequiresSpellFocus = requiresSpellFocus;
         }
-
-        return 0;
     }
 
     /**
@@ -1632,17 +1442,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 facingCasterFlags : the new facing caster flags value
      */
-    int SetFacingCasterFlags(lua_State* L, SpellEntry* entry)
+    void SetFacingCasterFlags(SpellEntry* entry, uint32 facingCasterFlags)
     {
-        uint32 facingCasterFlags = ALE::CHECKVAL<uint32>(L, 2);
         entry->FacingCasterFlags = facingCasterFlags;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->FacingCasterFlags = facingCasterFlags;
         }
-
-        return 0;
     }
 
     /**
@@ -1650,17 +1457,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 casterAuraState : the new caster aura state value
      */
-    int SetCasterAuraState(lua_State* L, SpellEntry* entry)
+    void SetCasterAuraState(SpellEntry* entry, uint32 casterAuraState)
     {
-        uint32 casterAuraState = ALE::CHECKVAL<uint32>(L, 2);
         entry->CasterAuraState = casterAuraState;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->CasterAuraState = casterAuraState;
         }
-
-        return 0;
     }
 
     /**
@@ -1668,17 +1472,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 targetAuraState : the new target aura state value
      */
-    int SetTargetAuraState(lua_State* L, SpellEntry* entry)
+    void SetTargetAuraState(SpellEntry* entry, uint32 targetAuraState)
     {
-        uint32 targetAuraState = ALE::CHECKVAL<uint32>(L, 2);
         entry->TargetAuraState = targetAuraState;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->TargetAuraState = targetAuraState;
         }
-
-        return 0;
     }
 
     /**
@@ -1686,17 +1487,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 casterAuraStateNot : the new caster aura state not value
      */
-    int SetCasterAuraStateNot(lua_State* L, SpellEntry* entry)
+    void SetCasterAuraStateNot(SpellEntry* entry, uint32 casterAuraStateNot)
     {
-        uint32 casterAuraStateNot = ALE::CHECKVAL<uint32>(L, 2);
         entry->CasterAuraStateNot = casterAuraStateNot;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->CasterAuraStateNot = casterAuraStateNot;
         }
-
-        return 0;
     }
 
     /**
@@ -1704,17 +1502,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 targetAuraStateNot : the new target aura state not value
      */
-    int SetTargetAuraStateNot(lua_State* L, SpellEntry* entry)
+    void SetTargetAuraStateNot(SpellEntry* entry, uint32 targetAuraStateNot)
     {
-        uint32 targetAuraStateNot = ALE::CHECKVAL<uint32>(L, 2);
         entry->TargetAuraStateNot = targetAuraStateNot;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->TargetAuraStateNot = targetAuraStateNot;
         }
-
-        return 0;
     }
 
     /**
@@ -1722,17 +1517,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 casterAuraSpell : the new caster aura spell ID
      */
-    int SetCasterAuraSpell(lua_State* L, SpellEntry* entry)
+    void SetCasterAuraSpell(SpellEntry* entry, uint32 casterAuraSpell)
     {
-        uint32 casterAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
         entry->CasterAuraSpell = casterAuraSpell;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->CasterAuraSpell = casterAuraSpell;
         }
-
-        return 0;
     }
 
     /**
@@ -1740,17 +1532,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 targetAuraSpell : the new target aura spell ID
      */
-    int SetTargetAuraSpell(lua_State* L, SpellEntry* entry)
+    void SetTargetAuraSpell(SpellEntry* entry, uint32 targetAuraSpell)
     {
-        uint32 targetAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
         entry->TargetAuraSpell = targetAuraSpell;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->TargetAuraSpell = targetAuraSpell;
         }
-
-        return 0;
     }
 
     /**
@@ -1758,17 +1547,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 excludeCasterAuraSpell : the new exclude caster aura spell ID
      */
-    int SetExcludeCasterAuraSpell(lua_State* L, SpellEntry* entry)
+    void SetExcludeCasterAuraSpell(SpellEntry* entry, uint32 excludeCasterAuraSpell)
     {
-        uint32 excludeCasterAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
         entry->ExcludeCasterAuraSpell = excludeCasterAuraSpell;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ExcludeCasterAuraSpell = excludeCasterAuraSpell;
         }
-
-        return 0;
     }
 
     /**
@@ -1776,17 +1562,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 excludeTargetAuraSpell : the new exclude target aura spell ID
      */
-    int SetExcludeTargetAuraSpell(lua_State* L, SpellEntry* entry)
+    void SetExcludeTargetAuraSpell(SpellEntry* entry, uint32 excludeTargetAuraSpell)
     {
-        uint32 excludeTargetAuraSpell = ALE::CHECKVAL<uint32>(L, 2);
         entry->ExcludeTargetAuraSpell = excludeTargetAuraSpell;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ExcludeTargetAuraSpell = excludeTargetAuraSpell;
         }
-
-        return 0;
     }
 
     /**
@@ -1794,17 +1577,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 recoveryTime : the new recovery time value
      */
-    int SetRecoveryTime(lua_State* L, SpellEntry* entry)
+    void SetRecoveryTime(SpellEntry* entry, uint32 recoveryTime)
     {
-        uint32 recoveryTime = ALE::CHECKVAL<uint32>(L, 2);
         entry->RecoveryTime = recoveryTime;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->RecoveryTime = recoveryTime;
         }
-
-        return 0;
     }
 
     /**
@@ -1812,17 +1592,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 categoryRecoveryTime : the new category recovery time value in milliseconds
      */
-    int SetCategoryRecoveryTime(lua_State* L, SpellEntry* entry)
+    void SetCategoryRecoveryTime(SpellEntry* entry, uint32 categoryRecoveryTime)
     {
-        uint32 categoryRecoveryTime = ALE::CHECKVAL<uint32>(L, 2);
         entry->CategoryRecoveryTime = categoryRecoveryTime;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->CategoryRecoveryTime = categoryRecoveryTime;
         }
-
-        return 0;
     }
 
     /**
@@ -1830,17 +1607,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 interruptFlags : the new interrupt flags bitmask
      */
-    int SetInterruptFlags(lua_State* L, SpellEntry* entry)
+    void SetInterruptFlags(SpellEntry* entry, uint32 interruptFlags)
     {
-        uint32 interruptFlags = ALE::CHECKVAL<uint32>(L, 2);
         entry->InterruptFlags = interruptFlags;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->InterruptFlags = interruptFlags;
         }
-
-        return 0;
     }
 
     /**
@@ -1848,17 +1622,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 auraInterruptFlags : the new aura interrupt flags bitmask
      */
-    int SetAuraInterruptFlags(lua_State* L, SpellEntry* entry)
+    void SetAuraInterruptFlags(SpellEntry* entry, uint32 auraInterruptFlags)
     {
-        uint32 auraInterruptFlags = ALE::CHECKVAL<uint32>(L, 2);
         entry->AuraInterruptFlags = auraInterruptFlags;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->AuraInterruptFlags = auraInterruptFlags;
         }
-
-        return 0;
     }
 
     /**
@@ -1866,17 +1637,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 channelInterruptFlags : the new channel interrupt flags bitmask
      */
-    int SetChannelInterruptFlags(lua_State* L, SpellEntry* entry)
+    void SetChannelInterruptFlags(SpellEntry* entry, uint32 channelInterruptFlags)
     {
-        uint32 channelInterruptFlags = ALE::CHECKVAL<uint32>(L, 2);
         entry->ChannelInterruptFlags = channelInterruptFlags;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ChannelInterruptFlags = channelInterruptFlags;
         }
-
-        return 0;
     }
 
     /**
@@ -1884,17 +1652,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 procFlags : the new proc flags bitmask
      */
-    int SetProcFlags(lua_State* L, SpellEntry* entry)
+    void SetProcFlags(SpellEntry* entry, uint32 procFlags)
     {
-        uint32 procFlags = ALE::CHECKVAL<uint32>(L, 2);
         entry->ProcFlags = procFlags;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ProcFlags = procFlags;
         }
-
-        return 0;
     }
 
     /**
@@ -1902,17 +1667,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 procChance : the new proc chance value
      */
-    int SetProcChance(lua_State* L, SpellEntry* entry)
+    void SetProcChance(SpellEntry* entry, uint32 procChance)
     {
-        uint32 procChance = ALE::CHECKVAL<uint32>(L, 2);
         entry->ProcChance = procChance;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ProcChance = procChance;
         }
-
-        return 0;
     }
 
     /**
@@ -1920,17 +1682,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 procCharges : the new proc charges value
      */
-    int SetProcCharges(lua_State* L, SpellEntry* entry)
+    void SetProcCharges(SpellEntry* entry, uint32 procCharges)
     {
-        uint32 procCharges = ALE::CHECKVAL<uint32>(L, 2);
         entry->ProcCharges = procCharges;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ProcCharges = procCharges;
         }
-
-        return 0;
     }
 
     /**
@@ -1938,17 +1697,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 maxLevel : the new max level value
      */
-    int SetMaxLevel(lua_State* L, SpellEntry* entry)
+    void SetMaxLevel(SpellEntry* entry, uint32 maxLevel)
     {
-        uint32 maxLevel = ALE::CHECKVAL<uint32>(L, 2);
         entry->MaxLevel = maxLevel;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->MaxLevel = maxLevel;
         }
-
-        return 0;
     }
 
     /**
@@ -1956,17 +1712,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 baseLevel : the new base level value
      */
-    int SetBaseLevel(lua_State* L, SpellEntry* entry)
+    void SetBaseLevel(SpellEntry* entry, uint32 baseLevel)
     {
-        uint32 baseLevel = ALE::CHECKVAL<uint32>(L, 2);
         entry->BaseLevel = baseLevel;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->BaseLevel = baseLevel;
         }
-
-        return 0;
     }
 
     /**
@@ -1974,17 +1727,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 spellLevel : the new spell level value
      */
-    int SetSpellLevel(lua_State* L, SpellEntry* entry)
+    void SetSpellLevel(SpellEntry* entry, uint32 spellLevel)
     {
-        uint32 spellLevel = ALE::CHECKVAL<uint32>(L, 2);
         entry->SpellLevel = spellLevel;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->SpellLevel = spellLevel;
         }
-
-        return 0;
     }
 
     /**
@@ -1992,17 +1742,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 manaCost : the new mana cost value
      */
-    int SetManaCost(lua_State* L, SpellEntry* entry)
+    void SetManaCost(SpellEntry* entry, uint32 manaCost)
     {
-        uint32 manaCost = ALE::CHECKVAL<uint32>(L, 2);
         entry->ManaCost = manaCost;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ManaCost = manaCost;
         }
-        
-        return 0;
     }
 
     /**
@@ -2010,17 +1757,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 powerType : the new power type ID
      */
-    int SetPowerType(lua_State* L, SpellEntry* entry)
+    void SetPowerType(SpellEntry* entry, uint32 powerType)
     {
-        uint32 powerType = ALE::CHECKVAL<uint32>(L, 2);
         entry->PowerType = powerType;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->PowerType = powerType;
         }
-        
-        return 0;
     }
 
     /**
@@ -2028,17 +1772,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 manaCostPerlevel : the new mana cost per level value
      */
-    int SetManaCostPerlevel(lua_State* L, SpellEntry* entry)
+    void SetManaCostPerlevel(SpellEntry* entry, uint32 manaCostPerlevel)
     {
-        uint32 manaCostPerlevel = ALE::CHECKVAL<uint32>(L, 2);
         entry->ManaCostPerlevel = manaCostPerlevel;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ManaCostPerlevel = manaCostPerlevel;
         }
-        
-        return 0;
     }
 
     /**
@@ -2046,17 +1787,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 manaPerSecond : the new mana per second value
      */
-    int SetManaPerSecond(lua_State* L, SpellEntry* entry)
+    void SetManaPerSecond(SpellEntry* entry, uint32 manaPerSecond)
     {
-        uint32 manaPerSecond = ALE::CHECKVAL<uint32>(L, 2);
         entry->ManaPerSecond = manaPerSecond;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ManaPerSecond = manaPerSecond;
         }
-        
-        return 0;
     }
 
     /**
@@ -2064,17 +1802,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 manaPerSecondPerLevel : the new mana per second per level value
      */
-    int SetManaPerSecondPerLevel(lua_State* L, SpellEntry* entry)
+    void SetManaPerSecondPerLevel(SpellEntry* entry, uint32 manaPerSecondPerLevel)
     {
-        uint32 manaPerSecondPerLevel = ALE::CHECKVAL<uint32>(L, 2);
         entry->ManaPerSecondPerLevel = manaPerSecondPerLevel;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ManaPerSecondPerLevel = manaPerSecondPerLevel;
         }
-        
-        return 0;
     }
 
     /**
@@ -2082,17 +1817,14 @@ namespace LuaSpellEntry
      *
      * @param float speed : the new speed value
      */
-    int SetSpeed(lua_State* L, SpellEntry* entry)
+    void SetSpeed(SpellEntry* entry, float speed)
     {
-        float speed = ALE::CHECKVAL<float>(L, 2);
         entry->Speed = speed;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->Speed = speed;
         }
-        
-        return 0;
     }
 
     /**
@@ -2100,17 +1832,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 stackAmount : the new stack amount value
      */
-    int SetStackAmount(lua_State* L, SpellEntry* entry)
+    void SetStackAmount(SpellEntry* entry, uint32 stackAmount)
     {
-        uint32 stackAmount = ALE::CHECKVAL<uint32>(L, 2);
         entry->StackAmount = stackAmount;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->StackAmount = stackAmount;
         }
-
-        return 0;
     }
 
     /**
@@ -2118,17 +1847,14 @@ namespace LuaSpellEntry
      *
      * @param int32 equippedItemClass : the new equipped item class value
      */
-    int SetEquippedItemClass(lua_State* L, SpellEntry* entry)
+    void SetEquippedItemClass(SpellEntry* entry, int32 equippedItemClass)
     {
-        int32 equippedItemClass = ALE::CHECKVAL<int32>(L, 2);
         entry->EquippedItemClass = equippedItemClass;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->EquippedItemClass = equippedItemClass;
         }
-
-        return 0;
     }
 
     /**
@@ -2136,17 +1862,14 @@ namespace LuaSpellEntry
      *
      * @param int32 equippedItemSubClassMask : the new equipped item sub class mask bitmasks
      */
-    int SetEquippedItemSubClassMask(lua_State* L, SpellEntry* entry)
+    void SetEquippedItemSubClassMask(SpellEntry* entry, int32 equippedItemSubClassMask)
     {
-        int32 equippedItemSubClassMask = ALE::CHECKVAL<int32>(L, 2);
         entry->EquippedItemSubClassMask = equippedItemSubClassMask;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->EquippedItemSubClassMask = equippedItemSubClassMask;
         }
-
-        return 0;
     }
 
     /**
@@ -2154,17 +1877,14 @@ namespace LuaSpellEntry
      *
      * @param int32 equippedItemInventoryTypeMask : the new equipped item inventory type mask bitmasks
      */
-    int SetEquippedItemInventoryTypeMask(lua_State* L, SpellEntry* entry)
+    void SetEquippedItemInventoryTypeMask(SpellEntry* entry, int32 equippedItemInventoryTypeMask)
     {
-        int32 equippedItemInventoryTypeMask = ALE::CHECKVAL<int32>(L, 2);
         entry->EquippedItemInventoryTypeMask = equippedItemInventoryTypeMask;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->EquippedItemInventoryTypeMask = equippedItemInventoryTypeMask;
         }
-
-        return 0;
     }
 
     /**
@@ -2172,17 +1892,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 spellIconID : the new spell icon ID value
      */
-    int SetSpellIconID(lua_State* L, SpellEntry* entry)
+    void SetSpellIconID(SpellEntry* entry, uint32 spellIconID)
     {
-        uint32 spellIconID = ALE::CHECKVAL<uint32>(L, 2);
         entry->SpellIconID = spellIconID;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->SpellIconID = spellIconID;
         }
-
-        return 0;
     }
 
     /**
@@ -2190,17 +1907,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 activeIconID : the new active icon ID value
      */
-    int SetActiveIconID(lua_State* L, SpellEntry* entry)
+    void SetActiveIconID(SpellEntry* entry, uint32 activeIconID)
     {
-        uint32 activeIconID = ALE::CHECKVAL<uint32>(L, 2);
         entry->ActiveIconID = activeIconID;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ActiveIconID = activeIconID;
         }
-
-        return 0;
     }
 
     /**
@@ -2208,17 +1922,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 spellPriority : the new spell priority value
      */
-    int SetSpellPriority(lua_State* L, SpellEntry* entry)
+    void SetSpellPriority(SpellEntry* entry, uint32 spellPriority)
     {
-        uint32 spellPriority = ALE::CHECKVAL<uint32>(L, 2);
         entry->SpellPriority = spellPriority;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->SpellPriority = spellPriority;
         }
-
-        return 0;
     }
 
     /**
@@ -2226,17 +1937,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 manaCostPercentage : the new mana cost percentage value
      */
-    int SetManaCostPercentage(lua_State* L, SpellEntry* entry)
+    void SetManaCostPercentage(SpellEntry* entry, uint32 manaCostPercentage)
     {
-        uint32 manaCostPercentage = ALE::CHECKVAL<uint32>(L, 2);
         entry->ManaCostPercentage = manaCostPercentage;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->ManaCostPercentage = manaCostPercentage;
         }
-        
-        return 0;
     }
 
     /**
@@ -2244,17 +1952,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 startRecoveryCategory : the new start recovery category value
      */
-    int SetStartRecoveryCategory(lua_State* L, SpellEntry* entry)
+    void SetStartRecoveryCategory(SpellEntry* entry, uint32 startRecoveryCategory)
     {
-        uint32 startRecoveryCategory = ALE::CHECKVAL<uint32>(L, 2);
         entry->StartRecoveryCategory = startRecoveryCategory;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->StartRecoveryCategory = startRecoveryCategory;
         }
-
-        return 0;
     }
 
     /**
@@ -2262,17 +1967,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 startRecoveryTime : the new start recovery time value
      */
-    int SetStartRecoveryTime(lua_State* L, SpellEntry* entry)
+    void SetStartRecoveryTime(SpellEntry* entry, uint32 startRecoveryTime)
     {
-        uint32 startRecoveryTime = ALE::CHECKVAL<uint32>(L, 2);
         entry->StartRecoveryTime = startRecoveryTime;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->StartRecoveryTime = startRecoveryTime;
         }
-
-        return 0;
     }
 
     /**
@@ -2280,17 +1982,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 maxTargetLevel : the new max target level value
      */
-    int SetMaxTargetLevel(lua_State* L, SpellEntry* entry)
+    void SetMaxTargetLevel(SpellEntry* entry, uint32 maxTargetLevel)
     {
-        uint32 maxTargetLevel = ALE::CHECKVAL<uint32>(L, 2);
         entry->MaxTargetLevel = maxTargetLevel;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->MaxTargetLevel = maxTargetLevel;
         }
-
-        return 0;
     }
 
     /**
@@ -2298,17 +1997,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 spellFamilyName : the new spell family name value
      */
-    int SetSpellFamilyName(lua_State* L, SpellEntry* entry)
+    void SetSpellFamilyName(SpellEntry* entry, uint32 spellFamilyName)
     {
-        uint32 spellFamilyName = ALE::CHECKVAL<uint32>(L, 2);
         entry->SpellFamilyName = spellFamilyName;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->SpellFamilyName = spellFamilyName;
         }
-
-        return 0;
     }
 
     /**
@@ -2316,17 +2012,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 maxAffectedTargets : the new max affected targets value
      */
-    int SetMaxAffectedTargets(lua_State* L, SpellEntry* entry)
+    void SetMaxAffectedTargets(SpellEntry* entry, uint32 maxAffectedTargets)
     {
-        uint32 maxAffectedTargets = ALE::CHECKVAL<uint32>(L, 2);
         entry->MaxAffectedTargets = maxAffectedTargets;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->MaxAffectedTargets = maxAffectedTargets;
         }
-
-        return 0;
     }
 
     /**
@@ -2334,17 +2027,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 dmgClass : the new damage class ID value
      */
-    int SetDmgClass(lua_State* L, SpellEntry* entry)
+    void SetDmgClass(SpellEntry* entry, uint32 dmgClass)
     {
-        uint32 dmgClass = ALE::CHECKVAL<uint32>(L, 2);
         entry->DmgClass = dmgClass;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->DmgClass = dmgClass;
         }
-
-        return 0;
     }
 
     /**
@@ -2352,17 +2042,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 preventionType : the new prevention type ID value
      */
-    int SetPreventionType(lua_State* L, SpellEntry* entry)
+    void SetPreventionType(SpellEntry* entry, uint32 preventionType)
     {
-        uint32 preventionType = ALE::CHECKVAL<uint32>(L, 2);
         entry->PreventionType = preventionType;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->PreventionType = preventionType;
         }
-
-        return 0;
     }
 
     /**
@@ -2370,17 +2057,14 @@ namespace LuaSpellEntry
      *
      * @param uint32 schoolMask : the new school mask bitmask value
      */
-    int SetSchoolMask(lua_State* L, SpellEntry* entry)
+    void SetSchoolMask(SpellEntry* entry, uint32 schoolMask)
     {
-        uint32 schoolMask = ALE::CHECKVAL<uint32>(L, 2);
         entry->SchoolMask = schoolMask;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->SchoolMask = schoolMask;
         }
-
-        return 0;
     }
 
     /**
@@ -2388,18 +2072,170 @@ namespace LuaSpellEntry
      *
      * @param uint32 runeCostID : the new rune cost ID value
      */
-    int SetRuneCostID(lua_State* L, SpellEntry* entry)
+    void SetRuneCostID(SpellEntry* entry, uint32 runeCostID)
     {
-        uint32 runeCostID = ALE::CHECKVAL<uint32>(L, 2);
         entry->RuneCostID = runeCostID;
 
         if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(entry->Id))
         {
             const_cast<SpellInfo*>(spellInfo)->RuneCostID = runeCostID;
         }
-
-        return 0;
     }
 }
 
-#endif
+void RegisterSpellEntryMethods(sol::state& lua)
+{
+    sol::usertype<SpellEntry> type = lua.new_usertype<SpellEntry>("SpellEntry", sol::no_constructor);
+
+    type["GetId"]                            = &LuaSpellEntry::GetId;
+    type["GetCategory"]                      = &LuaSpellEntry::GetCategory;
+    type["GetDispel"]                        = &LuaSpellEntry::GetDispel;
+    type["GetMechanic"]                      = &LuaSpellEntry::GetMechanic;
+    type["GetAttributes"]                    = &LuaSpellEntry::GetAttributes;
+    type["GetAttributesEx"]                  = &LuaSpellEntry::GetAttributesEx;
+    type["GetAttributesEx2"]                 = &LuaSpellEntry::GetAttributesEx2;
+    type["GetAttributesEx3"]                 = &LuaSpellEntry::GetAttributesEx3;
+    type["GetAttributesEx4"]                 = &LuaSpellEntry::GetAttributesEx4;
+    type["GetAttributesEx5"]                 = &LuaSpellEntry::GetAttributesEx5;
+    type["GetAttributesEx6"]                 = &LuaSpellEntry::GetAttributesEx6;
+    type["GetAttributesEx7"]                 = &LuaSpellEntry::GetAttributesEx7;
+    type["GetStances"]                       = &LuaSpellEntry::GetStances;
+    type["GetStancesNot"]                    = &LuaSpellEntry::GetStancesNot;
+    type["GetTargets"]                       = &LuaSpellEntry::GetTargets;
+    type["GetTargetCreatureType"]            = &LuaSpellEntry::GetTargetCreatureType;
+    type["GetRequiresSpellFocus"]            = &LuaSpellEntry::GetRequiresSpellFocus;
+    type["GetFacingCasterFlags"]             = &LuaSpellEntry::GetFacingCasterFlags;
+    type["GetCasterAuraState"]               = &LuaSpellEntry::GetCasterAuraState;
+    type["GetTargetAuraState"]               = &LuaSpellEntry::GetTargetAuraState;
+    type["GetCasterAuraStateNot"]            = &LuaSpellEntry::GetCasterAuraStateNot;
+    type["GetTargetAuraStateNot"]            = &LuaSpellEntry::GetTargetAuraStateNot;
+    type["GetCasterAuraSpell"]               = &LuaSpellEntry::GetCasterAuraSpell;
+    type["GetTargetAuraSpell"]               = &LuaSpellEntry::GetTargetAuraSpell;
+    type["GetExcludeCasterAuraSpell"]        = &LuaSpellEntry::GetExcludeCasterAuraSpell;
+    type["GetExcludeTargetAuraSpell"]        = &LuaSpellEntry::GetExcludeTargetAuraSpell;
+    type["GetCastingTimeIndex"]              = &LuaSpellEntry::GetCastingTimeIndex;
+    type["GetRecoveryTime"]                  = &LuaSpellEntry::GetRecoveryTime;
+    type["GetCategoryRecoveryTime"]          = &LuaSpellEntry::GetCategoryRecoveryTime;
+    type["GetInterruptFlags"]                = &LuaSpellEntry::GetInterruptFlags;
+    type["GetAuraInterruptFlags"]            = &LuaSpellEntry::GetAuraInterruptFlags;
+    type["GetChannelInterruptFlags"]         = &LuaSpellEntry::GetChannelInterruptFlags;
+    type["GetProcFlags"]                     = &LuaSpellEntry::GetProcFlags;
+    type["GetProcChance"]                    = &LuaSpellEntry::GetProcChance;
+    type["GetProcCharges"]                   = &LuaSpellEntry::GetProcCharges;
+    type["GetMaxLevel"]                      = &LuaSpellEntry::GetMaxLevel;
+    type["GetBaseLevel"]                     = &LuaSpellEntry::GetBaseLevel;
+    type["GetSpellLevel"]                    = &LuaSpellEntry::GetSpellLevel;
+    type["GetDurationIndex"]                 = &LuaSpellEntry::GetDurationIndex;
+    type["GetPowerType"]                     = &LuaSpellEntry::GetPowerType;
+    type["GetManaCost"]                      = &LuaSpellEntry::GetManaCost;
+    type["GetManaCostPerlevel"]              = &LuaSpellEntry::GetManaCostPerlevel;
+    type["GetManaPerSecond"]                 = &LuaSpellEntry::GetManaPerSecond;
+    type["GetManaPerSecondPerLevel"]         = &LuaSpellEntry::GetManaPerSecondPerLevel;
+    type["GetRangeIndex"]                    = &LuaSpellEntry::GetRangeIndex;
+    type["GetSpeed"]                         = &LuaSpellEntry::GetSpeed;
+    type["GetStackAmount"]                   = &LuaSpellEntry::GetStackAmount;
+    type["GetTotem"]                         = &LuaSpellEntry::GetTotem;
+    type["GetReagent"]                       = &LuaSpellEntry::GetReagent;
+    type["GetReagentCount"]                  = &LuaSpellEntry::GetReagentCount;
+    type["GetEquippedItemClass"]             = &LuaSpellEntry::GetEquippedItemClass;
+    type["GetEquippedItemSubClassMask"]      = &LuaSpellEntry::GetEquippedItemSubClassMask;
+    type["GetEquippedItemInventoryTypeMask"] = &LuaSpellEntry::GetEquippedItemInventoryTypeMask;
+    type["GetEffect"]                        = &LuaSpellEntry::GetEffect;
+    type["GetEffectDieSides"]                = &LuaSpellEntry::GetEffectDieSides;
+    type["GetEffectRealPointsPerLevel"]      = &LuaSpellEntry::GetEffectRealPointsPerLevel;
+    type["GetEffectBasePoints"]              = &LuaSpellEntry::GetEffectBasePoints;
+    type["GetEffectMechanic"]                = &LuaSpellEntry::GetEffectMechanic;
+    type["GetEffectImplicitTargetA"]         = &LuaSpellEntry::GetEffectImplicitTargetA;
+    type["GetEffectImplicitTargetB"]         = &LuaSpellEntry::GetEffectImplicitTargetB;
+    type["GetEffectRadiusIndex"]             = &LuaSpellEntry::GetEffectRadiusIndex;
+    type["GetEffectApplyAuraName"]           = &LuaSpellEntry::GetEffectApplyAuraName;
+    type["GetEffectAmplitude"]               = &LuaSpellEntry::GetEffectAmplitude;
+    type["GetEffectValueMultiplier"]         = &LuaSpellEntry::GetEffectValueMultiplier;
+    type["GetEffectChainTarget"]             = &LuaSpellEntry::GetEffectChainTarget;
+    type["GetEffectItemType"]                = &LuaSpellEntry::GetEffectItemType;
+    type["GetEffectMiscValue"]               = &LuaSpellEntry::GetEffectMiscValue;
+    type["GetEffectMiscValueB"]              = &LuaSpellEntry::GetEffectMiscValueB;
+    type["GetEffectTriggerSpell"]            = &LuaSpellEntry::GetEffectTriggerSpell;
+    type["GetEffectPointsPerComboPoint"]     = &LuaSpellEntry::GetEffectPointsPerComboPoint;
+    type["GetEffectSpellClassMask"]          = &LuaSpellEntry::GetEffectSpellClassMask;
+    type["GetSpellVisual"]                   = &LuaSpellEntry::GetSpellVisual;
+    type["GetSpellIconID"]                   = &LuaSpellEntry::GetSpellIconID;
+    type["GetActiveIconID"]                  = &LuaSpellEntry::GetActiveIconID;
+    type["GetSpellPriority"]                 = &LuaSpellEntry::GetSpellPriority;
+    type["GetSpellName"]                     = &LuaSpellEntry::GetSpellName;
+    type["GetRank"]                          = &LuaSpellEntry::GetRank;
+    type["GetManaCostPercentage"]            = &LuaSpellEntry::GetManaCostPercentage;
+    type["GetStartRecoveryCategory"]         = &LuaSpellEntry::GetStartRecoveryCategory;
+    type["GetStartRecoveryTime"]             = &LuaSpellEntry::GetStartRecoveryTime;
+    type["GetMaxTargetLevel"]                = &LuaSpellEntry::GetMaxTargetLevel;
+    type["GetSpellFamilyName"]               = &LuaSpellEntry::GetSpellFamilyName;
+    type["GetSpellFamilyFlags"]              = &LuaSpellEntry::GetSpellFamilyFlags;
+    type["GetMaxAffectedTargets"]            = &LuaSpellEntry::GetMaxAffectedTargets;
+    type["GetDmgClass"]                      = &LuaSpellEntry::GetDmgClass;
+    type["GetPreventionType"]                = &LuaSpellEntry::GetPreventionType;
+    type["GetEffectDamageMultiplier"]        = &LuaSpellEntry::GetEffectDamageMultiplier;
+    type["GetTotemCategory"]                 = &LuaSpellEntry::GetTotemCategory;
+    type["GetAreaGroupId"]                   = &LuaSpellEntry::GetAreaGroupId;
+    type["GetSchoolMask"]                    = &LuaSpellEntry::GetSchoolMask;
+    type["GetRuneCostID"]                    = &LuaSpellEntry::GetRuneCostID;
+    type["GetEffectBonusMultiplier"]         = &LuaSpellEntry::GetEffectBonusMultiplier;
+    type["SetCategory"]                      = &LuaSpellEntry::SetCategory;
+    type["SetDispel"]                        = &LuaSpellEntry::SetDispel;
+    type["SetMechanic"]                      = &LuaSpellEntry::SetMechanic;
+    type["SetAttributes"]                    = &LuaSpellEntry::SetAttributes;
+    type["SetAttributesEx"]                  = &LuaSpellEntry::SetAttributesEx;
+    type["SetAttributesEx2"]                 = &LuaSpellEntry::SetAttributesEx2;
+    type["SetAttributesEx3"]                 = &LuaSpellEntry::SetAttributesEx3;
+    type["SetAttributesEx4"]                 = &LuaSpellEntry::SetAttributesEx4;
+    type["SetAttributesEx5"]                 = &LuaSpellEntry::SetAttributesEx5;
+    type["SetAttributesEx6"]                 = &LuaSpellEntry::SetAttributesEx6;
+    type["SetAttributesEx7"]                 = &LuaSpellEntry::SetAttributesEx7;
+    type["SetStances"]                       = &LuaSpellEntry::SetStances;
+    type["SetStancesNot"]                    = &LuaSpellEntry::SetStancesNot;
+    type["SetTargets"]                       = &LuaSpellEntry::SetTargets;
+    type["SetTargetCreatureType"]            = &LuaSpellEntry::SetTargetCreatureType;
+    type["SetRequiresSpellFocus"]            = &LuaSpellEntry::SetRequiresSpellFocus;
+    type["SetFacingCasterFlags"]             = &LuaSpellEntry::SetFacingCasterFlags;
+    type["SetCasterAuraState"]               = &LuaSpellEntry::SetCasterAuraState;
+    type["SetTargetAuraState"]               = &LuaSpellEntry::SetTargetAuraState;
+    type["SetCasterAuraStateNot"]            = &LuaSpellEntry::SetCasterAuraStateNot;
+    type["SetTargetAuraStateNot"]            = &LuaSpellEntry::SetTargetAuraStateNot;
+    type["SetCasterAuraSpell"]               = &LuaSpellEntry::SetCasterAuraSpell;
+    type["SetTargetAuraSpell"]               = &LuaSpellEntry::SetTargetAuraSpell;
+    type["SetExcludeCasterAuraSpell"]        = &LuaSpellEntry::SetExcludeCasterAuraSpell;
+    type["SetExcludeTargetAuraSpell"]        = &LuaSpellEntry::SetExcludeTargetAuraSpell;
+    type["SetRecoveryTime"]                  = &LuaSpellEntry::SetRecoveryTime;
+    type["SetCategoryRecoveryTime"]          = &LuaSpellEntry::SetCategoryRecoveryTime;
+    type["SetInterruptFlags"]                = &LuaSpellEntry::SetInterruptFlags;
+    type["SetAuraInterruptFlags"]            = &LuaSpellEntry::SetAuraInterruptFlags;
+    type["SetChannelInterruptFlags"]         = &LuaSpellEntry::SetChannelInterruptFlags;
+    type["SetProcFlags"]                     = &LuaSpellEntry::SetProcFlags;
+    type["SetProcChance"]                    = &LuaSpellEntry::SetProcChance;
+    type["SetProcCharges"]                   = &LuaSpellEntry::SetProcCharges;
+    type["SetMaxLevel"]                      = &LuaSpellEntry::SetMaxLevel;
+    type["SetBaseLevel"]                     = &LuaSpellEntry::SetBaseLevel;
+    type["SetSpellLevel"]                    = &LuaSpellEntry::SetSpellLevel;
+    type["SetManaCost"]                      = &LuaSpellEntry::SetManaCost;
+    type["SetPowerType"]                     = &LuaSpellEntry::SetPowerType;
+    type["SetManaCostPerlevel"]              = &LuaSpellEntry::SetManaCostPerlevel;
+    type["SetManaPerSecond"]                 = &LuaSpellEntry::SetManaPerSecond;
+    type["SetManaPerSecondPerLevel"]         = &LuaSpellEntry::SetManaPerSecondPerLevel;
+    type["SetSpeed"]                         = &LuaSpellEntry::SetSpeed;
+    type["SetStackAmount"]                   = &LuaSpellEntry::SetStackAmount;
+    type["SetEquippedItemClass"]             = &LuaSpellEntry::SetEquippedItemClass;
+    type["SetEquippedItemSubClassMask"]      = &LuaSpellEntry::SetEquippedItemSubClassMask;
+    type["SetEquippedItemInventoryTypeMask"] = &LuaSpellEntry::SetEquippedItemInventoryTypeMask;
+    type["SetSpellIconID"]                   = &LuaSpellEntry::SetSpellIconID;
+    type["SetActiveIconID"]                  = &LuaSpellEntry::SetActiveIconID;
+    type["SetSpellPriority"]                 = &LuaSpellEntry::SetSpellPriority;
+    type["SetManaCostPercentage"]            = &LuaSpellEntry::SetManaCostPercentage;
+    type["SetStartRecoveryCategory"]         = &LuaSpellEntry::SetStartRecoveryCategory;
+    type["SetStartRecoveryTime"]             = &LuaSpellEntry::SetStartRecoveryTime;
+    type["SetMaxTargetLevel"]                = &LuaSpellEntry::SetMaxTargetLevel;
+    type["SetSpellFamilyName"]               = &LuaSpellEntry::SetSpellFamilyName;
+    type["SetMaxAffectedTargets"]            = &LuaSpellEntry::SetMaxAffectedTargets;
+    type["SetDmgClass"]                      = &LuaSpellEntry::SetDmgClass;
+    type["SetPreventionType"]                = &LuaSpellEntry::SetPreventionType;
+    type["SetSchoolMask"]                    = &LuaSpellEntry::SetSchoolMask;
+    type["SetRuneCostID"]                    = &LuaSpellEntry::SetRuneCostID;
+}
diff --git a/src/LuaEngine/methods/SpellInfoMethods.h b/src/LuaEngine/methods/SpellInfoMethods.cpp
similarity index 59%
rename from src/LuaEngine/methods/SpellInfoMethods.h
rename to src/LuaEngine/methods/SpellInfoMethods.cpp
index 3b69015718..d05ed9d214 100644
--- a/src/LuaEngine/methods/SpellInfoMethods.h
+++ b/src/LuaEngine/methods/SpellInfoMethods.cpp
@@ -4,8 +4,11 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef SPELLINFOMETHODS_H
-#define SPELLINFOMETHODS_H
+#include "ALEBind.h"
+
+#include "Common.h"
+#include "SharedDefines.h"
+#include "SpellInfo.h"
 
 /***
  * Represents spell metadata used for behavior, targeting, attributes, mechanics, auras, and conditions.
@@ -39,13 +42,11 @@ namespace LuaSpellInfo
      * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the [SpellInfo]'s name
      * @return [string] name
      */
-    int GetName(lua_State* L, SpellInfo* spell_info)
+    char const* GetName(SpellInfo* spell_info, sol::optional<uint8> locale)
     {
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 2, DEFAULT_LOCALE);
-        ALE::Push(L, spell_info->SpellName[static_cast<LocaleConstant>(locale)]);
-        return 1;
+        return spell_info->SpellName[static_cast<LocaleConstant>(locale.value_or(DEFAULT_LOCALE))];
     }
-    
+
     /**
      * Checks if the [SpellInfo] has a specific attribute.
      *
@@ -53,7 +54,7 @@ namespace LuaSpellInfo
      * Attributes are divided into different categories (from 0 to 8 in this context).
      *
      * Here is how each attribute is inspected:
-     * 
+     *
      * <pre>
      * 0 : SpellAttr0
      * 1 : SpellAttr1
@@ -70,16 +71,14 @@ namespace LuaSpellInfo
      * @param [uint32] attribute : the specific attribute to check.
      * @return [bool] has_attribute
      */
-    int HasAttribute(lua_State* L, SpellInfo* spell_info)
+    bool HasAttribute(SpellInfo* spell_info, int8 attributeType, uint32 attribute)
     {
-        int8 attributeType = ALE::CHECKVAL<int8>(L, 2);
-        uint32 attribute    = ALE::CHECKVAL<uint32>(L, 3);
-
         bool hasAttribute = false;
-        if ( attributeType == -1 ) {
-            hasAttribute = spell_info->HasAttribute(static_cast<SpellCustomAttributes>(attribute));           ;
-        }else{
-            switch(attributeType)
+        if (attributeType == -1)
+            hasAttribute = spell_info->HasAttribute(static_cast<SpellCustomAttributes>(attribute));
+        else
+        {
+            switch (attributeType)
             {
                 case 0:
                     hasAttribute = spell_info->HasAttribute(static_cast<SpellAttr0>(attribute));
@@ -110,10 +109,9 @@ namespace LuaSpellInfo
             }
         }
 
-        ALE::Push(L, hasAttribute);
-        return 1;
+        return hasAttribute;
     }
-    
+
     /**
      * Retrieves the attributes of the [SpellInfo] based on the attribute type.
      *
@@ -136,16 +134,15 @@ namespace LuaSpellInfo
      * @param [int8] attributeType : The type of the attribute.
      * @return [uint32] attributes
      */
-    int GetAttributes(lua_State* L, SpellInfo* spell_info)
+    uint32 GetAttributes(SpellInfo* spell_info, int8 attributeType)
     {
-        int8 attributeType = ALE::CHECKVAL<int8>(L, 2);
-        uint32 attributes;
+        uint32 attributes = 0;
 
-        if ( attributeType == -1 ) {
+        if (attributeType == -1)
             attributes = spell_info->AttributesCu;
-        }
-        else {
-            switch(attributeType)
+        else
+        {
+            switch (attributeType)
             {
                 case 0:
                     attributes = spell_info->Attributes;
@@ -174,42 +171,39 @@ namespace LuaSpellInfo
             }
         }
 
-        ALE::Push(L, attributes);
-        return 1;
+        return attributes;
     }
-    
+
     /**
      * Determines whether the [SpellInfo] affects an area (AOE - Area of Effect)
      *
      * The affected area will depend upon the specifics of the spell.
      * A target can be an individual unit, player, or an area, and the spellInfo stores these details.
-     * 
+     *
      * The function checks the spell's attributes to determine if the spell is designed to affect an area or not.
      * The outcome relies on spell's attributes field.
-     * 
+     *
      * @return [bool] is_affecting_area
      */
-    int IsAffectingArea(lua_State* L, SpellInfo* spell_info)
+    bool IsAffectingArea(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsAffectingArea());
-        return 1;
+        return spell_info->IsAffectingArea();
     }
-    
+
     /**
      * Retrieves the category of the [SpellInfo].
      *
      * A spell's category is a way of grouping similar spells together.
-     * It might define the spell's nature or its effect. 
+     * It might define the spell's nature or its effect.
      * For instance, damage spells, heal spells, and crowd-control spells might each have a different category.
      *
      * @return [uint32] category
      */
-    int GetCategory(lua_State* L, SpellInfo* spell_info)
+    uint32 GetCategory(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->GetCategory());
-        return 1;
+        return spell_info->GetCategory();
     }
-    
+
     /**
      * Checks if the [SpellInfo] has a specific effect.
      *
@@ -217,57 +211,50 @@ namespace LuaSpellInfo
      * These effects are identified by a predefined set of constants represented by the 'SpellEffects' enumeration.
      *
      * @param [uint8] effect : The specific effect to check.
-     * @return [bool] has_effect 
+     * @return [bool] has_effect
      */
-    int HasEffect(lua_State* L, SpellInfo* spell_info)
+    bool HasEffect(SpellInfo* spell_info, uint8 effect)
     {
-        uint8 effect = ALE::CHECKVAL<uint8>(L, 2);
-        ALE::Push(L, spell_info->HasEffect(static_cast<SpellEffects>(effect)));
-        return 1;
+        return spell_info->HasEffect(static_cast<SpellEffects>(effect));
     }
-    
+
     /**
      * Checks if the [SpellInfo] has a specific aura.
      *
-     * An aura represents a status change or modification due to a spell or ability. 
+     * An aura represents a status change or modification due to a spell or ability.
      * These auras are identified by a predefined set of constants represented by the 'AuraType' enumeration.
      *
      * @param [uint32] aura : The specific aura to check.
      * @return [bool] has_aura
      */
-    int HasAura(lua_State* L, SpellInfo* spell_info)
+    bool HasAura(SpellInfo* spell_info, uint32 aura)
     {
-        uint32 aura = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, spell_info->HasAura(static_cast<AuraType>(aura)));
-        return 1;
+        return spell_info->HasAura(static_cast<AuraType>(aura));
     }
-    
+
     /**
      * Checks if the [SpellInfo] has an area aura effect.
      *
      * Area aura is a type of spell effect that affects multiple targets within a certain area.
-     * 
+     *
      * @return [bool] has_area_aura_effect
      */
-    int HasAreaAuraEffect(lua_State* L, SpellInfo* spell_info)
+    bool HasAreaAuraEffect(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->HasAreaAuraEffect());
-        return 1;
+        return spell_info->HasAreaAuraEffect();
     }
-    
-   
+
     /**
      * Checks if the [SpellInfo] is an explicit discovery.
      *
-     * An "explicit discovery" may refer to a spell that is not intuitive or is hidden and must be specifically 
+     * An "explicit discovery" may refer to a spell that is not intuitive or is hidden and must be specifically
      * discovered by the player through some sort of action or event.
      *
      * @return [bool] is_explicit_discovery
      */
-    int IsExplicitDiscovery(lua_State* L, SpellInfo* spell_info)
+    bool IsExplicitDiscovery(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsExplicitDiscovery());
-        return 1;
+        return spell_info->IsExplicitDiscovery();
     }
 
     /**
@@ -278,10 +265,9 @@ namespace LuaSpellInfo
      *
      * @return [bool] is_loot_crafting
      */
-    int IsLootCrafting(lua_State* L, SpellInfo* spell_info)
+    bool IsLootCrafting(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsLootCrafting());
-        return 1;
+        return spell_info->IsLootCrafting();
     }
 
     /**
@@ -292,83 +278,76 @@ namespace LuaSpellInfo
      *
      * @return [bool] is_profression_or_riding
      */
-    int IsProfessionOrRiding(lua_State* L, SpellInfo* spell_info)
+    bool IsProfessionOrRiding(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsProfessionOrRiding());
-        return 1;
+        return spell_info->IsProfessionOrRiding();
     }
 
     /**
      * Checks if the [SpellInfo] is related to a profession skill.
      *
-     * Profession skills may refer to abilities related to a specific occupation or trade, 
+     * Profession skills may refer to abilities related to a specific occupation or trade,
      * such as blacksmithing, alchemy, fishing, etc.
      *
      * @return [bool] is_profession
      */
-    int IsProfession(lua_State* L, SpellInfo* spell_info)
+    bool IsProfession(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsProfession());
-        return 1;
+        return spell_info->IsProfession();
     }
 
     /**
      * Checks if the [SpellInfo] is related to a primary profession skill.
      *
-     * Primary profession skills usually refer to main occupations or trades of the player character, 
+     * Primary profession skills usually refer to main occupations or trades of the player character,
      * such as blacksmithing, alchemy, mining, etc.
      *
      * @return [bool] is_primary_profession
      */
-    int IsPrimaryProfession(lua_State* L, SpellInfo* spell_info)
+    bool IsPrimaryProfession(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsPrimaryProfession());
-        return 1;
+        return spell_info->IsPrimaryProfession();
     }
 
     /**
      * Checks if the [SpellInfo] represents the first rank of a primary profession skill.
-     * 
-     * Primary profession skills usually refer to main occupations or trades of the player character. 
+     *
+     * Primary profession skills usually refer to main occupations or trades of the player character.
      * The first rank typically indicates the introductory level of the profession.
      *
      * @return [bool] is_primary_profession_first_rank
      */
-    int IsPrimaryProfessionFirstRank(lua_State* L, SpellInfo* spell_info)
+    bool IsPrimaryProfessionFirstRank(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsPrimaryProfessionFirstRank());
-        return 1;
+        return spell_info->IsPrimaryProfessionFirstRank();
     }
 
     /**
      * Checks if the [SpellInfo] represents an ability learned with a profession skill.
      *
-     * Certain abilities or skills (like crafting item or gathering materials) 
+     * Certain abilities or skills (like crafting item or gathering materials)
      * can be learned as part of a profession.
      *
      * @return [bool] is_ability_learned_with_profession
      */
-    int IsAbilityLearnedWithProfession(lua_State* L, SpellInfo* spell_info)
+    bool IsAbilityLearnedWithProfession(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsAbilityLearnedWithProfession());
-        return 1;
+        return spell_info->IsAbilityLearnedWithProfession();
     }
 
     /**
      * Checks if the [SpellInfo] represents an ability of a specific skill type.
      *
-     * This function allows checking if a spell or ability belongs to a specific skill type. 
-     * The skill type is often represented as an integral value (in this case, uint32), 
+     * This function allows checking if a spell or ability belongs to a specific skill type.
+     * The skill type is often represented as an integral value (in this case, uint32),
      * where each value may correspond to a different skill category such as crafting, combat, magic, etc.
      *
      * @param [uint32] skillType: The skill type to check against. Should be an integral value representing the skill type.
      * @return [bool] is_ability_of_skill_type
      */
-    int IsAbilityOfSkillType(lua_State* L, SpellInfo* spell_info)
+    bool IsAbilityOfSkillType(SpellInfo* spell_info, uint32 skillType)
     {
-        uint32 skillType = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, spell_info->IsAbilityOfSkillType(skillType));
-        return 1;
+        return spell_info->IsAbilityOfSkillType(skillType);
     }
 
     /**
@@ -378,129 +357,119 @@ namespace LuaSpellInfo
      *
      * @return [bool] is_targeting_area
      */
-    int IsTargetingArea(lua_State* L, SpellInfo* spell_info)
+    bool IsTargetingArea(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsTargetingArea());
-        return 1;
+        return spell_info->IsTargetingArea();
     }
 
     /**
      * Checks if the [SpellInfo] requires an explicit unit target.
      *
-     * Certain spells or abilities can only be cast or used when a specific unit (like a player character, NPC, or enemy) is targeted. 
+     * Certain spells or abilities can only be cast or used when a specific unit (like a player character, NPC, or enemy) is targeted.
      * This function checks if the spell or ability represented by [SpellInfo] has this requirement.
      *
      * @return [bool] needs_explicit_unit_target
      */
-    int NeedsExplicitUnitTarget(lua_State* L, SpellInfo* spell_info)
+    bool NeedsExplicitUnitTarget(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->NeedsExplicitUnitTarget());
-        return 1;
+        return spell_info->NeedsExplicitUnitTarget();
     }
 
     /**
      * Checks if the [SpellInfo] requires to be triggered by the caster of another specified [SpellInfo].
      *
-     * Certain spells or abilities can only be activated or become effective when they are triggered by the caster 
-     * of another specific spell (the `triggeringSpell`). This function examines if the spell or ability represented 
+     * Certain spells or abilities can only be activated or become effective when they are triggered by the caster
+     * of another specific spell (the `triggeringSpell`). This function examines if the spell or ability represented
      * by [SpellInfo] has such requirement.
      *
      * @param [SpellInfo] triggeringSpell : the spell by the casting of which the ability or spell represented by [SpellInfo] is triggered
      * @return [bool] needs_to_be_triggered_by_caster
      */
-    int NeedsToBeTriggeredByCaster(lua_State* L, SpellInfo* spell_info)
+    bool NeedsToBeTriggeredByCaster(SpellInfo* spell_info, SpellInfo const* triggeringSpell)
     {
-        const SpellInfo* triggeringSpell = ALE::CHECKOBJ<SpellInfo>(L, 2);
-        ALE::Push(L, spell_info->NeedsToBeTriggeredByCaster(triggeringSpell));
-        return 1;
+        return spell_info->NeedsToBeTriggeredByCaster(triggeringSpell);
     }
 
     /**
      * Checks if the [SpellInfo] represents a self-casting spell or ability.
      *
-     * Self-casting spells or abilities are those that the casters use on themselves. This can include 
-     * defensive spells, healing spells, buffs, or any other type of effect that a player character or 
+     * Self-casting spells or abilities are those that the casters use on themselves. This can include
+     * defensive spells, healing spells, buffs, or any other type of effect that a player character or
      * NPC applies on themselves.
      *
      * @return [bool] is_self_cast
      */
-    int IsSelfCast(lua_State* L, SpellInfo* spell_info)
+    bool IsSelfCast(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsSelfCast());
-        return 1;
+        return spell_info->IsSelfCast();
     }
 
     /**
      * Checks if the [SpellInfo] represents a passive spell or ability.
      *
-     * Passive spells or abilities are those that are always in effect, without the need for the player or 
+     * Passive spells or abilities are those that are always in effect, without the need for the player or
      * NPC to manually activate them. They usually provide their bonus or effect as long as certain conditions are met.
      *
      * @return [bool] is_passive
      */
-    int IsPassive(lua_State* L, SpellInfo* spell_info)
+    bool IsPassive(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsPassive());
-        return 1;
+        return spell_info->IsPassive();
     }
 
     /**
      * Checks if the [SpellInfo] represents a spell or ability that can be set to autocast.
      *
-     * Autocasting is a feature that allows certain abilities or spells to be cast automatically by the game's 
-     * AI when certain conditions are met. This function checks if the spell or ability represented by [SpellInfo] 
+     * Autocasting is a feature that allows certain abilities or spells to be cast automatically by the game's
+     * AI when certain conditions are met. This function checks if the spell or ability represented by [SpellInfo]
      * can be set to autocast.
      *
      * @return [bool] is_autocastable
      */
-    int IsAutocastable(lua_State* L, SpellInfo* spell_info)
+    bool IsAutocastable(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsAutocastable());
-        return 1;
+        return spell_info->IsAutocastable();
     }
 
     /**
      * Determines if the [SpellInfo] represents a spell or ability that stack with different ranks.
      *
-     * Some spells or abilities can accumulate or "stack" their effects with multiple activations 
-     * and these effects can sometimes vary based on the rank or level of the spell. This function checks 
+     * Some spells or abilities can accumulate or "stack" their effects with multiple activations
+     * and these effects can sometimes vary based on the rank or level of the spell. This function checks
      * if the spell represented by [SpellInfo] has this capacity.
      *
      * @return [bool] is_stackable_with_ranks
      */
-    int IsStackableWithRanks(lua_State* L, SpellInfo* spell_info)
+    bool IsStackableWithRanks(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsStackableWithRanks());
-        return 1;
+        return spell_info->IsStackableWithRanks();
     }
 
     /**
      * Checks if the [SpellInfo] represents a passive spell or ability that is stackable with different ranks.
      *
-     * Some passive spells or abilities are designed to stack their effects with multiple activations, and these effects 
-     * can also vary depending on the rank of the spell. This function assesses whether the spell or ability represented 
+     * Some passive spells or abilities are designed to stack their effects with multiple activations, and these effects
+     * can also vary depending on the rank of the spell. This function assesses whether the spell or ability represented
      * by [SpellInfo] has this property.
      *
      * @return [bool] is_passive_stackable_with_ranks
      */
-    int IsPassiveStackableWithRanks(lua_State* L, SpellInfo* spell_info)
+    bool IsPassiveStackableWithRanks(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsPassiveStackableWithRanks());
-        return 1;
+        return spell_info->IsPassiveStackableWithRanks();
     }
 
     /**
      * Checks if the [SpellInfo] represents a multi-slot aura spell or effect.
      *
-     * A multi-slot aura is one that takes up more than one slot or position in the game's effect array or system. 
+     * A multi-slot aura is one that takes up more than one slot or position in the game's effect array or system.
      * This function checks if the spell or ability represented by [SpellInfo] has this property.
      *
      * @return [bool] is_multi_slot_aura
      */
-    int IsMultiSlotAura(lua_State* L, SpellInfo* spell_info)
+    bool IsMultiSlotAura(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsMultiSlotAura());
-        return 1;
+        return spell_info->IsMultiSlotAura();
     }
 
     /**
@@ -508,10 +477,9 @@ namespace LuaSpellInfo
      *
      * @return [bool] is_cooldown_started_on_event
      */
-    int IsCooldownStartedOnEvent(lua_State* L, SpellInfo* spell_info)
+    bool IsCooldownStartedOnEvent(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsCooldownStartedOnEvent());
-        return 1;
+        return spell_info->IsCooldownStartedOnEvent();
     }
 
     /**
@@ -519,10 +487,9 @@ namespace LuaSpellInfo
      *
      * @return [bool] is_death_persistant
      */
-    int IsDeathPersistent(lua_State* L, SpellInfo* spell_info)
+    bool IsDeathPersistent(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsDeathPersistent());
-        return 1;
+        return spell_info->IsDeathPersistent();
     }
 
     /**
@@ -530,10 +497,9 @@ namespace LuaSpellInfo
      *
      * @return [bool] : true if the [SpellInfo] requires a dead target; false otherwise
      */
-    int IsRequiringDeadTarget(lua_State* L, SpellInfo* spell_info)
+    bool IsRequiringDeadTarget(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsRequiringDeadTarget());
-        return 1;
+        return spell_info->IsRequiringDeadTarget();
     }
 
     /**
@@ -541,10 +507,9 @@ namespace LuaSpellInfo
      *
      * @return bool allowsDeadTarget
      */
-    int IsAllowingDeadTarget(lua_State* L, SpellInfo* spell_info)
+    bool IsAllowingDeadTarget(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsAllowingDeadTarget());
-        return 1;
+        return spell_info->IsAllowingDeadTarget();
     }
 
     /**
@@ -552,10 +517,9 @@ namespace LuaSpellInfo
      *
      * @return bool usableInCombat
      */
-    int CanBeUsedInCombat(lua_State* L, SpellInfo* spell_info)
+    bool CanBeUsedInCombat(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->CanBeUsedInCombat());
-        return 1;
+        return spell_info->CanBeUsedInCombat();
     }
 
     /**
@@ -563,10 +527,9 @@ namespace LuaSpellInfo
      *
      * @return bool isPositive
      */
-    int IsPositive(lua_State* L, SpellInfo* spell_info)
+    bool IsPositive(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsPositive());
-        return 1;
+        return spell_info->IsPositive();
     }
 
     /**
@@ -575,11 +538,9 @@ namespace LuaSpellInfo
      * @param uint8 effIndex
      * @return bool isPositiveEffect
      */
-    int IsPositiveEffect(lua_State* L, SpellInfo* spell_info)
+    bool IsPositiveEffect(SpellInfo* spell_info, uint8 effIndex)
     {
-        uint8 effIndex = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, spell_info->IsPositiveEffect(effIndex));
-        return 1;
+        return spell_info->IsPositiveEffect(effIndex);
     }
 
     /**
@@ -587,10 +548,9 @@ namespace LuaSpellInfo
      *
      * @return bool isChanneled
      */
-    int IsChanneled(lua_State* L, SpellInfo* spell_info)
+    bool IsChanneled(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsChanneled());
-        return 1;
+        return spell_info->IsChanneled();
     }
 
     /**
@@ -598,10 +558,9 @@ namespace LuaSpellInfo
      *
      * @return bool needsComboPoints
      */
-    int NeedsComboPoints(lua_State* L, SpellInfo* spell_info)
+    bool NeedsComboPoints(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->NeedsComboPoints());
-        return 1;
+        return spell_info->NeedsComboPoints();
     }
 
     /**
@@ -609,10 +568,9 @@ namespace LuaSpellInfo
      *
      * @return bool breaksStealth
      */
-    int IsBreakingStealth(lua_State* L, SpellInfo* spell_info)
+    bool IsBreakingStealth(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsBreakingStealth());
-        return 1;
+        return spell_info->IsBreakingStealth();
     }
 
     /**
@@ -620,10 +578,9 @@ namespace LuaSpellInfo
      *
      * @return bool isRangedWeaponSpell
      */
-    int IsRangedWeaponSpell(lua_State* L, SpellInfo* spell_info)
+    bool IsRangedWeaponSpell(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsRangedWeaponSpell());
-        return 1;
+        return spell_info->IsRangedWeaponSpell();
     }
 
     /**
@@ -631,107 +588,92 @@ namespace LuaSpellInfo
      *
      * @return bool isAutoRepeat
      */
-    int IsAutoRepeatRangedSpell(lua_State* L, SpellInfo* spell_info)
+    bool IsAutoRepeatRangedSpell(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsAutoRepeatRangedSpell());
-        return 1;
-    }  
+        return spell_info->IsAutoRepeatRangedSpell();
+    }
 
     /**
      * Returns `true` if the [SpellInfo] is affected by spell modifiers (e.g., talents, auras), `false` otherwise.
      *
      * @return bool isAffectedByMods
      */
-    int IsAffectedBySpellMods(lua_State* L, SpellInfo* spell_info)
+    bool IsAffectedBySpellMods(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsAffectedBySpellMods());
-        return 1;
+        return spell_info->IsAffectedBySpellMods();
     }
-    
-    /*  int IsAffectedBySpellMod(lua_State* L, SpellInfo* spell_info)
+
+    /*  bool IsAffectedBySpellMod(SpellInfo* spell_info, SpellInfo const* auraSpellInfo)
         {
-            const SpellInfo* auraSpellInfo = ALE::CHECKOBJ<SpellInfo>(L, 2);
-            ALE::Push(L, spell_info->IsAffectedBySpellMod(auraSpellInfo));
-            return 1;
+            return spell_info->IsAffectedBySpellMod(auraSpellInfo);
         }
     */
-    
+
     /**
      * Returns `true` if the [SpellInfo] can pierce through an immunity aura defined by the given [SpellInfo], `false` otherwise.
      *
      * @param [SpellInfo] auraSpellInfo : the spell representing the immunity aura
      * @return bool canPierce
      */
-    int CanPierceImmuneAura(lua_State* L, SpellInfo* spell_info)
+    bool CanPierceImmuneAura(SpellInfo* spell_info, SpellInfo const* auraSpellInfo)
     {
-        const SpellInfo* auraSpellInfo = ALE::CHECKOBJ<SpellInfo>(L, 2);
-        ALE::Push(L, spell_info->CanPierceImmuneAura(auraSpellInfo));
-        return 1;
+        return spell_info->CanPierceImmuneAura(auraSpellInfo);
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] can dispel the specified aura [SpellInfo], `false` otherwise.
      *
      * @param [SpellInfo] auraSpellInfo : the aura spell to check
      * @return bool canDispel
      */
-    int CanDispelAura(lua_State* L, SpellInfo* spell_info)
+    bool CanDispelAura(SpellInfo* spell_info, SpellInfo const* auraSpellInfo)
     {
-        const SpellInfo* auraSpellInfo = ALE::CHECKOBJ<SpellInfo>(L, 2);
-        ALE::Push(L, spell_info->CanDispelAura(auraSpellInfo));
-        return 1;
+        return spell_info->CanDispelAura(auraSpellInfo);
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] only affects a single target, `false` if it affects multiple or area targets.
      *
      * @return bool isSingleTarget
      */
-    int IsSingleTarget(lua_State* L, SpellInfo* spell_info)
+    bool IsSingleTarget(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->IsSingleTarget());
-        return 1;
+        return spell_info->IsSingleTarget();
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] is mutually exclusive with the specified [SpellInfo] due to specific aura exclusivity rules.
      *
      * @param [SpellInfo] otherSpellInfo : the spell to compare exclusivity with
      * @return bool isExclusive
      */
-    int IsAuraExclusiveBySpecificWith(lua_State* L, SpellInfo* spell_info)
+    bool IsAuraExclusiveBySpecificWith(SpellInfo* spell_info, SpellInfo const* spellInfo)
     {
-        const SpellInfo* spellInfo = ALE::CHECKOBJ<SpellInfo>(L, 2);
-        ALE::Push(L, spell_info->IsAuraExclusiveBySpecificWith(spellInfo));
-        return 1;
+        return spell_info->IsAuraExclusiveBySpecificWith(spellInfo);
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] is exclusive with the specified [SpellInfo] per caster, based on aura exclusivity rules.
      *
      * @param [SpellInfo] otherSpellInfo : the spell to compare exclusivity with
      * @return bool isExclusivePerCaster
      */
-    int IsAuraExclusiveBySpecificPerCasterWith(lua_State* L, SpellInfo* spell_info)
+    bool IsAuraExclusiveBySpecificPerCasterWith(SpellInfo* spell_info, SpellInfo const* spellInfo)
     {
-        const SpellInfo* spellInfo = ALE::CHECKOBJ<SpellInfo>(L, 2);
-        ALE::Push(L, spell_info->IsAuraExclusiveBySpecificPerCasterWith(spellInfo));
-        return 1;
+        return spell_info->IsAuraExclusiveBySpecificPerCasterWith(spellInfo);
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] can be cast while in the specified shapeshift form.
      *
      * @param uint32 form : the shapeshift form to check
      * @return bool isAllowed
      */
-    int CheckShapeshift(lua_State* L, SpellInfo* spell_info)
+    SpellCastResult CheckShapeshift(SpellInfo* spell_info, uint32 form)
     {
-        uint32 form = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, spell_info->CheckShapeshift(form));
-        return 1;
+        return spell_info->CheckShapeshift(form);
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] can be cast in the specified location.
      *
@@ -742,18 +684,11 @@ namespace LuaSpellInfo
      * @param bool strict = false : whether all conditions must strictly match
      * @return bool isAllowed
      */
-    int CheckLocation(lua_State* L, SpellInfo* spell_info)
+    SpellCastResult CheckLocation(SpellInfo* spell_info, uint32 map_id, uint32 zone_id, uint32 area_id, Player* player, sol::optional<bool> strict)
     {
-        uint32 map_id = ALE::CHECKVAL<uint32>(L, 2);
-        uint32 zone_id = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 area_id = ALE::CHECKVAL<uint32>(L, 4);
-        Player* player = ALE::CHECKOBJ<Player>(L, 5);
-        bool strict = ALE::CHECKVAL<bool>(L, 6, false);
-
-        ALE::Push(L, spell_info->CheckLocation(map_id, zone_id, area_id, player, strict));
-        return 1;
+        return spell_info->CheckLocation(map_id, zone_id, area_id, player, strict.value_or(false));
     }
-    
+
     /**
      * Returns `true` if the target is valid for the [SpellInfo].
      *
@@ -762,16 +697,11 @@ namespace LuaSpellInfo
      * @param bool implicit = true : whether implicit target checks should apply
      * @return bool isValid
      */
-    int CheckTarget(lua_State* L, SpellInfo* spell_info)
+    SpellCastResult CheckTarget(SpellInfo* spell_info, Unit const* caster, WorldObject const* target, sol::optional<bool> implicit)
     {
-        const Unit* caster = ALE::CHECKOBJ<Unit>(L, 2);
-        const WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 3);
-        bool implicit = ALE::CHECKVAL<bool>(L, 4, true);
-
-        ALE::Push(L, spell_info->CheckTarget(caster, target, implicit));
-        return 1;
+        return spell_info->CheckTarget(caster, target, implicit.value_or(true));
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] can be explicitly cast on the given [target] with the optional [Item].
      *
@@ -780,30 +710,22 @@ namespace LuaSpellInfo
      * @param [Item] item : optional item used in the cast
      * @return bool isValid
      */
-    int CheckExplicitTarget(lua_State* L, SpellInfo* spell_info)
+    SpellCastResult CheckExplicitTarget(SpellInfo* spell_info, Unit const* caster, WorldObject const* target, Item const* item)
     {
-        const Unit* caster = ALE::CHECKOBJ<Unit>(L, 2);
-        const WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 3);
-        const Item* item = ALE::CHECKOBJ<Item>(L, 4, true);
-
-        ALE::Push(L, spell_info->CheckExplicitTarget(caster, target, item));
-        return 1;
+        return spell_info->CheckExplicitTarget(caster, target, item);
     }
-    
+
     /**
      * Returns `true` if the [SpellInfo] can affect the [Unit] based on its creature type.
      *
      * @param [Unit] target : the [Unit] whose creature type is evaluated
      * @return bool isValid
      */
-    int CheckTargetCreatureType(lua_State* L, SpellInfo* spell_info)
+    bool CheckTargetCreatureType(SpellInfo* spell_info, Unit const* target)
     {
-        const Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-
-        ALE::Push(L, spell_info->CheckTargetCreatureType(target));
-        return 1;
+        return spell_info->CheckTargetCreatureType(target);
     }
-    
+
     /**
      * Returns the school mask of the [SpellInfo].
      *
@@ -811,12 +733,11 @@ namespace LuaSpellInfo
      *
      * @return uint32 schoolMask
      */
-    int GetSchoolMask(lua_State* L, SpellInfo* spell_info)
+    SpellSchoolMask GetSchoolMask(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->GetSchoolMask());
-        return 1;
+        return spell_info->GetSchoolMask();
     }
-    
+
     /**
      * Returns a combined mechanic mask of all effects for the [SpellInfo].
      *
@@ -824,54 +745,44 @@ namespace LuaSpellInfo
      *
      * @return uint32 mechanicMask
      */
-    int GetAllEffectsMechanicMask(lua_State* L, SpellInfo* spell_info)
+    uint64 GetAllEffectsMechanicMask(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->GetAllEffectsMechanicMask());
-        return 1;
+        return spell_info->GetAllEffectsMechanicMask();
     }
-    
+
     /**
      * Returns the mechanic mask of a specific effect of the [SpellInfo].
      *
      * @param uint32 effIndex
      * @return uint32 mechanicMask
      */
-    int GetEffectMechanicMask(lua_State* L, SpellInfo* spell_info)
+    uint64 GetEffectMechanicMask(SpellInfo* spell_info, uint32 effIndex)
     {
-        uint32 effIndex = ALE::CHECKVAL<uint32>(L, 2);
-        
-        ALE::Push(L, spell_info->GetEffectMechanicMask(static_cast<SpellEffIndex>(effIndex)));
-        return 1;
+        return spell_info->GetEffectMechanicMask(static_cast<SpellEffIndex>(effIndex));
     }
-    
+
     /**
      * Returns the mechanic mask for the [SpellInfo] based on an effect bitmask.
      *
      * @param uint32 effectmask : bitmask of effects to include
      * @return uint32 mechanicMask
      */
-    int GetSpellMechanicMaskByEffectMask(lua_State* L, SpellInfo* spell_info)
+    uint64 GetSpellMechanicMaskByEffectMask(SpellInfo* spell_info, uint32 effectmask)
     {
-        uint32 effectmask = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, spell_info->GetSpellMechanicMaskByEffectMask(effectmask));
-        return 1;
+        return spell_info->GetSpellMechanicMaskByEffectMask(effectmask);
     }
-    
+
     /**
      * Returns the mechanic of the specified effect index in the [SpellInfo].
      *
      * @param uint32 effIndex
      * @return uint32 mechanic
      */
-    int GetEffectMechanic(lua_State* L, SpellInfo* spell_info)
+    Mechanics GetEffectMechanic(SpellInfo* spell_info, uint32 effIndex)
     {
-        uint32 effIndex = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, spell_info->GetEffectMechanic(static_cast<SpellEffIndex>(effIndex)));
-        return 1;
+        return spell_info->GetEffectMechanic(static_cast<SpellEffIndex>(effIndex));
     }
-    
+
     /**
      * Returns the dispel mask for the [SpellInfo].
      *
@@ -880,14 +791,12 @@ namespace LuaSpellInfo
      * @param uint32 type : optional type of dispel to check. If not provided, uses the spell's own dispel type.
      * @return uint32 dispelMask
      */
-    int GetDispelMask(lua_State* L, SpellInfo* spell_info)
+    uint32 GetDispelMask(SpellInfo* spell_info, sol::optional<uint32> type)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2, false);
-
-        ALE::Push(L, type != 0 ? spell_info->GetDispelMask(static_cast<DispelType>(type)) : spell_info->GetDispelMask());
-        return 1;
+        uint32 dispelType = type.value_or(0);
+        return dispelType != 0 ? spell_info->GetDispelMask(static_cast<DispelType>(dispelType)) : spell_info->GetDispelMask();
     }
-    
+
     /**
      * Returns the explicit target mask of the [SpellInfo].
      *
@@ -895,12 +804,11 @@ namespace LuaSpellInfo
      *
      * @return uint32 targetMask
      */
-    int GetExplicitTargetMask(lua_State* L, SpellInfo* spell_info)
+    uint32 GetExplicitTargetMask(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->GetExplicitTargetMask());
-        return 1;
+        return spell_info->GetExplicitTargetMask();
     }
-    
+
     /**
      * Returns the aura state requirement for the [SpellInfo].
      *
@@ -908,12 +816,11 @@ namespace LuaSpellInfo
      *
      * @return uint32 auraState
      */
-    int GetAuraState(lua_State* L, SpellInfo* spell_info)
+    AuraStateType GetAuraState(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->GetAuraState());
-        return 1;
+        return spell_info->GetAuraState();
     }
-    
+
     /**
      * Returns the spell specific type of the [SpellInfo].
      *
@@ -921,10 +828,9 @@ namespace LuaSpellInfo
      *
      * @return uint32 spellSpecific
      */
-    int GetSpellSpecific(lua_State* L, SpellInfo* spell_info)
+    SpellSpecificType GetSpellSpecific(SpellInfo* spell_info)
     {
-        ALE::Push(L, spell_info->GetSpellSpecific());
-        return 1;
+        return spell_info->GetSpellSpecific();
     }
 
     /**
@@ -939,24 +845,15 @@ namespace LuaSpellInfo
     * @param uint8 effectIndex : The index of the effect (0, 1, or 2)
     * @return int32 miscValueA : The MiscValueA value, or 0 if the effect doesn't exist
     */
-    int GetEffectMiscValueA(lua_State* L, SpellInfo* spell_info)
+    int32 GetEffectMiscValueA(SpellInfo* spell_info, uint8 effectIndex)
     {
-        uint8 effectIndex = ALE::CHECKVAL<uint8>(L, 2);
-        
         if (effectIndex >= MAX_SPELL_EFFECTS)
-        {
-            ALE::Push(L, 0);
-            return 1;
-        }
-        
+            return 0;
+
         if (spell_info->Effects[effectIndex].Effect == 0)
-        {
-            ALE::Push(L, 0);
-            return 1;
-        }
-        
-        ALE::Push(L, spell_info->Effects[effectIndex].MiscValue);
-        return 1;
+            return 0;
+
+        return spell_info->Effects[effectIndex].MiscValue;
     }
 
     /**
@@ -967,24 +864,79 @@ namespace LuaSpellInfo
     * @param uint8 effectIndex : The index of the effect (0, 1, or 2)
     * @return int32 miscValueB : The MiscValueB value, or 0 if the effect doesn't exist
     */
-    int GetEffectMiscValueB(lua_State* L, SpellInfo* spell_info)
+    int32 GetEffectMiscValueB(SpellInfo* spell_info, uint8 effectIndex)
     {
-        uint8 effectIndex = ALE::CHECKVAL<uint8>(L, 2);
-        
         if (effectIndex >= MAX_SPELL_EFFECTS)
-        {
-            ALE::Push(L, 0);
-            return 1;
-        }
-        
+            return 0;
+
         if (spell_info->Effects[effectIndex].Effect == 0)
-        {
-            ALE::Push(L, 0);
-            return 1;
-        }
-        
-        ALE::Push(L, spell_info->Effects[effectIndex].MiscValueB);
-        return 1;
+            return 0;
+
+        return spell_info->Effects[effectIndex].MiscValueB;
     }
 }
-#endif
+
+void RegisterSpellInfoMethods(sol::state& lua)
+{
+    sol::usertype<SpellInfo> type = lua.new_usertype<SpellInfo>("SpellInfo", sol::no_constructor);
+
+    type["GetName"]                                = &LuaSpellInfo::GetName;
+    type["HasAttribute"]                           = &LuaSpellInfo::HasAttribute;
+    type["GetAttributes"]                          = &LuaSpellInfo::GetAttributes;
+    type["IsAffectingArea"]                        = &LuaSpellInfo::IsAffectingArea;
+    type["GetCategory"]                            = &LuaSpellInfo::GetCategory;
+    type["HasEffect"]                              = &LuaSpellInfo::HasEffect;
+    type["HasAura"]                                = &LuaSpellInfo::HasAura;
+    type["HasAreaAuraEffect"]                      = &LuaSpellInfo::HasAreaAuraEffect;
+    type["IsExplicitDiscovery"]                    = &LuaSpellInfo::IsExplicitDiscovery;
+    type["IsLootCrafting"]                         = &LuaSpellInfo::IsLootCrafting;
+    type["IsProfessionOrRiding"]                   = &LuaSpellInfo::IsProfessionOrRiding;
+    type["IsProfession"]                           = &LuaSpellInfo::IsProfession;
+    type["IsPrimaryProfession"]                    = &LuaSpellInfo::IsPrimaryProfession;
+    type["IsPrimaryProfessionFirstRank"]           = &LuaSpellInfo::IsPrimaryProfessionFirstRank;
+    type["IsAbilityLearnedWithProfession"]         = &LuaSpellInfo::IsAbilityLearnedWithProfession;
+    type["IsAbilityOfSkillType"]                   = &LuaSpellInfo::IsAbilityOfSkillType;
+    type["IsTargetingArea"]                        = &LuaSpellInfo::IsTargetingArea;
+    type["NeedsExplicitUnitTarget"]                = &LuaSpellInfo::NeedsExplicitUnitTarget;
+    type["NeedsToBeTriggeredByCaster"]             = &LuaSpellInfo::NeedsToBeTriggeredByCaster;
+    type["IsSelfCast"]                             = &LuaSpellInfo::IsSelfCast;
+    type["IsPassive"]                              = &LuaSpellInfo::IsPassive;
+    type["IsAutocastable"]                         = &LuaSpellInfo::IsAutocastable;
+    type["IsStackableWithRanks"]                   = &LuaSpellInfo::IsStackableWithRanks;
+    type["IsPassiveStackableWithRanks"]            = &LuaSpellInfo::IsPassiveStackableWithRanks;
+    type["IsMultiSlotAura"]                        = &LuaSpellInfo::IsMultiSlotAura;
+    type["IsCooldownStartedOnEvent"]               = &LuaSpellInfo::IsCooldownStartedOnEvent;
+    type["IsDeathPersistent"]                      = &LuaSpellInfo::IsDeathPersistent;
+    type["IsRequiringDeadTarget"]                  = &LuaSpellInfo::IsRequiringDeadTarget;
+    type["IsAllowingDeadTarget"]                   = &LuaSpellInfo::IsAllowingDeadTarget;
+    type["CanBeUsedInCombat"]                      = &LuaSpellInfo::CanBeUsedInCombat;
+    type["IsPositive"]                             = &LuaSpellInfo::IsPositive;
+    type["IsPositiveEffect"]                       = &LuaSpellInfo::IsPositiveEffect;
+    type["IsChanneled"]                            = &LuaSpellInfo::IsChanneled;
+    type["NeedsComboPoints"]                       = &LuaSpellInfo::NeedsComboPoints;
+    type["IsBreakingStealth"]                      = &LuaSpellInfo::IsBreakingStealth;
+    type["IsRangedWeaponSpell"]                    = &LuaSpellInfo::IsRangedWeaponSpell;
+    type["IsAutoRepeatRangedSpell"]                = &LuaSpellInfo::IsAutoRepeatRangedSpell;
+    type["IsAffectedBySpellMods"]                  = &LuaSpellInfo::IsAffectedBySpellMods;
+    type["CanPierceImmuneAura"]                    = &LuaSpellInfo::CanPierceImmuneAura;
+    type["CanDispelAura"]                          = &LuaSpellInfo::CanDispelAura;
+    type["IsSingleTarget"]                         = &LuaSpellInfo::IsSingleTarget;
+    type["IsAuraExclusiveBySpecificWith"]          = &LuaSpellInfo::IsAuraExclusiveBySpecificWith;
+    type["IsAuraExclusiveBySpecificPerCasterWith"] = &LuaSpellInfo::IsAuraExclusiveBySpecificPerCasterWith;
+    type["CheckShapeshift"]                        = &LuaSpellInfo::CheckShapeshift;
+    type["CheckLocation"]                          = ALEBind::Function(&LuaSpellInfo::CheckLocation);
+    type["CheckTarget"]                            = ALEBind::Function(&LuaSpellInfo::CheckTarget);
+    type["CheckExplicitTarget"]                    = ALEBind::Function(&LuaSpellInfo::CheckExplicitTarget);
+    type["CheckTargetCreatureType"]                = ALEBind::Function(&LuaSpellInfo::CheckTargetCreatureType);
+    type["GetSchoolMask"]                          = &LuaSpellInfo::GetSchoolMask;
+    type["GetAllEffectsMechanicMask"]              = &LuaSpellInfo::GetAllEffectsMechanicMask;
+    type["GetEffectMechanicMask"]                  = &LuaSpellInfo::GetEffectMechanicMask;
+    type["GetSpellMechanicMaskByEffectMask"]       = &LuaSpellInfo::GetSpellMechanicMaskByEffectMask;
+    type["GetEffectMechanic"]                      = &LuaSpellInfo::GetEffectMechanic;
+    type["GetDispelMask"]                          = &LuaSpellInfo::GetDispelMask;
+    type["GetExplicitTargetMask"]                  = &LuaSpellInfo::GetExplicitTargetMask;
+    type["GetAuraState"]                           = &LuaSpellInfo::GetAuraState;
+    type["GetSpellSpecific"]                       = &LuaSpellInfo::GetSpellSpecific;
+    type["GetEffectMiscValueA"]                    = &LuaSpellInfo::GetEffectMiscValueA;
+    type["GetEffectMiscValueB"]                    = &LuaSpellInfo::GetEffectMiscValueB;
+}
diff --git a/src/LuaEngine/methods/SpellMethods.h b/src/LuaEngine/methods/SpellMethods.cpp
similarity index 54%
rename from src/LuaEngine/methods/SpellMethods.h
rename to src/LuaEngine/methods/SpellMethods.cpp
index 52c14ef79a..9a80bb7fed 100644
--- a/src/LuaEngine/methods/SpellMethods.h
+++ b/src/LuaEngine/methods/SpellMethods.cpp
@@ -4,8 +4,11 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef SPELLMETHODS_H
-#define SPELLMETHODS_H
+#include "ALEBind.h"
+
+#include "ObjectMgr.h"
+#include "Spell.h"
+#include "SpellInfo.h"
 
 /***
  * An instance of a spell, created when the spell is cast by a [Unit].
@@ -19,10 +22,9 @@ namespace LuaSpell
      *
      * @return bool isAutoRepeating
      */
-    int IsAutoRepeat(lua_State* L, Spell* spell)
+    bool IsAutoRepeat(Spell* spell)
     {
-        ALE::Push(L, spell->IsAutoRepeat());
-        return 1;
+        return spell->IsAutoRepeat();
     }
 
     /**
@@ -30,10 +32,9 @@ namespace LuaSpell
      *
      * @return [Unit] caster
      */
-    int GetCaster(lua_State* L, Spell* spell)
+    Unit* GetCaster(Spell* spell)
     {
-        ALE::Push(L, spell->GetCaster());
-        return 1;
+        return spell->GetCaster();
     }
 
     /**
@@ -41,10 +42,9 @@ namespace LuaSpell
      *
      * @return int32 castTime
      */
-    int GetCastTime(lua_State* L, Spell* spell)
+    int32 GetCastTime(Spell* spell)
     {
-        ALE::Push(L, spell->GetCastTime());
-        return 1;
+        return spell->GetCastTime();
     }
 
     /**
@@ -52,10 +52,9 @@ namespace LuaSpell
      *
      * @return uint32 entryId
      */
-    int GetEntry(lua_State* L, Spell* spell)
+    uint32 GetEntry(Spell* spell)
     {
-        ALE::Push(L, spell->m_spellInfo->Id);
-        return 1;
+        return spell->m_spellInfo->Id;
     }
 
     /**
@@ -63,10 +62,9 @@ namespace LuaSpell
      *
      * @return uint32 powerCost
      */
-    int GetPowerCost(lua_State* L, Spell* spell)
+    uint32 GetPowerCost(Spell* spell)
     {
-        ALE::Push(L, spell->GetPowerCost());
-        return 1;
+        return spell->GetPowerCost();
     }
 
     /**
@@ -74,23 +72,21 @@ namespace LuaSpell
      *
      * @return table reagents : a table containing the [ItemTemplate]s and amount of reagents needed for the [Spell]
     */
-    int GetReagentCost(lua_State* L, Spell* spell)
+    sol::table GetReagentCost(Spell* spell, sol::this_state s)
     {
         auto spellInfo = spell->GetSpellInfo();
         auto reagents = spellInfo->Reagent;
         auto reagentCounts = spellInfo->ReagentCount;
-        lua_newtable(L);
+        sol::table tbl = sol::state_view(s).create_table();
         for (auto i = 0; i < MAX_SPELL_REAGENTS; ++i)
         {
             if (reagents[i] <= 0)
                 continue;
-            auto reagent = eObjectMgr->GetItemTemplate(reagents[i]);
+            auto reagent = sObjectMgr->GetItemTemplate(reagents[i]);
             auto count = reagentCounts[i];
-            ALE::Push(L, reagent);
-            ALE::Push(L, count);
-            lua_settable(L, -3);
+            tbl[reagent] = count;
         }
-        return 1;
+        return tbl;
     }
 
     /**
@@ -98,10 +94,9 @@ namespace LuaSpell
      *
      * @return int32 duration
      */
-    int GetDuration(lua_State* L, Spell* spell)
+    int32 GetDuration(Spell* spell)
     {
-        ALE::Push(L, spell->GetSpellInfo()->GetDuration());
-        return 1;
+        return spell->GetSpellInfo()->GetDuration();
     }
 
     /**
@@ -111,17 +106,14 @@ namespace LuaSpell
      * @return float y : y coordinate of the [Spell]
      * @return float z : z coordinate of the [Spell]
      */
-    int GetTargetDest(lua_State* L, Spell* spell)
+    std::tuple<sol::optional<float>, sol::optional<float>, sol::optional<float>> GetTargetDest(Spell* spell)
     {
         if (!spell->m_targets.HasDst())
-            return 3;
+            return { sol::nullopt, sol::nullopt, sol::nullopt };
         float x, y, z;
         spell->m_targets.GetDstPos()->GetPosition(x, y, z);
 
-        ALE::Push(L, x);
-        ALE::Push(L, y);
-        ALE::Push(L, z);
-        return 3;
+        return { x, y, z };
     }
 
     /**
@@ -136,19 +128,20 @@ namespace LuaSpell
      *
      * @return [Object] target
      */
-    int GetTarget(lua_State* L, Spell* spell)
+    sol::object GetTarget(Spell* spell, sol::this_state s)
     {
+        sol::state_view lua(s);
         if (GameObject* target = spell->m_targets.GetGOTarget())
-            ALE::Push(L, target);
+            return sol::make_object(lua, GameObjectRef(target));
         else if (Item* target = spell->m_targets.GetItemTarget())
-            ALE::Push(L, target);
+            return sol::make_object(lua, ItemRef(target));
         else if (Corpse* target = spell->m_targets.GetCorpseTarget())
-            ALE::Push(L, target);
+            return sol::make_object(lua, CorpseRef(target));
         else if (Unit* target = spell->m_targets.GetUnitTarget())
-            ALE::Push(L, target);
+            return ALEBind::ToLuaDynamic(lua, target);
         else if (WorldObject* target = spell->m_targets.GetObjectTarget())
-            ALE::Push(L, target);
-        return 1;
+            return ALEBind::ToLuaDynamic(lua, target);
+        return sol::make_object(lua, sol::lua_nil);
     }
 
     /**
@@ -156,11 +149,9 @@ namespace LuaSpell
      *
      * @param bool repeat : set variable to 'true' for spell to automatically repeat
      */
-    int SetAutoRepeat(lua_State* L, Spell* spell)
+    void SetAutoRepeat(Spell* spell, bool repeat)
     {
-        bool repeat = ALE::CHECKVAL<bool>(L, 2);
         spell->SetAutoRepeat(repeat);
-        return 0;
     }
 
     /**
@@ -168,29 +159,43 @@ namespace LuaSpell
      *
      * @param bool skipCheck = false : skips initial checks to see if the [Spell] can be casted or not, this is optional
      */
-    int Cast(lua_State* L, Spell* spell)
+    void Cast(Spell* spell, sol::optional<bool> skipCheck)
     {
-        bool skipCheck = ALE::CHECKVAL<bool>(L, 2, false);
-        spell->cast(skipCheck);
-        return 0;
+        spell->cast(skipCheck.value_or(false));
     }
 
     /**
      * Cancels the [Spell].
      */
-    int Cancel(lua_State* /*L*/, Spell* spell)
+    void Cancel(Spell* spell)
     {
         spell->cancel();
-        return 0;
     }
 
     /**
      * Finishes the [Spell].
      */
-    int Finish(lua_State* /*L*/, Spell* spell)
+    void Finish(Spell* spell)
     {
         spell->finish();
-        return 0;
     }
-};
-#endif
+}
+
+void RegisterSpellMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<Spell>> type = ALEBind::NewHandleType<ScopedRef<Spell>>(lua, "Spell");
+
+    type["IsAutoRepeat"]   = ALEBind::Method(&LuaSpell::IsAutoRepeat);
+    type["GetCaster"]      = ALEBind::Method(&LuaSpell::GetCaster);
+    type["GetCastTime"]    = ALEBind::Method(&LuaSpell::GetCastTime);
+    type["GetEntry"]       = ALEBind::Method(&LuaSpell::GetEntry);
+    type["GetPowerCost"]   = ALEBind::Method(&LuaSpell::GetPowerCost);
+    type["GetReagentCost"] = ALEBind::Method(&LuaSpell::GetReagentCost);
+    type["GetDuration"]    = ALEBind::Method(&LuaSpell::GetDuration);
+    type["GetTargetDest"]  = ALEBind::Method(&LuaSpell::GetTargetDest);
+    type["GetTarget"]      = ALEBind::Method(&LuaSpell::GetTarget);
+    type["SetAutoRepeat"]  = ALEBind::Method(&LuaSpell::SetAutoRepeat);
+    type["Cast"]           = ALEBind::Method(&LuaSpell::Cast);
+    type["Cancel"]         = ALEBind::Method(&LuaSpell::Cancel);
+    type["Finish"]         = ALEBind::Method(&LuaSpell::Finish);
+}
diff --git a/src/LuaEngine/methods/TicketMethods.cpp b/src/LuaEngine/methods/TicketMethods.cpp
new file mode 100644
index 0000000000..4d24da5ac5
--- /dev/null
+++ b/src/LuaEngine/methods/TicketMethods.cpp
@@ -0,0 +1,308 @@
+/*
+* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
+* This program is free software licensed under GPL version 3
+* Please see the included DOCS/LICENSE.md for more information
+*/
+
+#include "ALEBind.h"
+
+#include "TicketMgr.h"
+
+/***
+ * Represents a support ticket created by a [Player] using the in-game ticket system.
+ *
+ * Inherits all methods from: none
+ */
+namespace LuaTicket
+{
+    /**
+     * Returns true if the [Ticket] is closed or false.
+     *
+     * @return bool isClosed
+     */
+    bool IsClosed(GmTicket* ticket)
+    {
+        return ticket->IsClosed();
+    }
+
+    /**
+     * Returns true if the [Ticket] is completed or false.
+     *
+     * @return bool isCompleted
+     */
+    bool IsCompleted(GmTicket* ticket)
+    {
+        return ticket->IsCompleted();
+    }
+
+    /**
+     * Return true if this GUID is the same as the [Player] who created the [Ticket] or false.
+     *
+     * @param ObjectGuid playerGuid
+     *
+     * @return bool isSamePlayer
+     */
+    bool IsFromPlayer(GmTicket* ticket, ObjectGuid guid)
+    {
+        return ticket->IsFromPlayer(guid);
+    }
+
+    /**
+     * Return true if the [Ticket] is assigned or false.
+     *
+     * @return bool isAssigned
+     */
+    bool IsAssigned(GmTicket* ticket)
+    {
+        return ticket->IsAssigned();
+    }
+
+    /**
+     * Return true if the [Ticket] is assigned to the [Player] or false.
+     *
+     * @param ObjectGuid playerGuid
+     *
+     * @return bool isAssignedTo
+     */
+    bool IsAssignedTo(GmTicket* ticket, ObjectGuid guid)
+    {
+        return ticket->IsAssignedTo(guid);
+    }
+
+    /**
+     * Return true if the [Ticket] is not assigned to the [Player] or false.
+     *
+     * @param ObjectGuid playerGuid
+     *
+     * @return bool isAssignedNotTo
+     */
+    bool IsAssignedNotTo(GmTicket* ticket, ObjectGuid guid)
+    {
+        return ticket->IsAssignedNotTo(guid);
+    }
+
+    /**
+     * Return the [Ticket] id.
+     *
+     * @return uint32 ticketId
+     */
+    uint32 GetId(GmTicket* ticket)
+    {
+        return ticket->GetId();
+    }
+
+    /**
+     * Return the [Player] from the [Ticket].
+     *
+     * @return [Player] player
+     */
+    Player* GetPlayer(GmTicket* ticket)
+    {
+        return ticket->GetPlayer();
+    }
+
+    /**
+     * Return the [Player] name from the [Ticket].
+     *
+     * @return string playerName
+     */
+    std::string GetPlayerName(GmTicket* ticket)
+    {
+        return ticket->GetPlayerName();
+    }
+
+    /**
+     * Returns the message sent in the [Ticket].
+     *
+     * @return string message
+     */
+    std::string GetMessage(GmTicket* ticket)
+    {
+        return ticket->GetMessage();
+    }
+
+    /**
+     * Returns the assigned [Player].
+     *
+     * @return [Player] assignedPlayer
+     */
+    Player* GetAssignedPlayer(GmTicket* ticket)
+    {
+        return ticket->GetAssignedPlayer();
+    }
+
+    /**
+     * Returns the assigned guid.
+     *
+     * @return uint32 assignedGuid
+     */
+    ObjectGuid GetAssignedToGUID(GmTicket* ticket)
+    {
+        return ticket->GetAssignedToGUID();
+    }
+
+    /**
+     * Returns the last modified time from the [Ticket].
+     *
+     * @return uint64 lastModifiedTime
+     */
+    uint64 GetLastModifiedTime(GmTicket* ticket)
+    {
+        return ticket->GetLastModifiedTime();
+    }
+
+    /**
+     * Assign the [Ticket] to a player via his GUID.
+     *
+     * @param ObjectGuid playerGuid
+     * @param bool isAdmin : true if the [Player] is an Admin or false (default false)
+     */
+    void SetAssignedTo(GmTicket* ticket, ObjectGuid guid, sol::optional<bool> isAdmin)
+    {
+        ticket->SetAssignedTo(guid, isAdmin.value_or(false));
+    }
+
+    /**
+     * Set [Ticket] resolved by player via his GUID.
+     *
+     * @param ObjectGuid playerGuid
+     */
+    void SetResolvedBy(GmTicket* ticket, ObjectGuid guid)
+    {
+        ticket->SetResolvedBy(guid);
+    }
+
+    /**
+     * Set [Ticket] completed.
+     *
+     */
+    void SetCompleted(GmTicket* ticket)
+    {
+        ticket->SetCompleted();
+    }
+
+    /**
+     * Set [Ticket] message.
+     *
+     * @param string message: desired message
+     *
+     */
+    void SetMessage(GmTicket* ticket, std::string message)
+    {
+        ticket->SetMessage(message);
+    }
+
+    /**
+     * Set [Ticket] comment.
+     *
+     * @param string comment: desired comment
+     *
+     */
+    void SetComment(GmTicket* ticket, std::string comment)
+    {
+        ticket->SetComment(comment);
+    }
+
+    /**
+     * Set [Ticket] as viewed.
+     *
+     */
+    void SetViewed(GmTicket* ticket)
+    {
+        ticket->SetViewed();
+    }
+
+    /**
+     * Set [Ticket] as unassigned.
+     *
+     */
+    void SetUnassigned(GmTicket* ticket)
+    {
+        ticket->SetUnassigned();
+    }
+
+    /**
+     * Set the new [Ticket] creation position.
+     *
+     * @param uint32 mapId
+     * @param float x
+     * @param float y
+     * @param float z
+     *
+     */
+    void SetPosition(GmTicket* ticket, uint32 mapId, float x, float y, float z)
+    {
+        ticket->SetPosition(mapId, x, y, z);
+    }
+
+    /**
+     * Adds a response to the [Ticket].
+     *
+     * @param string response: desired response
+     *
+     */
+    void AppendResponse(GmTicket* ticket, std::string response)
+    {
+        ticket->AppendResponse(response);
+    }
+
+    /**
+     * Return the [Ticket] response.
+     *
+     * @return string response
+     */
+    std::string GetResponse(GmTicket* ticket)
+    {
+        return ticket->GetResponse();
+    }
+
+    /**
+     * Delete the [Ticket] response.
+     *
+     */
+    void DeleteResponse(GmTicket* ticket)
+    {
+        ticket->DeleteResponse();
+    }
+
+    /**
+     * Return the [Ticket] chatlog.
+     *
+     * @return string chatlog
+     */
+    std::string GetChatLog(GmTicket* ticket)
+    {
+        return ticket->GetChatLog();
+    }
+}
+
+void RegisterTicketMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<GmTicket>> type = ALEBind::NewHandleType<ScopedRef<GmTicket>>(lua, "Ticket");
+
+    type["IsClosed"]            = ALEBind::Method(&LuaTicket::IsClosed);
+    type["IsCompleted"]         = ALEBind::Method(&LuaTicket::IsCompleted);
+    type["IsFromPlayer"]        = ALEBind::Method(&LuaTicket::IsFromPlayer);
+    type["IsAssigned"]          = ALEBind::Method(&LuaTicket::IsAssigned);
+    type["IsAssignedTo"]        = ALEBind::Method(&LuaTicket::IsAssignedTo);
+    type["IsAssignedNotTo"]     = ALEBind::Method(&LuaTicket::IsAssignedNotTo);
+    type["GetId"]               = ALEBind::Method(&LuaTicket::GetId);
+    type["GetPlayer"]           = ALEBind::Method(&LuaTicket::GetPlayer);
+    type["GetPlayerName"]       = ALEBind::Method(&LuaTicket::GetPlayerName);
+    type["GetMessage"]          = ALEBind::Method(&LuaTicket::GetMessage);
+    type["GetAssignedPlayer"]   = ALEBind::Method(&LuaTicket::GetAssignedPlayer);
+    type["GetAssignedToGUID"]   = ALEBind::Method(&LuaTicket::GetAssignedToGUID);
+    type["GetLastModifiedTime"] = ALEBind::Method(&LuaTicket::GetLastModifiedTime);
+    type["SetAssignedTo"]       = ALEBind::Method(&LuaTicket::SetAssignedTo);
+    type["SetResolvedBy"]       = ALEBind::Method(&LuaTicket::SetResolvedBy);
+    type["SetCompleted"]        = ALEBind::Method(&LuaTicket::SetCompleted);
+    type["SetMessage"]          = ALEBind::Method(&LuaTicket::SetMessage);
+    type["SetComment"]          = ALEBind::Method(&LuaTicket::SetComment);
+    type["SetViewed"]           = ALEBind::Method(&LuaTicket::SetViewed);
+    type["SetUnassigned"]       = ALEBind::Method(&LuaTicket::SetUnassigned);
+    type["SetPosition"]         = ALEBind::Method(&LuaTicket::SetPosition);
+    type["AppendResponse"]      = ALEBind::Method(&LuaTicket::AppendResponse);
+    type["GetResponse"]         = ALEBind::Method(&LuaTicket::GetResponse);
+    type["DeleteResponse"]      = ALEBind::Method(&LuaTicket::DeleteResponse);
+    type["GetChatLog"]          = ALEBind::Method(&LuaTicket::GetChatLog);
+}
diff --git a/src/LuaEngine/methods/TicketMethods.h b/src/LuaEngine/methods/TicketMethods.h
deleted file mode 100644
index c158142910..0000000000
--- a/src/LuaEngine/methods/TicketMethods.h
+++ /dev/null
@@ -1,323 +0,0 @@
-/*
-* Copyright (C) 2010 - 2025 Eluna Lua Engine <https://elunaluaengine.github.io/>
-* This program is free software licensed under GPL version 3
-* Please see the included DOCS/LICENSE.md for more information
-*/
-
-#ifndef TICKETMETHODS_H
-#define TICKETMETHODS_H
-
-/***
- * Represents a support ticket created by a [Player] using the in-game ticket system.
- *
- * Inherits all methods from: none
- */
-namespace LuaTicket
-{
-    /**
-     * Returns true if the [Ticket] is closed or false.
-     *
-     * @return bool isClosed
-     */
-    int IsClosed(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->IsClosed());
-        return 1;
-    }
-
-    /**
-     * Returns true if the [Ticket] is completed or false.
-     *
-     * @return bool isCompleted
-     */
-    int IsCompleted(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->IsCompleted());
-        return 1;
-    }
-
-    /**
-     * Return true if this GUID is the same as the [Player] who created the [Ticket] or false.
-     *
-     * @param ObjectGuid playerGuid
-     *
-     * @return bool isSamePlayer
-     */
-    int IsFromPlayer(lua_State* L, GmTicket* ticket)
-    {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-
-        ALE::Push(L, ticket->IsFromPlayer(guid));
-        return 1;
-    }
-
-    /**
-     * Return true if the [Ticket] is assigned or false.
-     *
-     * @return bool isAssigned
-     */
-    int IsAssigned(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->IsAssigned());
-        return 1;
-    }
-
-    /**
-     * Return true if the [Ticket] is assigned to the [Player] or false.
-     *
-     * @param ObjectGuid playerGuid
-     *
-     * @return bool isAssignedTo
-     */
-    int IsAssignedTo(lua_State* L, GmTicket* ticket)
-    {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-
-        ALE::Push(L, ticket->IsAssignedTo(guid));
-        return 1;
-    }
-
-    /**
-     * Return true if the [Ticket] is not assigned to the [Player] or false.
-     *
-     * @param ObjectGuid playerGuid
-     *
-     * @return bool isAssignedNotTo
-     */
-    int IsAssignedNotTo(lua_State* L, GmTicket* ticket)
-    {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-
-        ALE::Push(L, ticket->IsAssignedNotTo(guid));
-        return 1;
-    }
-
-    /**
-     * Return the [Ticket] id.
-     *
-     * @return uint32 ticketId
-     */
-    int GetId(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetId());
-        return 1;
-    }
-
-    /**
-     * Return the [Player] from the [Ticket].
-     *
-     * @return [Player] player
-     */
-    int GetPlayer(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetPlayer());
-        return 1;
-    }
-
-    /**
-     * Return the [Player] name from the [Ticket].
-     *
-     * @return string playerName
-     */
-    int GetPlayerName(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetPlayerName());
-        return 1;
-    }
-
-    /**
-     * Returns the message sent in the [Ticket].
-     *
-     * @return string message
-     */
-    int GetMessage(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetMessage());
-        return 1;
-    }
-
-    /**
-     * Returns the assigned [Player].
-     *
-     * @return [Player] assignedPlayer
-     */
-    int GetAssignedPlayer(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetAssignedPlayer());
-        return 1;
-    }
-
-    /**
-     * Returns the assigned guid.
-     *
-     * @return uint32 assignedGuid
-     */
-    int GetAssignedToGUID(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetAssignedToGUID());
-        return 1;
-    }
-
-    /**
-     * Returns the last modified time from the [Ticket].
-     *
-     * @return uint64 lastModifiedTime
-     */
-    int GetLastModifiedTime(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetLastModifiedTime());
-        return 1;
-    }
-
-    /**
-     * Assign the [Ticket] to a player via his GUID.
-     *
-     * @param ObjectGuid playerGuid
-     * @param bool isAdmin : true if the [Player] is an Admin or false (default false)
-     */
-    int SetAssignedTo(lua_State* L, GmTicket* ticket)
-    {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        bool is_admin = ALE::CHECKVAL<bool>(L, 2, false);
-        ticket->SetAssignedTo(guid, is_admin);
-        return 0;
-    }
-
-    /**
-     * Set [Ticket] resolved by player via his GUID.
-     *
-     * @param ObjectGuid playerGuid
-     */
-    int SetResolvedBy(lua_State* L, GmTicket* ticket)
-    {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-        ticket->SetResolvedBy(guid);
-        return 0;
-    }
-
-    /**
-     * Set [Ticket] completed.
-     *
-     */
-    int SetCompleted(lua_State* /*L*/, GmTicket* ticket)
-    {
-        ticket->SetCompleted();
-        return 0;
-    }
-
-    /**
-     * Set [Ticket] message.
-     *
-     * @param string message: desired message
-     *
-     */
-    int SetMessage(lua_State* L, GmTicket* ticket)
-    {
-        std::string message = ALE::CHECKVAL<std::string>(L, 2);
-
-        ticket->SetMessage(message);
-        return 0;
-    }
-
-    /**
-     * Set [Ticket] comment.
-     *
-     * @param string comment: desired comment
-     *
-     */
-    int SetComment(lua_State* L, GmTicket* ticket)
-    {
-        std::string comment = ALE::CHECKVAL<std::string>(L, 2);
-
-        ticket->SetComment(comment);
-        return 0;
-    }
-
-    /**
-     * Set [Ticket] as viewed.
-     *
-     */
-    int SetViewed(lua_State* /*L*/, GmTicket* ticket)
-    {
-        ticket->SetViewed();
-        return 0;
-    }
-
-    /**
-     * Set [Ticket] as unassigned.
-     *
-     */
-    int SetUnassigned(lua_State* /*L*/, GmTicket* ticket)
-    {
-        ticket->SetUnassigned();
-        return 0;
-    }
-
-    /**
-     * Set the new [Ticket] creation position.
-     *
-     * @param uint32 mapId
-     * @param float x
-     * @param float y
-     * @param float z
-     *
-     */
-    int SetPosition(lua_State* L, GmTicket* ticket)
-    {
-        uint32 mapId = ALE::CHECKVAL<uint32>(L, 2);
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 2);
-        float z = ALE::CHECKVAL<float>(L, 2);
-
-        ticket->SetPosition(mapId, x, y, z);
-        return 0;
-    }
-
-    /**
-     * Adds a response to the [Ticket].
-     *
-     * @param string response: desired response
-     *
-     */
-    int AppendResponse(lua_State* L, GmTicket* ticket)
-    {
-        std::string response = ALE::CHECKVAL<std::string>(L, 2);
-
-        ticket->AppendResponse(response);
-        return 0;
-    }
-
-    /**
-     * Return the [Ticket] response.
-     *
-     * @return string response
-     */
-    int GetResponse(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetResponse());
-        return 1;
-    }
-
-    /**
-     * Delete the [Ticket] response.
-     *
-     */
-    int DeleteResponse(lua_State* /*L*/, GmTicket* ticket)
-    {
-        ticket->DeleteResponse();
-        return 0;
-    }
-
-    /**
-     * Return the [Ticket] chatlog.
-     *
-     * @return string chatlog
-     */
-    int GetChatLog(lua_State* L, GmTicket* ticket)
-    {
-        ALE::Push(L, ticket->GetChatLog());
-        return 1;
-    }
-};
-#endif
-
diff --git a/src/LuaEngine/methods/TransportMethods.h b/src/LuaEngine/methods/TransportMethods.cpp
similarity index 56%
rename from src/LuaEngine/methods/TransportMethods.h
rename to src/LuaEngine/methods/TransportMethods.cpp
index 941ce6732a..429eab72e4 100644
--- a/src/LuaEngine/methods/TransportMethods.h
+++ b/src/LuaEngine/methods/TransportMethods.cpp
@@ -4,8 +4,7 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef TRANSPORTMETHODS_H
-#define TRANSPORTMETHODS_H
+#include "ALEBind.h"
 
 #include "Transport.h"
 
@@ -21,17 +20,17 @@ namespace LuaTransport
      *
      * @return table passengers
      */
-    int GetPassengers(lua_State* L, Transport* transport)
+    sol::table GetPassengers(Transport* transport, sol::this_state s)
     {
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table();
+
         Transport::PassengerSet const& passengers = transport->GetPassengers();
-        lua_createtable(L, static_cast<int>(passengers.size()), 0);
         int i = 1;
         for (WorldObject* passenger : passengers)
-        {
-            ALE::Push(L, passenger);
-            lua_rawseti(L, -2, i++);
-        }
-        return 1;
+            tbl[i++] = ALEBind::ToLuaDynamic(lua, passenger);
+
+        return tbl;
     }
 
     /**
@@ -39,10 +38,9 @@ namespace LuaTransport
      *
      * @return bool isMotionTransport
      */
-    int IsMotionTransport(lua_State* L, Transport* transport)
+    bool IsMotionTransport(Transport* transport)
     {
-        ALE::Push(L, dynamic_cast<MotionTransport*>(transport) != nullptr);
-        return 1;
+        return dynamic_cast<MotionTransport*>(transport) != nullptr;
     }
 
     /**
@@ -51,12 +49,9 @@ namespace LuaTransport
      * @param [WorldObject] passenger : the object to add as a passenger
      * @param bool withAll = true : if true, also sets transport movement info on the passenger
      */
-    int AddPassenger(lua_State* L, Transport* transport)
+    void AddPassenger(Transport* transport, WorldObject* passenger, sol::optional<bool> withAll)
     {
-        WorldObject* passenger = ALE::CHECKOBJ<WorldObject>(L, 2);
-        bool withAll = ALE::CHECKVAL<bool>(L, 3, true);
-        transport->AddPassenger(passenger, withAll);
-        return 0;
+        transport->AddPassenger(passenger, withAll.value_or(true));
     }
 
     /**
@@ -65,12 +60,9 @@ namespace LuaTransport
      * @param [WorldObject] passenger : the object to remove
      * @param bool withAll = true : if true, also clears transport movement info from the passenger
      */
-    int RemovePassenger(lua_State* L, Transport* transport)
+    void RemovePassenger(Transport* transport, WorldObject* passenger, sol::optional<bool> withAll)
     {
-        WorldObject* passenger = ALE::CHECKOBJ<WorldObject>(L, 2);
-        bool withAll = ALE::CHECKVAL<bool>(L, 3, true);
-        transport->RemovePassenger(passenger, withAll);
-        return 0;
+        transport->RemovePassenger(passenger, withAll.value_or(true));
     }
 
     /**
@@ -80,14 +72,21 @@ namespace LuaTransport
      *
      * @param bool enabled : true to enable movement, false to stop
      */
-    int EnableMovement(lua_State* L, Transport* transport)
+    void EnableMovement(Transport* transport, bool enabled)
     {
-        bool enabled = ALE::CHECKVAL<bool>(L, 2);
         MotionTransport* mt = dynamic_cast<MotionTransport*>(transport);
         if (mt)
             mt->EnableMovement(enabled);
-        return 0;
     }
 }
 
-#endif
+void RegisterTransportMethods(sol::state& lua)
+{
+    sol::usertype<TransportRef> type = ALEBind::NewHandleType<TransportRef, GameObjectRef, WorldObjectRef, ObjectRef>(lua, "Transport");
+
+    type["GetPassengers"]     = ALEBind::Method(&LuaTransport::GetPassengers);
+    type["IsMotionTransport"] = ALEBind::Method(&LuaTransport::IsMotionTransport);
+    type["AddPassenger"]      = ALEBind::Method(&LuaTransport::AddPassenger);
+    type["RemovePassenger"]   = ALEBind::Method(&LuaTransport::RemovePassenger);
+    type["EnableMovement"]    = ALEBind::Method(&LuaTransport::EnableMovement);
+}
diff --git a/src/LuaEngine/methods/UnitMethods.h b/src/LuaEngine/methods/UnitMethods.cpp
similarity index 58%
rename from src/LuaEngine/methods/UnitMethods.h
rename to src/LuaEngine/methods/UnitMethods.cpp
index 1ded5af420..2806b7526c 100644
--- a/src/LuaEngine/methods/UnitMethods.h
+++ b/src/LuaEngine/methods/UnitMethods.cpp
@@ -4,8 +4,21 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef UNITMETHODS_H
-#define UNITMETHODS_H
+#include "ALEBind.h"
+#include "ALEUtility.h"
+
+#include "CellImpl.h"
+#include "Chat.h"
+#include "DBCStores.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "MotionMaster.h"
+#include "Player.h"
+#include "SpellInfo.h"
+#include "SpellMgr.h"
+#include "Unit.h"
+#include "WorldPacket.h"
+#include "WorldSession.h"
 
 /***
  * Represents a non-[Player] controlled [Unit] (i.e. NPCs).
@@ -55,15 +68,13 @@ namespace LuaUnit
     * @param int32 immunity : new value for the immunity mask
     * @param bool apply = true : if true, the immunity is applied, otherwise it is removed
     */
-    int SetImmuneTo(lua_State* L, Unit* unit)
+    void SetImmuneTo(Unit* unit, int32 immunity, sol::optional<bool> applyArg)
     {
-        int32 immunity = ALE::CHECKVAL<int32>(L, 2);
-        bool apply = ALE::CHECKVAL<bool>(L, 3, true);
+        bool apply = applyArg.value_or(true);
 
         unit->ApplySpellImmune(0, 5, immunity, apply);
-        return 0;
     }
-    
+
     /**
      * The [Unit] modifies a specific stat
      *
@@ -73,16 +84,11 @@ namespace LuaUnit
      * @param bool apply = false : Whether the modifier should be applied or removed
      * @return bool : Whether the stat modification was successful
      */
-    int HandleStatFlatModifier(lua_State* L, Unit* unit)
+    bool HandleStatFlatModifier(Unit* unit, int32 stat, int8 type, float value, sol::optional<bool> applyArg)
     {
-        int32 stat = ALE::CHECKVAL<int32>(L, 2);
-        int8  type = ALE::CHECKVAL<int8>(L, 3);
-
-        float value = ALE::CHECKVAL<float>(L, 4);
-        bool apply = ALE::CHECKVAL<bool>(L, 5, false);
+        bool apply = applyArg.value_or(false);
 
-        ALE::Push(L, unit->HandleStatFlatModifier(UnitMods(UNIT_MOD_STAT_START + stat), (UnitModifierFlatType)type, value, apply));
-        return 1;
+        return unit->HandleStatFlatModifier(UnitMods(UNIT_MOD_STAT_START + stat), (UnitModifierFlatType)type, value, apply);
     }
 
     /**
@@ -92,13 +98,11 @@ namespace LuaUnit
      * @param bool meleeAttack = false: attack with melee or not
      * @return didAttack : if the [Unit] did not attack
      */
-    int Attack(lua_State* L, Unit* unit)
+    bool Attack(Unit* unit, Unit* who, sol::optional<bool> meleeAttackArg)
     {
-        Unit* who = ALE::CHECKOBJ<Unit>(L, 2);
-        bool meleeAttack = ALE::CHECKVAL<bool>(L, 3, false);
+        bool meleeAttack = meleeAttackArg.value_or(false);
 
-        ALE::Push(L, unit->Attack(who, meleeAttack));
-        return 1;
+        return unit->Attack(who, meleeAttack);
     }
 
     /**
@@ -106,10 +110,9 @@ namespace LuaUnit
      *
      * @return bool isAttacking : if the [Unit] wasn't attacking already
      */
-    int AttackStop(lua_State* L, Unit* unit)
+    bool AttackStop(Unit* unit)
     {
-        ALE::Push(L, unit->AttackStop());
-        return 1;
+        return unit->AttackStop();
     }
 
     /**
@@ -117,10 +120,9 @@ namespace LuaUnit
      *
      * @return bool isStanding
      */
-    int IsStandState(lua_State* L, Unit* unit)
+    bool IsStandState(Unit* unit)
     {
-        ALE::Push(L, unit->IsStandState());
-        return 1;
+        return unit->IsStandState();
     }
 
     /**
@@ -128,10 +130,9 @@ namespace LuaUnit
      *
      * @return bool isMounted
      */
-    int IsMounted(lua_State* L, Unit* unit)
+    bool IsMounted(Unit* unit)
     {
-        ALE::Push(L, unit->IsMounted());
-        return 1;
+        return unit->IsMounted();
     }
 
     /**
@@ -139,11 +140,9 @@ namespace LuaUnit
      *
      * @return bool isRooted
      */
-    int IsRooted(lua_State* L, Unit* unit)
+    bool IsRooted(Unit* unit)
     {
-        ALE::Push(L, unit->HasRootAura() || unit->HasUnitMovementFlag(MOVEMENTFLAG_ROOT));
-
-        return 1;
+        return unit->HasRootAura() || unit->HasUnitMovementFlag(MOVEMENTFLAG_ROOT);
     }
 
     /**
@@ -151,10 +150,9 @@ namespace LuaUnit
      *
      * @return bool hasFullHealth
      */
-    int IsFullHealth(lua_State* L, Unit* unit)
+    bool IsFullHealth(Unit* unit)
     {
-        ALE::Push(L, unit->IsFullHealth());
-        return 1;
+        return unit->IsFullHealth();
     }
 
     /**
@@ -164,13 +162,9 @@ namespace LuaUnit
      * @param float radius
      * @return bool isAccessible
      */
-    int IsInAccessiblePlaceFor(lua_State* L, Unit* unit)
+    bool IsInAccessiblePlaceFor(Unit* unit, Creature* creature)
     {
-        Creature* creature = ALE::CHECKOBJ<Creature>(L, 2);
-
-        ALE::Push(L, unit->isInAccessiblePlaceFor(creature));
-
-        return 1;
+        return unit->isInAccessiblePlaceFor(creature);
     }
 
     /**
@@ -178,11 +172,9 @@ namespace LuaUnit
      *
      * @return bool isAuctioneer
      */
-    int IsAuctioneer(lua_State* L, Unit* unit)
+    bool IsAuctioneer(Unit* unit)
     {
-        ALE::Push(L, unit->IsAuctioner());
-
-        return 1;
+        return unit->IsAuctioner();
     }
 
     /**
@@ -190,10 +182,9 @@ namespace LuaUnit
      *
      * @return bool isGuildMaster
      */
-    int IsGuildMaster(lua_State* L, Unit* unit)
+    bool IsGuildMaster(Unit* unit)
     {
-        ALE::Push(L, unit->IsGuildMaster());
-        return 1;
+        return unit->IsGuildMaster();
     }
 
     /**
@@ -201,10 +192,9 @@ namespace LuaUnit
      *
      * @return bool isInnkeeper
      */
-    int IsInnkeeper(lua_State* L, Unit* unit)
+    bool IsInnkeeper(Unit* unit)
     {
-        ALE::Push(L, unit->IsInnkeeper());
-        return 1;
+        return unit->IsInnkeeper();
     }
 
     /**
@@ -212,10 +202,9 @@ namespace LuaUnit
      *
      * @return bool isTrainer
      */
-    int IsTrainer(lua_State* L, Unit* unit)
+    bool IsTrainer(Unit* unit)
     {
-        ALE::Push(L, unit->IsTrainer());
-        return 1;
+        return unit->IsTrainer();
     }
 
     /**
@@ -223,10 +212,9 @@ namespace LuaUnit
      *
      * @return bool hasGossip
      */
-    int IsGossip(lua_State* L, Unit* unit)
+    bool IsGossip(Unit* unit)
     {
-        ALE::Push(L, unit->IsGossip());
-        return 1;
+        return unit->IsGossip();
     }
 
     /**
@@ -234,10 +222,9 @@ namespace LuaUnit
      *
      * @return bool isTaxi
      */
-    int IsTaxi(lua_State* L, Unit* unit)
+    bool IsTaxi(Unit* unit)
     {
-        ALE::Push(L, unit->IsTaxi());
-        return 1;
+        return unit->IsTaxi();
     }
 
     /**
@@ -245,10 +232,9 @@ namespace LuaUnit
      *
      * @return bool isSpiritHealer
      */
-    int IsSpiritHealer(lua_State* L, Unit* unit)
+    bool IsSpiritHealer(Unit* unit)
     {
-        ALE::Push(L, unit->IsSpiritHealer());
-        return 1;
+        return unit->IsSpiritHealer();
     }
 
     /**
@@ -256,10 +242,9 @@ namespace LuaUnit
      *
      * @return bool isSpiritGuide
      */
-    int IsSpiritGuide(lua_State* L, Unit* unit)
+    bool IsSpiritGuide(Unit* unit)
     {
-        ALE::Push(L, unit->IsSpiritGuide());
-        return 1;
+        return unit->IsSpiritGuide();
     }
 
     /**
@@ -267,10 +252,9 @@ namespace LuaUnit
      *
      * @return bool isTabardDesigner
      */
-    int IsTabardDesigner(lua_State* L, Unit* unit)
+    bool IsTabardDesigner(Unit* unit)
     {
-        ALE::Push(L, unit->IsTabardDesigner());
-        return 1;
+        return unit->IsTabardDesigner();
     }
 
     /**
@@ -278,10 +262,9 @@ namespace LuaUnit
      *
      * @return bool isTabardDesigner
      */
-    int IsServiceProvider(lua_State* L, Unit* unit)
+    bool IsServiceProvider(Unit* unit)
     {
-        ALE::Push(L, unit->IsServiceProvider());
-        return 1;
+        return unit->IsServiceProvider();
     }
 
     /**
@@ -289,10 +272,9 @@ namespace LuaUnit
      *
      * @return bool isSpiritService
      */
-    int IsSpiritService(lua_State* L, Unit* unit)
+    bool IsSpiritService(Unit* unit)
     {
-        ALE::Push(L, unit->IsSpiritService());
-        return 1;
+        return unit->IsSpiritService();
     }
 
     /**
@@ -300,10 +282,9 @@ namespace LuaUnit
      *
      * @return bool isAlive
      */
-    int IsAlive(lua_State* L, Unit* unit)
+    bool IsAlive(Unit* unit)
     {
-        ALE::Push(L, unit->IsAlive());
-        return 1;
+        return unit->IsAlive();
     }
 
     /**
@@ -311,10 +292,9 @@ namespace LuaUnit
      *
      * @return bool isDead
      */
-    int IsDead(lua_State* L, Unit* unit)
+    bool IsDead(Unit* unit)
     {
-        ALE::Push(L, unit->isDead());
-        return 1;
+        return unit->isDead();
     }
 
     /**
@@ -322,10 +302,9 @@ namespace LuaUnit
      *
      * @return bool isDying
      */
-    int IsDying(lua_State* L, Unit* unit)
+    bool IsDying(Unit* unit)
     {
-        ALE::Push(L, unit->isDying());
-        return 1;
+        return unit->isDying();
     }
 
     /**
@@ -333,10 +312,9 @@ namespace LuaUnit
      *
      * @return bool isBanker
      */
-    int IsBanker(lua_State* L, Unit* unit)
+    bool IsBanker(Unit* unit)
     {
-        ALE::Push(L, unit->IsBanker());
-        return 1;
+        return unit->IsBanker();
     }
 
     /**
@@ -344,10 +322,9 @@ namespace LuaUnit
      *
      * @return bool isVendor
      */
-    int IsVendor(lua_State* L, Unit* unit)
+    bool IsVendor(Unit* unit)
     {
-        ALE::Push(L, unit->IsVendor());
-        return 1;
+        return unit->IsVendor();
     }
 
     /**
@@ -355,10 +332,9 @@ namespace LuaUnit
      *
      * @return bool isBattleMaster
      */
-    int IsBattleMaster(lua_State* L, Unit* unit)
+    bool IsBattleMaster(Unit* unit)
     {
-        ALE::Push(L, unit->IsBattleMaster());
-        return 1;
+        return unit->IsBattleMaster();
     }
 
     /**
@@ -366,10 +342,9 @@ namespace LuaUnit
      *
      * @return bool isCharmed
      */
-    int IsCharmed(lua_State* L, Unit* unit)
+    bool IsCharmed(Unit* unit)
     {
-        ALE::Push(L, unit->IsCharmed());
-        return 1;
+        return unit->IsCharmed();
     }
 
     /**
@@ -377,10 +352,9 @@ namespace LuaUnit
      *
      * @return bool isArmorer
      */
-    int IsArmorer(lua_State* L, Unit* unit)
+    bool IsArmorer(Unit* unit)
     {
-        ALE::Push(L, unit->IsArmorer());
-        return 1;
+        return unit->IsArmorer();
     }
 
     /**
@@ -388,10 +362,9 @@ namespace LuaUnit
      *
      * @return bool isAttackingPlayer
      */
-    int IsAttackingPlayer(lua_State* L, Unit* unit)
+    bool IsAttackingPlayer(Unit* unit)
     {
-        ALE::Push(L, unit->isAttackingPlayer());
-        return 1;
+        return unit->isAttackingPlayer();
     }
 
     /**
@@ -399,10 +372,9 @@ namespace LuaUnit
      *
      * @return bool isPvP
      */
-    int IsPvPFlagged(lua_State* L, Unit* unit)
+    bool IsPvPFlagged(Unit* unit)
     {
-        ALE::Push(L, unit->IsPvP());
-        return 1;
+        return unit->IsPvP();
     }
 
     /**
@@ -410,10 +382,9 @@ namespace LuaUnit
      *
      * @return bool isOnVehicle
      */
-    int IsOnVehicle(lua_State* L, Unit* unit)
+    Vehicle* IsOnVehicle(Unit* unit)
     {
-        ALE::Push(L, unit->GetVehicle());
-        return 1;
+        return unit->GetVehicle();
     }
 
     /**
@@ -421,10 +392,9 @@ namespace LuaUnit
      *
      * @return bool inCombat
      */
-    int IsInCombat(lua_State* L, Unit* unit)
+    bool IsInCombat(Unit* unit)
     {
-        ALE::Push(L, unit->IsInCombat());
-        return 1;
+        return unit->IsInCombat();
     }
 
     /**
@@ -432,10 +402,9 @@ namespace LuaUnit
      *
      * @return bool underWater
      */
-    int IsUnderWater(lua_State* L, Unit* unit)
+    bool IsUnderWater(Unit* unit)
     {
-        ALE::Push(L, unit->IsUnderWater());
-        return 1;
+        return unit->IsUnderWater();
     }
 
     /**
@@ -443,10 +412,9 @@ namespace LuaUnit
      *
      * @return bool inWater
      */
-    int IsInWater(lua_State* L, Unit* unit)
+    bool IsInWater(Unit* unit)
     {
-        ALE::Push(L, unit->IsInWater());
-        return 1;
+        return unit->IsInWater();
     }
 
     /**
@@ -454,10 +422,9 @@ namespace LuaUnit
      *
      * @return bool notMoving
      */
-    int IsStopped(lua_State* L, Unit* unit)
+    bool IsStopped(Unit* unit)
     {
-        ALE::Push(L, unit->IsStopped());
-        return 1;
+        return unit->IsStopped();
     }
 
     /**
@@ -465,10 +432,9 @@ namespace LuaUnit
      *
      * @return bool questGiver
      */
-    int IsQuestGiver(lua_State* L, Unit* unit)
+    bool IsQuestGiver(Unit* unit)
     {
-        ALE::Push(L, unit->IsQuestGiver());
-        return 1;
+        return unit->IsQuestGiver();
     }
 
     /**
@@ -477,10 +443,9 @@ namespace LuaUnit
      * @param int32 healthpct : percentage in integer from
      * @return bool isBelow
      */
-    int HealthBelowPct(lua_State* L, Unit* unit)
+    bool HealthBelowPct(Unit* unit, int32 pct)
     {
-        ALE::Push(L, unit->HealthBelowPct(ALE::CHECKVAL<int32>(L, 2)));
-        return 1;
+        return unit->HealthBelowPct(pct);
     }
 
     /**
@@ -489,10 +454,9 @@ namespace LuaUnit
      * @param int32 healthpct : percentage in integer from
      * @return bool isAbove
      */
-    int HealthAbovePct(lua_State* L, Unit* unit)
+    bool HealthAbovePct(Unit* unit, int32 pct)
     {
-        ALE::Push(L, unit->HealthAbovePct(ALE::CHECKVAL<int32>(L, 2)));
-        return 1;
+        return unit->HealthAbovePct(pct);
     }
 
     /**
@@ -501,12 +465,9 @@ namespace LuaUnit
      * @param uint32 spell : entry of the aura spell
      * @return bool hasAura
      */
-    int HasAura(lua_State* L, Unit* unit)
+    bool HasAura(Unit* unit, uint32 spell)
     {
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 2);
-
-        ALE::Push(L, unit->HasAura(spell));
-        return 1;
+        return unit->HasAura(spell);
     }
 
     /**
@@ -514,10 +475,9 @@ namespace LuaUnit
      *
      * @return bool isCasting
      */
-    int IsCasting(lua_State* L, Unit* unit)
+    bool IsCasting(Unit* unit)
     {
-        ALE::Push(L, unit->HasUnitState(UNIT_STATE_CASTING));
-        return 1;
+        return unit->HasUnitState(UNIT_STATE_CASTING);
     }
 
     /**
@@ -526,40 +486,19 @@ namespace LuaUnit
      * @param [UnitState] state : an unit state
      * @return bool hasState
      */
-    int HasUnitState(lua_State* L, Unit* unit)
+    bool HasUnitState(Unit* unit, uint32 state)
     {
-        uint32 state = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, unit->HasUnitState(state));
-        return 1;
+        return unit->HasUnitState(state);
     }
 
-    /*int IsVisible(lua_State* L, Unit* unit)
-    {
-        ALE::Push(L, unit->IsVisible());
-        return 1;
-    }*/
-
-    /*int IsMoving(lua_State* L, Unit* unit)
-    {
-        ALE::Push(L, unit->isMoving());
-        return 1;
-    }*/
-
-    /*int IsFlying(lua_State* L, Unit* unit)
-    {
-        ALE::Push(L, unit->IsFlying());
-        return 1;
-    }*/
-
     /**
      * Returns the [Unit]'s owner.
      *
      * @return [Unit] owner
      */
-    int GetOwner(lua_State* L, Unit* unit)
+    Unit* GetOwner(Unit* unit)
     {
-        ALE::Push(L, unit->GetOwner());
-        return 1;
+        return unit->GetOwner();
     }
 
     /**
@@ -567,10 +506,9 @@ namespace LuaUnit
      *
      * @return ObjectGuid ownerGUID
      */
-    int GetOwnerGUID(lua_State* L, Unit* unit)
+    ObjectGuid GetOwnerGUID(Unit* unit)
     {
-        ALE::Push(L, unit->GetOwnerGUID());
-        return 1;
+        return unit->GetOwnerGUID();
     }
 
     /**
@@ -578,10 +516,9 @@ namespace LuaUnit
      *
      * @return uint32 mountId : displayId of the mount
      */
-    int GetMountId(lua_State* L, Unit* unit)
+    uint32 GetMountId(Unit* unit)
     {
-        ALE::Push(L, unit->GetMountID());
-        return 1;
+        return unit->GetMountID();
     }
 
     /**
@@ -589,10 +526,9 @@ namespace LuaUnit
      *
      * @return ObjectGuid creatorGUID
      */
-    int GetCreatorGUID(lua_State* L, Unit* unit)
+    ObjectGuid GetCreatorGUID(Unit* unit)
     {
-        ALE::Push(L, unit->GetCreatorGUID());
-        return 1;
+        return unit->GetCreatorGUID();
     }
 
     /**
@@ -600,10 +536,9 @@ namespace LuaUnit
      *
      * @return ObjectGuid charmerGUID
      */
-    int GetCharmerGUID(lua_State* L, Unit* unit)
+    ObjectGuid GetCharmerGUID(Unit* unit)
     {
-        ALE::Push(L, unit->GetCharmerGUID());
-        return 1;
+        return unit->GetCharmerGUID();
     }
 
     /**
@@ -611,10 +546,9 @@ namespace LuaUnit
      *
      * @return ObjectGuid charmedGUID
      */
-    int GetCharmGUID(lua_State* L, Unit* unit)
+    ObjectGuid GetCharmGUID(Unit* unit)
     {
-        ALE::Push(L, unit->GetCharmGUID());
-        return 1;
+        return unit->GetCharmGUID();
     }
 
     /**
@@ -622,10 +556,9 @@ namespace LuaUnit
      *
      * @return ObjectGuid petGUID
      */
-    int GetPetGUID(lua_State* L, Unit* unit)
+    ObjectGuid GetPetGUID(Unit* unit)
     {
-        ALE::Push(L, unit->GetPetGUID());
-        return 1;
+        return unit->GetPetGUID();
     }
 
     /**
@@ -633,10 +566,9 @@ namespace LuaUnit
      *
      * @return ObjectGuid controllerGUID
      */
-    int GetControllerGUID(lua_State* L, Unit* unit)
+    ObjectGuid GetControllerGUID(Unit* unit)
     {
-        ALE::Push(L, unit->GetCharmerOrOwnerGUID());
-        return 1;
+        return unit->GetCharmerOrOwnerGUID();
     }
 
     /**
@@ -644,10 +576,9 @@ namespace LuaUnit
      *
      * @return ObjectGuid controllerGUID
      */
-    int GetControllerGUIDS(lua_State* L, Unit* unit)
+    ObjectGuid GetControllerGUIDS(Unit* unit)
     {
-        ALE::Push(L, unit->GetCharmerOrOwnerOrOwnGUID());
-        return 1;
+        return unit->GetCharmerOrOwnerOrOwnGUID();
     }
 
     /**
@@ -656,15 +587,12 @@ namespace LuaUnit
      * @param uint32 statType
      * @return float stat
      */
-    int GetStat(lua_State* L, Unit* unit)
+    sol::optional<float> GetStat(Unit* unit, uint32 stat)
     {
-        uint32 stat = ALE::CHECKVAL<uint32>(L, 2);
-
         if (stat >= MAX_STATS)
-            return 1;
+            return sol::nullopt;
 
-        ALE::Push(L, unit->GetStat((Stats)stat));
-        return 1;
+        return unit->GetStat((Stats)stat);
     }
 
     /**
@@ -673,15 +601,12 @@ namespace LuaUnit
      * @param uint32 spellSchool
      * @return uint32 spellPower
      */
-    int GetBaseSpellPower(lua_State* L, Unit* unit)
+    sol::optional<uint32> GetBaseSpellPower(Unit* unit, uint32 spellschool)
     {
-        uint32 spellschool = ALE::CHECKVAL<uint32>(L, 2);
-
         if (spellschool >= MAX_SPELL_SCHOOL)
-            return 1;
+            return sol::nullopt;
 
-        ALE::Push(L, unit->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + spellschool));
-        return 1;
+        return unit->GetUInt32Value(PLAYER_FIELD_MOD_DAMAGE_DONE_POS + spellschool);
     }
 
     /**
@@ -689,10 +614,9 @@ namespace LuaUnit
      *
      * @return [Unit] victim
      */
-    int GetVictim(lua_State* L, Unit* unit)
+    Unit* GetVictim(Unit* unit)
     {
-        ALE::Push(L, unit->GetVictim());
-        return 1;
+        return unit->GetVictim();
     }
 
     /**
@@ -711,14 +635,12 @@ namespace LuaUnit
      * @param [CurrentSpellTypes] spellType
      * @return [Spell] castedSpell
      */
-    int GetCurrentSpell(lua_State* L, Unit* unit)
+    Spell* GetCurrentSpell(Unit* unit, uint32 type)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
         if (type >= CURRENT_MAX_SPELL)
-            return luaL_argerror(L, 2, "valid CurrentSpellTypes expected");
+            throw std::invalid_argument("valid CurrentSpellTypes expected");
 
-        ALE::Push(L, unit->GetCurrentSpell(type));
-        return 1;
+        return unit->GetCurrentSpell(type);
     }
 
     /**
@@ -726,10 +648,9 @@ namespace LuaUnit
      *
      * @return uint8 standState
      */
-    int GetStandState(lua_State* L, Unit* unit)
+    uint8 GetStandState(Unit* unit)
     {
-        ALE::Push(L, unit->getStandState());
-        return 1;
+        return unit->getStandState();
     }
 
     /**
@@ -737,10 +658,9 @@ namespace LuaUnit
      *
      * @return uint32 displayId
      */
-    int GetDisplayId(lua_State* L, Unit* unit)
+    uint32 GetDisplayId(Unit* unit)
     {
-        ALE::Push(L, unit->GetDisplayId());
-        return 1;
+        return unit->GetDisplayId();
     }
 
     /**
@@ -748,10 +668,9 @@ namespace LuaUnit
      *
      * @return uint32 displayId
      */
-    int GetNativeDisplayId(lua_State* L, Unit* unit)
+    uint32 GetNativeDisplayId(Unit* unit)
     {
-        ALE::Push(L, unit->GetNativeDisplayId());
-        return 1;
+        return unit->GetNativeDisplayId();
     }
 
     /**
@@ -759,10 +678,9 @@ namespace LuaUnit
      *
      * @return uint8 level
      */
-    int GetLevel(lua_State* L, Unit* unit)
+    uint8 GetLevel(Unit* unit)
     {
-        ALE::Push(L, unit->GetLevel());
-        return 1;
+        return unit->GetLevel();
     }
 
     /**
@@ -770,19 +688,18 @@ namespace LuaUnit
      *
      * @return uint32 healthAmount
      */
-    int GetHealth(lua_State* L, Unit* unit)
+    uint32 GetHealth(Unit* unit)
     {
-        ALE::Push(L, unit->GetHealth());
-        return 1;
+        return unit->GetHealth();
     }
 
-    Powers PowerSelectorHelper(lua_State* L, Unit* unit, int powerType = -1)
+    Powers PowerSelectorHelper(Unit* unit, int powerType = -1)
     {
         if (powerType == -1)
             return unit->getPowerType();
 
         if (powerType < 0 || powerType >= int(MAX_POWERS))
-            luaL_argerror(L, 2, "valid Powers expected");
+            throw std::invalid_argument("valid Powers expected");
 
         return (Powers)powerType;
     }
@@ -807,13 +724,12 @@ namespace LuaUnit
      * @param int type = -1 : a valid power type from [Powers] or -1 for the [Unit]'s current power type
      * @return uint32 powerAmount
      */
-    int GetPower(lua_State* L, Unit* unit)
+    uint32 GetPower(Unit* unit, sol::optional<int> typeArg)
     {
-        int type = ALE::CHECKVAL<int>(L, 2, -1);
-        Powers power = PowerSelectorHelper(L, unit, type);
+        int type = typeArg.value_or(-1);
+        Powers power = PowerSelectorHelper(unit, type);
 
-        ALE::Push(L, unit->GetPower(power));
-        return 1;
+        return unit->GetPower(power);
     }
 
     /**
@@ -836,13 +752,12 @@ namespace LuaUnit
      * @param int type = -1 : a valid power type from [Powers] or -1 for the [Unit]'s current power type
      * @return uint32 maxPowerAmount
      */
-    int GetMaxPower(lua_State* L, Unit* unit)
+    uint32 GetMaxPower(Unit* unit, sol::optional<int> typeArg)
     {
-        int type = ALE::CHECKVAL<int>(L, 2, -1);
-        Powers power = PowerSelectorHelper(L, unit, type);
+        int type = typeArg.value_or(-1);
+        Powers power = PowerSelectorHelper(unit, type);
 
-        ALE::Push(L, unit->GetMaxPower(power));
-        return 1;
+        return unit->GetMaxPower(power);
     }
 
     /**
@@ -865,15 +780,14 @@ namespace LuaUnit
      * @param int type = -1 : a valid power type from [Powers] or -1 for the [Unit]'s current power type
      * @return float powerPct
      */
-    int GetPowerPct(lua_State* L, Unit* unit)
+    float GetPowerPct(Unit* unit, sol::optional<int> typeArg)
     {
-        int type = ALE::CHECKVAL<int>(L, 2, -1);
-        Powers power = PowerSelectorHelper(L, unit, type);
+        int type = typeArg.value_or(-1);
+        Powers power = PowerSelectorHelper(unit, type);
 
         float percent = ((float)unit->GetPower(power) / (float)unit->GetMaxPower(power)) * 100.0f;
 
-        ALE::Push(L, percent);
-        return 1;
+        return percent;
     }
 
     /**
@@ -895,10 +809,9 @@ namespace LuaUnit
      *
      * @return [Powers] powerType
      */
-    int GetPowerType(lua_State* L, Unit* unit)
+    Powers GetPowerType(Unit* unit)
     {
-        ALE::Push(L, unit->getPowerType());
-        return 1;
+        return unit->getPowerType();
     }
 
     /**
@@ -906,10 +819,9 @@ namespace LuaUnit
      *
      * @return uint32 maxHealth
      */
-    int GetMaxHealth(lua_State* L, Unit* unit)
+    uint32 GetMaxHealth(Unit* unit)
     {
-        ALE::Push(L, unit->GetMaxHealth());
-        return 1;
+        return unit->GetMaxHealth();
     }
 
     /**
@@ -917,10 +829,9 @@ namespace LuaUnit
      *
      * @return float healthPct
      */
-    int GetHealthPct(lua_State* L, Unit* unit)
+    float GetHealthPct(Unit* unit)
     {
-        ALE::Push(L, unit->GetHealthPct());
-        return 1;
+        return unit->GetHealthPct();
     }
 
     /**
@@ -928,10 +839,9 @@ namespace LuaUnit
      *
      * @return uint8 gender : 0 for male, 1 for female and 2 for none
      */
-    int GetGender(lua_State* L, Unit* unit)
+    uint8 GetGender(Unit* unit)
     {
-        ALE::Push(L, unit->getGender());
-        return 1;
+        return unit->getGender();
     }
 
     /**
@@ -939,10 +849,9 @@ namespace LuaUnit
      *
      * @return [Races] race
      */
-    int GetRace(lua_State* L, Unit* unit)
+    uint8 GetRace(Unit* unit)
     {
-        ALE::Push(L, unit->getRace());
-        return 1;
+        return unit->getRace();
     }
 
     /**
@@ -950,10 +859,9 @@ namespace LuaUnit
      *
      * @return [Classes] class
      */
-    int GetClass(lua_State* L, Unit* unit)
+    uint8 GetClass(Unit* unit)
     {
-        ALE::Push(L, unit->getClass());
-        return 1;
+        return unit->getClass();
     }
 
     /**
@@ -961,10 +869,9 @@ namespace LuaUnit
     *
     * @return uint32 racemask
     */
-    int GetRaceMask(lua_State* L, Unit* unit)
+    uint32 GetRaceMask(Unit* unit)
     {
-        ALE::Push(L, unit->getRaceMask());
-        return 1;
+        return unit->getRaceMask();
     }
 
     /**
@@ -972,10 +879,9 @@ namespace LuaUnit
     *
     * @return uint32 classmask
     */
-    int GetClassMask(lua_State* L, Unit* unit)
+    uint32 GetClassMask(Unit* unit)
     {
-        ALE::Push(L, unit->getClassMask());
-        return 1;
+        return unit->getClassMask();
     }
 
     /**
@@ -1002,10 +908,9 @@ namespace LuaUnit
      *
      * @return [CreatureType] creatureType
      */
-    int GetCreatureType(lua_State* L, Unit* unit)
+    uint32 GetCreatureType(Unit* unit)
     {
-        ALE::Push(L, unit->GetCreatureType());
-        return 1;
+        return unit->GetCreatureType();
     }
 
     /**
@@ -1029,18 +934,17 @@ namespace LuaUnit
      * @param [LocaleConstant] locale = DEFAULT_LOCALE
      * @return string className : class name or nil
      */
-    int GetClassAsString(lua_State* L, Unit* unit)
+    sol::optional<std::string> GetClassAsString(Unit* unit, sol::optional<uint8> localeArg)
     {
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 2, DEFAULT_LOCALE);
+        uint8 locale = localeArg.value_or(DEFAULT_LOCALE);
         if (locale >= TOTAL_LOCALES)
-            return luaL_argerror(L, 2, "valid LocaleConstant expected");
+            throw std::invalid_argument("valid LocaleConstant expected");
 
-        const ChrClassesEntry* entry = sChrClassesStore.LookupEntry(unit->getClass());
+        ChrClassesEntry const* entry = sChrClassesStore.LookupEntry(unit->getClass());
         if (!entry)
-            return 1;
+            return sol::nullopt;
 
-        ALE::Push(L, entry->name[locale]);
-        return 1;
+        return std::string(entry->name[locale]);
     }
 
     /**
@@ -1064,18 +968,17 @@ namespace LuaUnit
      * @param [LocaleConstant] locale = DEFAULT_LOCALE : locale to return the race name in
      * @return string raceName : race name or nil
      */
-    int GetRaceAsString(lua_State* L, Unit* unit)
+    sol::optional<std::string> GetRaceAsString(Unit* unit, sol::optional<uint8> localeArg)
     {
-        uint8 locale = ALE::CHECKVAL<uint8>(L, 2, DEFAULT_LOCALE);
+        uint8 locale = localeArg.value_or(DEFAULT_LOCALE);
         if (locale >= TOTAL_LOCALES)
-            return luaL_argerror(L, 2, "valid LocaleConstant expected");
+            throw std::invalid_argument("valid LocaleConstant expected");
 
-        const ChrRacesEntry* entry = sChrRacesStore.LookupEntry(unit->getRace());
+        ChrRacesEntry const* entry = sChrRacesStore.LookupEntry(unit->getRace());
         if (!entry)
-            return 1;
+            return sol::nullopt;
 
-        ALE::Push(L, entry->name[locale]);
-        return 1;
+        return std::string(entry->name[locale]);
     }
 
     /**
@@ -1083,10 +986,9 @@ namespace LuaUnit
      *
      * @return uint32 faction
      */
-    int GetFaction(lua_State* L, Unit* unit)
+    uint32 GetFaction(Unit* unit)
     {
-        ALE::Push(L, unit->GetFaction());
-        return 1;
+        return unit->GetFaction();
     }
 
     /**
@@ -1095,11 +997,9 @@ namespace LuaUnit
      * @param uint32 spellID : entry of the aura spell
      * @return [Aura] aura : aura object or nil
      */
-    int GetAura(lua_State* L, Unit* unit)
+    Aura* GetAura(Unit* unit, uint32 spellID)
     {
-        uint32 spellID = ALE::CHECKVAL<uint32>(L, 2);
-        ALE::Push(L, unit->GetAura(spellID));
-        return 1;
+        return unit->GetAura(spellID);
     }
 
     /**
@@ -1108,9 +1008,9 @@ namespace LuaUnit
      * @param float range = 533.333 : search radius
      * @return table friendyUnits : table filled with friendly units
      */
-    int GetFriendlyUnitsInRange(lua_State* L, Unit* unit)
+    sol::table GetFriendlyUnitsInRange(Unit* unit, sol::optional<float> rangeArg, sol::this_state s)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
 
         std::list<Unit*> list;
 
@@ -1118,21 +1018,17 @@ namespace LuaUnit
         Acore::UnitListSearcher<Acore::AnyFriendlyUnitInObjectRangeCheck> searcher(unit, list, checker);
         Cell::VisitObjects(unit, searcher, range);
 
-        ALEUtil::ObjectGUIDCheck guidCheck(unit->GET_GUID());
+        ALEUtil::ObjectGUIDCheck guidCheck(unit->GetGUID());
         list.remove_if(guidCheck);
 
-        lua_createtable(L, list.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table();
         uint32 i = 0;
 
         for (std::list<Unit*>::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            ALE::Push(L, *it);
-            lua_rawseti(L, tbl, ++i);
-        }
+            tbl[++i] = ALEBind::ToLuaDynamic(lua, *it);
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -1141,29 +1037,25 @@ namespace LuaUnit
      * @param float range = 533.333 : search radius
      * @return table unfriendyUnits : table filled with unfriendly units
      */
-    int GetUnfriendlyUnitsInRange(lua_State* L, Unit* unit)
+    sol::table GetUnfriendlyUnitsInRange(Unit* unit, sol::optional<float> rangeArg, sol::this_state s)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
 
         std::list<Unit*> list;
         Acore::AnyUnfriendlyUnitInObjectRangeCheck checker(unit, unit, range);
         Acore::UnitListSearcher<Acore::AnyUnfriendlyUnitInObjectRangeCheck> searcher(unit, list, checker);
         Cell::VisitObjects(unit, searcher, range);
-        ALEUtil::ObjectGUIDCheck guidCheck(unit->GET_GUID());
+        ALEUtil::ObjectGUIDCheck guidCheck(unit->GetGUID());
         list.remove_if(guidCheck);
 
-        lua_createtable(L, list.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table();
         uint32 i = 0;
 
         for (std::list<Unit*>::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            ALE::Push(L, *it);
-            lua_rawseti(L, tbl, ++i);
-        }
+            tbl[++i] = ALEBind::ToLuaDynamic(lua, *it);
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -1171,27 +1063,19 @@ namespace LuaUnit
      *
      * @return [Vehicle] vehicle
      */
-    int GetVehicleKit(lua_State* L, Unit* unit)
+    Vehicle* GetVehicleKit(Unit* unit)
     {
-        ALE::Push(L, unit->GetVehicleKit());
-        return 1;
+        return unit->GetVehicleKit();
     }
 
-    /*int GetVehicle(lua_State* L, Unit* unit)
-    {
-    ALE::Push(L, unit->GetVehicle());
-    return 1;
-    }*/
-
     /**
      * Returns the Critter Guid
      *
      * @return ObjectGuid critterGuid
      */
-    int GetCritterGUID(lua_State* L, Unit* unit)
+    ObjectGuid GetCritterGUID(Unit* unit)
     {
-        ALE::Push(L, unit->GetCritterGUID());
-        return 1;
+        return unit->GetCritterGUID();
     }
 
     /**
@@ -1215,15 +1099,12 @@ namespace LuaUnit
      * @param [UnitMoveType] type
      * @return float speed
      */
-    int GetSpeed(lua_State* L, Unit* unit)
+    float GetSpeed(Unit* unit, uint32 type)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
         if (type >= MAX_MOVE_TYPE)
-            return luaL_argerror(L, 2, "valid UnitMoveType expected");
+            throw std::invalid_argument("valid UnitMoveType expected");
 
-        ALE::Push(L, unit->GetSpeed((UnitMoveType)type));
-
-        return 1;
+        return unit->GetSpeed((UnitMoveType)type);
     }
 
     /**
@@ -1247,17 +1128,12 @@ namespace LuaUnit
     * @param [UnitMoveType] type
     * @return float speed
     */
-    int GetSpeedRate(lua_State* L, Unit* unit)
+    float GetSpeedRate(Unit* unit, uint32 type)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
         if (type >= MAX_MOVE_TYPE)
-        {
-            return luaL_argerror(L, 2, "valid UnitMoveType expected");
-        }
+            throw std::invalid_argument("valid UnitMoveType expected");
 
-        ALE::Push(L, unit->GetSpeedRate((UnitMoveType)type));
-
-        return 1;
+        return unit->GetSpeedRate((UnitMoveType)type);
     }
 
     /**
@@ -1292,10 +1168,9 @@ namespace LuaUnit
      *
      * @return [MovementGeneratorType] movementType
      */
-    int GetMovementType(lua_State* L, Unit* unit)
+    MovementGeneratorType GetMovementType(Unit* unit)
     {
-        ALE::Push(L, unit->GetMotionMaster()->GetCurrentMovementGeneratorType());
-        return 1;
+        return unit->GetMotionMaster()->GetCurrentMovementGeneratorType();
     }
 
     /**
@@ -1303,27 +1178,23 @@ namespace LuaUnit
      *
      * @return table attackers : table of [Unit]s attacking the unit
      */
-    int GetAttackers(lua_State* L, Unit* unit)
+    sol::table GetAttackers(Unit* unit, sol::this_state s)
     {
-        const Unit::AttackerSet& attackers = unit->getAttackers();
+        Unit::AttackerSet const& attackers = unit->getAttackers();
+
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table();
+        uint32 i = 0;
 
-        lua_newtable(L);
-        int table = lua_gettop(L);
-        uint32 i = 1;
         for (Unit* attacker : attackers)
         {
             if (!attacker)
-            {
                 continue;
-            }
 
-            ALE::Push(L, attacker);
-            lua_rawseti(L, table, i);
-            ++i;
+            tbl[++i] = ALEBind::ToLuaDynamic(lua, attacker);
         }
 
-        lua_settop(L, table); // push table to top of stack
-        return 1;
+        return tbl;
     }
 
     /**
@@ -1331,12 +1202,9 @@ namespace LuaUnit
      *
      * @param ObjectGuid guid : new owner guid
      */
-    int SetOwnerGUID(lua_State* L, Unit* unit)
+    void SetOwnerGUID(Unit* unit, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
-
         unit->SetOwnerGUID(guid);
-        return 0;
     }
 
     /**
@@ -1344,12 +1212,11 @@ namespace LuaUnit
      *
      * @param bool apply = true : true if set on, false if off
      */
-    int SetPvP(lua_State* L, Unit* unit)
+    void SetPvP(Unit* unit, sol::optional<bool> applyArg)
     {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
+        bool apply = applyArg.value_or(true);
 
         unit->SetPvP(apply);
-        return 0;
     }
 
     /**
@@ -1364,14 +1231,12 @@ namespace LuaUnit
      *
      * @param [SheathState] sheathState : valid SheathState
      */
-    int SetSheath(lua_State* L, Unit* unit)
+    void SetSheath(Unit* unit, uint32 sheathed)
     {
-        uint32 sheathed = ALE::CHECKVAL<uint32>(L, 2);
         if (sheathed >= MAX_SHEATH_STATE)
-            return luaL_argerror(L, 2, "valid SheathState expected");
+            throw std::invalid_argument("valid SheathState expected");
 
         unit->SetSheath((SheathState)sheathed);
-        return 0;
     }
 
     /**
@@ -1379,12 +1244,10 @@ namespace LuaUnit
      *
      * @param string name : new name
      */
-    int SetName(lua_State* L, Unit* unit)
+    void SetName(Unit* unit, std::string const& name)
     {
-        const char* name = ALE::CHECKVAL<const char*>(L, 2);
-        if (std::string(name).length() > 0)
+        if (name.length() > 0)
             unit->SetName(name);
-        return 0;
     }
 
     /**
@@ -1410,17 +1273,13 @@ namespace LuaUnit
      * @param float rate
      * @param bool forced = false
      */
-    int SetSpeed(lua_State* L, Unit* unit)
+    void SetSpeed(Unit* unit, uint32 type, float rate, sol::optional<bool> forcedArg)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
-        float rate = ALE::CHECKVAL<float>(L, 3);
-        bool forced = ALE::CHECKVAL<bool>(L, 4, false);
+        bool forced = forcedArg.value_or(false);
         if (type >= MAX_MOVE_TYPE)
-            return luaL_argerror(L, 2, "valid UnitMoveType expected");
+            throw std::invalid_argument("valid UnitMoveType expected");
 
         unit->SetSpeed((UnitMoveType)type, rate, forced);
-
-        return 0;
     }
 
     /**
@@ -1446,16 +1305,12 @@ namespace LuaUnit
      * @param float rate
      * @param bool forced = false
      */
-    int SetSpeedRate(lua_State* L, Unit* unit)
+    void SetSpeedRate(Unit* unit, uint32 type, float rate)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
-        float rate = ALE::CHECKVAL<float>(L, 3);
         if (type >= MAX_MOVE_TYPE)
-            return luaL_argerror(L, 2, "valid UnitMoveType expected");
+            throw std::invalid_argument("valid UnitMoveType expected");
 
         unit->SetSpeedRate((UnitMoveType)type, rate);
-
-        return 0;
     }
 
     /**
@@ -1463,13 +1318,9 @@ namespace LuaUnit
      *
      * @param uint32 faction : new faction ID
      */
-    int SetFaction(lua_State* L, Unit* unit)
+    void SetFaction(Unit* unit, uint32 factionId)
     {
-        uint32 factionId = ALE::CHECKVAL<uint32>(L, 2);
-
         unit->SetFaction(factionId);
-
-        return 0;
     }
 
     /**
@@ -1477,12 +1328,10 @@ namespace LuaUnit
      *
      * @param uint8 level : new level
      */
-    int SetLevel(lua_State* L, Unit* unit)
+    void SetLevel(Unit* unit, uint8 newlevel)
     {
-        uint8 newlevel = ALE::CHECKVAL<uint8>(L, 2);
-
         if (newlevel < 1)
-            return luaL_argerror(L, 2, "level cannot be below 1");
+            throw std::invalid_argument("level cannot be below 1");
 
         if (Player* player = unit->ToPlayer())
         {
@@ -1492,8 +1341,6 @@ namespace LuaUnit
         }
         else
             unit->SetLevel(newlevel);
-
-        return 0;
     }
 
     /**
@@ -1501,11 +1348,9 @@ namespace LuaUnit
      *
      * @param uint32 health : new health
      */
-    int SetHealth(lua_State* L, Unit* unit)
+    void SetHealth(Unit* unit, uint32 amt)
     {
-        uint32 amt = ALE::CHECKVAL<uint32>(L, 2);
         unit->SetHealth(amt);
-        return 0;
     }
 
     /**
@@ -1513,11 +1358,9 @@ namespace LuaUnit
      *
      * @param uint32 maxHealth : new max health
      */
-    int SetMaxHealth(lua_State* L, Unit* unit)
+    void SetMaxHealth(Unit* unit, uint32 amt)
     {
-        uint32 amt = ALE::CHECKVAL<uint32>(L, 2);
         unit->SetMaxHealth(amt);
-        return 0;
     }
 
     /**
@@ -1540,14 +1383,12 @@ namespace LuaUnit
      * @param uint32 amount : new power amount
      * @param int type = -1 : a valid power type from [Powers] or -1 for the [Unit]'s current power type
      */
-    int SetPower(lua_State* L, Unit* unit)
+    void SetPower(Unit* unit, uint32 amt, sol::optional<int> typeArg)
     {
-        uint32 amt = ALE::CHECKVAL<uint32>(L, 2);
-        int type = ALE::CHECKVAL<int>(L, 3, -1);
-        Powers power = PowerSelectorHelper(L, unit, type);
+        int type = typeArg.value_or(-1);
+        Powers power = PowerSelectorHelper(unit, type);
 
         unit->SetPower(power, amt);
-        return 0;
     }
 
     /**
@@ -1570,14 +1411,12 @@ namespace LuaUnit
      * @param int32 amount : amount to modify
      * @param int type = -1 : a valid power type from [Powers] or -1 for the [Unit]'s current power type
      */
-    int ModifyPower(lua_State* L, Unit* unit)
+    void ModifyPower(Unit* unit, int32 amt, sol::optional<int> typeArg)
     {
-        int32 amt = ALE::CHECKVAL<int32>(L, 2);
-        int type = ALE::CHECKVAL<int>(L, 3, -1);
-        Powers power = PowerSelectorHelper(L, unit, type);
+        int type = typeArg.value_or(-1);
+        Powers power = PowerSelectorHelper(unit, type);
 
         unit->ModifyPower(power, amt);
-        return 0;
     }
 
     /**
@@ -1600,14 +1439,12 @@ namespace LuaUnit
      * @param int type = -1 : a valid power type from [Powers] or -1 for the [Unit]'s current power type
      * @param uint32 maxPower : new max power amount
      */
-    int SetMaxPower(lua_State* L, Unit* unit)
+    void SetMaxPower(Unit* unit, sol::optional<int> typeArg, uint32 amt)
     {
-        int type = ALE::CHECKVAL<int>(L, 2, -1);
-        uint32 amt = ALE::CHECKVAL<uint32>(L, 3);
-        Powers power = PowerSelectorHelper(L, unit, type);
+        int type = typeArg.value_or(-1);
+        Powers power = PowerSelectorHelper(unit, type);
 
         unit->SetMaxPower(power, amt);
-        return 0;
     }
 
     /**
@@ -1629,14 +1466,12 @@ namespace LuaUnit
      *
      * @param [Powers] type : a valid power type
      */
-    int SetPowerType(lua_State* L, Unit* unit)
+    void SetPowerType(Unit* unit, uint32 type)
     {
-        uint32 type = ALE::CHECKVAL<uint32>(L, 2);
         if (type >= int(MAX_POWERS))
-            return luaL_argerror(L, 2, "valid Powers expected");
+            throw std::invalid_argument("valid Powers expected");
 
         unit->setPowerType((Powers)type);
-        return 0;
     }
 
     /**
@@ -1644,11 +1479,9 @@ namespace LuaUnit
      *
      * @param uint32 displayId
      */
-    int SetDisplayId(lua_State* L, Unit* unit)
+    void SetDisplayId(Unit* unit, uint32 model)
     {
-        uint32 model = ALE::CHECKVAL<uint32>(L, 2);
         unit->SetDisplayId(model);
-        return 0;
     }
 
     /**
@@ -1656,11 +1489,9 @@ namespace LuaUnit
      *
      * @param uint32 displayId
      */
-    int SetNativeDisplayId(lua_State* L, Unit* unit)
+    void SetNativeDisplayId(Unit* unit, uint32 model)
     {
-        uint32 model = ALE::CHECKVAL<uint32>(L, 2);
         unit->SetNativeDisplayId(model);
-        return 0;
     }
 
     /**
@@ -1668,11 +1499,9 @@ namespace LuaUnit
      *
      * @param uint32 orientation
      */
-    int SetFacing(lua_State* L, Unit* unit)
+    void SetFacing(Unit* unit, float o)
     {
-        float o = ALE::CHECKVAL<float>(L, 2);
         unit->SetFacingTo(o);
-        return 0;
     }
 
     /**
@@ -1680,11 +1509,9 @@ namespace LuaUnit
      *
      * @param [WorldObject] target
      */
-    int SetFacingToObject(lua_State* L, Unit* unit)
+    void SetFacingToObject(Unit* unit, WorldObject* obj)
     {
-        WorldObject* obj = ALE::CHECKOBJ<WorldObject>(L, 2);
         unit->SetFacingToObject(obj);
-        return 0;
     }
 
     /**
@@ -1692,11 +1519,9 @@ namespace LuaUnit
      *
      * @param ObjectGuid guid
      */
-    int SetCreatorGUID(lua_State* L, Unit* unit)
+    void SetCreatorGUID(Unit* unit, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         unit->SetCreatorGUID(guid);
-        return 0;
     }
 
     /**
@@ -1704,11 +1529,9 @@ namespace LuaUnit
      *
      * @param ObjectGuid guid
      */
-    int SetPetGUID(lua_State* L, Unit* unit)
+    void SetPetGUID(Unit* unit, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         unit->SetPetGUID(guid);
-        return 0;
     }
 
     /**
@@ -1716,11 +1539,10 @@ namespace LuaUnit
      *
      * @param bool enable = true
      */
-    int SetWaterWalk(lua_State* L, Unit* unit)
+    void SetWaterWalk(Unit* unit, sol::optional<bool> enableArg)
     {
-        bool enable = ALE::CHECKVAL<bool>(L, 2, true);
+        bool enable = enableArg.value_or(true);
         unit->SetWaterWalking(enable);
-        return 0;
     }
 
     /**
@@ -1728,11 +1550,9 @@ namespace LuaUnit
      *
      * @param uint8 state : stand state
      */
-    int SetStandState(lua_State* L, Unit* unit)
+    void SetStandState(Unit* unit, uint8 state)
     {
-        uint8 state = ALE::CHECKVAL<uint8>(L, 2);
         unit->SetStandState(state);
-        return 0;
     }
 
     /**
@@ -1740,11 +1560,9 @@ namespace LuaUnit
      *
      * @param [Unit] enemy : the [Unit] to start combat with
      */
-    int SetInCombatWith(lua_State* L, Unit* unit)
+    void SetInCombatWith(Unit* unit, Unit* enemy)
     {
-        Unit* enemy = ALE::CHECKOBJ<Unit>(L, 2);
         unit->SetInCombatWith(enemy);
-        return 0;
     }
 
     /**
@@ -1752,9 +1570,9 @@ namespace LuaUnit
      *
      * @param bool apply = true
      */
-    int SetFFA(lua_State* L, Unit* unit)
+    void SetFFA(Unit* unit, sol::optional<bool> applyArg)
     {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
+        bool apply = applyArg.value_or(true);
 
         if (apply)
         {
@@ -1768,7 +1586,6 @@ namespace LuaUnit
             for (Unit::ControlSet::iterator itr = unit->m_Controlled.begin(); itr != unit->m_Controlled.end(); ++itr)
                 (*itr)->RemoveByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP);
         }
-        return 0;
     }
 
     /**
@@ -1776,9 +1593,9 @@ namespace LuaUnit
      *
      * @param bool apply = true
      */
-    int SetSanctuary(lua_State* L, Unit* unit)
+    void SetSanctuary(Unit* unit, sol::optional<bool> applyArg)
     {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
+        bool apply = applyArg.value_or(true);
 
         if (apply)
         {
@@ -1788,8 +1605,6 @@ namespace LuaUnit
         }
         else
             unit->RemoveByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_SANCTUARY);
-
-        return 0;
     }
 
     /**
@@ -1799,30 +1614,20 @@ namespace LuaUnit
      *
      * @param [ObjectGuid] guid : The GUID of the critter to set
      */
-    int SetCritterGUID(lua_State* L, Unit* unit)
+    void SetCritterGUID(Unit* unit, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         unit->SetCritterGUID(guid);
-        return 0;
     }
 
-    /*int SetStunned(lua_State* L, Unit* unit)
-    {
-    bool apply = ALE::CHECKVAL<bool>(L, 2, true);
-    unit->SetControlled(apply, UNIT_STATE_STUNNED);
-    return 0;
-    }*/
-
     /**
      * Roots the [Unit] to the ground, if 'false' specified, unroots the [Unit].
      *
      * @param bool apply = true
      */
-    int SetRooted(lua_State* L, Unit* unit)
+    void SetRooted(Unit* unit, sol::optional<bool> applyArg)
     {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
+        bool apply = applyArg.value_or(true);
         unit->SetControlled(apply, UNIT_STATE_ROOT);
-        return 0;
     }
 
     /**
@@ -1830,11 +1635,10 @@ namespace LuaUnit
      *
      * @param bool apply = true
      */
-    int SetConfused(lua_State* L, Unit* unit)
+    void SetConfused(Unit* unit, sol::optional<bool> applyArg)
     {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
+        bool apply = applyArg.value_or(true);
         unit->SetControlled(apply, UNIT_STATE_CONFUSED);
-        return 0;
     }
 
     /**
@@ -1842,34 +1646,18 @@ namespace LuaUnit
      *
      * @param bool apply = true
      */
-    int SetFeared(lua_State* L, Unit* unit)
+    void SetFeared(Unit* unit, sol::optional<bool> applyArg)
     {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
+        bool apply = applyArg.value_or(true);
         unit->SetControlled(apply, UNIT_STATE_FLEEING);
-        return 0;
     }
 
-    /*int SetCanFly(lua_State* L, Unit* unit)
-    {
-        bool apply = ALE::CHECKVAL<bool>(L, 2, true);
-        unit->SetCanFly(apply);
-        return 0;
-    }*/
-
-    /*int SetVisible(lua_State* L, Unit* unit)
-    {
-        bool x = ALE::CHECKVAL<bool>(L, 2, true);
-        unit->SetVisible(x);
-        return 0;
-    }*/
-
     /**
      * Clears the [Unit]'s threat list.
      */
-    int ClearThreatList(lua_State* /*L*/, Unit* unit)
+    void ClearThreatList(Unit* unit)
     {
         unit->GetThreatMgr().ClearAllThreat();
-        return 0;
     }
 
     /**
@@ -1877,32 +1665,26 @@ namespace LuaUnit
      *
      * @return table threatList : table of [Unit]s in the threat list
      */
-    int GetThreatList(lua_State* L, Unit* unit)
+    sol::object GetThreatList(Unit* unit, sol::this_state s)
     {
+        sol::state_view lua(s);
+
         if (!unit->CanHaveThreatList())
-        {
-            ALE::Push(L);
-            return 1;
-        }
+            return sol::make_object(lua, sol::lua_nil);
+
+        sol::table tbl = lua.create_table();
+        uint32 i = 0;
 
-        lua_newtable(L);
-        int table = lua_gettop(L);
-        uint32 i = 1;
         for (ThreatReference const* item : unit->GetThreatMgr().GetSortedThreatList())
         {
             Unit* victim = item->GetVictim();
             if (!victim)
-            {
                 continue;
-            }
 
-            ALE::Push(L, victim);
-            lua_rawseti(L, table, i);
-            ++i;
+            tbl[++i] = ALEBind::ToLuaDynamic(lua, victim);
         }
 
-        lua_settop(L, table); // push table to top of stack
-        return 1;
+        return sol::make_object(lua, tbl);
     }
 
     /**
@@ -1910,26 +1692,21 @@ namespace LuaUnit
      *
      * @param uint32 displayId
      */
-    int Mount(lua_State* L, Unit* unit)
+    void Mount(Unit* unit, uint32 displayId)
     {
-        uint32 displayId = ALE::CHECKVAL<uint32>(L, 2);
-
         unit->Mount(displayId);
-        return 0;
     }
 
     /**
      * Dismounts the [Unit].
      */
-    int Dismount(lua_State* /*L*/, Unit* unit)
+    void Dismount(Unit* unit)
     {
         if (unit->IsMounted())
         {
             unit->Dismount();
             unit->RemoveAurasByType(SPELL_AURA_MOUNTED);
         }
-
-        return 0;
     }
 
     /**
@@ -1937,10 +1714,9 @@ namespace LuaUnit
      *
      * @param uint32 emoteId
      */
-    int PerformEmote(lua_State* L, Unit* unit)
+    void PerformEmote(Unit* unit, uint32 emoteId)
     {
-        unit->HandleEmoteCommand(ALE::CHECKVAL<uint32>(L, 2));
-        return 0;
+        unit->HandleEmoteCommand(emoteId);
     }
 
     /**
@@ -1948,12 +1724,9 @@ namespace LuaUnit
      *
      * @param uint32 emoteId
      */
-    int EmoteState(lua_State* L, Unit* unit)
+    void EmoteState(Unit* unit, uint32 emoteId)
     {
-        uint32 emoteId = ALE::CHECKVAL<uint32>(L, 2);
-
         unit->SetUInt32Value(UNIT_NPC_EMOTESTATE, emoteId);
-        return 0;
     }
 
     /**
@@ -1961,10 +1734,9 @@ namespace LuaUnit
      *
      * @return int32 percentage
      */
-    int CountPctFromCurHealth(lua_State* L, Unit* unit)
+    uint32 CountPctFromCurHealth(Unit* unit, int32 pct)
     {
-        ALE::Push(L, unit->CountPctFromCurHealth(ALE::CHECKVAL<int32>(L, 2)));
-        return 1;
+        return unit->CountPctFromCurHealth(pct);
     }
 
     /**
@@ -1972,10 +1744,9 @@ namespace LuaUnit
      *
      * @return int32 percentage
      */
-    int CountPctFromMaxHealth(lua_State* L, Unit* unit)
+    uint32 CountPctFromMaxHealth(Unit* unit, int32 pct)
     {
-        ALE::Push(L, unit->CountPctFromMaxHealth(ALE::CHECKVAL<int32>(L, 2)));
-        return 1;
+        return unit->CountPctFromMaxHealth(pct);
     }
 
     /**
@@ -1986,38 +1757,24 @@ namespace LuaUnit
      * @param string msg
      * @param [Player] target
      */
-    int SendChatMessageToPlayer(lua_State* L, Unit* unit)
+    void SendChatMessageToPlayer(Unit* unit, uint8 type, uint32 lang, std::string const& msg, Player* target)
     {
-        uint8 type = ALE::CHECKVAL<uint8>(L, 2);
-        uint32 lang = ALE::CHECKVAL<uint32>(L, 3);
-        std::string msg = ALE::CHECKVAL<std::string>(L, 4);
-        Player* target = ALE::CHECKOBJ<Player>(L, 5);
-
         if (type >= MAX_CHAT_MSG_TYPE)
-            return luaL_argerror(L, 2, "valid ChatMsg expected");
+            throw std::invalid_argument("valid ChatMsg expected");
         if (lang >= LANGUAGES_COUNT)
-            return luaL_argerror(L, 3, "valid Language expected");
+            throw std::invalid_argument("valid Language expected");
 
         WorldPacket data;
         ChatHandler::BuildChatPacket(data, ChatMsg(type), Language(lang), unit, target, msg);
         target->GetSession()->SendPacket(&data);
-        return 0;
     }
 
-    /*static void PrepareMove(Unit* unit)
-    {
-        unit->GetMotionMaster()->MovementExpired(); // Chase
-        unit->StopMoving(); // Some
-        unit->GetMotionMaster()->Clear(); // all
-    }*/
-
     /**
      * Stops the [Unit]'s movement
      */
-    int MoveStop(lua_State* /*L*/, Unit* unit)
+    void MoveStop(Unit* unit)
     {
         unit->StopMoving();
-        return 0;
     }
 
     /**
@@ -2025,11 +1782,10 @@ namespace LuaUnit
      *
      * @param bool reset = true : cleans movement
      */
-    int MoveExpire(lua_State* L, Unit* unit)
+    void MoveExpire(Unit* unit, sol::optional<bool> resetArg)
     {
-        bool reset = ALE::CHECKVAL<bool>(L, 2, true);
+        bool reset = resetArg.value_or(true);
         unit->GetMotionMaster()->MovementExpired(reset);
-        return 0;
     }
 
     /**
@@ -2037,20 +1793,18 @@ namespace LuaUnit
      *
      * @param bool reset = true : clean movement
      */
-    int MoveClear(lua_State* L, Unit* unit)
+    void MoveClear(Unit* unit, sol::optional<bool> resetArg)
     {
-        bool reset = ALE::CHECKVAL<bool>(L, 2, true);
+        bool reset = resetArg.value_or(true);
         unit->GetMotionMaster()->Clear(reset);
-        return 0;
     }
 
     /**
      * The [Unit] will be idle
      */
-    int MoveIdle(lua_State* /*L*/, Unit* unit)
+    void MoveIdle(Unit* unit)
     {
         unit->GetMotionMaster()->MoveIdle();
-        return 0;
     }
 
     /**
@@ -2058,22 +1812,19 @@ namespace LuaUnit
      *
      * @param float radius : limit on how far the [Unit] will move at random
      */
-    int MoveRandom(lua_State* L, Unit* unit)
+    void MoveRandom(Unit* unit, float radius)
     {
-        float radius = ALE::CHECKVAL<float>(L, 2);
         float x, y, z;
         unit->GetPosition(x, y, z);
         unit->GetMotionMaster()->MoveRandom(radius);
-        return 0;
     }
 
     /**
      * The [Unit] will move to its set home location
      */
-    int MoveHome(lua_State* /*L*/, Unit* unit)
+    void MoveHome(Unit* unit)
     {
         unit->GetMotionMaster()->MoveTargetedHome();
-        return 0;
     }
 
     /**
@@ -2083,13 +1834,11 @@ namespace LuaUnit
      * @param float dist = 0 : distance to start following
      * @param float angle = 0
      */
-    int MoveFollow(lua_State* L, Unit* unit)
+    void MoveFollow(Unit* unit, Unit* target, sol::optional<float> distArg, sol::optional<float> angleArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-        float dist = ALE::CHECKVAL<float>(L, 3, 0.0f);
-        float angle = ALE::CHECKVAL<float>(L, 4, 0.0f);
+        float dist = distArg.value_or(0.0f);
+        float angle = angleArg.value_or(0.0f);
         unit->GetMotionMaster()->MoveFollow(target, dist, angle);
-        return 0;
     }
 
     /**
@@ -2099,22 +1848,19 @@ namespace LuaUnit
      * @param float dist = 0 : distance start chasing
      * @param float angle = 0
      */
-    int MoveChase(lua_State* L, Unit* unit)
+    void MoveChase(Unit* unit, Unit* target, sol::optional<float> distArg, sol::optional<float> angleArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-        float dist = ALE::CHECKVAL<float>(L, 3, 0.0f);
-        float angle = ALE::CHECKVAL<float>(L, 4, 0.0f);
+        float dist = distArg.value_or(0.0f);
+        float angle = angleArg.value_or(0.0f);
         unit->GetMotionMaster()->MoveChase(target, dist, angle);
-        return 0;
     }
 
     /**
      * The [Unit] will move confused
      */
-    int MoveConfused(lua_State* /*L*/, Unit* unit)
+    void MoveConfused(Unit* unit)
     {
         unit->GetMotionMaster()->MoveConfused();
-        return 0;
     }
 
     /**
@@ -2123,12 +1869,10 @@ namespace LuaUnit
      * @param [Unit] target
      * @param uint32 time = 0 : flee delay
      */
-    int MoveFleeing(lua_State* L, Unit* unit)
+    void MoveFleeing(Unit* unit, Unit* target, sol::optional<uint32> timeArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-        uint32 time = ALE::CHECKVAL<uint32>(L, 3, 0);
+        uint32 time = timeArg.value_or(0);
         unit->GetMotionMaster()->MoveFleeing(target, time);
-        return 0;
     }
 
     /**
@@ -2140,15 +1884,10 @@ namespace LuaUnit
      * @param float z
      * @param bool genPath = true : if true, generates path
      */
-    int MoveTo(lua_State* L, Unit* unit)
+    void MoveTo(Unit* unit, uint32 id, float x, float y, float z, sol::optional<bool> genPathArg)
     {
-        uint32 id = ALE::CHECKVAL<uint32>(L, 2);
-        float x = ALE::CHECKVAL<float>(L, 3);
-        float y = ALE::CHECKVAL<float>(L, 4);
-        float z = ALE::CHECKVAL<float>(L, 5);
-        bool genPath = ALE::CHECKVAL<bool>(L, 6, true);
+        bool genPath = genPathArg.value_or(true);
         unit->GetMotionMaster()->MovePoint(id, x, y, z, FORCED_MOVEMENT_NONE, 0.f, 0.f, genPath);
-        return 0;
     }
 
     /**
@@ -2161,17 +1900,11 @@ namespace LuaUnit
      * @param float maxHeight : maximum height
      * @param uint32 id = 0 : unique movement Id
      */
-    int MoveJump(lua_State* L, Unit* unit)
+    void MoveJump(Unit* unit, float x, float y, float z, float zSpeed, float maxHeight, sol::optional<uint32> idArg)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float z = ALE::CHECKVAL<float>(L, 4);
-        float zSpeed = ALE::CHECKVAL<float>(L, 5);
-        float maxHeight = ALE::CHECKVAL<float>(L, 6);
-        uint32 id = ALE::CHECKVAL<uint32>(L, 7, 0);
+        uint32 id = idArg.value_or(0);
         Position pos(x, y, z);
         unit->GetMotionMaster()->MoveJump(pos, zSpeed, maxHeight, id);
-        return 0;
     }
 
     /**
@@ -2182,16 +1915,11 @@ namespace LuaUnit
      * @param [Player] receiver : specific [Unit] to receive the message
      * @param bool bossWhisper = false : is a boss whisper
      */
-    int SendUnitWhisper(lua_State* L, Unit* unit)
+    void SendUnitWhisper(Unit* unit, std::string const& msg, uint32 lang, Player* receiver, sol::optional<bool> bossWhisperArg)
     {
-        const char* msg = ALE::CHECKVAL<const char*>(L, 2);
-        uint32 lang = ALE::CHECKVAL<uint32>(L, 3);
-        (void)lang; // ensure that the variable is referenced in order to pass compiler checks
-        Player* receiver = ALE::CHECKOBJ<Player>(L, 4);
-        bool bossWhisper = ALE::CHECKVAL<bool>(L, 5, false);
-        if (std::string(msg).length() > 0)
+        bool bossWhisper = bossWhisperArg.value_or(false);
+        if (msg.length() > 0)
             unit->Whisper(msg, (Language)lang, receiver, bossWhisper);
-        return 0;
     }
 
     /**
@@ -2201,14 +1929,12 @@ namespace LuaUnit
      * @param [Unit] receiver = nil : specific [Unit] to receive the message
      * @param bool bossEmote = false : is a boss emote
      */
-    int SendUnitEmote(lua_State* L, Unit* unit)
+    void SendUnitEmote(Unit* unit, std::string const& msg, sol::optional<UnitRef> receiverArg, sol::optional<bool> bossEmoteArg)
     {
-        const char* msg = ALE::CHECKVAL<const char*>(L, 2);
-        Unit* receiver = ALE::CHECKOBJ<Unit>(L, 3, false);
-        bool bossEmote = ALE::CHECKVAL<bool>(L, 4, false);
-        if (std::string(msg).length() > 0)
+        Unit* receiver = receiverArg ? receiverArg->Resolve() : nullptr;
+        bool bossEmote = bossEmoteArg.value_or(false);
+        if (msg.length() > 0)
             unit->TextEmote(msg, receiver, bossEmote);
-        return 0;
     }
 
     /**
@@ -2217,13 +1943,10 @@ namespace LuaUnit
      * @param string msg : message for the [Unit] to say
      * @param uint32 language : language for the [Unit] to speak
      */
-    int SendUnitSay(lua_State* L, Unit* unit)
+    void SendUnitSay(Unit* unit, std::string const& msg, uint32 language)
     {
-        const char* msg = ALE::CHECKVAL<const char*>(L, 2);
-        uint32 language = ALE::CHECKVAL<uint32>(L, 3);
-        if (std::string(msg).length() > 0)
+        if (msg.length() > 0)
             unit->Say(msg, (Language)language, unit);
-        return 0;
     }
 
     /**
@@ -2232,22 +1955,18 @@ namespace LuaUnit
      * @param string msg : message for the [Unit] to yell
      * @param uint32 language : language for the [Unit] to speak
      */
-    int SendUnitYell(lua_State* L, Unit* unit)
+    void SendUnitYell(Unit* unit, std::string const& msg, uint32 language)
     {
-        const char* msg = ALE::CHECKVAL<const char*>(L, 2);
-        uint32 language = ALE::CHECKVAL<uint32>(L, 3);
-        if (std::string(msg).length() > 0)
+        if (msg.length() > 0)
             unit->Yell(msg, (Language)language, unit);
-        return 0;
     }
 
     /**
      * Unmorphs the [Unit] setting it's display ID back to the native display ID.
      */
-    int DeMorph(lua_State* /*L*/, Unit* unit)
+    void DeMorph(Unit* unit)
     {
         unit->DeMorph();
-        return 0;
     }
 
     /**
@@ -2257,17 +1976,15 @@ namespace LuaUnit
      * @param uint32 spell : entry of a spell
      * @param bool triggered = false : if true the spell is instant and has no cost
      */
-    int CastSpell(lua_State* L, Unit* unit)
+    void CastSpell(Unit* unit, sol::optional<UnitRef> targetArg, uint32 spell, sol::optional<bool> triggeredArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2, false);
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 3);
-        bool triggered = ALE::CHECKVAL<bool>(L, 4, false);
+        Unit* target = targetArg ? targetArg->Resolve() : nullptr;
+        bool triggered = triggeredArg.value_or(false);
         SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(spell);
         if (!spellEntry)
-            return 0;
+            return;
 
         unit->CastSpell(target, spell, triggered);
-        return 0;
     }
 
     /**
@@ -2283,22 +2000,20 @@ namespace LuaUnit
      * @param [Item] castItem = nil
      * @param ObjectGuid originalCaster = ObjectGuid()
      */
-    int CastCustomSpell(lua_State* L, Unit* unit)
+    void CastCustomSpell(Unit* unit, sol::optional<UnitRef> targetArg, uint32 spell, sol::optional<bool> triggeredArg, sol::optional<int32> bp0Arg, sol::optional<int32> bp1Arg, sol::optional<int32> bp2Arg, sol::optional<ItemRef> castItemArg, sol::optional<ObjectGuid> originalCasterArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2, false);
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 3);
-        bool triggered = ALE::CHECKVAL<bool>(L, 4, false);
-        bool has_bp0 = !lua_isnoneornil(L, 5);
-        int32 bp0 = ALE::CHECKVAL<int32>(L, 5, 0);
-        bool has_bp1 = !lua_isnoneornil(L, 6);
-        int32 bp1 = ALE::CHECKVAL<int32>(L, 6, 0);
-        bool has_bp2 = !lua_isnoneornil(L, 7);
-        int32 bp2 = ALE::CHECKVAL<int32>(L, 7, 0);
-        Item* castItem = ALE::CHECKOBJ<Item>(L, 8, false);
-        ObjectGuid originalCaster = ALE::CHECKVAL<ObjectGuid>(L, 9, ObjectGuid());
+        Unit* target = targetArg ? targetArg->Resolve() : nullptr;
+        bool triggered = triggeredArg.value_or(false);
+        bool has_bp0 = bp0Arg.has_value();
+        int32 bp0 = bp0Arg.value_or(0);
+        bool has_bp1 = bp1Arg.has_value();
+        int32 bp1 = bp1Arg.value_or(0);
+        bool has_bp2 = bp2Arg.has_value();
+        int32 bp2 = bp2Arg.value_or(0);
+        Item* castItem = castItemArg ? castItemArg->Resolve() : nullptr;
+        ObjectGuid originalCaster = originalCasterArg.value_or(ObjectGuid());
 
-        unit->CastCustomSpell(target, spell, has_bp0 ? &bp0 : NULL, has_bp1 ? &bp1 : NULL, has_bp2 ? &bp2 : NULL, triggered, castItem, NULL, ObjectGuid(originalCaster));
-        return 0;
+        unit->CastCustomSpell(target, spell, has_bp0 ? &bp0 : nullptr, has_bp1 ? &bp1 : nullptr, has_bp2 ? &bp2 : nullptr, triggered, castItem, nullptr, ObjectGuid(originalCaster));
     }
 
     /**
@@ -2310,24 +2025,18 @@ namespace LuaUnit
      * @param uint32 spell : entry of a spell
      * @param bool triggered = false : if true the spell is instant and has no cost
      */
-    int CastSpellAoF(lua_State* L, Unit* unit)
+    void CastSpellAoF(Unit* unit, float _x, float _y, float _z, uint32 spell, sol::optional<bool> triggeredArg)
     {
-        float _x = ALE::CHECKVAL<float>(L, 2);
-        float _y = ALE::CHECKVAL<float>(L, 3);
-        float _z = ALE::CHECKVAL<float>(L, 4);
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 5);
-        bool triggered = ALE::CHECKVAL<bool>(L, 6, true);
+        bool triggered = triggeredArg.value_or(true);
         unit->CastSpell(_x, _y, _z, spell, triggered);
-        return 0;
     }
 
     /**
      * Clears the [Unit]'s combat
      */
-    int ClearInCombat(lua_State* /*L*/, Unit* unit)
+    void ClearInCombat(Unit* unit)
     {
         unit->ClearInCombat();
-        return 0;
     }
 
     /**
@@ -2335,11 +2044,10 @@ namespace LuaUnit
      *
      * @param uint32 spell = 0 : entry of a spell
      */
-    int StopSpellCast(lua_State* L, Unit* unit)
+    void StopSpellCast(Unit* unit, sol::optional<uint32> spellIdArg)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2, 0);
+        uint32 spellId = spellIdArg.value_or(0);
         unit->CastStop(spellId);
-        return 0;
     }
 
     /**
@@ -2350,10 +2058,9 @@ namespace LuaUnit
      * @param int32 spellType : type of spell to interrupt
      * @param bool delayed = true : skips if the spell is delayed
      */
-    int InterruptSpell(lua_State* L, Unit* unit)
+    void InterruptSpell(Unit* unit, int spellType, sol::optional<bool> delayedArg)
     {
-        int spellType = ALE::CHECKVAL<int>(L, 2);
-        bool delayed = ALE::CHECKVAL<bool>(L, 3, true);
+        bool delayed = delayedArg.value_or(true);
         switch (spellType)
         {
         case 0:
@@ -2369,11 +2076,10 @@ namespace LuaUnit
             spellType = CURRENT_AUTOREPEAT_SPELL;
             break;
         default:
-            return luaL_argerror(L, 2, "valid CurrentSpellTypes expected");
+            throw std::invalid_argument("valid CurrentSpellTypes expected");
         }
 
         unit->InterruptSpell((CurrentSpellTypes)spellType, delayed);
-        return 0;
     }
 
     /**
@@ -2383,16 +2089,13 @@ namespace LuaUnit
      * @param [Unit] target : aura will be applied on the target
      * @return [Aura] aura
      */
-    int AddAura(lua_State* L, Unit* unit)
+    Aura* AddAura(Unit* unit, uint32 spell, Unit* target)
     {
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 2);
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 3);
         SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(spell);
         if (!spellEntry)
-            return 1;
+            return nullptr;
 
-        ALE::Push(L, unit->AddAura(spell, target));
-        return 1;
+        return unit->AddAura(spell, target);
     }
 
     /**
@@ -2400,11 +2103,9 @@ namespace LuaUnit
      *
      * @param uint32 spell : entry of a spell
      */
-    int RemoveAura(lua_State* L, Unit* unit)
+    void RemoveAura(Unit* unit, uint32 spellId)
     {
-        uint32 spellId = ALE::CHECKVAL<uint32>(L, 2);
         unit->RemoveAurasDueToSpell(spellId);
-        return 0;
     }
 
     /**
@@ -2412,19 +2113,17 @@ namespace LuaUnit
      *
      *     Note: talents and racials are also auras, use with caution
      */
-    int RemoveAllAuras(lua_State* /*L*/, Unit* unit)
+    void RemoveAllAuras(Unit* unit)
     {
         unit->RemoveAllAuras();
-        return 0;
     }
 
     /**
      * Removes all positive visible [Aura]'s from the [Unit].
      */
-    int RemoveArenaAuras(lua_State* /*L*/, Unit* unit)
+    void RemoveArenaAuras(Unit* unit)
     {
         unit->RemoveArenaAuras();
-        return 0;
     }
 
     /**
@@ -2432,12 +2131,9 @@ namespace LuaUnit
      *
      * @param [UnitState] state
      */
-    int AddUnitState(lua_State* L, Unit* unit)
+    void AddUnitState(Unit* unit, uint32 state)
     {
-        uint32 state = ALE::CHECKVAL<uint32>(L, 2);
-
         unit->AddUnitState(state);
-        return 0;
     }
 
     /**
@@ -2445,12 +2141,9 @@ namespace LuaUnit
      *
      * @param [UnitState] state
      */
-    int ClearUnitState(lua_State* L, Unit* unit)
+    void ClearUnitState(Unit* unit, uint32 state)
     {
-        uint32 state = ALE::CHECKVAL<uint32>(L, 2);
-
         unit->ClearUnitState(state);
-        return 0;
     }
 
     /**
@@ -2461,15 +2154,9 @@ namespace LuaUnit
      * @param float z
      * @param float o : orientation
      */
-    int NearTeleport(lua_State* L, Unit* unit)
+    void NearTeleport(Unit* unit, float x, float y, float z, float o)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float z = ALE::CHECKVAL<float>(L, 4);
-        float o = ALE::CHECKVAL<float>(L, 5);
-
         unit->NearTeleportTo(x, y, z, o);
-        return 0;
     }
 
     /**
@@ -2495,28 +2182,26 @@ namespace LuaUnit
      * @param [SpellSchools] school = MAX_SPELL_SCHOOL : school the damage is done in or MAX_SPELL_SCHOOL for direct damage
      * @param uint32 spell = 0 : spell that inflicts the damage
      */
-    int DealDamage(lua_State* L, Unit* unit)
+    void DealDamage(Unit* unit, Unit* target, uint32 damage, sol::optional<bool> durabilitylossArg, sol::optional<uint32> schoolArg, sol::optional<uint32> spellArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-        uint32 damage = ALE::CHECKVAL<uint32>(L, 3);
-        bool durabilityloss = ALE::CHECKVAL<bool>(L, 4, true);
-        uint32 school = ALE::CHECKVAL<uint32>(L, 5, MAX_SPELL_SCHOOL);
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 6, 0);
+        bool durabilityloss = durabilitylossArg.value_or(true);
+        uint32 school = schoolArg.value_or(MAX_SPELL_SCHOOL);
+        uint32 spell = spellArg.value_or(0);
         if (school > MAX_SPELL_SCHOOL)
-            return luaL_argerror(L, 6, "valid SpellSchool expected");
+            throw std::invalid_argument("valid SpellSchool expected");
 
         // flat melee damage without resistence/etc reduction
         if (school == MAX_SPELL_SCHOOL)
         {
-            Unit::DealDamage(unit, target, damage, NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, durabilityloss);
+            Unit::DealDamage(unit, target, damage, nullptr, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, durabilityloss);
             unit->SendAttackStateUpdate(HITINFO_AFFECTS_VICTIM, target, 1, SPELL_SCHOOL_MASK_NORMAL, damage, 0, 0, VICTIMSTATE_HIT, 0);
-            return 0;
+            return;
         }
 
         SpellSchoolMask schoolmask = SpellSchoolMask(1 << school);
 
         if (Unit::IsDamageReducedByArmor(schoolmask))
-            damage = Unit::CalcArmorReducedDamage(unit, target, damage, NULL, BASE_ATTACK);
+            damage = Unit::CalcArmorReducedDamage(unit, target, damage, nullptr, BASE_ATTACK);
 
         if (!spell)
         {
@@ -2531,23 +2216,22 @@ namespace LuaUnit
             uint32 absorb = dmgInfo.GetAbsorb();
             uint32 resist = dmgInfo.GetResist();
             unit->DealDamageMods(target, damage, &absorb);
-            Unit::DealDamage(unit, target, damage, NULL, DIRECT_DAMAGE, schoolmask, NULL, false);
+            Unit::DealDamage(unit, target, damage, nullptr, DIRECT_DAMAGE, schoolmask, nullptr, false);
             unit->SendAttackStateUpdate(HITINFO_AFFECTS_VICTIM, target, 0, schoolmask, damage, absorb, resist, VICTIMSTATE_HIT, 0);
-            return 0;
+            return;
         }
 
         if (!spell)
-            return 0;
+            return;
 
         SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell);
         if (!spellInfo)
-            return 0;
+            return;
 
         SpellNonMeleeDamage dmgInfo(unit, target, spellInfo, spellInfo->GetSchoolMask());
         Unit::DealDamageMods(dmgInfo.target, dmgInfo.damage, &dmgInfo.absorb);
         unit->SendSpellNonMeleeDamageLog(&dmgInfo);
         unit->DealSpellDamage(&dmgInfo, true);
-        return 0;
     }
 
     /**
@@ -2558,19 +2242,15 @@ namespace LuaUnit
      * @param uint32 amount : amount to heal
      * @param bool critical = false : if true, heal is logged as critical
      */
-    int DealHeal(lua_State* L, Unit* unit)
+    void DealHeal(Unit* unit, Unit* target, uint32 spell, uint32 amount, sol::optional<bool> criticalArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 amount = ALE::CHECKVAL<uint32>(L, 4);
-        bool critical = ALE::CHECKVAL<bool>(L, 5, false);
+        bool critical = criticalArg.value_or(false);
 
-        if (const SpellInfo* info = sSpellMgr->GetSpellInfo(spell))
+        if (SpellInfo const* info = sSpellMgr->GetSpellInfo(spell))
         {
             HealInfo healInfo(unit, target, amount, info, info->GetSchoolMask());
             unit->HealBySpell(healInfo, critical);
         }
-        return 0;
     }
 
     /**
@@ -2579,13 +2259,11 @@ namespace LuaUnit
      * @param [Unit] target : [Unit] to kill
      * @param bool durLoss = true : when true, the target's items suffer durability loss
      */
-    int Kill(lua_State* L, Unit* unit)
+    void Kill(Unit* unit, Unit* target, sol::optional<bool> durLossArg)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-        bool durLoss = ALE::CHECKVAL<bool>(L, 3, true);
+        bool durLoss = durLossArg.value_or(true);
 
         Unit::Kill(unit, target, durLoss);
-        return 0;
     }
 
     /**
@@ -2610,19 +2288,16 @@ namespace LuaUnit
      * @param [SpellSchoolMask] schoolMask = 0 : [SpellSchoolMask] of the threat causer
      * @param uint32 spell = 0 : spell entry used for threat
      */
-    int AddThreat(lua_State* L, Unit* unit)
+    void AddThreat(Unit* unit, Unit* victim, sol::optional<float> threatArg, sol::optional<uint32> spellArg, sol::optional<uint32> schoolMaskArg)
     {
-        Unit* victim = ALE::CHECKOBJ<Unit>(L, 2);
-        float threat = ALE::CHECKVAL<float>(L, 3, true);
-        uint32 spell = ALE::CHECKVAL<uint32>(L, 4, 0);
+        float threat = threatArg.value_or(1.0f);
+        uint32 spell = spellArg.value_or(0);
 
-        uint32 schoolMask = ALE::CHECKVAL<uint32>(L, 5, 0);
+        uint32 schoolMask = schoolMaskArg.value_or(0);
         if (schoolMask > SPELL_SCHOOL_MASK_ALL)
-        {
-            return luaL_argerror(L, 4, "valid SpellSchoolMask expected");
-        }
-        unit->AddThreat(victim, threat, (SpellSchoolMask)schoolMask, spell ? sSpellMgr->GetSpellInfo(spell) : NULL);
-        return 0;
+            throw std::invalid_argument("valid SpellSchoolMask expected");
+
+        unit->AddThreat(victim, threat, (SpellSchoolMask)schoolMask, spell ? sSpellMgr->GetSpellInfo(spell) : nullptr);
     }
 
     /**
@@ -2631,110 +2306,29 @@ namespace LuaUnit
      * @param [Unit] victim : [Unit] that caused the threat
      * @param int32 percent : threat amount in pct
      */
-    int ModifyThreatPct(lua_State* L, Unit* unit)
+    void ModifyThreatPct(Unit* unit, Unit* victim, sol::optional<int32> threatPctArg)
     {
-        Unit* victim = ALE::CHECKOBJ<Unit>(L, 2);
-        int32 threatPct = ALE::CHECKVAL<int32>(L, 3, true);
+        int32 threatPct = threatPctArg.value_or(1);
 
         unit->GetThreatMgr().ModifyThreatByPercent(victim, threatPct);
-        return 0;
-    }
-
-    /*int RestoreDisplayId(lua_State* L, Unit* unit)
-    {
-        unit->RestoreDisplayId();
-        return 0;
-    }*/
-
-    /*int RestoreFaction(lua_State* L, Unit* unit)
-    {
-        unit->RestoreFaction();
-        return 0;
-    }*/
-
-    /*int RemoveBindSightAuras(lua_State* L, Unit* unit)
-    {
-        unit->RemoveBindSightAuras();
-        return 0;
-    }*/
-
-    /*int RemoveCharmAuras(lua_State* L, Unit* unit)
-    {
-        unit->RemoveCharmAuras();
-        return 0;
-    }*/
-
-    /*int DisableMelee(lua_State* L, Unit* unit)
-    {
-    bool apply = ALE::CHECKVAL<bool>(L, 2, true);
-
-    if (apply)
-    unit->AddUnitState(UNIT_STATE_CANNOT_AUTOATTACK);
-    else
-    unit->ClearUnitState(UNIT_STATE_CANNOT_AUTOATTACK);
-    return 0;
-    }*/
-
-    /*int SummonGuardian(lua_State* L, Unit* unit)
-    {
-    uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-    float x = ALE::CHECKVAL<float>(L, 3);
-    float y = ALE::CHECKVAL<float>(L, 4);
-    float z = ALE::CHECKVAL<float>(L, 5);
-    float o = ALE::CHECKVAL<float>(L, 6);
-    uint32 desp = ALE::CHECKVAL<uint32>(L, 7, 0);
-
-    SummonPropertiesEntry const* properties = sSummonPropertiesStore.LookupEntry(61);
-    if (!properties)
-    return 1;
-    Position pos;
-    pos.Relocate(x,y,z,o);
-    TempSummon* summon = unit->GetMap()->SummonCreature(entry, pos, properties, desp, unit);
-
-    if (!summon)
-    return 1;
-
-    if (summon->HasUnitTypeMask(UNIT_MASK_GUARDIAN))
-    ((Guardian*)summon)->InitStatsForLevel(unit->getLevel());
-
-    if (properties && properties->Category == SUMMON_CATEGORY_ALLY)
-    summon->setFaction(unit->getFaction());
-    if (summon->GetEntry() == 27893)
-    {
-    if (uint32 weapon = unit->GetUInt32Value(PLAYER_VISIBLE_ITEM_16_ENTRYID))
-    {
-    summon->SetDisplayId(11686);
-    summon->SetUInt32Value(UNIT_VIRTUAL_ITEM_SLOT_ID, weapon);
-    }
-    else
-    summon->SetDisplayId(1126);
     }
-    summon->AI()->EnterEvadeMode();
-
-    ALE::Push(L, summon);
-    return 1;
-    }*/
 
     /**
      * Clear the threat of a [Unit] in the threat list.
      *
      * @param [Unit] target
      */
-    int ClearThreat(lua_State* L, Unit* unit)
+    void ClearThreat(Unit* unit, Unit* target)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-
         unit->GetThreatMgr().ClearThreat(target);
-        return 0;
     }
 
     /**
      * Resets the [Unit]'s threat list, setting all threat targets' threat to 0.
      */
-    int ResetAllThreat(lua_State* /*L*/, Unit* unit)
+    void ResetAllThreat(Unit* unit)
     {
         unit->GetThreatMgr().ResetAllThreat();
-        return 0;
     }
 
     /**
@@ -2743,12 +2337,173 @@ namespace LuaUnit
      * @param [Unit] target
      * @return float threat
      */
-    int GetThreat(lua_State* L, Unit* unit)
+    float GetThreat(Unit* unit, Unit* target)
     {
-        Unit* target = ALE::CHECKOBJ<Unit>(L, 2);
-
-        ALE::Push(L, unit->GetThreatMgr().GetThreat(target));
-        return 1;
+        return unit->GetThreatMgr().GetThreat(target);
     }
-};
-#endif
+}
+
+void RegisterUnitMethods(sol::state& lua)
+{
+    sol::usertype<UnitRef> type = ALEBind::NewHandleType<UnitRef, WorldObjectRef, ObjectRef>(lua, "Unit");
+
+    type["SetImmuneTo"]              = ALEBind::Method(&LuaUnit::SetImmuneTo);
+    type["HandleStatFlatModifier"]   = ALEBind::Method(&LuaUnit::HandleStatFlatModifier);
+    type["Attack"]                   = ALEBind::Method(&LuaUnit::Attack);
+    type["AttackStop"]               = ALEBind::Method(&LuaUnit::AttackStop);
+    type["IsStandState"]             = ALEBind::Method(&LuaUnit::IsStandState);
+    type["IsMounted"]                = ALEBind::Method(&LuaUnit::IsMounted);
+    type["IsRooted"]                 = ALEBind::Method(&LuaUnit::IsRooted);
+    type["IsFullHealth"]             = ALEBind::Method(&LuaUnit::IsFullHealth);
+    type["IsInAccessiblePlaceFor"]   = ALEBind::Method(&LuaUnit::IsInAccessiblePlaceFor);
+    type["IsAuctioneer"]             = ALEBind::Method(&LuaUnit::IsAuctioneer);
+    type["IsGuildMaster"]            = ALEBind::Method(&LuaUnit::IsGuildMaster);
+    type["IsInnkeeper"]              = ALEBind::Method(&LuaUnit::IsInnkeeper);
+    type["IsTrainer"]                = ALEBind::Method(&LuaUnit::IsTrainer);
+    type["IsGossip"]                 = ALEBind::Method(&LuaUnit::IsGossip);
+    type["IsTaxi"]                   = ALEBind::Method(&LuaUnit::IsTaxi);
+    type["IsSpiritHealer"]           = ALEBind::Method(&LuaUnit::IsSpiritHealer);
+    type["IsSpiritGuide"]            = ALEBind::Method(&LuaUnit::IsSpiritGuide);
+    type["IsTabardDesigner"]         = ALEBind::Method(&LuaUnit::IsTabardDesigner);
+    type["IsServiceProvider"]        = ALEBind::Method(&LuaUnit::IsServiceProvider);
+    type["IsSpiritService"]          = ALEBind::Method(&LuaUnit::IsSpiritService);
+    type["IsAlive"]                  = ALEBind::Method(&LuaUnit::IsAlive);
+    type["IsDead"]                   = ALEBind::Method(&LuaUnit::IsDead);
+    type["IsDying"]                  = ALEBind::Method(&LuaUnit::IsDying);
+    type["IsBanker"]                 = ALEBind::Method(&LuaUnit::IsBanker);
+    type["IsVendor"]                 = ALEBind::Method(&LuaUnit::IsVendor);
+    type["IsBattleMaster"]           = ALEBind::Method(&LuaUnit::IsBattleMaster);
+    type["IsCharmed"]                = ALEBind::Method(&LuaUnit::IsCharmed);
+    type["IsArmorer"]                = ALEBind::Method(&LuaUnit::IsArmorer);
+    type["IsAttackingPlayer"]        = ALEBind::Method(&LuaUnit::IsAttackingPlayer);
+    type["IsPvPFlagged"]             = ALEBind::Method(&LuaUnit::IsPvPFlagged);
+    type["IsOnVehicle"]              = ALEBind::Method(&LuaUnit::IsOnVehicle);
+    type["IsInCombat"]               = ALEBind::Method(&LuaUnit::IsInCombat);
+    type["IsUnderWater"]             = ALEBind::Method(&LuaUnit::IsUnderWater);
+    type["IsInWater"]                = ALEBind::Method(&LuaUnit::IsInWater);
+    type["IsStopped"]                = ALEBind::Method(&LuaUnit::IsStopped);
+    type["IsQuestGiver"]             = ALEBind::Method(&LuaUnit::IsQuestGiver);
+    type["HealthBelowPct"]           = ALEBind::Method(&LuaUnit::HealthBelowPct);
+    type["HealthAbovePct"]           = ALEBind::Method(&LuaUnit::HealthAbovePct);
+    type["HasAura"]                  = ALEBind::Method(&LuaUnit::HasAura);
+    type["IsCasting"]                = ALEBind::Method(&LuaUnit::IsCasting);
+    type["HasUnitState"]             = ALEBind::Method(&LuaUnit::HasUnitState);
+    type["GetOwner"]                 = ALEBind::Method(&LuaUnit::GetOwner);
+    type["GetOwnerGUID"]             = ALEBind::Method(&LuaUnit::GetOwnerGUID);
+    type["GetMountId"]               = ALEBind::Method(&LuaUnit::GetMountId);
+    type["GetCreatorGUID"]           = ALEBind::Method(&LuaUnit::GetCreatorGUID);
+    type["GetCharmerGUID"]           = ALEBind::Method(&LuaUnit::GetCharmerGUID);
+    type["GetCharmGUID"]             = ALEBind::Method(&LuaUnit::GetCharmGUID);
+    type["GetPetGUID"]               = ALEBind::Method(&LuaUnit::GetPetGUID);
+    type["GetControllerGUID"]        = ALEBind::Method(&LuaUnit::GetControllerGUID);
+    type["GetControllerGUIDS"]       = ALEBind::Method(&LuaUnit::GetControllerGUIDS);
+    type["GetStat"]                  = ALEBind::Method(&LuaUnit::GetStat);
+    type["GetBaseSpellPower"]        = ALEBind::Method(&LuaUnit::GetBaseSpellPower);
+    type["GetVictim"]                = ALEBind::Method(&LuaUnit::GetVictim);
+    type["GetCurrentSpell"]          = ALEBind::Method(&LuaUnit::GetCurrentSpell);
+    type["GetStandState"]            = ALEBind::Method(&LuaUnit::GetStandState);
+    type["GetDisplayId"]             = ALEBind::Method(&LuaUnit::GetDisplayId);
+    type["GetNativeDisplayId"]       = ALEBind::Method(&LuaUnit::GetNativeDisplayId);
+    type["GetLevel"]                 = ALEBind::Method(&LuaUnit::GetLevel);
+    type["GetHealth"]                = ALEBind::Method(&LuaUnit::GetHealth);
+    type["GetPower"]                 = ALEBind::Method(&LuaUnit::GetPower);
+    type["GetMaxPower"]              = ALEBind::Method(&LuaUnit::GetMaxPower);
+    type["GetPowerPct"]              = ALEBind::Method(&LuaUnit::GetPowerPct);
+    type["GetPowerType"]             = ALEBind::Method(&LuaUnit::GetPowerType);
+    type["GetMaxHealth"]             = ALEBind::Method(&LuaUnit::GetMaxHealth);
+    type["GetHealthPct"]             = ALEBind::Method(&LuaUnit::GetHealthPct);
+    type["GetGender"]                = ALEBind::Method(&LuaUnit::GetGender);
+    type["GetRace"]                  = ALEBind::Method(&LuaUnit::GetRace);
+    type["GetClass"]                 = ALEBind::Method(&LuaUnit::GetClass);
+    type["GetRaceMask"]              = ALEBind::Method(&LuaUnit::GetRaceMask);
+    type["GetClassMask"]             = ALEBind::Method(&LuaUnit::GetClassMask);
+    type["GetCreatureType"]          = ALEBind::Method(&LuaUnit::GetCreatureType);
+    type["GetClassAsString"]         = ALEBind::Method(&LuaUnit::GetClassAsString);
+    type["GetRaceAsString"]          = ALEBind::Method(&LuaUnit::GetRaceAsString);
+    type["GetFaction"]               = ALEBind::Method(&LuaUnit::GetFaction);
+    type["GetAura"]                  = ALEBind::Method(&LuaUnit::GetAura);
+    type["GetFriendlyUnitsInRange"]  = ALEBind::Method(&LuaUnit::GetFriendlyUnitsInRange);
+    type["GetUnfriendlyUnitsInRange"] = ALEBind::Method(&LuaUnit::GetUnfriendlyUnitsInRange);
+    type["GetVehicleKit"]            = ALEBind::Method(&LuaUnit::GetVehicleKit);
+    type["GetCritterGUID"]           = ALEBind::Method(&LuaUnit::GetCritterGUID);
+    type["GetSpeed"]                 = ALEBind::Method(&LuaUnit::GetSpeed);
+    type["GetSpeedRate"]             = ALEBind::Method(&LuaUnit::GetSpeedRate);
+    type["GetMovementType"]          = ALEBind::Method(&LuaUnit::GetMovementType);
+    type["GetAttackers"]             = ALEBind::Method(&LuaUnit::GetAttackers);
+    type["SetOwnerGUID"]             = ALEBind::Method(&LuaUnit::SetOwnerGUID);
+    type["SetPvP"]                   = ALEBind::Method(&LuaUnit::SetPvP);
+    type["SetSheath"]                = ALEBind::Method(&LuaUnit::SetSheath);
+    type["SetName"]                  = ALEBind::Method(&LuaUnit::SetName);
+    type["SetSpeed"]                 = ALEBind::Method(&LuaUnit::SetSpeed);
+    type["SetSpeedRate"]             = ALEBind::Method(&LuaUnit::SetSpeedRate);
+    type["SetFaction"]               = ALEBind::Method(&LuaUnit::SetFaction);
+    type["SetLevel"]                 = ALEBind::Method(&LuaUnit::SetLevel);
+    type["SetHealth"]                = ALEBind::Method(&LuaUnit::SetHealth);
+    type["SetMaxHealth"]             = ALEBind::Method(&LuaUnit::SetMaxHealth);
+    type["SetPower"]                 = ALEBind::Method(&LuaUnit::SetPower);
+    type["ModifyPower"]              = ALEBind::Method(&LuaUnit::ModifyPower);
+    type["SetMaxPower"]              = ALEBind::Method(&LuaUnit::SetMaxPower);
+    type["SetPowerType"]             = ALEBind::Method(&LuaUnit::SetPowerType);
+    type["SetDisplayId"]             = ALEBind::Method(&LuaUnit::SetDisplayId);
+    type["SetNativeDisplayId"]       = ALEBind::Method(&LuaUnit::SetNativeDisplayId);
+    type["SetFacing"]                = ALEBind::Method(&LuaUnit::SetFacing);
+    type["SetFacingToObject"]        = ALEBind::Method(&LuaUnit::SetFacingToObject);
+    type["SetCreatorGUID"]           = ALEBind::Method(&LuaUnit::SetCreatorGUID);
+    type["SetPetGUID"]               = ALEBind::Method(&LuaUnit::SetPetGUID);
+    type["SetWaterWalk"]             = ALEBind::Method(&LuaUnit::SetWaterWalk);
+    type["SetStandState"]            = ALEBind::Method(&LuaUnit::SetStandState);
+    type["SetInCombatWith"]          = ALEBind::Method(&LuaUnit::SetInCombatWith);
+    type["SetFFA"]                   = ALEBind::Method(&LuaUnit::SetFFA);
+    type["SetSanctuary"]             = ALEBind::Method(&LuaUnit::SetSanctuary);
+    type["SetCritterGUID"]           = ALEBind::Method(&LuaUnit::SetCritterGUID);
+    type["SetRooted"]                = ALEBind::Method(&LuaUnit::SetRooted);
+    type["SetConfused"]              = ALEBind::Method(&LuaUnit::SetConfused);
+    type["SetFeared"]                = ALEBind::Method(&LuaUnit::SetFeared);
+    type["ClearThreatList"]          = ALEBind::Method(&LuaUnit::ClearThreatList);
+    type["GetThreatList"]            = ALEBind::Method(&LuaUnit::GetThreatList);
+    type["Mount"]                    = ALEBind::Method(&LuaUnit::Mount);
+    type["Dismount"]                 = ALEBind::Method(&LuaUnit::Dismount);
+    type["PerformEmote"]             = ALEBind::Method(&LuaUnit::PerformEmote);
+    type["EmoteState"]               = ALEBind::Method(&LuaUnit::EmoteState);
+    type["CountPctFromCurHealth"]    = ALEBind::Method(&LuaUnit::CountPctFromCurHealth);
+    type["CountPctFromMaxHealth"]    = ALEBind::Method(&LuaUnit::CountPctFromMaxHealth);
+    type["SendChatMessageToPlayer"]  = ALEBind::Method(&LuaUnit::SendChatMessageToPlayer);
+    type["MoveStop"]                 = ALEBind::Method(&LuaUnit::MoveStop);
+    type["MoveExpire"]               = ALEBind::Method(&LuaUnit::MoveExpire);
+    type["MoveClear"]                = ALEBind::Method(&LuaUnit::MoveClear);
+    type["MoveIdle"]                 = ALEBind::Method(&LuaUnit::MoveIdle);
+    type["MoveRandom"]               = ALEBind::Method(&LuaUnit::MoveRandom);
+    type["MoveHome"]                 = ALEBind::Method(&LuaUnit::MoveHome);
+    type["MoveFollow"]               = ALEBind::Method(&LuaUnit::MoveFollow);
+    type["MoveChase"]                = ALEBind::Method(&LuaUnit::MoveChase);
+    type["MoveConfused"]             = ALEBind::Method(&LuaUnit::MoveConfused);
+    type["MoveFleeing"]              = ALEBind::Method(&LuaUnit::MoveFleeing);
+    type["MoveTo"]                   = ALEBind::Method(&LuaUnit::MoveTo);
+    type["MoveJump"]                 = ALEBind::Method(&LuaUnit::MoveJump);
+    type["SendUnitWhisper"]          = ALEBind::Method(&LuaUnit::SendUnitWhisper);
+    type["SendUnitEmote"]            = ALEBind::Method(&LuaUnit::SendUnitEmote);
+    type["SendUnitSay"]              = ALEBind::Method(&LuaUnit::SendUnitSay);
+    type["SendUnitYell"]             = ALEBind::Method(&LuaUnit::SendUnitYell);
+    type["DeMorph"]                  = ALEBind::Method(&LuaUnit::DeMorph);
+    type["CastSpell"]                = ALEBind::Method(&LuaUnit::CastSpell);
+    type["CastCustomSpell"]          = ALEBind::Method(&LuaUnit::CastCustomSpell);
+    type["CastSpellAoF"]             = ALEBind::Method(&LuaUnit::CastSpellAoF);
+    type["ClearInCombat"]            = ALEBind::Method(&LuaUnit::ClearInCombat);
+    type["StopSpellCast"]            = ALEBind::Method(&LuaUnit::StopSpellCast);
+    type["InterruptSpell"]           = ALEBind::Method(&LuaUnit::InterruptSpell);
+    type["AddAura"]                  = ALEBind::Method(&LuaUnit::AddAura);
+    type["RemoveAura"]               = ALEBind::Method(&LuaUnit::RemoveAura);
+    type["RemoveAllAuras"]           = ALEBind::Method(&LuaUnit::RemoveAllAuras);
+    type["RemoveArenaAuras"]         = ALEBind::Method(&LuaUnit::RemoveArenaAuras);
+    type["AddUnitState"]             = ALEBind::Method(&LuaUnit::AddUnitState);
+    type["ClearUnitState"]           = ALEBind::Method(&LuaUnit::ClearUnitState);
+    type["NearTeleport"]             = ALEBind::Method(&LuaUnit::NearTeleport);
+    type["DealDamage"]               = ALEBind::Method(&LuaUnit::DealDamage);
+    type["DealHeal"]                 = ALEBind::Method(&LuaUnit::DealHeal);
+    type["Kill"]                     = ALEBind::Method(&LuaUnit::Kill);
+    type["AddThreat"]                = ALEBind::Method(&LuaUnit::AddThreat);
+    type["ModifyThreatPct"]          = ALEBind::Method(&LuaUnit::ModifyThreatPct);
+    type["ClearThreat"]              = ALEBind::Method(&LuaUnit::ClearThreat);
+    type["ResetAllThreat"]           = ALEBind::Method(&LuaUnit::ResetAllThreat);
+    type["GetThreat"]                = ALEBind::Method(&LuaUnit::GetThreat);
+}
diff --git a/src/LuaEngine/methods/VehicleMethods.h b/src/LuaEngine/methods/VehicleMethods.cpp
similarity index 52%
rename from src/LuaEngine/methods/VehicleMethods.h
rename to src/LuaEngine/methods/VehicleMethods.cpp
index bb0a40c558..9c01896f56 100644
--- a/src/LuaEngine/methods/VehicleMethods.h
+++ b/src/LuaEngine/methods/VehicleMethods.cpp
@@ -4,8 +4,10 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef VEHICLEMETHODS_H
-#define VEHICLEMETHODS_H
+#include "ALEBind.h"
+
+#include "Unit.h"
+#include "Vehicle.h"
 
 /***
  * Represents a vehicle in the game, which can carry passengers and provide special abilities or movement.
@@ -20,11 +22,9 @@ namespace LuaVehicle
      * @param [Unit] passenger
      * @return bool isOnBoard
      */
-    int IsOnBoard(lua_State* L, Vehicle* vehicle)
+    bool IsOnBoard(Vehicle* vehicle, Unit* passenger)
     {
-        Unit* passenger = ALE::CHECKOBJ<Unit>(L, 2);
-        ALE::Push(L, passenger->IsOnVehicle(vehicle->GetBase()));
-        return 1;
+        return passenger->IsOnVehicle(vehicle->GetBase());
     }
 
     /**
@@ -32,10 +32,9 @@ namespace LuaVehicle
      *
      * @return [Unit] owner
      */
-    int GetOwner(lua_State* L, Vehicle* vehicle)
+    Unit* GetOwner(Vehicle* vehicle)
     {
-        ALE::Push(L, vehicle->GetBase());
-        return 1;
+        return vehicle->GetBase();
     }
 
     /**
@@ -43,10 +42,9 @@ namespace LuaVehicle
      *
      * @return uint32 entry
      */
-    int GetEntry(lua_State* L, Vehicle* vehicle)
+    uint32 GetEntry(Vehicle* vehicle)
     {
-        ALE::Push(L, vehicle->GetVehicleInfo()->m_ID);
-        return 1;
+        return vehicle->GetVehicleInfo()->m_ID;
     }
 
     /**
@@ -55,11 +53,9 @@ namespace LuaVehicle
      * @param int8 seat
      * @return [Unit] passenger
      */
-    int GetPassenger(lua_State* L, Vehicle* vehicle)
+    Unit* GetPassenger(Vehicle* vehicle, int8 seatId)
     {
-        int8 seatId = ALE::CHECKVAL<int8>(L, 2);
-        ALE::Push(L, vehicle->GetPassenger(seatId));
-        return 1;
+        return vehicle->GetPassenger(seatId);
     }
 
     /**
@@ -68,13 +64,9 @@ namespace LuaVehicle
      * @param [Unit] passenger
      * @param int8 seat
      */
-    int AddPassenger(lua_State* L, Vehicle* vehicle)
+    void AddPassenger(Vehicle* vehicle, Unit* passenger, int8 seatId)
     {
-        Unit* passenger = ALE::CHECKOBJ<Unit>(L, 2);
-        int8 seatId = ALE::CHECKVAL<int8>(L, 3);
-
         vehicle->AddPassenger(passenger, seatId);
-        return 0;
     }
 
     /**
@@ -82,12 +74,20 @@ namespace LuaVehicle
      *
      * @param [Unit] passenger
      */
-    int RemovePassenger(lua_State* L, Vehicle* vehicle)
+    void RemovePassenger(Vehicle* vehicle, Unit* passenger)
     {
-        Unit* passenger = ALE::CHECKOBJ<Unit>(L, 2);
         vehicle->RemovePassenger(passenger);
-        return 0;
     }
 }
 
-#endif // VEHICLEMETHODS_H
+void RegisterVehicleMethods(sol::state& lua)
+{
+    sol::usertype<ScopedRef<Vehicle>> type = ALEBind::NewHandleType<ScopedRef<Vehicle>>(lua, "Vehicle");
+
+    type["IsOnBoard"]       = ALEBind::Method(&LuaVehicle::IsOnBoard);
+    type["GetOwner"]        = ALEBind::Method(&LuaVehicle::GetOwner);
+    type["GetEntry"]        = ALEBind::Method(&LuaVehicle::GetEntry);
+    type["GetPassenger"]    = ALEBind::Method(&LuaVehicle::GetPassenger);
+    type["AddPassenger"]    = ALEBind::Method(&LuaVehicle::AddPassenger);
+    type["RemovePassenger"] = ALEBind::Method(&LuaVehicle::RemovePassenger);
+}
diff --git a/src/LuaEngine/methods/WorldObjectMethods.h b/src/LuaEngine/methods/WorldObjectMethods.cpp
similarity index 52%
rename from src/LuaEngine/methods/WorldObjectMethods.h
rename to src/LuaEngine/methods/WorldObjectMethods.cpp
index a92a435b01..d6b5c6e4cc 100644
--- a/src/LuaEngine/methods/WorldObjectMethods.h
+++ b/src/LuaEngine/methods/WorldObjectMethods.cpp
@@ -4,8 +4,20 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef WORLDOBJECTMETHODS_H
-#define WORLDOBJECTMETHODS_H
+#include "ALEBind.h"
+#include "ALEEventMgr.h"
+#include "ALEUtility.h"
+
+#include "CellImpl.h"
+#include "DBCStores.h"
+#include "GameObject.h"
+#include "GridNotifiers.h"
+#include "GridNotifiersImpl.h"
+#include "Object.h"
+#include "Opcodes.h"
+#include "Player.h"
+#include "TemporarySummon.h"
+#include "WorldPacket.h"
 
 /***
  * Represents a [WorldObject] in the game world.
@@ -19,10 +31,9 @@ namespace LuaWorldObject
      *
      * @return string name
      */
-    int GetName(lua_State* L, WorldObject* obj)
+    std::string GetName(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetName());
-        return 1;
+        return worldobject->GetName();
     }
 
     /**
@@ -30,10 +41,9 @@ namespace LuaWorldObject
      *
      * @return [Map] mapObject
      */
-    int GetMap(lua_State* L, WorldObject* obj)
+    Map* GetMap(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetMap());
-        return 1;
+        return worldobject->GetMap();
     }
 
     /**
@@ -41,10 +51,9 @@ namespace LuaWorldObject
      *
      * @return uint32 phase
      */
-    int GetPhaseMask(lua_State* L, WorldObject* obj)
+    uint32 GetPhaseMask(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetPhaseMask());
-        return 1;
+        return worldobject->GetPhaseMask();
     }
 
     /**
@@ -53,12 +62,10 @@ namespace LuaWorldObject
     * @param uint32 phaseMask
     * @param bool update = true : update visibility to nearby objects
     */
-    int SetPhaseMask(lua_State* L, WorldObject* obj)
+    void SetPhaseMask(WorldObject* worldobject, uint32 phaseMask, sol::optional<bool> updateArg)
     {
-        uint32 phaseMask = ALE::CHECKVAL<uint32>(L, 2);
-        bool update = ALE::CHECKVAL<bool>(L, 3, true);
-        obj->SetPhaseMask(phaseMask, update);
-        return 0;
+        bool update = updateArg.value_or(true);
+        worldobject->SetPhaseMask(phaseMask, update);
     }
 
     /**
@@ -66,10 +73,9 @@ namespace LuaWorldObject
      *
      * @return uint32 instanceId
      */
-    int GetInstanceId(lua_State* L, WorldObject* obj)
+    uint32 GetInstanceId(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetInstanceId());
-        return 1;
+        return worldobject->GetInstanceId();
     }
 
     /**
@@ -77,10 +83,9 @@ namespace LuaWorldObject
      *
      * @return uint32 areaId
      */
-    int GetAreaId(lua_State* L, WorldObject* obj)
+    uint32 GetAreaId(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetAreaId());
-        return 1;
+        return worldobject->GetAreaId();
     }
 
     /**
@@ -88,10 +93,9 @@ namespace LuaWorldObject
      *
      * @return uint32 zoneId
      */
-    int GetZoneId(lua_State* L, WorldObject* obj)
+    uint32 GetZoneId(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetZoneId());
-        return 1;
+        return worldobject->GetZoneId();
     }
 
     /**
@@ -99,10 +103,9 @@ namespace LuaWorldObject
      *
      * @return uint32 mapId
      */
-    int GetMapId(lua_State* L, WorldObject* obj)
+    uint32 GetMapId(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetMapId());
-        return 1;
+        return worldobject->GetMapId();
     }
 
     /**
@@ -110,10 +113,9 @@ namespace LuaWorldObject
      *
      * @return float x
      */
-    int GetX(lua_State* L, WorldObject* obj)
+    float GetX(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetPositionX());
-        return 1;
+        return worldobject->GetPositionX();
     }
 
     /**
@@ -121,10 +123,9 @@ namespace LuaWorldObject
      *
      * @return float y
      */
-    int GetY(lua_State* L, WorldObject* obj)
+    float GetY(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetPositionY());
-        return 1;
+        return worldobject->GetPositionY();
     }
 
     /**
@@ -132,10 +133,9 @@ namespace LuaWorldObject
      *
      * @return float z
      */
-    int GetZ(lua_State* L, WorldObject* obj)
+    float GetZ(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetPositionZ());
-        return 1;
+        return worldobject->GetPositionZ();
     }
 
     /**
@@ -143,10 +143,9 @@ namespace LuaWorldObject
      *
      * @return float orientation / facing
      */
-    int GetO(lua_State* L, WorldObject* obj)
+    float GetO(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetOrientation());
-        return 1;
+        return worldobject->GetOrientation();
     }
 
     /**
@@ -157,13 +156,9 @@ namespace LuaWorldObject
      * @return float z : z coordinate (height) of the [WorldObject]
      * @return float o : facing / orientation of  the [WorldObject]
      */
-    int GetLocation(lua_State* L, WorldObject* obj)
+    std::tuple<float, float, float, float> GetLocation(WorldObject* worldobject)
     {
-        ALE::Push(L, obj->GetPositionX());
-        ALE::Push(L, obj->GetPositionY());
-        ALE::Push(L, obj->GetPositionZ());
-        ALE::Push(L, obj->GetOrientation());
-        return 4;
+        return std::tuple<float, float, float, float>(worldobject->GetPositionX(), worldobject->GetPositionY(), worldobject->GetPositionZ(), worldobject->GetOrientation());
     }
 
     /**
@@ -175,20 +170,19 @@ namespace LuaWorldObject
      *
      * @return [Player] nearestPlayer
      */
-    int GetNearestPlayer(lua_State* L, WorldObject* obj)
+    Unit* GetNearestPlayer(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint32> hostileArg, sol::optional<uint32> deadArg)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 3, 0);
-        uint32 dead = ALE::CHECKVAL<uint32>(L, 4, 1);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint32 hostile = hostileArg.value_or(0);
+        uint32 dead = deadArg.value_or(1);
 
-        Unit* target = NULL;
-        ALEUtil::WorldObjectInRangeCheck checker(true, obj, range, TYPEMASK_PLAYER, 0, hostile, dead);
+        Unit* target = nullptr;
+        ALEUtil::WorldObjectInRangeCheck checker(true, worldobject, range, TYPEMASK_PLAYER, 0, hostile, dead);
 
-        Acore::UnitLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, target, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::UnitLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, target, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        ALE::Push(L, target);
-        return 1;
+        return target;
     }
 
     /**
@@ -200,20 +194,19 @@ namespace LuaWorldObject
      *
      * @return [GameObject] nearestGameObject
      */
-    int GetNearestGameObject(lua_State* L, WorldObject* obj)
+    GameObject* GetNearestGameObject(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint32> entryArg, sol::optional<uint32> hostileArg)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 3, 0);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 4, 0);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint32 entry = entryArg.value_or(0);
+        uint32 hostile = hostileArg.value_or(0);
 
-        GameObject* target = NULL;
-        ALEUtil::WorldObjectInRangeCheck checker(true, obj, range, TYPEMASK_GAMEOBJECT, entry, hostile);
+        GameObject* target = nullptr;
+        ALEUtil::WorldObjectInRangeCheck checker(true, worldobject, range, TYPEMASK_GAMEOBJECT, entry, hostile);
 
-        Acore::GameObjectLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, target, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::GameObjectLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, target, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        ALE::Push(L, target);
-        return 1;
+        return target;
     }
 
     /**
@@ -226,21 +219,20 @@ namespace LuaWorldObject
      *
      * @return [Creature] nearestCreature
      */
-    int GetNearestCreature(lua_State* L, WorldObject* obj)
+    Creature* GetNearestCreature(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint32> entryArg, sol::optional<uint32> hostileArg, sol::optional<uint32> deadArg)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 3, 0);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 4, 0);
-        uint32 dead = ALE::CHECKVAL<uint32>(L, 5, 1);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint32 entry = entryArg.value_or(0);
+        uint32 hostile = hostileArg.value_or(0);
+        uint32 dead = deadArg.value_or(1);
 
-        Creature* target = NULL;
-        ALEUtil::WorldObjectInRangeCheck checker(true, obj, range, TYPEMASK_UNIT, entry, hostile, dead);
+        Creature* target = nullptr;
+        ALEUtil::WorldObjectInRangeCheck checker(true, worldobject, range, TYPEMASK_UNIT, entry, hostile, dead);
 
-        Acore::CreatureLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, target, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::CreatureLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, target, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        ALE::Push(L, target);
-        return 1;
+        return target;
     }
 
     /**
@@ -252,30 +244,25 @@ namespace LuaWorldObject
      *
      * @return table playersInRange : table of [Player]s
      */
-    int GetPlayersInRange(lua_State* L, WorldObject* obj)
+    sol::table GetPlayersInRange(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint32> hostileArg, sol::optional<uint32> deadArg, sol::this_state s)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 3, 0);
-        uint32 dead = ALE::CHECKVAL<uint32>(L, 4, 1);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint32 hostile = hostileArg.value_or(0);
+        uint32 dead = deadArg.value_or(1);
 
         std::list<Player*> list;
-        ALEUtil::WorldObjectInRangeCheck checker(false, obj, range, TYPEMASK_PLAYER, 0, hostile, dead);
+        ALEUtil::WorldObjectInRangeCheck checker(false, worldobject, range, TYPEMASK_PLAYER, 0, hostile, dead);
 
-        Acore::PlayerListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, list, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::PlayerListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, list, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        lua_createtable(L, list.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (std::list<Player*>::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            ALE::Push(L, *it);
-            lua_rawseti(L, tbl, ++i);
-        }
+            tbl[++i] = PlayerRef(*it);
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -288,31 +275,26 @@ namespace LuaWorldObject
      *
      * @return table creaturesInRange : table of [Creature]s
      */
-    int GetCreaturesInRange(lua_State* L, WorldObject* obj)
+    sol::table GetCreaturesInRange(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint32> entryArg, sol::optional<uint32> hostileArg, sol::optional<uint32> deadArg, sol::this_state s)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 3, 0);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 4, 0);
-        uint32 dead = ALE::CHECKVAL<uint32>(L, 5, 1);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint32 entry = entryArg.value_or(0);
+        uint32 hostile = hostileArg.value_or(0);
+        uint32 dead = deadArg.value_or(1);
 
         std::list<Creature*> list;
-        ALEUtil::WorldObjectInRangeCheck checker(false, obj, range, TYPEMASK_UNIT, entry, hostile, dead);
+        ALEUtil::WorldObjectInRangeCheck checker(false, worldobject, range, TYPEMASK_UNIT, entry, hostile, dead);
 
-        Acore::CreatureListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, list, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::CreatureListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, list, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        lua_createtable(L, list.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (std::list<Creature*>::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            ALE::Push(L, *it);
-            lua_rawseti(L, tbl, ++i);
-        }
+            tbl[++i] = CreatureRef(*it);
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -324,30 +306,25 @@ namespace LuaWorldObject
      *
      * @return table gameObjectsInRange : table of [GameObject]s
      */
-    int GetGameObjectsInRange(lua_State* L, WorldObject* obj)
+    sol::table GetGameObjectsInRange(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint32> entryArg, sol::optional<uint32> hostileArg, sol::this_state s)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 3, 0);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 4, 0);
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint32 entry = entryArg.value_or(0);
+        uint32 hostile = hostileArg.value_or(0);
 
         std::list<GameObject*> list;
-        ALEUtil::WorldObjectInRangeCheck checker(false, obj, range, TYPEMASK_GAMEOBJECT, entry, hostile);
+        ALEUtil::WorldObjectInRangeCheck checker(false, worldobject, range, TYPEMASK_GAMEOBJECT, entry, hostile);
 
-        Acore::GameObjectListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, list, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::GameObjectListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, list, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        lua_createtable(L, list.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::table tbl = sol::state_view(s).create_table();
         uint32 i = 0;
 
         for (std::list<GameObject*>::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            ALE::Push(L, *it);
-            lua_rawseti(L, tbl, ++i);
-        }
+            tbl[++i] = GameObjectRef(*it);
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -362,25 +339,24 @@ namespace LuaWorldObject
      *
      * @return [WorldObject] worldObject
      */
-    int GetNearObject(lua_State* L, WorldObject* obj)
+    WorldObject* GetNearObject(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint16> typeArg, sol::optional<uint32> entryArg, sol::optional<uint32> hostileArg, sol::optional<uint32> deadArg)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint16 type = ALE::CHECKVAL<uint16>(L, 3, 0); // TypeMask
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 4, 0);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 5, 0); // 0 none, 1 hostile, 2 friendly
-        uint32 dead = ALE::CHECKVAL<uint32>(L, 6, 1); // 0 both, 1 alive, 2 dead
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint16 type = typeArg.value_or(0); // TypeMask
+        uint32 entry = entryArg.value_or(0);
+        uint32 hostile = hostileArg.value_or(0); // 0 none, 1 hostile, 2 friendly
+        uint32 dead = deadArg.value_or(1); // 0 both, 1 alive, 2 dead
 
         float x, y, z;
-        obj->GetPosition(x, y, z);
-        ALEUtil::WorldObjectInRangeCheck checker(true, obj, range, type, entry, hostile, dead);
+        worldobject->GetPosition(x, y, z);
+        ALEUtil::WorldObjectInRangeCheck checker(true, worldobject, range, type, entry, hostile, dead);
 
-        WorldObject* target = NULL;
+        WorldObject* target = nullptr;
 
-        Acore::WorldObjectLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, target, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::WorldObjectLastSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, target, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        ALE::Push(L, target);
-        return 1;
+        return target;
     }
 
     /**
@@ -395,35 +371,31 @@ namespace LuaWorldObject
      *
      * @return table worldObjectList : table of [WorldObject]s
      */
-    int GetNearObjects(lua_State* L, WorldObject* obj)
+    sol::table GetNearObjects(WorldObject* worldobject, sol::optional<float> rangeArg, sol::optional<uint16> typeArg, sol::optional<uint32> entryArg, sol::optional<uint32> hostileArg, sol::optional<uint32> deadArg, sol::this_state s)
     {
-        float range = ALE::CHECKVAL<float>(L, 2, SIZE_OF_GRIDS);
-        uint16 type = ALE::CHECKVAL<uint16>(L, 3, 0); // TypeMask
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 4, 0);
-        uint32 hostile = ALE::CHECKVAL<uint32>(L, 5, 0); // 0 none, 1 hostile, 2 friendly
-        uint32 dead = ALE::CHECKVAL<uint32>(L, 6, 1); // 0 both, 1 alive, 2 dead
+        float range = rangeArg.value_or(SIZE_OF_GRIDS);
+        uint16 type = typeArg.value_or(0); // TypeMask
+        uint32 entry = entryArg.value_or(0);
+        uint32 hostile = hostileArg.value_or(0); // 0 none, 1 hostile, 2 friendly
+        uint32 dead = deadArg.value_or(1); // 0 both, 1 alive, 2 dead
 
         float x, y, z;
-        obj->GetPosition(x, y, z);
-        ALEUtil::WorldObjectInRangeCheck checker(false, obj, range, type, entry, hostile, dead);
+        worldobject->GetPosition(x, y, z);
+        ALEUtil::WorldObjectInRangeCheck checker(false, worldobject, range, type, entry, hostile, dead);
 
         std::list<WorldObject*> list;
 
-        Acore::WorldObjectListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(obj, list, checker);
-        Cell::VisitObjects(obj, searcher, range);
+        Acore::WorldObjectListSearcher<ALEUtil::WorldObjectInRangeCheck> searcher(worldobject, list, checker);
+        Cell::VisitObjects(worldobject, searcher, range);
 
-        lua_createtable(L, list.size(), 0);
-        int tbl = lua_gettop(L);
+        sol::state_view lua(s);
+        sol::table tbl = lua.create_table();
         uint32 i = 0;
 
         for (std::list<WorldObject*>::const_iterator it = list.begin(); it != list.end(); ++it)
-        {
-            ALE::Push(L, *it);
-            lua_rawseti(L, tbl, ++i);
-        }
+            tbl[++i] = ALEBind::ToLuaDynamic(lua, *it);
 
-        lua_settop(L, tbl);
-        return 1;
+        return tbl;
     }
 
     /**
@@ -441,19 +413,19 @@ namespace LuaWorldObject
      *
      * @return float dist : the distance in yards
      */
-    int GetDistance(lua_State* L, WorldObject* obj)
+    float GetDistance(WorldObject* worldobject, sol::object first, sol::optional<float> yArg, sol::optional<float> zArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, false);
-        if (target)
-            ALE::Push(L, obj->GetDistance(target));
-        else
-        {
-            float X = ALE::CHECKVAL<float>(L, 2);
-            float Y = ALE::CHECKVAL<float>(L, 3);
-            float Z = ALE::CHECKVAL<float>(L, 4);
-            ALE::Push(L, obj->GetDistance(X, Y, Z));
-        }
-        return 1;
+        if (first.is<WorldObjectRef>())
+            if (WorldObject* target = first.as<WorldObjectRef>().Resolve())
+                return worldobject->GetDistance(target);
+
+        if (!first.is<float>() || !yArg || !zArg)
+            throw std::invalid_argument("WorldObject or coordinates (x, y, z) expected");
+
+        float X = first.as<float>();
+        float Y = *yArg;
+        float Z = *zArg;
+        return worldobject->GetDistance(X, Y, Z);
     }
 
     /**
@@ -471,11 +443,12 @@ namespace LuaWorldObject
      *
      * @return float dist : the distance in yards
      */
-    int GetExactDistance(lua_State* L, WorldObject* obj)
+    float GetExactDistance(WorldObject* worldobject, sol::object first, sol::optional<float> yArg, sol::optional<float> zArg)
     {
         float x, y, z;
-        obj->GetPosition(x, y, z);
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, false);
+        worldobject->GetPosition(x, y, z);
+
+        WorldObject* target = first.is<WorldObjectRef>() ? first.as<WorldObjectRef>().Resolve() : nullptr;
         if (target)
         {
             float x2, y2, z2;
@@ -486,13 +459,15 @@ namespace LuaWorldObject
         }
         else
         {
-            x -= ALE::CHECKVAL<float>(L, 2);
-            y -= ALE::CHECKVAL<float>(L, 3);
-            z -= ALE::CHECKVAL<float>(L, 4);
+            if (!first.is<float>() || !yArg || !zArg)
+                throw std::invalid_argument("WorldObject or coordinates (x, y, z) expected");
+
+            x -= first.as<float>();
+            y -= *yArg;
+            z -= *zArg;
         }
 
-        ALE::Push(L, std::sqrt(x*x + y*y + z*z));
-        return 1;
+        return std::sqrt(x*x + y*y + z*z);
     }
 
     /**
@@ -509,18 +484,18 @@ namespace LuaWorldObject
      *
      * @return float dist : the distance in yards
      */
-    int GetDistance2d(lua_State* L, WorldObject* obj)
+    float GetDistance2d(WorldObject* worldobject, sol::object first, sol::optional<float> yArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, false);
-        if (target)
-            ALE::Push(L, obj->GetDistance2d(target));
-        else
-        {
-            float X = ALE::CHECKVAL<float>(L, 2);
-            float Y = ALE::CHECKVAL<float>(L, 3);
-            ALE::Push(L, obj->GetDistance2d(X, Y));
-        }
-        return 1;
+        if (first.is<WorldObjectRef>())
+            if (WorldObject* target = first.as<WorldObjectRef>().Resolve())
+                return worldobject->GetDistance2d(target);
+
+        if (!first.is<float>() || !yArg)
+            throw std::invalid_argument("WorldObject or coordinates (x, y) expected");
+
+        float X = first.as<float>();
+        float Y = *yArg;
+        return worldobject->GetDistance2d(X, Y);
     }
 
     /**
@@ -537,11 +512,12 @@ namespace LuaWorldObject
      *
      * @return float dist : the distance in yards
      */
-    int GetExactDistance2d(lua_State* L, WorldObject* obj)
+    float GetExactDistance2d(WorldObject* worldobject, sol::object first, sol::optional<float> yArg)
     {
         float x, y, z;
-        obj->GetPosition(x, y, z);
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, false);
+        worldobject->GetPosition(x, y, z);
+
+        WorldObject* target = first.is<WorldObjectRef>() ? first.as<WorldObjectRef>().Resolve() : nullptr;
         if (target)
         {
             float x2, y2, z2;
@@ -551,12 +527,14 @@ namespace LuaWorldObject
         }
         else
         {
-            x -= ALE::CHECKVAL<float>(L, 2);
-            y -= ALE::CHECKVAL<float>(L, 3);
+            if (!first.is<float>() || !yArg)
+                throw std::invalid_argument("WorldObject or coordinates (x, y) expected");
+
+            x -= first.as<float>();
+            y -= *yArg;
         }
 
-        ALE::Push(L, std::sqrt(x*x + y*y));
-        return 1;
+        return std::sqrt(x*x + y*y);
     }
 
     /**
@@ -569,18 +547,12 @@ namespace LuaWorldObject
      * @return float y
      * @return float z
      */
-    int GetRelativePoint(lua_State* L, WorldObject* obj)
+    std::tuple<float, float, float> GetRelativePoint(WorldObject* worldobject, float dist, float rad)
     {
-        float dist = ALE::CHECKVAL<float>(L, 2);
-        float rad = ALE::CHECKVAL<float>(L, 3);
-
         float x, y, z;
-        obj->GetClosePoint(x, y, z, 0.0f, dist, rad);
+        worldobject->GetClosePoint(x, y, z, 0.0f, dist, rad);
 
-        ALE::Push(L, x);
-        ALE::Push(L, y);
-        ALE::Push(L, z);
-        return 3;
+        return std::tuple<float, float, float>(x, y, z);
     }
 
     /**
@@ -597,19 +569,18 @@ namespace LuaWorldObject
      *
      * @return float angle : angle in radians in range 0..2*pi
      */
-    int GetAngle(lua_State* L, WorldObject* obj)
+    float GetAngle(WorldObject* worldobject, sol::object first, sol::optional<float> yArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, false);
-        if (target)
-            ALE::Push(L, obj->GetAbsoluteAngle(target));
-        else
-        {
-            float x = ALE::CHECKVAL<float>(L, 2);
-            float y = ALE::CHECKVAL<float>(L, 3);
-            ALE::Push(L, obj->GetAbsoluteAngle(x, y));
-        }
+        if (first.is<WorldObjectRef>())
+            if (WorldObject* target = first.as<WorldObjectRef>().Resolve())
+                return worldobject->GetAbsoluteAngle(target);
+
+        if (!first.is<float>() || !yArg)
+            throw std::invalid_argument("WorldObject or coordinates (x, y) expected");
 
-        return 1;
+        float x = first.as<float>();
+        float y = *yArg;
+        return worldobject->GetAbsoluteAngle(x, y);
     }
 
     /**
@@ -617,10 +588,9 @@ namespace LuaWorldObject
      *
      * @return [Transport] transport
      */
-    int GetTransport(lua_State* L, WorldObject* obj)
+    Transport* GetTransport(WorldObject* worldobject)
     {
-        ALE::Push(L, static_cast<Transport*>(obj->GetTransport()));
-        return 1;
+        return static_cast<Transport*>(worldobject->GetTransport());
     }
 
     /**
@@ -628,11 +598,9 @@ namespace LuaWorldObject
      *
      * @param [WorldPacket] packet
      */
-    int SendPacket(lua_State* L, WorldObject* obj)
+    void SendPacket(WorldObject* worldobject, WorldPacket* data)
     {
-        WorldPacket* data = ALE::CHECKOBJ<WorldPacket>(L, 2);
-        obj->SendMessageToSet(data, true);
-        return 0;
+        worldobject->SendMessageToSet(data, true);
     }
 
     /**
@@ -646,17 +614,11 @@ namespace LuaWorldObject
      * @param uint32 respawnDelay = 30 : respawn time in seconds
      * @return [GameObject] gameObject
      */
-    int SummonGameObject(lua_State* L, WorldObject* obj)
+    GameObject* SummonGameObject(WorldObject* worldobject, uint32 entry, float x, float y, float z, float o, sol::optional<uint32> respawnDelayArg)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        float x = ALE::CHECKVAL<float>(L, 3);
-        float y = ALE::CHECKVAL<float>(L, 4);
-        float z = ALE::CHECKVAL<float>(L, 5);
-        float o = ALE::CHECKVAL<float>(L, 6);
-        uint32 respawnDelay = ALE::CHECKVAL<uint32>(L, 7, 30);
-
-        ALE::Push(L, obj->SummonGameObject(entry, x, y, z, o, 0, 0, 0, 0, respawnDelay));
-        return 1;
+        uint32 respawnDelay = respawnDelayArg.value_or(30);
+
+        return worldobject->SummonGameObject(entry, x, y, z, o, 0, 0, 0, 0, respawnDelay);
     }
 
     /**
@@ -685,15 +647,10 @@ namespace LuaWorldObject
      * @param uint32 despawnTimer = 0 : despawn time in milliseconds
      * @return [Creature] spawnedCreature
      */
-    int SpawnCreature(lua_State* L, WorldObject* obj)
+    Creature* SpawnCreature(WorldObject* worldobject, uint32 entry, float x, float y, float z, float o, sol::optional<uint32> spawnTypeArg, sol::optional<uint32> despawnTimerArg)
     {
-        uint32 entry = ALE::CHECKVAL<uint32>(L, 2);
-        float x = ALE::CHECKVAL<float>(L, 3);
-        float y = ALE::CHECKVAL<float>(L, 4);
-        float z = ALE::CHECKVAL<float>(L, 5);
-        float o = ALE::CHECKVAL<float>(L, 6);
-        uint32 spawnType = ALE::CHECKVAL<uint32>(L, 7, 8);
-        uint32 despawnTimer = ALE::CHECKVAL<uint32>(L, 8, 0);
+        uint32 spawnType = spawnTypeArg.value_or(8);
+        uint32 despawnTimer = despawnTimerArg.value_or(0);
 
         TempSummonType type;
         switch (spawnType)
@@ -723,11 +680,10 @@ namespace LuaWorldObject
                 type = TEMPSUMMON_MANUAL_DESPAWN;
                 break;
             default:
-                return luaL_argerror(L, 7, "valid SpawnType expected");
+                throw std::invalid_argument("valid SpawnType expected");
         }
 
-        ALE::Push(L, obj->SummonCreature(entry, x, y, z, o, type, despawnTimer));
-        return 1;
+        return worldobject->SummonCreature(entry, x, y, z, o, type, despawnTimer);
     }
 
     /**
@@ -755,35 +711,29 @@ namespace LuaWorldObject
      * @param uint32 repeats = 1 : how many times for the event to repeat, 0 is infinite
      * @return int eventId : unique ID for the timed event used to cancel it or nil
      */
-    int RegisterEvent(lua_State* L, WorldObject* obj)
+    uint64 RegisterEvent(WorldObject* worldobject, sol::protected_function function, sol::object delay, sol::optional<uint32> repeatsArg)
     {
-        luaL_checktype(L, 2, LUA_TFUNCTION);
         uint32 min, max;
-        if (lua_istable(L, 3))
+        if (delay.is<sol::table>())
         {
-            ALE::Push(L, 1);
-            lua_gettable(L, 3);
-            min = ALE::CHECKVAL<uint32>(L, -1);
-            ALE::Push(L, 2);
-            lua_gettable(L, 3);
-            max = ALE::CHECKVAL<uint32>(L, -1);
-            lua_pop(L, 2);
+            sol::table delayTable = delay.as<sol::table>();
+            min = delayTable.get<uint32>(1);
+            max = delayTable.get<uint32>(2);
         }
         else
-            min = max = ALE::CHECKVAL<uint32>(L, 3);
-        uint32 repeats = ALE::CHECKVAL<uint32>(L, 4, 1);
+        {
+            sol::optional<uint32> delayValue = delay.as<sol::optional<uint32>>();
+            if (!delayValue)
+                throw std::invalid_argument("number or table expected");
+
+            min = max = *delayValue;
+        }
+        uint32 repeats = repeatsArg.value_or(1);
 
         if (min > max)
-            return luaL_argerror(L, 3, "min is bigger than max delay");
+            throw std::invalid_argument("min is bigger than max delay");
 
-        lua_pushvalue(L, 2);
-        int functionRef = luaL_ref(L, LUA_REGISTRYINDEX);
-        if (functionRef != LUA_REFNIL && functionRef != LUA_NOREF)
-        {
-            obj->ALEEvents->AddEvent(functionRef, min, max, repeats);
-            ALE::Push(L, functionRef);
-        }
-        return 1;
+        return worldobject->ALEEvents->AddEvent(function, min, max, repeats);
     }
 
     /**
@@ -791,21 +741,18 @@ namespace LuaWorldObject
      *
      * @param int eventId : event Id to remove
      */
-    int RemoveEventById(lua_State* L, WorldObject* obj)
+    void RemoveEventById(WorldObject* worldobject, uint64 eventId)
     {
-        int eventId = ALE::CHECKVAL<int>(L, 2);
-        obj->ALEEvents->SetState(eventId, LUAEVENT_STATE_ABORT);
-        return 0;
+        worldobject->ALEEvents->SetState(eventId, LUAEVENT_STATE_ABORT);
     }
 
     /**
      * Removes all timed events from a [WorldObject]
      *
      */
-    int RemoveEvents(lua_State* /*L*/, WorldObject* obj)
+    void RemoveEvents(WorldObject* worldobject)
     {
-        obj->ALEEvents->SetStates(LUAEVENT_STATE_ABORT);
-        return 0;
+        worldobject->ALEEvents->SetStates(LUAEVENT_STATE_ABORT);
     }
 
     /**
@@ -820,21 +767,19 @@ namespace LuaWorldObject
      * @param float z
      * @return bool isInLoS
      */
-    int IsWithinLoS(lua_State* L, WorldObject* obj)
+    bool IsWithinLoS(WorldObject* worldobject, sol::object first, sol::optional<float> yArg, sol::optional<float> zArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, false);
+        if (first.is<WorldObjectRef>())
+            if (WorldObject* target = first.as<WorldObjectRef>().Resolve())
+                return worldobject->IsWithinLOSInMap(target);
 
-        if (target)
-            ALE::Push(L, obj->IsWithinLOSInMap(target));
-        else
-        {
-            float x = ALE::CHECKVAL<float>(L, 2);
-            float y = ALE::CHECKVAL<float>(L, 3);
-            float z = ALE::CHECKVAL<float>(L, 4);
-            ALE::Push(L, obj->IsWithinLOS(x, y, z));
-        }
+        if (!first.is<float>() || !yArg || !zArg)
+            throw std::invalid_argument("WorldObject or coordinates (x, y, z) expected");
 
-        return 1;
+        float x = first.as<float>();
+        float y = *yArg;
+        float z = *zArg;
+        return worldobject->IsWithinLOS(x, y, z);
     }
 
     /**
@@ -843,11 +788,9 @@ namespace LuaWorldObject
      * @param [WorldObject] worldobject
      * @return bool isInMap
      */
-    int IsInMap(lua_State* L, WorldObject* obj)
+    bool IsInMap(WorldObject* worldobject, WorldObject* target)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, true);
-        ALE::Push(L, obj->IsInMap(target));
-        return 1;
+        return worldobject->IsInMap(target);
     }
 
     /**
@@ -861,14 +804,9 @@ namespace LuaWorldObject
      * @param float distance
      * @return bool isInDistance
      */
-    int IsWithinDist3d(lua_State* L, WorldObject* obj)
+    bool IsWithinDist3d(WorldObject* worldobject, float x, float y, float z, float dist)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float z = ALE::CHECKVAL<float>(L, 4);
-        float dist = ALE::CHECKVAL<float>(L, 5);
-        ALE::Push(L, obj->IsWithinDist3d(x, y, z, dist));
-        return 1;
+        return worldobject->IsWithinDist3d(x, y, z, dist);
     }
 
     /**
@@ -882,13 +820,9 @@ namespace LuaWorldObject
      * @param float distance
      * @return bool isInDistance
      */
-    int IsWithinDist2d(lua_State* L, WorldObject* obj)
+    bool IsWithinDist2d(WorldObject* worldobject, float x, float y, float dist)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float dist = ALE::CHECKVAL<float>(L, 4);
-        ALE::Push(L, obj->IsWithinDist2d(x, y, dist));
-        return 1;
+        return worldobject->IsWithinDist2d(x, y, dist);
     }
 
     /**
@@ -901,13 +835,10 @@ namespace LuaWorldObject
      * @param bool is3D = true : if false, only x,y coordinates used for checking
      * @return bool isInDistance
      */
-    int IsWithinDist(lua_State* L, WorldObject* obj)
+    bool IsWithinDist(WorldObject* worldobject, WorldObject* target, float distance, sol::optional<bool> is3DArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2, true);
-        float distance = ALE::CHECKVAL<float>(L, 3);
-        bool is3D = ALE::CHECKVAL<bool>(L, 4, true);
-        ALE::Push(L, obj->IsWithinDist(target, distance, is3D));
-        return 1;
+        bool is3D = is3DArg.value_or(true);
+        return worldobject->IsWithinDist(target, distance, is3D);
     }
 
     /**
@@ -920,14 +851,11 @@ namespace LuaWorldObject
      * @param bool is3D = true : if false, only x,y coordinates used for checking
      * @return bool isInDistance
      */
-    int IsWithinDistInMap(lua_State* L, WorldObject* obj)
+    bool IsWithinDistInMap(WorldObject* worldobject, WorldObject* target, float distance, sol::optional<bool> is3DArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2);
-        float distance = ALE::CHECKVAL<float>(L, 3);
-        bool is3D = ALE::CHECKVAL<bool>(L, 4, true);
+        bool is3D = is3DArg.value_or(true);
 
-        ALE::Push(L, obj->IsWithinDistInMap(target, distance, is3D));
-        return 1;
+        return worldobject->IsWithinDistInMap(target, distance, is3D);
     }
 
     /**
@@ -941,15 +869,11 @@ namespace LuaWorldObject
      * @param bool is3D = true : if false, only x,y coordinates used for checking
      * @return bool isInDistance
      */
-    int IsInRange(lua_State* L, WorldObject* obj)
+    bool IsInRange(WorldObject* worldobject, WorldObject* target, float minrange, float maxrange, sol::optional<bool> is3DArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2);
-        float minrange = ALE::CHECKVAL<float>(L, 3);
-        float maxrange = ALE::CHECKVAL<float>(L, 4);
-        bool is3D = ALE::CHECKVAL<bool>(L, 5, true);
+        bool is3D = is3DArg.value_or(true);
 
-        ALE::Push(L, obj->IsInRange(target, minrange, maxrange, is3D));
-        return 1;
+        return worldobject->IsInRange(target, minrange, maxrange, is3D);
     }
 
     /**
@@ -963,15 +887,9 @@ namespace LuaWorldObject
      * @param float maxrange
      * @return bool isInDistance
      */
-    int IsInRange2d(lua_State* L, WorldObject* obj)
+    bool IsInRange2d(WorldObject* worldobject, float x, float y, float minrange, float maxrange)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float minrange = ALE::CHECKVAL<float>(L, 4);
-        float maxrange = ALE::CHECKVAL<float>(L, 5);
-
-        ALE::Push(L, obj->IsInRange2d(x, y, minrange, maxrange));
-        return 1;
+        return worldobject->IsInRange2d(x, y, minrange, maxrange);
     }
 
     /**
@@ -986,16 +904,9 @@ namespace LuaWorldObject
      * @param float maxrange
      * @return bool isInDistance
      */
-    int IsInRange3d(lua_State* L, WorldObject* obj)
+    bool IsInRange3d(WorldObject* worldobject, float x, float y, float z, float minrange, float maxrange)
     {
-        float x = ALE::CHECKVAL<float>(L, 2);
-        float y = ALE::CHECKVAL<float>(L, 3);
-        float z = ALE::CHECKVAL<float>(L, 4);
-        float minrange = ALE::CHECKVAL<float>(L, 5);
-        float maxrange = ALE::CHECKVAL<float>(L, 6);
-
-        ALE::Push(L, obj->IsInRange3d(x, y, z, minrange, maxrange));
-        return 1;
+        return worldobject->IsInRange3d(x, y, z, minrange, maxrange);
     }
 
     /**
@@ -1005,13 +916,11 @@ namespace LuaWorldObject
      * @param float arc = pi
      * @return bool isInFront
      */
-    int IsInFront(lua_State* L, WorldObject* obj)
+    bool IsInFront(WorldObject* worldobject, WorldObject* target, sol::optional<float> arcArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2);
-        float arc = ALE::CHECKVAL<float>(L, 3, static_cast<float>(M_PI));
+        float arc = arcArg.value_or(static_cast<float>(M_PI));
 
-        ALE::Push(L, obj->isInFront(target, arc));
-        return 1;
+        return worldobject->isInFront(target, arc);
     }
 
     /**
@@ -1021,13 +930,11 @@ namespace LuaWorldObject
      * @param float arc = pi
      * @return bool isInBack
      */
-    int IsInBack(lua_State* L, WorldObject* obj)
+    bool IsInBack(WorldObject* worldobject, WorldObject* target, sol::optional<float> arcArg)
     {
-        WorldObject* target = ALE::CHECKOBJ<WorldObject>(L, 2);
-        float arc = ALE::CHECKVAL<float>(L, 3, static_cast<float>(M_PI));
+        float arc = arcArg.value_or(static_cast<float>(M_PI));
 
-        ALE::Push(L, obj->isInBack(target, arc));
-        return 1;
+        return worldobject->isInBack(target, arc);
     }
 
     /**
@@ -1041,18 +948,16 @@ namespace LuaWorldObject
      * @param uint32 music : entry of a music
      * @param [Player] player = nil : [Player] to play the music to
      */
-    int PlayMusic(lua_State* L, WorldObject* obj)
+    void PlayMusic(WorldObject* worldobject, uint32 musicid, sol::optional<PlayerRef> playerArg)
     {
-        uint32 musicid = ALE::CHECKVAL<uint32>(L, 2);
-        Player* player = ALE::CHECKOBJ<Player>(L, 3, false);
+        Player* player = playerArg ? playerArg->Resolve() : nullptr;
 
         WorldPacket data(SMSG_PLAY_MUSIC, 4);
         data << uint32(musicid);
         if (player)
             player->SendDirectMessage(&data);
         else
-            obj->SendMessageToSet(&data, true);
-        return 0;
+            worldobject->SendMessageToSet(&data, true);
     }
 
     /**
@@ -1066,18 +971,16 @@ namespace LuaWorldObject
      * @param uint32 sound : entry of a sound
      * @param [Player] player = nil : [Player] to play the sound to
      */
-    int PlayDirectSound(lua_State* L, WorldObject* obj)
+    void PlayDirectSound(WorldObject* worldobject, uint32 soundId, sol::optional<PlayerRef> playerArg)
     {
-        uint32 soundId = ALE::CHECKVAL<uint32>(L, 2);
-        Player* player = ALE::CHECKOBJ<Player>(L, 3, false);
+        Player* player = playerArg ? playerArg->Resolve() : nullptr;
         if (!sSoundEntriesStore.LookupEntry(soundId))
-            return 0;
+            return;
 
         if (player)
-            obj->PlayDirectSound(soundId, player);
+            worldobject->PlayDirectSound(soundId, player);
         else
-            obj->PlayDirectSound(soundId);
-        return 0;
+            worldobject->PlayDirectSound(soundId);
     }
 
     /**
@@ -1092,18 +995,69 @@ namespace LuaWorldObject
      * @param uint32 sound : entry of a sound
      * @param [Player] player = nil : [Player] to play the sound to
      */
-    int PlayDistanceSound(lua_State* L, WorldObject* obj)
+    void PlayDistanceSound(WorldObject* worldobject, uint32 soundId, sol::optional<PlayerRef> playerArg)
     {
-        uint32 soundId = ALE::CHECKVAL<uint32>(L, 2);
-        Player* player = ALE::CHECKOBJ<Player>(L, 3, false);
+        Player* player = playerArg ? playerArg->Resolve() : nullptr;
         if (!sSoundEntriesStore.LookupEntry(soundId))
-            return 0;
+            return;
 
         if (player)
-            obj->PlayDistanceSound(soundId, player);
+            worldobject->PlayDistanceSound(soundId, player);
         else
-            obj->PlayDistanceSound(soundId);
-        return 0;
+            worldobject->PlayDistanceSound(soundId);
     }
-};
-#endif
+}
+
+void RegisterWorldObjectMethods(sol::state& lua)
+{
+    sol::usertype<WorldObjectRef> type = ALEBind::NewHandleType<WorldObjectRef, ObjectRef>(lua, "WorldObject");
+
+    type["GetName"]               = ALEBind::Method(&LuaWorldObject::GetName);
+    type["GetMap"]                = ALEBind::Method(&LuaWorldObject::GetMap);
+    type["GetPhaseMask"]          = ALEBind::Method(&LuaWorldObject::GetPhaseMask);
+    type["SetPhaseMask"]          = ALEBind::Method(&LuaWorldObject::SetPhaseMask);
+    type["GetInstanceId"]         = ALEBind::Method(&LuaWorldObject::GetInstanceId);
+    type["GetAreaId"]             = ALEBind::Method(&LuaWorldObject::GetAreaId);
+    type["GetZoneId"]             = ALEBind::Method(&LuaWorldObject::GetZoneId);
+    type["GetMapId"]              = ALEBind::Method(&LuaWorldObject::GetMapId);
+    type["GetX"]                  = ALEBind::Method(&LuaWorldObject::GetX);
+    type["GetY"]                  = ALEBind::Method(&LuaWorldObject::GetY);
+    type["GetZ"]                  = ALEBind::Method(&LuaWorldObject::GetZ);
+    type["GetO"]                  = ALEBind::Method(&LuaWorldObject::GetO);
+    type["GetLocation"]           = ALEBind::Method(&LuaWorldObject::GetLocation);
+    type["GetNearestPlayer"]      = ALEBind::Method(&LuaWorldObject::GetNearestPlayer);
+    type["GetNearestGameObject"]  = ALEBind::Method(&LuaWorldObject::GetNearestGameObject);
+    type["GetNearestCreature"]    = ALEBind::Method(&LuaWorldObject::GetNearestCreature);
+    type["GetPlayersInRange"]     = ALEBind::Method(&LuaWorldObject::GetPlayersInRange);
+    type["GetCreaturesInRange"]   = ALEBind::Method(&LuaWorldObject::GetCreaturesInRange);
+    type["GetGameObjectsInRange"] = ALEBind::Method(&LuaWorldObject::GetGameObjectsInRange);
+    type["GetNearObject"]         = ALEBind::Method(&LuaWorldObject::GetNearObject);
+    type["GetNearObjects"]        = ALEBind::Method(&LuaWorldObject::GetNearObjects);
+    type["GetDistance"]           = ALEBind::Method(&LuaWorldObject::GetDistance);
+    type["GetExactDistance"]      = ALEBind::Method(&LuaWorldObject::GetExactDistance);
+    type["GetDistance2d"]         = ALEBind::Method(&LuaWorldObject::GetDistance2d);
+    type["GetExactDistance2d"]    = ALEBind::Method(&LuaWorldObject::GetExactDistance2d);
+    type["GetRelativePoint"]      = ALEBind::Method(&LuaWorldObject::GetRelativePoint);
+    type["GetAngle"]              = ALEBind::Method(&LuaWorldObject::GetAngle);
+    type["GetTransport"]          = ALEBind::Method(&LuaWorldObject::GetTransport);
+    type["SendPacket"]            = ALEBind::Method(&LuaWorldObject::SendPacket);
+    type["SummonGameObject"]      = ALEBind::Method(&LuaWorldObject::SummonGameObject);
+    type["SpawnCreature"]         = ALEBind::Method(&LuaWorldObject::SpawnCreature);
+    type["RegisterEvent"]         = ALEBind::Method(&LuaWorldObject::RegisterEvent);
+    type["RemoveEventById"]       = ALEBind::Method(&LuaWorldObject::RemoveEventById);
+    type["RemoveEvents"]          = ALEBind::Method(&LuaWorldObject::RemoveEvents);
+    type["IsWithinLoS"]           = ALEBind::Method(&LuaWorldObject::IsWithinLoS);
+    type["IsInMap"]               = ALEBind::Method(&LuaWorldObject::IsInMap);
+    type["IsWithinDist3d"]        = ALEBind::Method(&LuaWorldObject::IsWithinDist3d);
+    type["IsWithinDist2d"]        = ALEBind::Method(&LuaWorldObject::IsWithinDist2d);
+    type["IsWithinDist"]          = ALEBind::Method(&LuaWorldObject::IsWithinDist);
+    type["IsWithinDistInMap"]     = ALEBind::Method(&LuaWorldObject::IsWithinDistInMap);
+    type["IsInRange"]             = ALEBind::Method(&LuaWorldObject::IsInRange);
+    type["IsInRange2d"]           = ALEBind::Method(&LuaWorldObject::IsInRange2d);
+    type["IsInRange3d"]           = ALEBind::Method(&LuaWorldObject::IsInRange3d);
+    type["IsInFront"]             = ALEBind::Method(&LuaWorldObject::IsInFront);
+    type["IsInBack"]              = ALEBind::Method(&LuaWorldObject::IsInBack);
+    type["PlayMusic"]             = ALEBind::Method(&LuaWorldObject::PlayMusic);
+    type["PlayDirectSound"]       = ALEBind::Method(&LuaWorldObject::PlayDirectSound);
+    type["PlayDistanceSound"]     = ALEBind::Method(&LuaWorldObject::PlayDistanceSound);
+}
diff --git a/src/LuaEngine/methods/WorldPacketMethods.h b/src/LuaEngine/methods/WorldPacketMethods.cpp
similarity index 62%
rename from src/LuaEngine/methods/WorldPacketMethods.h
rename to src/LuaEngine/methods/WorldPacketMethods.cpp
index 3972eee316..1667c6ed7e 100644
--- a/src/LuaEngine/methods/WorldPacketMethods.h
+++ b/src/LuaEngine/methods/WorldPacketMethods.cpp
@@ -4,8 +4,10 @@
 * Please see the included DOCS/LICENSE.md for more information
 */
 
-#ifndef WORLDPACKETMETHODS_H
-#define WORLDPACKETMETHODS_H
+#include "ALEBind.h"
+
+#include "Opcodes.h"
+#include "WorldPacket.h"
 
 /***
  * A packet used to pass messages between the server and a client.
@@ -18,17 +20,16 @@
  *
  * Inherits all methods from: none
  */
-namespace LuaPacket
+namespace LuaWorldPacket
 {
     /**
      * Returns the opcode of the [WorldPacket].
      *
      * @return uint16 opcode
      */
-    int GetOpcode(lua_State* L, WorldPacket* packet)
+    uint16 GetOpcode(WorldPacket* packet)
     {
-        ALE::Push(L, packet->GetOpcode());
-        return 1;
+        return packet->GetOpcode();
     }
 
     /**
@@ -36,10 +37,9 @@ namespace LuaPacket
      *
      * @return uint32 size
      */
-    int GetSize(lua_State* L, WorldPacket* packet)
+    uint32 GetSize(WorldPacket* packet)
     {
-        ALE::Push(L, packet->size());
-        return 1;
+        return packet->size();
     }
 
     /**
@@ -47,13 +47,11 @@ namespace LuaPacket
      *
      * @param [Opcodes] opcode : see Opcodes.h for all known opcodes
      */
-    int SetOpcode(lua_State* L, WorldPacket* packet)
+    void SetOpcode(WorldPacket* packet, uint32 opcode)
     {
-        uint32 opcode = ALE::CHECKVAL<uint32>(L, 2);
         if (opcode >= NUM_MSG_TYPES)
-            return luaL_argerror(L, 2, "valid opcode expected");
-        packet->SetOpcode((OpcodesList)opcode);
-        return 0;
+            throw std::invalid_argument("valid opcode expected");
+        packet->SetOpcode(static_cast<Opcodes>(opcode));
     }
 
     /**
@@ -61,12 +59,11 @@ namespace LuaPacket
      *
      * @return int8 value
      */
-    int ReadByte(lua_State* L, WorldPacket* packet)
+    int8 ReadByte(WorldPacket* packet)
     {
         int8 _byte;
         (*packet) >> _byte;
-        ALE::Push(L, _byte);
-        return 1;
+        return _byte;
     }
 
     /**
@@ -74,12 +71,11 @@ namespace LuaPacket
      *
      * @return uint8 value
      */
-    int ReadUByte(lua_State* L, WorldPacket* packet)
+    uint8 ReadUByte(WorldPacket* packet)
     {
         uint8 _ubyte;
         (*packet) >> _ubyte;
-        ALE::Push(L, _ubyte);
-        return 1;
+        return _ubyte;
     }
 
     /**
@@ -87,12 +83,11 @@ namespace LuaPacket
      *
      * @return int16 value
      */
-    int ReadShort(lua_State* L, WorldPacket* packet)
+    int16 ReadShort(WorldPacket* packet)
     {
         int16 _short;
         (*packet) >> _short;
-        ALE::Push(L, _short);
-        return 1;
+        return _short;
     }
 
     /**
@@ -100,12 +95,11 @@ namespace LuaPacket
      *
      * @return uint16 value
      */
-    int ReadUShort(lua_State* L, WorldPacket* packet)
+    uint16 ReadUShort(WorldPacket* packet)
     {
         uint16 _ushort;
         (*packet) >> _ushort;
-        ALE::Push(L, _ushort);
-        return 1;
+        return _ushort;
     }
 
     /**
@@ -113,12 +107,11 @@ namespace LuaPacket
      *
      * @return int32 value
      */
-    int ReadLong(lua_State* L, WorldPacket* packet)
+    int32 ReadLong(WorldPacket* packet)
     {
         int32 _long;
         (*packet) >> _long;
-        ALE::Push(L, _long);
-        return 1;
+        return _long;
     }
 
     /**
@@ -126,12 +119,11 @@ namespace LuaPacket
      *
      * @return uint32 value
      */
-    int ReadULong(lua_State* L, WorldPacket* packet)
+    uint32 ReadULong(WorldPacket* packet)
     {
         uint32 _ulong;
         (*packet) >> _ulong;
-        ALE::Push(L, _ulong);
-        return 1;
+        return _ulong;
     }
 
     /**
@@ -139,12 +131,11 @@ namespace LuaPacket
      *
      * @return float value
      */
-    int ReadFloat(lua_State* L, WorldPacket* packet)
+    float ReadFloat(WorldPacket* packet)
     {
         float _val;
         (*packet) >> _val;
-        ALE::Push(L, _val);
-        return 1;
+        return _val;
     }
 
     /**
@@ -152,12 +143,11 @@ namespace LuaPacket
      *
      * @return double value
      */
-    int ReadDouble(lua_State* L, WorldPacket* packet)
+    double ReadDouble(WorldPacket* packet)
     {
         double _val;
         (*packet) >> _val;
-        ALE::Push(L, _val);
-        return 1;
+        return _val;
     }
 
     /**
@@ -165,12 +155,11 @@ namespace LuaPacket
      *
      * @return ObjectGuid value : value returned as string
      */
-    int ReadGUID(lua_State* L, WorldPacket* packet)
+    ObjectGuid ReadGUID(WorldPacket* packet)
     {
         ObjectGuid guid;
         (*packet) >> guid;
-        ALE::Push(L, guid);
-        return 1;
+        return guid;
     }
 
     /**
@@ -179,25 +168,23 @@ namespace LuaPacket
      *
      * @return uint64 value : value returned as string
      */
-    int ReadPackedGUID(lua_State* L, WorldPacket* packet)
+    uint64 ReadPackedGUID(WorldPacket* packet)
     {
         uint64 guid;
         packet->readPackGUID(guid);
-        ALE::Push(L, guid);
-        return 1;
+        return guid;
     }
-	
+
     /**
      * Reads and returns a string value from the [WorldPacket].
      *
      * @return string value
      */
-    int ReadString(lua_State* L, WorldPacket* packet)
+    std::string ReadString(WorldPacket* packet)
     {
         std::string _val;
         (*packet) >> _val;
-        ALE::Push(L, _val);
-        return 1;
+        return _val;
     }
 
     /**
@@ -205,11 +192,9 @@ namespace LuaPacket
      *
      * @param ObjectGuid value : the value to be written to the [WorldPacket]
      */
-    int WriteGUID(lua_State* L, WorldPacket* packet)
+    void WriteGUID(WorldPacket* packet, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         (*packet) << guid;
-        return 0;
     }
 
     /**
@@ -217,12 +202,10 @@ namespace LuaPacket
      *
      * @param ObjectGuid value : the ObjectGuid to be packed to the [WorldPacket]
      */
-    int WritePackedGUID(lua_State* L, WorldPacket* packet)
+    void WritePackedGUID(WorldPacket* packet, ObjectGuid guid)
     {
-        ObjectGuid guid = ALE::CHECKVAL<ObjectGuid>(L, 2);
         PackedGuid packedGuid(guid);
         (*packet) << packedGuid;
-        return 0;
     }
 
     /**
@@ -230,11 +213,9 @@ namespace LuaPacket
      *
      * @param string value : the string to be written to the [WorldPacket]
      */
-    int WriteString(lua_State* L, WorldPacket* packet)
+    void WriteString(WorldPacket* packet, std::string _val)
     {
-        std::string _val = ALE::CHECKVAL<std::string>(L, 2);
         (*packet) << _val;
-        return 0;
     }
 
     /**
@@ -242,11 +223,9 @@ namespace LuaPacket
      *
      * @param int8 value : the int8 value to be written to the [WorldPacket]
      */
-    int WriteByte(lua_State* L, WorldPacket* packet)
+    void WriteByte(WorldPacket* packet, int8 byte)
     {
-        int8 byte = ALE::CHECKVAL<int8>(L, 2);
         (*packet) << byte;
-        return 0;
     }
 
     /**
@@ -254,11 +233,9 @@ namespace LuaPacket
      *
      * @param uint8 value : the uint8 value to be written to the [WorldPacket]
      */
-    int WriteUByte(lua_State* L, WorldPacket* packet)
+    void WriteUByte(WorldPacket* packet, uint8 byte)
     {
-        uint8 byte = ALE::CHECKVAL<uint8>(L, 2);
         (*packet) << byte;
-        return 0;
     }
 
     /**
@@ -266,11 +243,9 @@ namespace LuaPacket
      *
      * @param int16 value : the int16 value to be written to the [WorldPacket]
      */
-    int WriteShort(lua_State* L, WorldPacket* packet)
+    void WriteShort(WorldPacket* packet, int16 _short)
     {
-        int16 _short = ALE::CHECKVAL<int16>(L, 2);
         (*packet) << _short;
-        return 0;
     }
 
     /**
@@ -278,11 +253,9 @@ namespace LuaPacket
      *
      * @param uint16 value : the uint16 value to be written to the [WorldPacket]
      */
-    int WriteUShort(lua_State* L, WorldPacket* packet)
+    void WriteUShort(WorldPacket* packet, uint16 _ushort)
     {
-        uint16 _ushort = ALE::CHECKVAL<uint16>(L, 2);
         (*packet) << _ushort;
-        return 0;
     }
 
     /**
@@ -290,11 +263,9 @@ namespace LuaPacket
      *
      * @param int32 value : the int32 value to be written to the [WorldPacket]
      */
-    int WriteLong(lua_State* L, WorldPacket* packet)
+    void WriteLong(WorldPacket* packet, int32 _long)
     {
-        int32 _long = ALE::CHECKVAL<int32>(L, 2);
         (*packet) << _long;
-        return 0;
     }
 
     /**
@@ -302,11 +273,9 @@ namespace LuaPacket
      *
      * @param uint32 value : the uint32 value to be written to the [WorldPacket]
      */
-    int WriteULong(lua_State* L, WorldPacket* packet)
+    void WriteULong(WorldPacket* packet, uint32 _ulong)
     {
-        uint32 _ulong = ALE::CHECKVAL<uint32>(L, 2);
         (*packet) << _ulong;
-        return 0;
     }
 
     /**
@@ -314,11 +283,9 @@ namespace LuaPacket
      *
      * @param float value : the float value to be written to the [WorldPacket]
      */
-    int WriteFloat(lua_State* L, WorldPacket* packet)
+    void WriteFloat(WorldPacket* packet, float _val)
     {
-        float _val = ALE::CHECKVAL<float>(L, 2);
         (*packet) << _val;
-        return 0;
     }
 
     /**
@@ -326,12 +293,39 @@ namespace LuaPacket
      *
      * @param double value : the double value to be written to the [WorldPacket]
      */
-    int WriteDouble(lua_State* L, WorldPacket* packet)
+    void WriteDouble(WorldPacket* packet, double _val)
     {
-        double _val = ALE::CHECKVAL<double>(L, 2);
         (*packet) << _val;
-        return 0;
     }
-};
+}
+
+void RegisterWorldPacketMethods(sol::state& lua)
+{
+    sol::usertype<WorldPacket> type = lua.new_usertype<WorldPacket>("WorldPacket", sol::no_constructor);
 
-#endif
+    type["GetOpcode"]       = &LuaWorldPacket::GetOpcode;
+    type["GetSize"]         = &LuaWorldPacket::GetSize;
+    type["SetOpcode"]       = &LuaWorldPacket::SetOpcode;
+    type["ReadByte"]        = &LuaWorldPacket::ReadByte;
+    type["ReadUByte"]       = &LuaWorldPacket::ReadUByte;
+    type["ReadShort"]       = &LuaWorldPacket::ReadShort;
+    type["ReadUShort"]      = &LuaWorldPacket::ReadUShort;
+    type["ReadLong"]        = &LuaWorldPacket::ReadLong;
+    type["ReadULong"]       = &LuaWorldPacket::ReadULong;
+    type["ReadFloat"]       = &LuaWorldPacket::ReadFloat;
+    type["ReadDouble"]      = &LuaWorldPacket::ReadDouble;
+    type["ReadGUID"]        = &LuaWorldPacket::ReadGUID;
+    type["ReadPackedGUID"]  = &LuaWorldPacket::ReadPackedGUID;
+    type["ReadString"]      = &LuaWorldPacket::ReadString;
+    type["WriteGUID"]       = &LuaWorldPacket::WriteGUID;
+    type["WritePackedGUID"] = &LuaWorldPacket::WritePackedGUID;
+    type["WriteString"]     = &LuaWorldPacket::WriteString;
+    type["WriteByte"]       = &LuaWorldPacket::WriteByte;
+    type["WriteUByte"]      = &LuaWorldPacket::WriteUByte;
+    type["WriteShort"]      = &LuaWorldPacket::WriteShort;
+    type["WriteUShort"]     = &LuaWorldPacket::WriteUShort;
+    type["WriteLong"]       = &LuaWorldPacket::WriteLong;
+    type["WriteULong"]      = &LuaWorldPacket::WriteULong;
+    type["WriteFloat"]      = &LuaWorldPacket::WriteFloat;
+    type["WriteDouble"]     = &LuaWorldPacket::WriteDouble;
+}
diff --git a/src/lualib/lua/CMakeLists.txt b/src/lualib/lua/CMakeLists.txt
index 3f36675640..de87fb327b 100644
--- a/src/lualib/lua/CMakeLists.txt
+++ b/src/lualib/lua/CMakeLists.txt
@@ -129,7 +129,11 @@ else()
   install(TARGETS lua_interpreter DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
 endif()
 
-add_executable(lua_compiler ${LUA_SOURCE_FOLDER}/luac.c)
+if (LUA_STATIC)
+  add_executable(lua_compiler ${LUA_SOURCE_FOLDER}/luac.c)
+else()
+  add_executable(lua_compiler ${LUA_SOURCE_FOLDER}/luac.c ${LOCAL_SOURCES_C})
+endif()
 target_link_libraries(lua_compiler lualib)
 target_compile_definitions(lua_compiler PRIVATE _CRT_SECURE_NO_WARNINGS)
 if (NOT WIN32)
diff --git a/src/lualib/luajit/CMakeLists.txt b/src/lualib/luajit/CMakeLists.txt
index 64c0cf4791..839b95daba 100644
--- a/src/lualib/luajit/CMakeLists.txt
+++ b/src/lualib/luajit/CMakeLists.txt
@@ -66,7 +66,7 @@ if (WIN32)
     set_target_properties(lualib
     PROPERTIES
     IMPORTED_LOCATION ${LUA_BIN_FOLDER}/src/lua51.lib
-    INTERFACE_INCLUDE_DIRECTORIES "${LUA_SRC_FOLDER}/src"
+  INTERFACE_INCLUDE_DIRECTORIES "${LUA_BIN_FOLDER}/src"
     INTERFACE_COMPILE_DEFINITIONS "LUAJIT_VERSION=1"
     )
 
@@ -99,7 +99,7 @@ if (WIN32)
     PROPERTIES
     IMPORTED_LOCATION ${LUA_BIN_FOLDER}/src/lua51.dll
     IMPORTED_IMPLIB ${LUA_BIN_FOLDER}/src/lua51.lib
-    INTERFACE_INCLUDE_DIRECTORIES "${LUA_SRC_FOLDER}/src"
+  INTERFACE_INCLUDE_DIRECTORIES "${LUA_BIN_FOLDER}/src"
     INTERFACE_COMPILE_DEFINITIONS "LUAJIT_VERSION=1"
     )
 
@@ -155,7 +155,7 @@ if (UNIX OR APPLE)
   set_target_properties(lualib
   PROPERTIES
   # IMPORTED_LOCATION ${LUAJIT_LIB_PATH} # cmake bullshit. spent days figuring this and turns out set_target_properties does squat shit while set_property works fine.
-  INTERFACE_INCLUDE_DIRECTORIES "${LUA_SRC_FOLDER}/src"
+  INTERFACE_INCLUDE_DIRECTORIES "${LUA_BIN_FOLDER}/src"
   INTERFACE_COMPILE_DEFINITIONS "LUAJIT_VERSION=1"
   )
   set_property(TARGET lualib PROPERTY IMPORTED_LOCATION ${LUAJIT_LIB_PATH})
diff --git a/src/lualib/sol/LICENSE.txt b/src/lualib/sol/LICENSE.txt
new file mode 100644
index 0000000000..5813440548
--- /dev/null
+++ b/src/lualib/sol/LICENSE.txt
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-2022 Rapptz, ThePhD, and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/src/lualib/sol/README.md b/src/lualib/sol/README.md
new file mode 100644
index 0000000000..cf0e9e616e
--- /dev/null
+++ b/src/lualib/sol/README.md
@@ -0,0 +1,161 @@
+# sol2
+
+[![Documentation Status](https://readthedocs.org/projects/sol2/badge/?version=latest)](http://sol2.readthedocs.io/en/latest/?badge=latest)
+
+
+
+sol2 is a C++ library binding to Lua. It currently supports all Lua versions 5.1+ (LuaJIT 2.0+ and MoonJIT included). sol2 aims to be easy to use and easy to add to a project. The library is header-only for easy integration with projects, and a single header can be used for drag-and-drop start up.
+
+
+
+## Sneak Peek
+
+```cpp
+#include <sol/sol.hpp>
+#include <cassert>
+
+int main() {
+    sol::state lua;
+    int x = 0;
+    lua.set_function("beep", [&x]{ ++x; });
+    lua.script("beep()");
+    assert(x == 1);
+}
+```
+
+```cpp
+#include <sol/sol.hpp>
+#include <cassert>
+
+struct vars {
+    int boop = 0;
+};
+
+int main() {
+    sol::state lua;
+    lua.new_usertype<vars>("vars", "boop", &vars::boop);
+    lua.script("beep = vars.new()\n"
+               "beep.boop = 1");
+    assert(lua.get<vars>("beep").boop == 1);
+}
+```
+
+More examples are given in the examples directory [here](https://github.com/ThePhD/sol2/tree/develop/examples). 
+
+
+## Documentation
+
+Find it [here](http://sol2.rtfd.io/). A run-through kind of tutorial is [here](http://sol2.readthedocs.io/en/latest/tutorial/all-the-things.html)! The API documentation goes over most cases (particularly, the "api/usertype" and "api/table_proxy" and "api/function" sections) that should still get you off your feet and going, and there's an examples directory [here](https://github.com/ThePhD/sol2/tree/develop/examples) as well.
+
+
+
+
+# "I need X Feature or Fix, Right Now™"
+
+Find the support option that's right for you, [here](https://github.com/ThePhD/.github/blob/main/SUPPORT.md)! If you're happy to wait, you can just file a boring issue and we'll get to it Whenever There Is Time™.
+
+
+
+## I want to donate to help!
+
+You can find [donation and sponorship options here](https://github.com/ThePhD/.github/blob/main/SUPPORT.md#support-in-general) and from the little heart button near the top of this repository that will take you to a bevy of links in which you can donate and show support for this project and others!
+
+
+
+
+# Features
+
+- [Fastest in the land](http://sol2.readthedocs.io/en/latest/benchmarks.html) (see: sol2 bar in graph).
+- Supports retrieval and setting of multiple types including: 
+  * `std::string`, `std::wstring`, `std::u16string` and `std::u32string` support (and for views).
+  * understands and works with containers such as `std::map/unordered_map`, c-style arrays, vectors, non-standard custom containers and more.
+  * user-defined types, with or **without** registering that type 
+  * `std::unique_ptr`, `std::shared_ptr`, and optional support of other pointer types like `boost::shared_ptr`.
+  * custom `optional<T>` that works with references, and support for the inferior `std::optional`.
+  * C++17 support for variants and similar new types.
+- Lambda, function, and member function bindings are supported.
+- Intermediate type for checking if a variable exists.
+- Simple API that completely abstracts away the C stack API, including `protected_function` with the ability to use an error-handling function.
+- `operator[]`-style manipulation of tables
+- C++ type representations in Lua userdata as `usertype`s with guaranteed cleanup.
+- Customization points to allow your C++ objects to be pushed and retrieved from Lua as multiple consecutive objects, or anything else you desire!
+- Overloaded function calls: `my_function(1); my_function("Hello")` in the same Lua script route to different function calls based on parameters
+- Support for tables, nested tables, table iteration with `table.for_each` / `begin()` and `end()` iterators.
+- Zero string overhead for usertype function lookup.
+
+
+
+## Supported Compilers
+
+sol2 makes use of C++17 features. GCC 7.x.x and Clang 3.9.x (with `-std=c++1z` and appropriate standard library) or higher should be able to compile without problems. However, the officially supported and CI-tested compilers are:
+
+- GCC 7.x.x+ (MinGW 7.x.x+)
+- Clang 3.9.x+
+- Visual Studio 2017 Community (Visual C++ 15.0)+
+
+Please make sure you use the `-std=c++2a`, `-std=c++1z`, `-std=c++17` or better standard flags 
+(some of these flags are the defaults in later versions of GCC, such as 7+ and better).
+
+If you would like support for an older compiler (at the cost of some features), use the latest tagged sol2 branch. If you would like support for an even older compiler, feel free to contact me for a Custom Solution.
+
+sol2 is checked by-hand for other platforms as well, including Android-based builds with GCC and iOS-based builds out of XCode with Apple-clang. It should work on both of these platforms, so long as you have the proper standards flags. If something doesn't work or you need special options, you may need to look into the different ways to support the project to have it done for you!
+
+
+
+## Creating a single header
+
+You can grab a single header (and the single forward header) out of the library [here](https://github.com/ThePhD/sol2/tree/develop/single). For stable version, check the releases tab on GitHub for a provided single header file for maximum ease of use. A script called [`single.py`](https://github.com/ThePhD/sol2/blob/develop/single/single.py) is provided in the repository if there's some bleeding edge change that hasn't been published on the releases page. You can run this script to create a single file version of the library so you can only include that part of it. Check `single.py --help` for more info.
+
+If you use CMake, you can also configure and generate a project that will generate the `sol2_single_header` for you. You can also include the project using CMake. Run CMake for more details. Thanks @Nava2, @alkino, @mrgreywater and others for help with making the CMake build a reality.
+
+
+
+
+# Testing
+
+Testing turns on certain CI-only variables in the CMake to test a myriad of configuration options. You can generate the tests by running CMake and configuring `SOL2_TESTS`, `SOL2_TESTS_SINGLE`, `SOL2_TESTS_EXAMPLES`, and `SOL2_EXAMPLES` to be on. Make sure `SOL2_SINGLE` is also on.
+
+You will need any flavor of python3 and an available compiler. The testing suite will build its own version of Lua and LuaJIT, so you do not have to provide one (you may provide one with the `LUA_LOCAL_DIR` variable).
+
+
+
+# Presentations
+
+"A Sun For the Moon - A Zero-Overhead Lua Abstraction using C++"  
+ThePhD
+Lua Workshop 2016 - Mashape, San Francisco, CA  
+[Deck](https://github.com/ThePhD/sol2/blob/develop/documentation/presentation/2016.10.14%20-%20ThePhD%20-%20No%20Overhead%20C%20Abstraction.pdf)
+
+"Wrapping Lua C in C++ - Efficiently, Nicely, and with a Touch of Magic"  
+ThePhD
+Boston C++ Meetup November 2017 - CiC (Milk Street), Boston, MA  
+[Deck](https://github.com/ThePhD/sol2/blob/develop/documentation/presentation/2017.11.08%20-%20ThePhD%20-%20Wrapping%20Lua%20C%20in%20C%2B%2B.pdf)
+
+"Biting the CMake Bullet"  
+ThePhD
+Boston C++ Meetup February 2018 - CiC (Main Street), Cambridge, MA  
+[Deck](https://github.com/ThePhD/sol2/blob/develop/documentation/presentation/2018.02.06%20-%20ThePhD%20-%20Biting%20the%20CMake%20Bullet.pdf)
+
+"Compile Fast, Run Faster, Scale Forever: A look into the sol2 Library"  
+ThePhD
+C++Now 2018 - Hudson Commons, Aspen Physics Center, Aspen, Colorado  
+[Deck](https://github.com/ThePhD/sol2/blob/develop/documentation/presentation/2018.05.10%20-%20ThePhD%20-%20Compile%20Fast%2C%20Run%20Faster%2C%20Scale%20Forever.pdf)
+
+"Scripting at the Speed of Thought: Using Lua in C++ with sol2"  
+ThePhD
+CppCon 2018 - 404 Keystone, Meydenbauer Center, Aspen, Colorado  
+[Deck](https://github.com/ThePhD/sol2/blob/develop/documentation/presentation/2018.09.28%20-%20ThePhD%20-%20Scripting%20at%20the%20Speed%20of%20Thought.pdf)
+
+"The Plan for Tomorrow: Compile-Time Extension Points in C++"
+ThePhD
+C++Now 2019 - Flug Auditorium, Aspen Physics Center, Aspen, Colorado
+[Deck](https://github.com/ThePhD/sol2/blob/develop/documentation/presentation/2019.05.10%20-%20ThePhD%20-%20The%20Plan%20for%20Tomorrow%20-%20Compile-Time%20Extension%20Points%20in%20C%2b%2b.pdf)
+
+
+
+
+# License
+
+sol2 is distributed with an MIT License. You can see LICENSE.txt for more info.
+
+If you need a custom solution, [feel free to reach out](https://soasis.org/contact/opensource/).
diff --git a/src/lualib/sol/config.hpp b/src/lualib/sol/config.hpp
new file mode 100644
index 0000000000..3b7ef023f5
--- /dev/null
+++ b/src/lualib/sol/config.hpp
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// This file was generated with a script.
+// Generated 2022-06-25 08:14:19.336233 UTC
+// This header was generated with sol v3.3.0 (revision eba86625)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_CONFIG_HPP
+#define SOL_SINGLE_CONFIG_HPP
+
+// beginning of sol/config.hpp
+
+/* Base, empty configuration file!
+
+     To override, place a file in your include paths of the form:
+
+. (your include path here)
+| sol (directory, or equivalent)
+  | config.hpp (your config.hpp file)
+
+     So that when sol2 includes the file
+
+#include <sol/config.hpp>
+
+     it gives you the configuration values you desire. Configuration values can be
+seen in the safety.rst of the doc/src, or at
+https://sol2.readthedocs.io/en/latest/safety.html ! You can also pass them through
+the build system, or the command line options of your compiler.
+
+*/
+
+// end of sol/config.hpp
+
+#endif // SOL_SINGLE_CONFIG_HPP
diff --git a/src/lualib/sol/forward.hpp b/src/lualib/sol/forward.hpp
new file mode 100644
index 0000000000..8690690871
--- /dev/null
+++ b/src/lualib/sol/forward.hpp
@@ -0,0 +1,1321 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// This file was generated with a script.
+// Generated 2022-06-25 08:14:19.328625 UTC
+// This header was generated with sol v3.3.0 (revision eba86625)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
+#define SOL_SINGLE_INCLUDE_FORWARD_HPP
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 2
+#define SOL_VERSION_PATCH 3
+#define SOL_VERSION_STRING "3.2.3"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN) #_TOKEN
+#define SOL_TOKEN_TO_STRING_I_(_TOKEN) SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN)
+
+#define SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT) _LEFT##_RIGHT
+#define SOL_CONCAT_TOKENS_I_(_LEFT, _RIGHT) SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT)
+
+#define SOL_RAW_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_RAW_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_IS_ON(OP_SYMBOL) SOL_RAW_IS_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_OFF(OP_SYMBOL) SOL_RAW_IS_OFF(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL ## _I_)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(SOL_BUILD_CXX_MODE)
+	#if (SOL_BUILD_CXX_MODE != 0)
+		#define SOL_BUILD_CXX_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_CXX_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__cplusplus)
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_BUILD_C_MODE)
+	#if (SOL_BUILD_C_MODE != 0)
+		#define SOL_BUILD_C_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_C_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__STDC__)
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_C_MODE)
+	#include <stddef.h>
+	#include <stdint.h>
+	#include <limits.h>
+#else
+	#include <cstddef>
+	#include <cstdint>
+	#include <climits>
+#endif
+
+#if defined(SOL_COMPILER_VCXX)
+	#if defined(SOL_COMPILER_VCXX != 0)
+		#define SOL_COMPILER_VCXX_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_VCXX_I_ SOL_OFF
+	#endif
+#elif defined(_MSC_VER)
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_GCC)
+	#if defined(SOL_COMPILER_GCC != 0)
+		#define SOL_COMPILER_GCC_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_GCC_I_ SOL_OFF
+	#endif
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_CLANG)
+	#if defined(SOL_COMPILER_CLANG != 0)
+		#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#endif
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_EDG)
+	#if defined(SOL_COMPILER_EDG != 0)
+		#define SOL_COMPILER_EDG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_EDG_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_COMPILER_EDG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_MINGW)
+	#if (SOL_COMPILER_MINGW != 0)
+		#define SOL_COMPILER_MINGW_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_MINGW_I_ SOL_OFF
+	#endif
+#elif defined(__MINGW32__)
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(SOL_PLATFORM_WINDOWS)
+	#if (SOL_PLATFORM_WINDOWS != 0)
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+	#endif
+#elif defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_CYGWIN)
+	#if (SOL_PLATFORM_CYGWIN != 0)
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#endif
+#elif defined(__CYGWIN__)
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_APPLE)
+	#if (SOL_PLATFORM_APPLE != 0)
+		#define SOL_PLATFORM_APPLE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+	#endif
+#elif defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_UNIX)
+	#if (SOL_PLATFORM_UNIX != 0)
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_LINUX)
+	#if (SOL_PLATFORM_LINUX != 0)
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__LINUX__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL)
+	#if SOL_NO_THREAD_LOCAL != 0
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+	#else
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON)
+	#if SOL_ALL_SAFETIES_ON != 0
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+	#else
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER)
+	#if SOL_SAFE_GETTER != 0
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE)
+	#if SOL_SAFE_USERTYPE != 0
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES)
+	#if SOL_SAFE_REFERENCES != 0
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTIONS)
+	#if SOL_SAFE_FUNCTIONS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#elif defined (SOL_SAFE_FUNCTION_OBJECTS)
+	#if SOL_SAFE_FUNCTION_OBJECTS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS)
+	#if SOL_SAFE_FUNCTION_CALLS != 0
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES)
+	#if SOL_SAFE_PROXIES != 0
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS)
+	#if SOL_SAFE_NUMERICS != 0
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_ALL_INTEGER_VALUES_FIT)
+	#if (SOL_ALL_INTEGER_VALUES_FIT != 0)
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_ON
+	#else
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_OFF
+	#endif
+#elif !SOL_IS_DEFAULT_OFF(SOL_SAFE_NUMERICS) && SOL_IS_OFF(SOL_SAFE_NUMERICS)
+	// if numerics is intentionally turned off, flip this on
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_ON
+#else
+	// default to off
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK)
+	#if SOL_SAFE_STACK_CHECK != 0
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_CHECK_NUMBER_PRECISION)
+	#if SOL_NO_CHECK_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#elif defined(SOL_NO_CHECKING_NUMBER_PRECISION)
+	#if SOL_NO_CHECKING_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP)
+	#if SOL_ENABLE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_INTEROP)
+	#if SOL_USE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG) && SOL_IS_ON(SOL_PLATFORM_APPLE)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR)
+	#if (SOL_DEFAULT_PASS_ON_ERROR != 0)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	#if (SOL_FUNCTION_CALL_VALUE_SEMANTICS != 0)
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_ON
+	#else
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_MINGW_CCTYPE_IS_POISONED)
+	#if (SOL_MINGW_CCTYPE_IS_POISONED != 0)
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+	#else
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_MINGW) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_CHAR8_T)
+	#if (SOL_CHAR8_T != 0)
+		#define SOL_CHAR8_T_I_ SOL_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_char8_t)
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	#include <boost/version.hpp>
+
+	#if BOOST_VERSION >= 107500 // Since Boost 1.75.0 boost::none is constexpr
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+	#else
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ const
+	#endif // BOOST_VERSION
+#else
+	// assume boost isn't using a garbage version
+	#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+#endif
+
+#if defined(SOL2_CI)
+	#if (SOL2_CI != 0)
+		#define SOL2_CI_I_ SOL_ON
+	#else
+		#define SOL2_CI_I_ SOL_OFF
+	#endif
+#else
+	#define SOL2_CI_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_C_ASSERT)
+	#define SOL_USER_C_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_C_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_M_ASSERT)
+	#define SOL_USER_M_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_M_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+// beginning of sol/prologue.hpp
+
+#if defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue was already included in translation unit and not properly ended with an epilogue."
+#endif
+
+#define SOL_PROLOGUE_I_ 1
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
+
+	#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
+	#else
+		#include <type_traits>
+		
+		#define _MOVE(...) static_cast<::std::remove_reference_t<( __VA_ARGS__ )>&&>( __VA_OPT__(,) )
+	#endif
+#endif
+
+// end of sol/prologue.hpp
+
+// beginning of sol/epilogue.hpp
+
+#if !defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue is missing from this translation unit."
+#else
+	#undef SOL_PROLOGUE_I_
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#undef _FWD
+	#undef _MOVE
+#endif
+
+// end of sol/epilogue.hpp
+
+// beginning of sol/detail/build_version.hpp
+
+#if defined(SOL_DLL)
+	#if (SOL_DLL != 0)
+		#define SOL_DLL_I_ SOL_ON
+	#else
+		#define SOL_DLL_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(DLL_) || defined(_DLL))
+	#define SOL_DLL_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_DLL_I_ SOL_DEFAULT_OFF
+#endif // DLL definition
+
+#if defined(SOL_HEADER_ONLY)
+	#if (SOL_HEADER_ONLY != 0)
+		#define SOL_HEADER_ONLY_I_ SOL_ON
+	#else
+		#define SOL_HEADER_ONLY_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_HEADER_ONLY_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_BUILD)
+	#if (SOL_BUILD != 0)
+		#define SOL_BUILD_I_ SOL_ON
+	#else
+		#define SOL_BUILD_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_BUILD_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_BUILD_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_UNITY_BUILD)
+	#if (SOL_UNITY_BUILD != 0)
+		#define SOL_UNITY_BUILD_I_ SOL_ON
+	#else
+		#define SOL_UNITY_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_UNITY_BUILD_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_C_FUNCTION_LINKAGE)
+	#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+		// C++
+		#define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
+	#else
+		// normal
+		#define SOL_C_FUNCTION_LINKAGE_I_
+	#endif // C++ or not
+#endif // Linkage specification for C functions
+
+#if defined(SOL_API_LINKAGE)
+	#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_DLL)
+		#if SOL_IS_ON(SOL_COMPILER_VCXX) || SOL_IS_ON(SOL_PLATFORM_WINDOWS) || SOL_IS_ON(SOL_PLATFORM_CYGWIN)
+			// MSVC Compiler; or, Windows, or Cygwin platforms
+			#if SOL_IS_ON(SOL_BUILD)
+				// Building the library
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					// Using GCC
+					#define SOL_API_LINKAGE_I_ __attribute__((dllexport))
+				#else
+					// Using Clang, MSVC, etc...
+					#define SOL_API_LINKAGE_I_ __declspec(dllexport)
+				#endif
+			#else
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					#define SOL_API_LINKAGE_I_ __attribute__((dllimport))
+				#else
+					#define SOL_API_LINKAGE_I_ __declspec(dllimport)
+				#endif
+			#endif
+		#else
+			// extern if building normally on non-MSVC
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#elif SOL_IS_ON(SOL_UNITY_BUILD)
+		// Built-in library, like how stb typical works
+		#if SOL_IS_ON(SOL_HEADER_ONLY)
+			// Header only, so functions are defined "inline"
+			#define SOL_API_LINKAGE_I_ inline
+		#else
+			// Not header only, so seperately compiled files
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#else
+		// Normal static library
+		#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+			#define SOL_API_LINKAGE_I_
+		#else
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#endif // DLL or not
+#endif // Build definitions
+
+#if defined(SOL_PUBLIC_FUNC_DECL)
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_PUBLIC_FUNC_DECL
+#else
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DECL_)
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_INTERNAL_FUNC_DECL_
+#else
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_PUBLIC_FUNC_DEF)
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_PUBLIC_FUNC_DEF
+#else
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DEF)
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_INTERNAL_FUNC_DEF
+#else
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_FUNC_DECL)
+	#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_FUNC_DEFN)
+	#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DEFN_I_ __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DEFN_I_ __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DEFN_I_
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DECL)
+	#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DEFN)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#else
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
+	#else
+		#define SOL_HIDDEN_FUNC_DEFN_I_
+	#endif
+#endif
+
+// end of sol/detail/build_version.hpp
+
+// end of sol/version.hpp
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_packaged_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using packaged_coroutine = basic_packaged_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+#endif // SOL_SINGLE_INCLUDE_FORWARD_HPP
diff --git a/src/lualib/sol/sol.hpp b/src/lualib/sol/sol.hpp
new file mode 100644
index 0000000000..8b0b7d36ea
--- /dev/null
+++ b/src/lualib/sol/sol.hpp
@@ -0,0 +1,28907 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// This file was generated with a script.
+// Generated 2022-06-25 08:14:19.151876 UTC
+// This header was generated with sol v3.3.0 (revision eba86625)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_HPP
+#define SOL_SINGLE_INCLUDE_HPP
+
+// beginning of sol/sol.hpp
+
+#ifndef SOL_HPP
+#define SOL_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 2
+#define SOL_VERSION_PATCH 3
+#define SOL_VERSION_STRING "3.2.3"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN) #_TOKEN
+#define SOL_TOKEN_TO_STRING_I_(_TOKEN) SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN)
+
+#define SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT) _LEFT##_RIGHT
+#define SOL_CONCAT_TOKENS_I_(_LEFT, _RIGHT) SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT)
+
+#define SOL_RAW_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_RAW_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_IS_ON(OP_SYMBOL) SOL_RAW_IS_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_OFF(OP_SYMBOL) SOL_RAW_IS_OFF(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL ## _I_)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(SOL_BUILD_CXX_MODE)
+	#if (SOL_BUILD_CXX_MODE != 0)
+		#define SOL_BUILD_CXX_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_CXX_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__cplusplus)
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_BUILD_C_MODE)
+	#if (SOL_BUILD_C_MODE != 0)
+		#define SOL_BUILD_C_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_C_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__STDC__)
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_C_MODE)
+	#include <stddef.h>
+	#include <stdint.h>
+	#include <limits.h>
+#else
+	#include <cstddef>
+	#include <cstdint>
+	#include <climits>
+#endif
+
+#if defined(SOL_COMPILER_VCXX)
+	#if defined(SOL_COMPILER_VCXX != 0)
+		#define SOL_COMPILER_VCXX_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_VCXX_I_ SOL_OFF
+	#endif
+#elif defined(_MSC_VER)
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_GCC)
+	#if defined(SOL_COMPILER_GCC != 0)
+		#define SOL_COMPILER_GCC_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_GCC_I_ SOL_OFF
+	#endif
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_CLANG)
+	#if defined(SOL_COMPILER_CLANG != 0)
+		#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#endif
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_EDG)
+	#if defined(SOL_COMPILER_EDG != 0)
+		#define SOL_COMPILER_EDG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_EDG_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_COMPILER_EDG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_MINGW)
+	#if (SOL_COMPILER_MINGW != 0)
+		#define SOL_COMPILER_MINGW_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_MINGW_I_ SOL_OFF
+	#endif
+#elif defined(__MINGW32__)
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(SOL_PLATFORM_WINDOWS)
+	#if (SOL_PLATFORM_WINDOWS != 0)
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+	#endif
+#elif defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_CYGWIN)
+	#if (SOL_PLATFORM_CYGWIN != 0)
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#endif
+#elif defined(__CYGWIN__)
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_APPLE)
+	#if (SOL_PLATFORM_APPLE != 0)
+		#define SOL_PLATFORM_APPLE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+	#endif
+#elif defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_UNIX)
+	#if (SOL_PLATFORM_UNIX != 0)
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_LINUX)
+	#if (SOL_PLATFORM_LINUX != 0)
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__LINUX__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL)
+	#if SOL_NO_THREAD_LOCAL != 0
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+	#else
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON)
+	#if SOL_ALL_SAFETIES_ON != 0
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+	#else
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER)
+	#if SOL_SAFE_GETTER != 0
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE)
+	#if SOL_SAFE_USERTYPE != 0
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES)
+	#if SOL_SAFE_REFERENCES != 0
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTIONS)
+	#if SOL_SAFE_FUNCTIONS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#elif defined (SOL_SAFE_FUNCTION_OBJECTS)
+	#if SOL_SAFE_FUNCTION_OBJECTS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS)
+	#if SOL_SAFE_FUNCTION_CALLS != 0
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES)
+	#if SOL_SAFE_PROXIES != 0
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS)
+	#if SOL_SAFE_NUMERICS != 0
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_ALL_INTEGER_VALUES_FIT)
+	#if (SOL_ALL_INTEGER_VALUES_FIT != 0)
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_ON
+	#else
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_OFF
+	#endif
+#elif !SOL_IS_DEFAULT_OFF(SOL_SAFE_NUMERICS) && SOL_IS_OFF(SOL_SAFE_NUMERICS)
+	// if numerics is intentionally turned off, flip this on
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_ON
+#else
+	// default to off
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK)
+	#if SOL_SAFE_STACK_CHECK != 0
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_CHECK_NUMBER_PRECISION)
+	#if SOL_NO_CHECK_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#elif defined(SOL_NO_CHECKING_NUMBER_PRECISION)
+	#if SOL_NO_CHECKING_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP)
+	#if SOL_ENABLE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_INTEROP)
+	#if SOL_USE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG) && SOL_IS_ON(SOL_PLATFORM_APPLE)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR)
+	#if (SOL_DEFAULT_PASS_ON_ERROR != 0)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	#if (SOL_FUNCTION_CALL_VALUE_SEMANTICS != 0)
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_ON
+	#else
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_MINGW_CCTYPE_IS_POISONED)
+	#if (SOL_MINGW_CCTYPE_IS_POISONED != 0)
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+	#else
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_MINGW) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_CHAR8_T)
+	#if (SOL_CHAR8_T != 0)
+		#define SOL_CHAR8_T_I_ SOL_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_char8_t)
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	#include <boost/version.hpp>
+
+	#if BOOST_VERSION >= 107500 // Since Boost 1.75.0 boost::none is constexpr
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+	#else
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ const
+	#endif // BOOST_VERSION
+#else
+	// assume boost isn't using a garbage version
+	#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+#endif
+
+#if defined(SOL2_CI)
+	#if (SOL2_CI != 0)
+		#define SOL2_CI_I_ SOL_ON
+	#else
+		#define SOL2_CI_I_ SOL_OFF
+	#endif
+#else
+	#define SOL2_CI_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_C_ASSERT)
+	#define SOL_USER_C_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_C_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_M_ASSERT)
+	#define SOL_USER_M_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_M_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+// beginning of sol/prologue.hpp
+
+#if defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue was already included in translation unit and not properly ended with an epilogue."
+#endif
+
+#define SOL_PROLOGUE_I_ 1
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
+
+	#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
+	#else
+		#include <type_traits>
+		
+		#define _MOVE(...) static_cast<::std::remove_reference_t<( __VA_ARGS__ )>&&>( __VA_OPT__(,) )
+	#endif
+#endif
+
+// end of sol/prologue.hpp
+
+// beginning of sol/epilogue.hpp
+
+#if !defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue is missing from this translation unit."
+#else
+	#undef SOL_PROLOGUE_I_
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#undef _FWD
+	#undef _MOVE
+#endif
+
+// end of sol/epilogue.hpp
+
+// beginning of sol/detail/build_version.hpp
+
+#if defined(SOL_DLL)
+	#if (SOL_DLL != 0)
+		#define SOL_DLL_I_ SOL_ON
+	#else
+		#define SOL_DLL_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(DLL_) || defined(_DLL))
+	#define SOL_DLL_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_DLL_I_ SOL_DEFAULT_OFF
+#endif // DLL definition
+
+#if defined(SOL_HEADER_ONLY)
+	#if (SOL_HEADER_ONLY != 0)
+		#define SOL_HEADER_ONLY_I_ SOL_ON
+	#else
+		#define SOL_HEADER_ONLY_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_HEADER_ONLY_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_BUILD)
+	#if (SOL_BUILD != 0)
+		#define SOL_BUILD_I_ SOL_ON
+	#else
+		#define SOL_BUILD_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_BUILD_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_BUILD_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_UNITY_BUILD)
+	#if (SOL_UNITY_BUILD != 0)
+		#define SOL_UNITY_BUILD_I_ SOL_ON
+	#else
+		#define SOL_UNITY_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_UNITY_BUILD_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_C_FUNCTION_LINKAGE)
+	#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+		// C++
+		#define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
+	#else
+		// normal
+		#define SOL_C_FUNCTION_LINKAGE_I_
+	#endif // C++ or not
+#endif // Linkage specification for C functions
+
+#if defined(SOL_API_LINKAGE)
+	#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_DLL)
+		#if SOL_IS_ON(SOL_COMPILER_VCXX) || SOL_IS_ON(SOL_PLATFORM_WINDOWS) || SOL_IS_ON(SOL_PLATFORM_CYGWIN)
+			// MSVC Compiler; or, Windows, or Cygwin platforms
+			#if SOL_IS_ON(SOL_BUILD)
+				// Building the library
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					// Using GCC
+					#define SOL_API_LINKAGE_I_ __attribute__((dllexport))
+				#else
+					// Using Clang, MSVC, etc...
+					#define SOL_API_LINKAGE_I_ __declspec(dllexport)
+				#endif
+			#else
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					#define SOL_API_LINKAGE_I_ __attribute__((dllimport))
+				#else
+					#define SOL_API_LINKAGE_I_ __declspec(dllimport)
+				#endif
+			#endif
+		#else
+			// extern if building normally on non-MSVC
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#elif SOL_IS_ON(SOL_UNITY_BUILD)
+		// Built-in library, like how stb typical works
+		#if SOL_IS_ON(SOL_HEADER_ONLY)
+			// Header only, so functions are defined "inline"
+			#define SOL_API_LINKAGE_I_ inline
+		#else
+			// Not header only, so seperately compiled files
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#else
+		// Normal static library
+		#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+			#define SOL_API_LINKAGE_I_
+		#else
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#endif // DLL or not
+#endif // Build definitions
+
+#if defined(SOL_PUBLIC_FUNC_DECL)
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_PUBLIC_FUNC_DECL
+#else
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DECL_)
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_INTERNAL_FUNC_DECL_
+#else
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_PUBLIC_FUNC_DEF)
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_PUBLIC_FUNC_DEF
+#else
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DEF)
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_INTERNAL_FUNC_DEF
+#else
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_FUNC_DECL)
+	#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_FUNC_DEFN)
+	#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DEFN_I_ __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DEFN_I_ __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DEFN_I_
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DECL)
+	#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DEFN)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#else
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
+	#else
+		#define SOL_HIDDEN_FUNC_DEFN_I_
+	#endif
+#endif
+
+// end of sol/detail/build_version.hpp
+
+// end of sol/version.hpp
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
+#ifdef check
+#pragma push_macro("check")
+#undef check
+#endif
+#endif // Unreal Engine 4 Bullshit
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wconversion"
+#if __GNUC__ > 6
+#pragma GCC diagnostic ignored "-Wnoexcept-type"
+#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+#pragma warning(push)
+#pragma warning(disable : 4505) // unreferenced local function has been removed GEE THANKS
+#endif                          // clang++ vs. g++ vs. VC++
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_packaged_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using packaged_coroutine = basic_packaged_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+// beginning of sol/forward_detail.hpp
+
+#ifndef SOL_FORWARD_DETAIL_HPP
+#define SOL_FORWARD_DETAIL_HPP
+
+// beginning of sol/traits.hpp
+
+// beginning of sol/tuple.hpp
+
+// beginning of sol/base_traits.hpp
+
+#include <type_traits>
+
+namespace sol {
+	namespace detail {
+		struct unchecked_t { };
+		const unchecked_t unchecked = unchecked_t {};
+	} // namespace detail
+
+	namespace meta {
+		using sfinae_yes_t = std::true_type;
+		using sfinae_no_t = std::false_type;
+
+		template <typename...>
+		using void_t = void;
+
+		template <typename T>
+		using unqualified = std::remove_cv<std::remove_reference_t<T>>;
+
+		template <typename T>
+		using unqualified_t = typename unqualified<T>::type;
+
+		namespace meta_detail {
+			template <typename T>
+			struct unqualified_non_alias : unqualified<T> { };
+
+			template <template <class...> class Test, class, class... Args>
+			struct is_detected : std::false_type { };
+
+			template <template <class...> class Test, class... Args>
+			struct is_detected<Test, void_t<Test<Args...>>, Args...> : std::true_type { };
+		} // namespace meta_detail
+
+		template <template <class...> class Trait, class... Args>
+		using is_detected = typename meta_detail::is_detected<Trait, void, Args...>::type;
+
+		template <template <class...> class Trait, class... Args>
+		constexpr inline bool is_detected_v = is_detected<Trait, Args...>::value;
+
+		template <std::size_t I>
+		using index_value = std::integral_constant<std::size_t, I>;
+
+		template <bool>
+		struct conditional {
+			template <typename T, typename U>
+			using type = T;
+		};
+
+		template <>
+		struct conditional<false> {
+			template <typename T, typename U>
+			using type = U;
+		};
+
+		template <bool B, typename T, typename U>
+		using conditional_t = typename conditional<B>::template type<T, U>;
+
+		namespace meta_detail {
+			template <typename T, template <typename...> class Templ>
+			struct is_specialization_of : std::false_type { };
+			template <typename... T, template <typename...> class Templ>
+			struct is_specialization_of<Templ<T...>, Templ> : std::true_type { };
+		} // namespace meta_detail
+
+		template <typename T, template <typename...> class Templ>
+		using is_specialization_of = meta_detail::is_specialization_of<std::remove_cv_t<T>, Templ>;
+
+		template <typename T, template <typename...> class Templ>
+		inline constexpr bool is_specialization_of_v = is_specialization_of<std::remove_cv_t<T>, Templ>::value;
+
+		template <typename T>
+		struct identity {
+			typedef T type;
+		};
+
+		template <typename T>
+		using identity_t = typename identity<T>::type;
+
+		template <typename T>
+		using is_builtin_type = std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_pointer<T>::value || std::is_array<T>::value>;
+
+		namespace meta_detail {
+			template <typename T, typename = void>
+			struct has_internal_marker_impl : std::false_type { };
+			template <typename T>
+			struct has_internal_marker_impl<T, void_t<typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_>> : std::true_type { };
+
+			template <typename T>
+			using has_internal_marker = has_internal_marker_impl<T>;
+
+			template <typename T>
+			constexpr inline bool has_internal_marker_v = has_internal_marker<T>::value;
+		} // namespace meta_detail
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/base_traits.hpp
+
+#include <tuple>
+#include <cstddef>
+
+namespace sol {
+	namespace detail {
+		using swallow = std::initializer_list<int>;
+	} // namespace detail
+
+	namespace meta {
+		template <typename T>
+		using is_tuple = is_specialization_of<T, std::tuple>;
+
+		template <typename T>
+		constexpr inline bool is_tuple_v = is_tuple<T>::value;
+
+		namespace detail {
+			template <typename... Args>
+			struct tuple_types_ {
+				typedef types<Args...> type;
+			};
+
+			template <typename... Args>
+			struct tuple_types_<std::tuple<Args...>> {
+				typedef types<Args...> type;
+			};
+		} // namespace detail
+
+		template <typename... Args>
+		using tuple_types = typename detail::tuple_types_<Args...>::type;
+
+		template <typename Arg>
+		struct pop_front_type;
+
+		template <typename Arg>
+		using pop_front_type_t = typename pop_front_type<Arg>::type;
+
+		template <typename... Args>
+		struct pop_front_type<types<Args...>> {
+			typedef void front_type;
+			typedef types<Args...> type;
+		};
+
+		template <typename Arg, typename... Args>
+		struct pop_front_type<types<Arg, Args...>> {
+			typedef Arg front_type;
+			typedef types<Args...> type;
+		};
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element = std::tuple_element<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element_t = std::tuple_element_t<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element = unqualified<tuple_element_t<N, Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element_t = unqualified_t<tuple_element_t<N, Tuple>>;
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/tuple.hpp
+
+// beginning of sol/bind_traits.hpp
+
+namespace sol { namespace meta {
+	namespace meta_detail {
+		template <typename F>
+		using detect_deducible_signature = decltype(&F::operator());
+	} // namespace meta_detail
+
+	template <typename F>
+	using call_operator_deducible = typename is_detected<meta_detail::detect_deducible_signature, F>::type;
+
+	template <typename F>
+	constexpr inline bool call_operator_deducible_v = call_operator_deducible<F>::value;
+
+	namespace meta_detail {
+
+		template <std::size_t I, typename T>
+		struct void_tuple_element : meta::tuple_element<I, T> { };
+
+		template <std::size_t I>
+		struct void_tuple_element<I, std::tuple<>> {
+			typedef void type;
+		};
+
+		template <std::size_t I, typename T>
+		using void_tuple_element_t = typename void_tuple_element<I, T>::type;
+
+		template <bool it_is_noexcept, bool has_c_variadic, typename T, typename R, typename... Args>
+		struct basic_traits {
+		private:
+			using first_type = meta::conditional_t<std::is_void<T>::value, int, T>&;
+
+		public:
+			inline static constexpr const bool is_noexcept = it_is_noexcept;
+			inline static constexpr bool is_member_function = std::is_void<T>::value;
+			inline static constexpr bool has_c_var_arg = has_c_variadic;
+			inline static constexpr std::size_t arity = sizeof...(Args);
+			inline static constexpr std::size_t free_arity = sizeof...(Args) + static_cast<std::size_t>(!std::is_void<T>::value);
+			typedef types<Args...> args_list;
+			typedef std::tuple<Args...> args_tuple;
+			typedef T object_type;
+			typedef R return_type;
+			typedef tuple_types<R> returns_list;
+			typedef R(function_type)(Args...);
+			typedef meta::conditional_t<std::is_void<T>::value, args_list, types<first_type, Args...>> free_args_list;
+			typedef meta::conditional_t<std::is_void<T>::value, R(Args...), R(first_type, Args...)> free_function_type;
+			typedef meta::conditional_t<std::is_void<T>::value, R (*)(Args...), R (*)(first_type, Args...)> free_function_pointer_type;
+			typedef std::remove_pointer_t<free_function_pointer_type> signature_type;
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+		template <typename Signature, bool b = call_operator_deducible<Signature>::value>
+		struct fx_traits : public basic_traits<false, false, void, void> { };
+
+		// Free Functions
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...), false> : public basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...), false> : public basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		// Member Functions
+		/* C-Style Variadics */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...), false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...), false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};
+
+#endif // noexcept is part of a function's type
+
+#if SOL_IS_ON(SOL_COMPILER_VCXX) && SOL_IS_ON(SOL_PLATFORM_X86)
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...), false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall cannot be applied to functions with varargs*/
+		/*template <typename R, typename... Args>
+		struct fx_traits<__stdcall R(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (__stdcall *)(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) & noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) & noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) && noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) && noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};*/
+#endif // noexcept is part of a function's type
+#endif // __stdcall x86 VC++ bug
+
+		template <typename Signature>
+		struct fx_traits<Signature, true> : public fx_traits<typename fx_traits<decltype(&Signature::operator())>::function_type, false> { };
+
+		template <typename Signature, bool b = std::is_member_object_pointer<Signature>::value>
+		struct callable_traits : public fx_traits<std::decay_t<Signature>> { };
+
+		template <typename R, typename T>
+		struct callable_traits<R(T::*), true> {
+			typedef meta::conditional_t<std::is_array_v<R>, std::add_lvalue_reference_t<R>, R> return_type;
+			typedef return_type Arg;
+			typedef T object_type;
+			using signature_type = R(T::*);
+			inline static constexpr bool is_noexcept = false;
+			inline static constexpr bool is_member_function = false;
+			inline static constexpr std::size_t arity = 1;
+			inline static constexpr std::size_t free_arity = 2;
+			typedef std::tuple<Arg> args_tuple;
+			typedef types<Arg> args_list;
+			typedef types<T, Arg> free_args_list;
+			typedef meta::tuple_types<return_type> returns_list;
+			typedef return_type(function_type)(T&, return_type);
+			typedef return_type (*function_pointer_type)(T&, Arg);
+			typedef return_type (*free_function_pointer_type)(T&, Arg);
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+	} // namespace meta_detail
+
+	template <typename Signature>
+	using bind_traits = meta_detail::callable_traits<Signature>;
+
+	namespace meta_detail {
+		template <typename, bool>
+		struct is_probably_stateless_lambda : std::false_type { };
+
+		template <typename T>
+		struct is_probably_stateless_lambda<T, true> : std::is_convertible<T, typename bind_traits<T>::function_type*>::type { };
+	} // namespace meta_detail
+
+	template <typename T>
+	using is_probably_stateless_lambda = typename meta_detail::is_probably_stateless_lambda<T, std::is_empty_v<T> && call_operator_deducible_v<T>>::type;
+
+	template <typename T>
+	inline constexpr bool is_probably_stateless_lambda_v = is_probably_stateless_lambda<T>::value;
+
+	template <typename Signature>
+	using function_args_t = typename bind_traits<Signature>::args_list;
+
+	template <typename Signature>
+	using function_signature_t = typename bind_traits<Signature>::signature_type;
+
+	template <typename Signature>
+	using function_return_t = typename bind_traits<Signature>::return_type;
+}} // namespace sol::meta
+
+// end of sol/bind_traits.hpp
+
+// beginning of sol/pointer_like.hpp
+
+#include <utility>
+#include <type_traits>
+#include <memory>
+
+namespace sol {
+
+	namespace meta {
+		namespace meta_detail {
+			template <typename T>
+			using is_dereferenceable_test = decltype(*std::declval<T>());
+
+			template <typename T>
+			using is_explicitly_dereferenceable_test = decltype(std::declval<T>().operator*());
+		} // namespace meta_detail
+
+		template <typename T>
+		using is_pointer_like = std::integral_constant<bool,
+		     !std::is_array_v<T> && (std::is_pointer_v<T> || is_detected_v<meta_detail::is_explicitly_dereferenceable_test, T>)>;
+
+		template <typename T>
+		constexpr inline bool is_pointer_like_v = is_pointer_like<T>::value;
+	} // namespace meta
+
+	namespace detail {
+
+		template <typename T>
+		auto unwrap(T&& item) -> decltype(std::forward<T>(item)) {
+			return std::forward<T>(item);
+		}
+
+		template <typename T>
+		T& unwrap(std::reference_wrapper<T> arg) {
+			return arg.get();
+		}
+
+		template <typename T>
+		inline decltype(auto) deref(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline decltype(auto) deref_move_only(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu> && !std::is_pointer_v<Tu> && !std::is_copy_constructible_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline T* ptr(T& val) {
+			return std::addressof(val);
+		}
+
+		template <typename T>
+		inline T* ptr(std::reference_wrapper<T> val) {
+			return std::addressof(val.get());
+		}
+
+		template <typename T>
+		inline T* ptr(T* val) {
+			return val;
+		}
+	} // namespace detail
+} // namespace sol
+
+// end of sol/pointer_like.hpp
+
+// beginning of sol/string_view.hpp
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <functional>
+
+namespace sol {
+	template <typename C, typename T = std::char_traits<C>>
+	using basic_string_view = std::basic_string_view<C, T>;
+
+	typedef std::string_view string_view;
+	typedef std::wstring_view wstring_view;
+	typedef std::u16string_view u16string_view;
+	typedef std::u32string_view u32string_view;
+	typedef std::hash<std::string_view> string_view_hash;
+} // namespace sol
+
+// end of sol/string_view.hpp
+
+#include <type_traits>
+#include <cstdint>
+#include <memory>
+#include <functional>
+#include <array>
+#include <iterator>
+#include <iosfwd>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant is weird on XCode, thanks XCode
+
+namespace sol { namespace meta {
+	template <typename T>
+	struct unwrapped {
+		typedef T type;
+	};
+
+	template <typename T>
+	struct unwrapped<std::reference_wrapper<T>> {
+		typedef T type;
+	};
+
+	template <typename T>
+	using unwrapped_t = typename unwrapped<T>::type;
+
+	template <typename T>
+	struct unwrap_unqualified : unwrapped<unqualified_t<T>> { };
+
+	template <typename T>
+	using unwrap_unqualified_t = typename unwrap_unqualified<T>::type;
+
+	template <typename T>
+	struct remove_member_pointer;
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*> {
+		typedef R type;
+	};
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*const> {
+		typedef R type;
+	};
+
+	template <typename T>
+	using remove_member_pointer_t = remove_member_pointer<T>;
+
+	template <typename T, typename...>
+	struct all_same : std::true_type { };
+
+	template <typename T, typename U, typename... Args>
+	struct all_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value && all_same<T, Args...>::value> { };
+
+	template <typename T, typename...>
+	struct any_same : std::false_type { };
+
+	template <typename T, typename U, typename... Args>
+	struct any_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value || any_same<T, Args...>::value> { };
+
+	template <typename T, typename... Args>
+	constexpr inline bool any_same_v = any_same<T, Args...>::value;
+
+	template <bool B>
+	using boolean = std::integral_constant<bool, B>;
+
+	template <bool B>
+	constexpr inline bool boolean_v = boolean<B>::value;
+
+	template <typename T>
+	using neg = boolean<!T::value>;
+
+	template <typename T>
+	constexpr inline bool neg_v = neg<T>::value;
+
+	template <typename... Args>
+	struct all : boolean<true> { };
+
+	template <typename T, typename... Args>
+	struct all<T, Args...> : std::conditional_t<T::value, all<Args...>, boolean<false>> { };
+
+	template <typename... Args>
+	struct any : boolean<false> { };
+
+	template <typename T, typename... Args>
+	struct any<T, Args...> : std::conditional_t<T::value, boolean<true>, any<Args...>> { };
+
+	template <typename... Args>
+	constexpr inline bool all_v = all<Args...>::value;
+
+	template <typename... Args>
+	constexpr inline bool any_v = any<Args...>::value;
+
+	enum class enable_t { _ };
+
+	constexpr const auto enabler = enable_t::_;
+
+	template <bool value, typename T = void>
+	using disable_if_t = std::enable_if_t<!value, T>;
+
+	template <typename... Args>
+	using enable = std::enable_if_t<all<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable = std::enable_if_t<neg<all<Args...>>::value, enable_t>;
+
+	template <typename... Args>
+	using enable_any = std::enable_if_t<any<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable_any = std::enable_if_t<neg<any<Args...>>::value, enable_t>;
+
+	template <typename V, typename... Vs>
+	struct find_in_pack_v : boolean<false> { };
+
+	template <typename V, typename Vs1, typename... Vs>
+	struct find_in_pack_v<V, Vs1, Vs...> : any<boolean<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> { };
+
+	namespace meta_detail {
+		template <std::size_t I, typename T, typename... Args>
+		struct index_in_pack : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+		template <std::size_t I, typename T, typename T1, typename... Args>
+		struct index_in_pack<I, T, T1, Args...>
+		: conditional_t<std::is_same<T, T1>::value, std::integral_constant<std::ptrdiff_t, I>, index_in_pack<I + 1, T, Args...>> { };
+	} // namespace meta_detail
+
+	template <typename T, typename... Args>
+	struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> { };
+
+	template <typename T, typename List>
+	struct index_in : meta_detail::index_in_pack<0, T, List> { };
+
+	template <typename T, typename... Args>
+	struct index_in<T, types<Args...>> : meta_detail::index_in_pack<0, T, Args...> { };
+
+	template <std::size_t I, typename... Args>
+	struct at_in_pack { };
+
+	template <std::size_t I, typename... Args>
+	using at_in_pack_t = typename at_in_pack<I, Args...>::type;
+
+	template <std::size_t I, typename Arg, typename... Args>
+	struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> { };
+
+	template <typename Arg, typename... Args>
+	struct at_in_pack<0, Arg, Args...> {
+		typedef Arg type;
+	};
+
+	namespace meta_detail {
+		template <typename, typename TI>
+		using on_even = meta::boolean<(TI::value % 2) == 0>;
+
+		template <typename, typename TI>
+		using on_odd = meta::boolean<(TI::value % 2) == 1>;
+
+		template <typename, typename>
+		using on_always = std::true_type;
+
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename... Ts>
+		struct count_when_for_pack : std::integral_constant<std::size_t, 0> { };
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename T, typename... Ts>
+			          struct count_when_for_pack<When, Limit, I, Pred, T, Ts...> : conditional_t < sizeof...(Ts)
+			     == 0
+			|| Limit<2, std::integral_constant<std::size_t, I + static_cast<std::size_t>(Limit != 0 && Pred<T>::value)>,
+			     count_when_for_pack<When, Limit - static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value),
+			          I + static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value&& Pred<T>::value), Pred, Ts...>> { };
+	} // namespace meta_detail
+
+	template <template <typename...> class Pred, typename... Ts>
+	struct count_for_pack : meta_detail::count_when_for_pack<meta_detail::on_always, sizeof...(Ts), 0, Pred, Ts...> { };
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_pack_v = count_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename List>
+	struct count_for;
+
+	template <template <typename...> class Pred, typename... Args>
+	struct count_for<Pred, types<Args...>> : count_for_pack<Pred, Args...> { };
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_for_to_pack : meta_detail::count_when_for_pack<meta_detail::on_always, Limit, 0, Pred, Ts...> { };
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_to_pack_v = count_for_to_pack<Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_when_for_to_pack : meta_detail::count_when_for_pack<When, Limit, 0, Pred, Ts...> { };
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_when_for_to_pack_v = count_when_for_to_pack<When, Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_even_for_pack = count_when_for_to_pack<meta_detail::on_even, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_even_for_pack_v = count_even_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_odd_for_pack = count_when_for_to_pack<meta_detail::on_odd, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_odd_for_pack_v = count_odd_for_pack<Pred, Ts...>::value;
+
+	template <typename... Args>
+	struct return_type {
+		typedef std::tuple<Args...> type;
+	};
+
+	template <typename T>
+	struct return_type<T> {
+		typedef T type;
+	};
+
+	template <>
+	struct return_type<> {
+		typedef void type;
+	};
+
+	template <typename... Args>
+	using return_type_t = typename return_type<Args...>::type;
+
+	namespace meta_detail {
+		template <typename>
+		struct always_true : std::true_type { };
+		struct is_invokable_tester {
+			template <typename Fun, typename... Args>
+			static always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+			template <typename...>
+			static std::false_type test(...);
+		};
+	} // namespace meta_detail
+
+	template <typename T>
+	struct is_invokable;
+	template <typename Fun, typename... Args>
+	struct is_invokable<Fun(Args...)> : decltype(meta_detail::is_invokable_tester::test<Fun, Args...>(0)) { };
+
+	namespace meta_detail {
+
+		template <typename T, typename = void>
+		struct is_invocable : std::is_function<std::remove_pointer_t<T>> { };
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_same<decltype(void(&T::operator())), void>::value>> { };
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F { };
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && !std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F {
+				~Derived() = delete;
+			};
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		struct has_begin_end_impl {
+			template <typename T, typename U = unqualified_t<T>, typename B = decltype(std::declval<U&>().begin()),
+				typename E = decltype(std::declval<U&>().end())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_type_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::key_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_comp_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().key_comp())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_load_factor_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().load_factor())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_mapped_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::mapped_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_value_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::value_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_iterator_impl {
+			template <typename T, typename V = typename unqualified_t<T>::iterator>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_value_pair_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::value_type, typename F = decltype(std::declval<V&>().first),
+				typename S = decltype(std::declval<V&>().second)>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		template <typename T>
+		struct has_push_back_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_insert_with_iterator_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert(
+				std::declval<std::add_rvalue_reference_t<typename C::iterator>>(), std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = !std::is_same_v<decltype(test<T>(0)), sfinae_no_t>;
+		};
+
+		template <typename T>
+		struct has_insert_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = !std::is_same_v<decltype(test<T>(0)), sfinae_no_t>;
+		};
+
+		template <typename T>
+		struct has_insert_after_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(),
+				std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_max_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().max_size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_to_string_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().to_string())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_less_test<T, U, void_t<decltype(std::declval<T&>() < std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_equal_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_equal_test<T, U, void_t<decltype(std::declval<T&>() == std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_equal_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_less_equal_test<T, U, void_t<decltype(std::declval<T&>() <= std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_left_shift_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_left_shift_test<T, U, void_t<decltype(std::declval<T&>() << std::declval<U&>())>> : public std::true_type { };
+
+		template <typename T, typename = void>
+		class supports_adl_to_string_test : public std::false_type { };
+		template <typename T>
+		class supports_adl_to_string_test<T, void_t<decltype(to_string(std::declval<const T&>()))>> : public std::true_type { };
+
+		template <typename T, bool b>
+		struct is_matched_lookup_impl : std::false_type { };
+		template <typename T>
+		struct is_matched_lookup_impl<T, true> : std::is_same<typename T::key_type, typename T::value_type> { };
+
+		template <typename T>
+		using non_void_t = meta::conditional_t<std::is_void_v<T>, ::sol::detail::unchecked_t, T>;
+	} // namespace meta_detail
+
+	template <typename T, typename U = T>
+	class supports_op_less : public meta_detail::supports_op_less_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_equal : public meta_detail::supports_op_equal_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_less_equal : public meta_detail::supports_op_less_equal_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_left_shift : public meta_detail::supports_op_left_shift_test<T, U> { };
+
+	template <typename T>
+	class supports_adl_to_string : public meta_detail::supports_adl_to_string_test<T> { };
+
+	template <typename T>
+	class supports_to_string_member : public meta::boolean<meta_detail::has_to_string_test<meta_detail::non_void_t<T>>::value> { };
+
+	template <typename T>
+	using is_invocable = boolean<meta_detail::is_invocable<T>::value>;
+
+	template <typename T>
+	constexpr inline bool is_invocable_v = is_invocable<T>::value;
+
+	template <typename T>
+	struct has_begin_end : decltype(meta_detail::has_begin_end_impl::test<T>(0)) { };
+
+	template <typename T>
+	constexpr inline bool has_begin_end_v = has_begin_end<T>::value;
+
+	template <typename T>
+	struct has_key_value_pair : decltype(meta_detail::has_key_value_pair_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_key_type : decltype(meta_detail::has_key_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_key_comp : decltype(meta_detail::has_key_comp_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_load_factor : decltype(meta_detail::has_load_factor_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_mapped_type : decltype(meta_detail::has_mapped_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_iterator : decltype(meta_detail::has_iterator_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_value_type : decltype(meta_detail::has_value_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	using has_push_back = meta::boolean<meta_detail::has_push_back_test<T>::value>;
+
+	template <typename T>
+	using has_max_size = meta::boolean<meta_detail::has_max_size_test<T>::value>;
+
+	template <typename T>
+	using has_insert = meta::boolean<meta_detail::has_insert_test<T>::value>;
+
+	template <typename T>
+	using has_insert_with_iterator = meta::boolean<meta_detail::has_insert_with_iterator_test<T>::value>;
+
+	template <typename T>
+	using has_insert_after = meta::boolean<meta_detail::has_insert_after_test<T>::value>;
+
+	template <typename T>
+	using has_size = meta::boolean<meta_detail::has_size_test<T>::value>;
+
+	template <typename T>
+	using is_associative = meta::all<has_key_type<T>, has_key_value_pair<T>, has_mapped_type<T>>;
+
+	template <typename T>
+	using is_lookup = meta::all<has_key_type<T>, has_value_type<T>>;
+
+	template <typename T>
+	using is_ordered = meta::all<has_key_comp<T>, meta::neg<has_load_factor<T>>>;
+
+	template <typename T>
+	using is_matched_lookup = meta_detail::is_matched_lookup_impl<T, is_lookup<T>::value>;
+
+	template <typename T>
+	using is_initializer_list = meta::is_specialization_of<T, std::initializer_list>;
+
+	template <typename T>
+	constexpr inline bool is_initializer_list_v = is_initializer_list<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_literal_array_of = boolean<std::is_array_v<T> && std::is_same_v<std::remove_all_extents_t<T>, CharT>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_literal_array = boolean<std::is_array_v<T> && any_same_v<std::remove_all_extents_t<T>, char,
+#if SOL_IS_ON(SOL_CHAR8_T)
+	char8_t,
+#endif
+	char16_t, char32_t, wchar_t>>;
+
+	template <typename T>
+	constexpr inline bool is_string_literal_array_v = is_string_literal_array<T>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_of : std::false_type { };
+
+	template <typename CharT, typename CharTargetT, typename TraitsT, typename AllocT>
+	struct is_string_of<std::basic_string<CharT, TraitsT, AllocT>, CharTargetT> : std::is_same<CharT, CharTargetT> { };
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_of_v = is_string_of<T, CharT>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_view_of : std::false_type { };
+
+	template <typename CharT, typename CharTargetT, typename TraitsT>
+	struct is_string_view_of<std::basic_string_view<CharT, TraitsT>, CharTargetT> : std::is_same<CharT, CharTargetT> { };
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_view_of_v = is_string_view_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like
+		= meta::boolean<is_specialization_of_v<T, std::basic_string> || is_specialization_of_v<T, std::basic_string_view> || is_string_literal_array_v<T>>;
+
+	template <typename T>
+	constexpr inline bool is_string_like_v = is_string_like<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_constructible = meta::boolean<
+		is_string_literal_array_of_v<T,
+		     CharT> || std::is_same_v<T, const CharT*> || std::is_same_v<T, CharT> || is_string_of_v<T, CharT> || std::is_same_v<T, std::initializer_list<CharT>> || is_string_view_of_v<T, CharT> || std::is_null_pointer_v<T>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_constructible_v = is_string_constructible<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like_or_constructible = meta::boolean<is_string_like_v<T> || is_string_constructible_v<T>>;
+
+	template <typename T>
+	struct is_pair : std::false_type { };
+
+	template <typename T1, typename T2>
+	struct is_pair<std::pair<T1, T2>> : std::true_type { };
+
+	template <typename T, typename Char>
+	using is_c_str_of = any<std::is_same<T, const Char*>, std::is_same<T, Char const* const>, std::is_same<T, Char*>, is_string_literal_array_of<T, Char>>;
+
+	template <typename T, typename Char>
+	constexpr inline bool is_c_str_of_v = is_c_str_of<T, Char>::value;
+
+	template <typename T>
+	using is_c_str = is_c_str_of<T, char>;
+
+	template <typename T>
+	constexpr inline bool is_c_str_v = is_c_str<T>::value;
+
+	template <typename T, typename Char>
+	using is_c_str_or_string_of = any<is_c_str_of<T, Char>, is_string_of<T, Char>>;
+
+	template <typename T, typename Char>
+	constexpr inline bool is_c_str_or_string_of_v = is_c_str_or_string_of<T, Char>::value;
+
+	template <typename T>
+	using is_c_str_or_string = is_c_str_or_string_of<T, char>;
+
+	template <typename T>
+	constexpr inline bool is_c_str_or_string_v = is_c_str_or_string<T>::value;
+
+	template <typename T>
+	struct is_move_only : all<neg<std::is_reference<T>>, neg<std::is_copy_constructible<unqualified_t<T>>>, std::is_move_constructible<unqualified_t<T>>> { };
+
+	template <typename T>
+	using is_not_move_only = neg<is_move_only<T>>;
+
+	namespace meta_detail {
+		template <typename T>
+		decltype(auto) force_tuple(T&& x) {
+			if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>) {
+				return std::forward<T>(x);
+			}
+			else {
+				return std::tuple<T>(std::forward<T>(x));
+			}
+		}
+	} // namespace meta_detail
+
+	template <typename... X>
+	decltype(auto) tuplefy(X&&... x) {
+		return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
+	}
+
+	template <typename T, typename = void>
+	struct iterator_tag {
+		using type = std::input_iterator_tag;
+	};
+
+	template <typename T>
+	struct iterator_tag<T, conditional_t<false, typename std::iterator_traits<T>::iterator_category, void>> {
+		using type = typename std::iterator_traits<T>::iterator_category;
+	};
+
+}} // namespace sol::meta
+
+// end of sol/traits.hpp
+
+namespace sol {
+	namespace detail {
+		const bool default_safe_function_calls =
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_CALLS)
+		     true;
+#else
+		     false;
+#endif
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+	}} // namespace meta::meta_detail
+
+	namespace stack { namespace stack_detail {
+		using undefined_method_func = void (*)(stack_reference);
+
+		template <typename T>
+		void set_undefined_methods_on(stack_reference);
+
+		struct undefined_metatable;
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+#endif // SOL_FORWARD_DETAIL_HPP
+// end of sol/forward_detail.hpp
+
+// beginning of sol/assert.hpp
+
+#if SOL_IS_ON(SOL2_CI)
+
+struct pre_main {
+	pre_main() {
+#ifdef _MSC_VER
+		_set_abort_behavior(0, _WRITE_ABORT_MSG);
+#endif
+	}
+} inline sol2_ci_dont_lock_ci_please = {};
+
+#endif // Prevent lockup when doing Continuous Integration
+
+#if SOL_IS_ON(SOL_USER_C_ASSERT)
+	#define sol_c_assert(...) SOL_C_ASSERT(__VA_ARGS__)
+#else
+	#if SOL_IS_ON(SOL_DEBUG_BUILD)
+		#include <exception>
+		#include <iostream>
+		#include <cstdlib>
+
+			#define sol_c_assert(...)                                                                                               \
+				do {                                                                                                               \
+					if (!(__VA_ARGS__)) {                                                                                           \
+						std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << std::endl; \
+						std::terminate();                                                                                        \
+					}                                                                                                             \
+				} while (false)
+	#else
+		#define sol_c_assert(...)           \
+			do {                           \
+				if (false) {              \
+					(void)(__VA_ARGS__); \
+				}                         \
+			} while (false)
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USER_M_ASSERT)
+	#define sol_m_assert(message, ...) SOL_M_ASSERT(message, __VA_ARGS__)
+#else
+	#if SOL_IS_ON(SOL_DEBUG_BUILD)
+		#include <exception>
+		#include <iostream>
+		#include <cstdlib>
+
+		#define sol_m_assert(message, ...)                                                                                                         \
+			do {                                                                                                                                  \
+				if (!(__VA_ARGS__)) {                                                                                                              \
+					std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << ": " << message << std::endl; \
+					std::terminate();                                                                                                           \
+				}                                                                                                                                \
+			} while (false)
+	#else
+		#define sol_m_assert(message, ...)    \
+			do {                             \
+				if (false) {                \
+					(void)(__VA_ARGS__);   \
+					(void)sizeof(message); \
+				}                           \
+			} while (false)
+	#endif
+#endif
+
+// end of sol/assert.hpp
+
+// beginning of sol/bytecode.hpp
+
+// beginning of sol/compatibility.hpp
+
+// beginning of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA)
+	#include <lua.h>
+	#include <lualib.h>
+	#include <lauxlib.h>
+#elif SOL_IS_ON(SOL_USE_LUA_HPP)
+	#include <lua.hpp>
+#else
+	extern "C" {
+		#include <lua.h>
+		#include <lauxlib.h>
+		#include <lualib.h>
+	}
+#endif // C++ Mangling for Lua vs. Not
+
+#if defined(SOL_LUAJIT)
+	#if (SOL_LUAJIT != 0)
+		#define SOL_USE_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(LUAJIT_VERSION)
+	#define SOL_USE_LUAJIT_I_ SOL_ON
+#else
+	#define SOL_USE_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif // luajit
+
+#if SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+	#include <luajit.h>
+#elif SOL_IS_ON(SOL_USE_LUAJIT)
+	extern "C" {
+		#include <luajit.h>
+	}
+#endif // C++ LuaJIT ... whatever that means
+
+#if defined(SOL_LUAJIT_VERSION)
+	#define SOL_LUAJIT_VERSION_I_ SOL_LUAJIT_VERSION
+#elif SOL_IS_ON(SOL_USE_LUAJIT)
+	#define SOL_LUAJIT_VERSION_I_ LUAJIT_VERSION_NUM
+#else
+	#define SOL_LUAJIT_VERSION_I_ 0
+#endif
+
+#if defined(SOL_LUAJIT_FFI_DISABLED)
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
+#elif defined(LUAJIT_DISABLE_FFI)
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
+#else
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(MOONJIT_VERSION)
+	#define SOL_USE_MOONJIT_I_ SOL_ON
+#else
+	#define SOL_USE_MOONJIT_I_ SOL_OFF
+#endif
+
+#if !defined(SOL_LUA_VERSION)
+	#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif !defined(LUA_VERSION_NUM) || !(LUA_VERSION_NUM)
+		// Definitely 5.0
+		#define SOL_LUA_VERSION 500
+	#else
+		// ??? Not sure, assume latest?
+		#define SOL_LUA_VERSION 504
+	#endif // Lua Version 503, 502, 501 || luajit, 500
+#endif // SOL_LUA_VERSION
+
+#if defined(SOL_LUA_VERSION)
+	#define SOL_LUA_VERSION_I_ SOL_LUA_VERSION
+#else
+	#define SOL_LUA_VERSION_I_ 504
+#endif
+
+#if defined(SOL_EXCEPTIONS_ALWAYS_UNSAFE)
+	#if (SOL_EXCEPTIONS_ALWAYS_UNSAFE != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
+	#if (SOL_EXCEPTIONS_SAFE_PROPAGATION != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#elif SOL_LUAJIT_VERSION_I_ >= 20100
+	// LuaJIT 2.1.0-beta3 and better have exception support locked in for all platforms (mostly)
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#elif SOL_LUAJIT_VERSION_I_ >= 20000
+	// LuaJIT 2.0.x have exception support only on x64 builds
+	#if SOL_IS_ON(SOL_PLATFORM_X64)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#else
+	// otherwise, there is no exception safety for
+	// shoving exceptions through Lua and errors should
+	// always be serialized
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_EXCEPTIONS_CATCH_ALL)
+	#if (SOL_EXCEPTIONS_CATCH_ALL != 0)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_ON
+	#else
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_USE_LUAJIT)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#elif SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#elif SOL_IS_ON(SOL_USE_CXX_LUA)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#else
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_ON
+	#endif
+#endif
+
+#if defined(SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE)
+	#if (SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE != 0)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS) && SOL_IS_ON(SOL_USE_LUAJIT)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION)
+	#if (SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION != 0)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_USE_LUAJIT) && (SOL_LUA_VERSION > 501)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined (SOL_LUA_BIT32_LIB)
+	#if SOL_LUA_BIT32_LIB != 0
+		#define SOL_LUA_BIT32_LIB_I_ SOL_ON
+	#else
+		#define SOL_LUA_BIT32_LIB_I_ SOL_OFF
+	#endif
+#else
+	// Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
+	// Lua 5.2, or other versions of Lua with the compat flag, or Lua that is not 5.2 with the specific define (5.4.1 either removed it entirely or broke it)
+	#if (SOL_LUA_VERSION_I_ == 502) || (defined(LUA_COMPAT_BITLIB) && (LUA_COMPAT_BITLIB != 0)) || (SOL_LUA_VERSION_I_ < 504 && (defined(LUA_COMPAT_5_2) && (LUA_COMPAT_5_2 != 0)))
+		#define SOL_LUA_BIT32_LIB_I_ SOL_ON
+	#else
+		#define SOL_LUA_BIT32_LIB_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined (SOL_LUA_NIL_IN_TABLES)
+	#if SOL_LUA_NIL_IN_TABLES != 0
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_ON
+	#else
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_OFF
+	#endif
+#else
+	#if defined(LUA_NILINTABLE) && (LUA_NILINTABLE != 0)
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+// end of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_COMPATIBILITY_LAYER)
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+#ifndef COMPAT53_LUA_CPP
+#define COMPAT53_LUA_CPP 1
+#endif // Build Lua Compat layer as C++
+#endif
+#ifndef COMPAT53_INCLUDE_SOURCE
+#define COMPAT53_INCLUDE_SOURCE 1
+#endif // Build Compat Layer Inline
+
+// beginning of sol/compatibility/compat-5.3.h
+
+#ifndef KEPLER_PROJECT_COMPAT53_H_
+#define KEPLER_PROJECT_COMPAT53_H_
+
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#ifndef COMPAT53_PREFIX
+/* we chose this name because many other lua bindings / libs have
+* their own compatibility layer, and that use the compat53 declaration
+* frequently, causing all kinds of linker / compiler issues
+*/
+#  define COMPAT53_PREFIX kp_compat53
+#endif // COMPAT53_PREFIX
+
+#ifndef COMPAT53_API
+#  if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE
+#    if defined(__GNUC__) || defined(__clang__)
+#      define COMPAT53_API __attribute__((__unused__)) static inline 
+#    else
+#      define COMPAT53_API static inline 
+#    endif /* Clang/GCC */
+#  else /* COMPAT53_INCLUDE_SOURCE */
+/* we are not including source, so everything is extern */
+#      define COMPAT53_API extern
+#  endif /* COMPAT53_INCLUDE_SOURCE */
+#endif /* COMPAT53_PREFIX */
+
+#define COMPAT53_CONCAT_HELPER(a, b) a##b
+#define COMPAT53_CONCAT(a, b) COMPAT53_CONCAT_HELPER(a, b)
+
+/* declarations for Lua 5.1 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+/* XXX not implemented:
+* lua_arith (new operators)
+* lua_upvalueid
+* lua_upvaluejoin
+* lua_version
+* lua_yieldk
+*/
+
+#ifndef LUA_OK
+#  define LUA_OK 0
+#endif
+#ifndef LUA_OPADD
+#  define LUA_OPADD 0
+#endif
+#ifndef LUA_OPSUB
+#  define LUA_OPSUB 1
+#endif
+#ifndef LUA_OPMUL
+#  define LUA_OPMUL 2
+#endif
+#ifndef LUA_OPDIV
+#  define LUA_OPDIV 3
+#endif
+#ifndef LUA_OPMOD
+#  define LUA_OPMOD 4
+#endif
+#ifndef LUA_OPPOW
+#  define LUA_OPPOW 5
+#endif
+#ifndef LUA_OPUNM
+#  define LUA_OPUNM 6
+#endif
+#ifndef LUA_OPEQ
+#  define LUA_OPEQ 0
+#endif
+#ifndef LUA_OPLT
+#  define LUA_OPLT 1
+#endif
+#ifndef LUA_OPLE
+#  define LUA_OPLE 2
+#endif
+
+/* LuaJIT/Lua 5.1 does not have the updated
+* error codes for thread status/function returns (but some patched versions do)
+* define it only if it's not found
+*/
+#if !defined(LUA_ERRGCMM)
+/* Use + 2 because in some versions of Lua (Lua 5.1)
+* LUA_ERRFILE is defined as (LUA_ERRERR+1)
+* so we need to avoid it (LuaJIT might have something at this
+* integer value too)
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#if !defined(MOONJIT_VERSION)
+typedef size_t lua_Unsigned;
+#endif
+
+typedef struct luaL_Buffer_53 {
+	luaL_Buffer b; /* make incorrect code crash! */
+	char *ptr;
+	size_t nelems;
+	size_t capacity;
+	lua_State *L2;
+} luaL_Buffer_53;
+#define luaL_Buffer luaL_Buffer_53
+
+/* In PUC-Rio 5.1, userdata is a simple FILE*
+* In LuaJIT, it's a struct where the first member is a FILE*
+* We can't support the `closef` member
+*/
+typedef struct luaL_Stream {
+	FILE *f;
+} luaL_Stream;
+
+#define lua_absindex COMPAT53_CONCAT(COMPAT53_PREFIX, _absindex)
+COMPAT53_API int lua_absindex(lua_State *L, int i);
+
+#define lua_arith COMPAT53_CONCAT(COMPAT53_PREFIX, _arith)
+COMPAT53_API void lua_arith(lua_State *L, int op);
+
+#define lua_compare COMPAT53_CONCAT(COMPAT53_PREFIX, _compare)
+COMPAT53_API int lua_compare(lua_State *L, int idx1, int idx2, int op);
+
+#define lua_copy COMPAT53_CONCAT(COMPAT53_PREFIX, _copy)
+COMPAT53_API void lua_copy(lua_State *L, int from, int to);
+
+#define lua_getuservalue(L, i) \
+  (lua_getfenv((L), (i)), lua_type((L), -1))
+#define lua_setuservalue(L, i) \
+  (luaL_checktype((L), -1, LUA_TTABLE), lua_setfenv((L), (i)))
+
+#define lua_len COMPAT53_CONCAT(COMPAT53_PREFIX, _len)
+COMPAT53_API void lua_len(lua_State *L, int i);
+
+#define lua_pushstring(L, s) \
+  (lua_pushstring((L), (s)), lua_tostring((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  ((((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len))), lua_tostring((L), -1))
+
+#ifndef luaL_newlibtable
+#  define luaL_newlibtable(L, l) \
+  (lua_createtable((L), 0, sizeof((l))/sizeof(*(l))-1))
+#endif
+#ifndef luaL_newlib
+#  define luaL_newlib(L, l) \
+  (luaL_newlibtable((L), (l)), luaL_register((L), NULL, (l)))
+#endif
+
+#ifndef lua_pushglobaltable
+#  define lua_pushglobaltable(L) \
+  lua_pushvalue((L), LUA_GLOBALSINDEX)
+#endif
+#define lua_rawgetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawgetp)
+COMPAT53_API int lua_rawgetp(lua_State *L, int i, const void *p);
+
+#define lua_rawsetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawsetp)
+COMPAT53_API void lua_rawsetp(lua_State *L, int i, const void *p);
+
+#define lua_rawlen(L, i) lua_objlen((L), (i))
+
+#define lua_tointeger(L, i) lua_tointegerx((L), (i), NULL)
+
+#define lua_tonumberx COMPAT53_CONCAT(COMPAT53_PREFIX, _tonumberx)
+COMPAT53_API lua_Number lua_tonumberx(lua_State *L, int i, int *isnum);
+
+#define luaL_checkversion COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkversion)
+COMPAT53_API void luaL_checkversion(lua_State *L);
+
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+COMPAT53_API int lua_load(lua_State *L, lua_Reader reader, void *data, const char* source, const char* mode);
+
+#define luaL_loadfilex COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadfilex)
+COMPAT53_API int luaL_loadfilex(lua_State *L, const char *filename, const char *mode);
+
+#define luaL_loadbufferx COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadbufferx)
+COMPAT53_API int luaL_loadbufferx(lua_State *L, const char *buff, size_t sz, const char *name, const char *mode);
+
+#define luaL_checkstack COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkstack_53)
+COMPAT53_API void luaL_checkstack(lua_State *L, int sp, const char *msg);
+
+#define luaL_getsubtable COMPAT53_CONCAT(COMPAT53_PREFIX, L_getsubtable)
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char *name);
+
+#define luaL_len COMPAT53_CONCAT(COMPAT53_PREFIX, L_len)
+COMPAT53_API lua_Integer luaL_len(lua_State *L, int i);
+
+#define luaL_setfuncs COMPAT53_CONCAT(COMPAT53_PREFIX, L_setfuncs)
+COMPAT53_API void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup);
+
+#define luaL_setmetatable COMPAT53_CONCAT(COMPAT53_PREFIX, L_setmetatable)
+COMPAT53_API void luaL_setmetatable(lua_State *L, const char *tname);
+
+#define luaL_testudata COMPAT53_CONCAT(COMPAT53_PREFIX, L_testudata)
+COMPAT53_API void *luaL_testudata(lua_State *L, int i, const char *tname);
+
+#define luaL_traceback COMPAT53_CONCAT(COMPAT53_PREFIX, L_traceback)
+COMPAT53_API void luaL_traceback(lua_State *L, lua_State *L1, const char *msg, int level);
+
+#define luaL_fileresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_fileresult)
+COMPAT53_API int luaL_fileresult(lua_State *L, int stat, const char *fname);
+
+#define luaL_execresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_execresult)
+COMPAT53_API int luaL_execresult(lua_State *L, int stat);
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_call((L), (na), (nr)))
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_pcall((L), (na), (nr), (err)))
+
+#define lua_resume(L, from, nargs) \
+  ((void)(from), lua_resume((L), (nargs)))
+
+#define luaL_buffinit COMPAT53_CONCAT(COMPAT53_PREFIX, _buffinit_53)
+COMPAT53_API void luaL_buffinit(lua_State *L, luaL_Buffer_53 *B);
+
+#define luaL_prepbuffsize COMPAT53_CONCAT(COMPAT53_PREFIX, _prepbufsize_53)
+COMPAT53_API char *luaL_prepbuffsize(luaL_Buffer_53 *B, size_t s);
+
+#define luaL_addlstring COMPAT53_CONCAT(COMPAT53_PREFIX, _addlstring_53)
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53 *B, const char *s, size_t l);
+
+#define luaL_addvalue COMPAT53_CONCAT(COMPAT53_PREFIX, _addvalue_53)
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53 *B);
+
+#define luaL_pushresult COMPAT53_CONCAT(COMPAT53_PREFIX, _pushresult_53)
+COMPAT53_API void luaL_pushresult(luaL_Buffer_53 *B);
+
+#undef luaL_buffinitsize
+#define luaL_buffinitsize(L, B, s) \
+  (luaL_buffinit((L), (B)), luaL_prepbuffsize((B), (s)))
+
+#undef luaL_prepbuffer
+#define luaL_prepbuffer(B) \
+  luaL_prepbuffsize((B), LUAL_BUFFERSIZE)
+
+#undef luaL_addchar
+#define luaL_addchar(B, c) \
+  ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize((B), 1)), \
+   ((B)->ptr[(B)->nelems++] = (c)))
+
+#undef luaL_addsize
+#define luaL_addsize(B, s) \
+  ((B)->nelems += (s))
+
+#undef luaL_addstring
+#define luaL_addstring(B, s) \
+  luaL_addlstring((B), (s), strlen((s)))
+
+#undef luaL_pushresultsize
+#define luaL_pushresultsize(B, s) \
+  (luaL_addsize((B), (s)), luaL_pushresult((B)))
+
+#if defined(LUA_COMPAT_APIINTCASTS)
+#define lua_pushunsigned(L, n) \
+  lua_pushinteger((L), (lua_Integer)(n))
+#define lua_tounsignedx(L, i, is) \
+  ((lua_Unsigned)lua_tointegerx((L), (i), (is)))
+#define lua_tounsigned(L, i) \
+  lua_tounsignedx((L), (i), NULL)
+#define luaL_checkunsigned(L, a) \
+  ((lua_Unsigned)luaL_checkinteger((L), (a)))
+#define luaL_optunsigned(L, a, d) \
+  ((lua_Unsigned)luaL_optinteger((L), (a), (lua_Integer)(d)))
+#endif
+
+#endif /* Lua 5.1 only */
+
+/* declarations for Lua 5.1 and 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+typedef int lua_KContext;
+
+typedef int(*lua_KFunction)(lua_State *L, int status, lua_KContext ctx);
+
+#define lua_dump(L, w, d, s) \
+  ((void)(s), lua_dump((L), (w), (d)))
+
+#define lua_getfield(L, i, k) \
+  (lua_getfield((L), (i), (k)), lua_type((L), -1))
+
+#define lua_gettable(L, i) \
+  (lua_gettable((L), (i)), lua_type((L), -1))
+
+#define lua_geti COMPAT53_CONCAT(COMPAT53_PREFIX, _geti)
+COMPAT53_API int lua_geti(lua_State *L, int index, lua_Integer i);
+
+#define lua_isinteger COMPAT53_CONCAT(COMPAT53_PREFIX, _isinteger)
+COMPAT53_API int lua_isinteger(lua_State *L, int index);
+
+#define lua_tointegerx COMPAT53_CONCAT(COMPAT53_PREFIX, _tointegerx_53)
+COMPAT53_API lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum);
+
+#define lua_numbertointeger(n, p) \
+  ((*(p) = (lua_Integer)(n)), 1)
+
+#define lua_rawget(L, i) \
+  (lua_rawget((L), (i)), lua_type((L), -1))
+
+#define lua_rawgeti(L, i, n) \
+  (lua_rawgeti((L), (i), (n)), lua_type((L), -1))
+
+#define lua_rotate COMPAT53_CONCAT(COMPAT53_PREFIX, _rotate)
+COMPAT53_API void lua_rotate(lua_State *L, int idx, int n);
+
+#define lua_seti COMPAT53_CONCAT(COMPAT53_PREFIX, _seti)
+COMPAT53_API void lua_seti(lua_State *L, int index, lua_Integer i);
+
+#define lua_stringtonumber COMPAT53_CONCAT(COMPAT53_PREFIX, _stringtonumber)
+COMPAT53_API size_t lua_stringtonumber(lua_State *L, const char *s);
+
+#define luaL_tolstring COMPAT53_CONCAT(COMPAT53_PREFIX, L_tolstring)
+COMPAT53_API const char *luaL_tolstring(lua_State *L, int idx, size_t *len);
+
+#define luaL_getmetafield(L, o, e) \
+  (luaL_getmetafield((L), (o), (e)) ? lua_type((L), -1) : LUA_TNIL)
+
+#define luaL_newmetatable(L, tn) \
+  (luaL_newmetatable((L), (tn)) ? (lua_pushstring((L), (tn)), lua_setfield((L), -2, "__name"), 1) : 0)
+
+#define luaL_requiref COMPAT53_CONCAT(COMPAT53_PREFIX, L_requiref_53)
+COMPAT53_API void luaL_requiref(lua_State *L, const char *modname,
+	lua_CFunction openf, int glb);
+
+#endif /* Lua 5.1 and Lua 5.2 */
+
+/* declarations for Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 502
+
+/* XXX not implemented:
+* lua_isyieldable
+* lua_getextraspace
+* lua_arith (new operators)
+* lua_pushfstring (new formats)
+*/
+
+#define lua_getglobal(L, n) \
+  (lua_getglobal((L), (n)), lua_type((L), -1))
+
+#define lua_getuservalue(L, i) \
+  (lua_getuservalue((L), (i)), lua_type((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  (((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len)))
+
+#define lua_rawgetp(L, i, p) \
+  (lua_rawgetp((L), (i), (p)), lua_type((L), -1))
+
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx); \
+  static int (_name ## _52)(lua_State *L) { \
+    lua_KContext ctx; \
+    int status = lua_getctx(L, &ctx); \
+    return (_name)(L, status, ctx); \
+  } \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  lua_pcallk((L), (na), (nr), (err), (ctx), cont ## _52)
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  lua_callk((L), (na), (nr), (ctx), cont ## _52)
+
+#define lua_yieldk(L, nr, ctx, cont) \
+  lua_yieldk((L), (nr), (ctx), cont ## _52)
+
+#ifdef lua_call
+#  undef lua_call
+#  define lua_call(L, na, nr) \
+  (lua_callk)((L), (na), (nr), 0, NULL)
+#endif
+
+#ifdef lua_pcall
+#  undef lua_pcall
+#  define lua_pcall(L, na, nr, err) \
+  (lua_pcallk)((L), (na), (nr), (err), 0, NULL)
+#endif
+
+#ifdef lua_yield
+#  undef lua_yield
+#  define lua_yield(L, nr) \
+  (lua_yieldk)((L), (nr), 0, NULL)
+#endif
+
+#endif /* Lua 5.2 only */
+
+/* other Lua versions */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 || LUA_VERSION_NUM > 504
+
+#  error "unsupported Lua version (i.e. not Lua 5.1, 5.2, 5.3, or 5.4)"
+
+#endif /* other Lua versions except 5.1, 5.2, 5.3, and 5.4 */
+
+/* helper macro for defining continuation functions (for every version
+* *except* Lua 5.2) */
+#ifndef LUA_KFUNCTION
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+#endif
+
+#if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE == 1
+// beginning of sol/compatibility/compat-5.3.c.h
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+
+/* don't compile it again if it already is included via compat53.h */
+#ifndef KEPLER_PROJECT_COMPAT53_C_
+#define KEPLER_PROJECT_COMPAT53_C_
+
+/* definitions for Lua 5.1 only */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+#ifndef COMPAT53_FOPEN_NO_LOCK
+#if defined(_MSC_VER)
+#define COMPAT53_FOPEN_NO_LOCK 1
+#else /* otherwise */
+#define COMPAT53_FOPEN_NO_LOCK 0
+#endif /* VC++ only so far */
+#endif /* No-lock fopen_s usage if possible */
+
+#if defined(_MSC_VER) && COMPAT53_FOPEN_NO_LOCK
+#include <share.h>
+#endif /* VC++ _fsopen for share-allowed file read */
+
+#ifndef COMPAT53_HAVE_STRERROR_R
+#if defined(__GLIBC__) || defined(_POSIX_VERSION) || defined(__APPLE__) || (!defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ < 6))
+#define COMPAT53_HAVE_STRERROR_R 1
+#else /* none of the defines matched: define to 0 */
+#define COMPAT53_HAVE_STRERROR_R 0
+#endif /* have strerror_r of some form */
+#endif /* strerror_r */
+
+#ifndef COMPAT53_HAVE_STRERROR_S
+#if defined(_MSC_VER) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__STDC_LIB_EXT1__) && __STDC_LIB_EXT1__)
+#define COMPAT53_HAVE_STRERROR_S 1
+#else /* not VC++ or C11 */
+#define COMPAT53_HAVE_STRERROR_S 0
+#endif /* strerror_s from VC++ or C11 */
+#endif /* strerror_s */
+
+#ifndef COMPAT53_LUA_FILE_BUFFER_SIZE
+#define COMPAT53_LUA_FILE_BUFFER_SIZE 4096
+#endif /* Lua File Buffer Size */
+
+static char* compat53_strerror(int en, char* buff, size_t sz) {
+#if COMPAT53_HAVE_STRERROR_R
+	/* use strerror_r here, because it's available on these specific platforms */
+	if (sz > 0) {
+		buff[0] = '\0';
+		/* we don't care whether the GNU version or the XSI version is used: */
+		if (strerror_r(en, buff, sz)) {
+			/* Yes, we really DO want to ignore the return value!
+			 * GCC makes that extra hard, not even a (void) cast will do. */
+		}
+		if (buff[0] == '\0') {
+			/* Buffer is unchanged, so we probably have called GNU strerror_r which
+			 * returned a static constant string. Chances are that strerror will
+			 * return the same static constant string and therefore be thread-safe. */
+			return strerror(en);
+		}
+	}
+	return buff; /* sz is 0 *or* strerror_r wrote into the buffer */
+#elif COMPAT53_HAVE_STRERROR_S
+	/* for MSVC and other C11 implementations, use strerror_s since it's
+	 * provided by default by the libraries */
+	strerror_s(buff, sz, en);
+	return buff;
+#else
+	/* fallback, but strerror is not guaranteed to be threadsafe due to modifying
+	 * errno itself and some impls not locking a static buffer for it ... but most
+	 * known systems have threadsafe errno: this might only change if the locale
+	 * is changed out from under someone while this function is being called */
+	(void)buff;
+	(void)sz;
+	return strerror(en);
+#endif
+}
+
+COMPAT53_API int lua_absindex(lua_State* L, int i) {
+	if (i < 0 && i > LUA_REGISTRYINDEX)
+		i += lua_gettop(L) + 1;
+	return i;
+}
+
+static void compat53_call_lua(lua_State* L, char const code[], size_t len, int nargs, int nret) {
+	lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
+	if (lua_type(L, -1) != LUA_TFUNCTION) {
+		lua_pop(L, 1);
+		if (luaL_loadbuffer(L, code, len, "=none"))
+			lua_error(L);
+		lua_pushvalue(L, -1);
+		lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
+	}
+	lua_insert(L, -nargs - 1);
+	lua_call(L, nargs, nret);
+}
+
+COMPAT53_API void lua_arith(lua_State* L, int op) {
+	static const char compat53_arith_code[]
+	     = "local op,a,b=...\n"
+	       "if op==0 then return a+b\n"
+	       "elseif op==1 then return a-b\n"
+	       "elseif op==2 then return a*b\n"
+	       "elseif op==3 then return a/b\n"
+	       "elseif op==4 then return a%b\n"
+	       "elseif op==5 then return a^b\n"
+	       "elseif op==6 then return -a\n"
+	       "end\n";
+
+	if (op < LUA_OPADD || op > LUA_OPUNM)
+		luaL_error(L, "invalid 'op' argument for lua_arith");
+	luaL_checkstack(L, 5, "not enough stack slots");
+	if (op == LUA_OPUNM)
+		lua_pushvalue(L, -1);
+	lua_pushnumber(L, op);
+	lua_insert(L, -3);
+	compat53_call_lua(L, compat53_arith_code, sizeof(compat53_arith_code) - 1, 3, 1);
+}
+
+COMPAT53_API int lua_compare(lua_State* L, int idx1, int idx2, int op) {
+	static const char compat53_compare_code[]
+	     = "local a,b=...\n"
+	       "return a<=b\n";
+
+	int result = 0;
+	switch (op) {
+	case LUA_OPEQ:
+		return lua_equal(L, idx1, idx2);
+	case LUA_OPLT:
+		return lua_lessthan(L, idx1, idx2);
+	case LUA_OPLE:
+		luaL_checkstack(L, 5, "not enough stack slots");
+		idx1 = lua_absindex(L, idx1);
+		idx2 = lua_absindex(L, idx2);
+		lua_pushvalue(L, idx1);
+		lua_pushvalue(L, idx2);
+		compat53_call_lua(L, compat53_compare_code, sizeof(compat53_compare_code) - 1, 2, 1);
+		result = lua_toboolean(L, -1);
+		lua_pop(L, 1);
+		return result;
+	default:
+		luaL_error(L, "invalid 'op' argument for lua_compare");
+	}
+	return 0;
+}
+
+COMPAT53_API void lua_copy(lua_State* L, int from, int to) {
+	int abs_to = lua_absindex(L, to);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushvalue(L, from);
+	lua_replace(L, abs_to);
+}
+
+COMPAT53_API void lua_len(lua_State* L, int i) {
+	switch (lua_type(L, i)) {
+	case LUA_TSTRING:
+		lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TTABLE:
+		if (!luaL_callmeta(L, i, "__len"))
+			lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TUSERDATA:
+		if (luaL_callmeta(L, i, "__len"))
+			break;
+		/* FALLTHROUGH */
+	default:
+		luaL_error(L, "attempt to get length of a %s value", lua_typename(L, lua_type(L, i)));
+	}
+}
+
+COMPAT53_API int lua_rawgetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	lua_pushlightuserdata(L, (void*)p);
+	lua_rawget(L, abs_i);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API void lua_rawsetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushlightuserdata(L, (void*)p);
+	lua_insert(L, -2);
+	lua_rawset(L, abs_i);
+}
+
+COMPAT53_API lua_Number lua_tonumberx(lua_State* L, int i, int* isnum) {
+	lua_Number n = lua_tonumber(L, i);
+	if (isnum != NULL) {
+		*isnum = (n != 0 || lua_isnumber(L, i));
+	}
+	return n;
+}
+
+COMPAT53_API void luaL_checkversion(lua_State* L) {
+	(void)L;
+}
+
+COMPAT53_API void luaL_checkstack(lua_State* L, int sp, const char* msg) {
+	if (!lua_checkstack(L, sp + LUA_MINSTACK)) {
+		if (msg != NULL)
+			luaL_error(L, "stack overflow (%s)", msg);
+		else {
+			lua_pushliteral(L, "stack overflow");
+			lua_error(L);
+		}
+	}
+}
+
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char* name) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 3, "not enough stack slots");
+	lua_pushstring(L, name);
+	lua_gettable(L, abs_i);
+	if (lua_istable(L, -1))
+		return 1;
+	lua_pop(L, 1);
+	lua_newtable(L);
+	lua_pushstring(L, name);
+	lua_pushvalue(L, -2);
+	lua_settable(L, abs_i);
+	return 0;
+}
+
+COMPAT53_API lua_Integer luaL_len(lua_State* L, int i) {
+	lua_Integer res = 0;
+	int isnum = 0;
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_len(L, i);
+	res = lua_tointegerx(L, -1, &isnum);
+	lua_pop(L, 1);
+	if (!isnum)
+		luaL_error(L, "object length is not an integer");
+	return res;
+}
+
+COMPAT53_API void luaL_setfuncs(lua_State* L, const luaL_Reg* l, int nup) {
+	luaL_checkstack(L, nup + 1, "too many upvalues");
+	for (; l->name != NULL; l++) { /* fill the table with given functions */
+		int i;
+		lua_pushstring(L, l->name);
+		for (i = 0; i < nup; i++) /* copy upvalues to the top */
+			lua_pushvalue(L, -(nup + 1));
+		lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
+		lua_settable(L, -(nup + 3));       /* table must be below the upvalues, the name and the closure */
+	}
+	lua_pop(L, nup); /* remove upvalues */
+}
+
+COMPAT53_API void luaL_setmetatable(lua_State* L, const char* tname) {
+	luaL_checkstack(L, 1, "not enough stack slots");
+	luaL_getmetatable(L, tname);
+	lua_setmetatable(L, -2);
+}
+
+COMPAT53_API void* luaL_testudata(lua_State* L, int i, const char* tname) {
+	void* p = lua_touserdata(L, i);
+	luaL_checkstack(L, 2, "not enough stack slots");
+	if (p == NULL || !lua_getmetatable(L, i))
+		return NULL;
+	else {
+		int res = 0;
+		luaL_getmetatable(L, tname);
+		res = lua_rawequal(L, -1, -2);
+		lua_pop(L, 2);
+		if (!res)
+			p = NULL;
+	}
+	return p;
+}
+
+static int compat53_countlevels(lua_State* L) {
+	lua_Debug ar;
+	int li = 1, le = 1;
+	/* find an upper bound */
+	while (lua_getstack(L, le, &ar)) {
+		li = le;
+		le *= 2;
+	}
+	/* do a binary search */
+	while (li < le) {
+		int m = (li + le) / 2;
+		if (lua_getstack(L, m, &ar))
+			li = m + 1;
+		else
+			le = m;
+	}
+	return le - 1;
+}
+
+static int compat53_findfield(lua_State* L, int objidx, int level) {
+	if (level == 0 || !lua_istable(L, -1))
+		return 0;                               /* not found */
+	lua_pushnil(L);                              /* start 'next' loop */
+	while (lua_next(L, -2)) {                    /* for each pair in table */
+		if (lua_type(L, -2) == LUA_TSTRING) {   /* ignore non-string keys */
+			if (lua_rawequal(L, objidx, -1)) { /* found object? */
+				lua_pop(L, 1);                /* remove value (but keep name) */
+				return 1;
+			}
+			else if (compat53_findfield(L, objidx, level - 1)) { /* try recursively */
+				lua_remove(L, -2);                              /* remove table (but keep name) */
+				lua_pushliteral(L, ".");
+				lua_insert(L, -2); /* place '.' between the two names */
+				lua_concat(L, 3);
+				return 1;
+			}
+		}
+		lua_pop(L, 1); /* remove value */
+	}
+	return 0; /* not found */
+}
+
+static int compat53_pushglobalfuncname(lua_State* L, lua_Debug* ar) {
+	int top = lua_gettop(L);
+	lua_getinfo(L, "f", ar); /* push function */
+	lua_pushvalue(L, LUA_GLOBALSINDEX);
+	if (compat53_findfield(L, top + 1, 2)) {
+		lua_copy(L, -1, top + 1); /* move name to proper place */
+		lua_pop(L, 2);            /* remove pushed values */
+		return 1;
+	}
+	else {
+		lua_settop(L, top); /* remove function and global table */
+		return 0;
+	}
+}
+
+static void compat53_pushfuncname(lua_State* L, lua_Debug* ar) {
+	if (*ar->namewhat != '\0') /* is there a name? */
+		lua_pushfstring(L, "function " LUA_QS, ar->name);
+	else if (*ar->what == 'm') /* main? */
+		lua_pushliteral(L, "main chunk");
+	else if (*ar->what == 'C') {
+		if (compat53_pushglobalfuncname(L, ar)) {
+			lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
+			lua_remove(L, -2); /* remove name */
+		}
+		else
+			lua_pushliteral(L, "?");
+	}
+	else
+		lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
+}
+
+#define COMPAT53_LEVELS1 12 /* size of the first part of the stack */
+#define COMPAT53_LEVELS2 10 /* size of the second part of the stack */
+
+COMPAT53_API void luaL_traceback(lua_State* L, lua_State* L1, const char* msg, int level) {
+	lua_Debug ar;
+	int top = lua_gettop(L);
+	int numlevels = compat53_countlevels(L1);
+	int mark = (numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2) ? COMPAT53_LEVELS1 : 0;
+	if (msg)
+		lua_pushfstring(L, "%s\n", msg);
+	lua_pushliteral(L, "stack traceback:");
+	while (lua_getstack(L1, level++, &ar)) {
+		if (level == mark) {                       /* too many levels? */
+			lua_pushliteral(L, "\n\t...");        /* add a '...' */
+			level = numlevels - COMPAT53_LEVELS2; /* and skip to last ones */
+		}
+		else {
+			lua_getinfo(L1, "Slnt", &ar);
+			lua_pushfstring(L, "\n\t%s:", ar.short_src);
+			if (ar.currentline > 0)
+				lua_pushfstring(L, "%d:", ar.currentline);
+			lua_pushliteral(L, " in ");
+			compat53_pushfuncname(L, &ar);
+			lua_concat(L, lua_gettop(L) - top);
+		}
+	}
+	lua_concat(L, lua_gettop(L) - top);
+}
+
+COMPAT53_API int luaL_fileresult(lua_State* L, int stat, const char* fname) {
+	const char* serr = NULL;
+	int en = errno; /* calls to Lua API may change this value */
+	char buf[512] = { 0 };
+	if (stat) {
+		lua_pushboolean(L, 1);
+		return 1;
+	}
+	else {
+		lua_pushnil(L);
+		serr = compat53_strerror(en, buf, sizeof(buf));
+		if (fname)
+			lua_pushfstring(L, "%s: %s", fname, serr);
+		else
+			lua_pushstring(L, serr);
+		lua_pushnumber(L, (lua_Number)en);
+		return 3;
+	}
+}
+
+static int compat53_checkmode(lua_State* L, const char* mode, const char* modename, int err) {
+	if (mode && strchr(mode, modename[0]) == NULL) {
+		lua_pushfstring(L, "attempt to load a %s chunk (mode is '%s')", modename, mode);
+		return err;
+	}
+	return LUA_OK;
+}
+
+typedef struct {
+	lua_Reader reader;
+	void* ud;
+	int has_peeked_data;
+	const char* peeked_data;
+	size_t peeked_data_size;
+} compat53_reader_data;
+
+static const char* compat53_reader(lua_State* L, void* ud, size_t* size) {
+	compat53_reader_data* data = (compat53_reader_data*)ud;
+	if (data->has_peeked_data) {
+		data->has_peeked_data = 0;
+		*size = data->peeked_data_size;
+		return data->peeked_data;
+	}
+	else
+		return data->reader(L, data->ud, size);
+}
+
+COMPAT53_API int lua_load(lua_State* L, lua_Reader reader, void* data, const char* source, const char* mode) {
+	int status = LUA_OK;
+	compat53_reader_data compat53_data = { reader, data, 1, 0, 0 };
+	compat53_data.peeked_data = reader(L, data, &(compat53_data.peeked_data_size));
+	if (compat53_data.peeked_data && compat53_data.peeked_data_size && compat53_data.peeked_data[0] == LUA_SIGNATURE[0]) /* binary file? */
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	else
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	if (status != LUA_OK)
+		return status;
+		/* we need to call the original 5.1 version of lua_load! */
+#undef lua_load
+	return lua_load(L, compat53_reader, &compat53_data, source);
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+}
+
+typedef struct {
+	int n;                                    /* number of pre-read characters */
+	FILE* f;                                  /* file being read */
+	char buff[COMPAT53_LUA_FILE_BUFFER_SIZE]; /* area for reading file */
+} compat53_LoadF;
+
+static const char* compat53_getF(lua_State* L, void* ud, size_t* size) {
+	compat53_LoadF* lf = (compat53_LoadF*)ud;
+	(void)L;            /* not used */
+	if (lf->n > 0) {    /* are there pre-read characters to be read? */
+		*size = lf->n; /* return them (chars already in buffer) */
+		lf->n = 0;     /* no more pre-read characters */
+	}
+	else { /* read a block from file */
+		  /* 'fread' can return > 0 *and* set the EOF flag. If next call to
+		  'compat53_getF' called 'fread', it might still wait for user input.
+		  The next check avoids this problem. */
+		if (feof(lf->f))
+			return NULL;
+		*size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */
+	}
+	return lf->buff;
+}
+
+static int compat53_errfile(lua_State* L, const char* what, int fnameindex) {
+	char buf[512] = { 0 };
+	const char* serr = compat53_strerror(errno, buf, sizeof(buf));
+	const char* filename = lua_tostring(L, fnameindex) + 1;
+	lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
+	lua_remove(L, fnameindex);
+	return LUA_ERRFILE;
+}
+
+static int compat53_skipBOM(compat53_LoadF* lf) {
+	const char* p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */
+	int c;
+	lf->n = 0;
+	do {
+		c = getc(lf->f);
+		if (c == EOF || c != *(const unsigned char*)p++)
+			return c;
+		lf->buff[lf->n++] = (char)c; /* to be read by the parser */
+	} while (*p != '\0');
+	lf->n = 0;          /* prefix matched; discard it */
+	return getc(lf->f); /* return next character */
+}
+
+/*
+** reads the first character of file 'f' and skips an optional BOM mark
+** in its beginning plus its first line if it starts with '#'. Returns
+** true if it skipped the first line.  In any case, '*cp' has the
+** first "valid" character of the file (after the optional BOM and
+** a first-line comment).
+*/
+static int compat53_skipcomment(compat53_LoadF* lf, int* cp) {
+	int c = *cp = compat53_skipBOM(lf);
+	if (c == '#') { /* first line is a comment (Unix exec. file)? */
+		do {       /* skip first line */
+			c = getc(lf->f);
+		} while (c != EOF && c != '\n');
+		*cp = getc(lf->f); /* skip end-of-line, if present */
+		return 1;          /* there was a comment */
+	}
+	else
+		return 0; /* no comment */
+}
+
+COMPAT53_API int luaL_loadfilex(lua_State* L, const char* filename, const char* mode) {
+	compat53_LoadF lf;
+	int status, readstatus;
+	int c;
+	int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
+	if (filename == NULL) {
+		lua_pushliteral(L, "=stdin");
+		lf.f = stdin;
+	}
+	else {
+		lua_pushfstring(L, "@%s", filename);
+#if defined(_MSC_VER)
+		/* This code is here to stop a deprecation error that stops builds
+		 * if a certain macro is defined. While normally not caring would
+		 * be best, some header-only libraries and builds can't afford to
+		 * dictate this to the user. A quick check shows that fopen_s this
+		 * goes back to VS 2005, and _fsopen goes back to VS 2003 .NET,
+		 * possibly even before that so we don't need to do any version
+		 * number checks, since this has been there since forever.  */
+
+		/* TO USER: if you want the behavior of typical fopen_s/fopen,
+		 * which does lock the file on VC++, define the macro used below to 0 */
+#if COMPAT53_FOPEN_NO_LOCK
+		lf.f = _fsopen(filename, "r", _SH_DENYNO); /* do not lock the file in any way */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#else  /* use default locking version */
+		if (fopen_s(&lf.f, filename, "r") != 0)
+			return compat53_errfile(L, "open", fnameindex);
+#endif /* Locking vs. No-locking fopen variants */
+#else
+		lf.f = fopen(filename, "r"); /* default stdlib doesn't forcefully lock files here */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#endif
+	}
+	if (compat53_skipcomment(&lf, &c))       /* read initial portion */
+		lf.buff[lf.n++] = '\n';             /* add line to correct line numbers */
+	if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
+#if defined(_MSC_VER)
+		if (freopen_s(&lf.f, filename, "rb", lf.f) != 0)
+			return compat53_errfile(L, "reopen", fnameindex);
+#else
+		lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "reopen", fnameindex);
+#endif
+		compat53_skipcomment(&lf, &c); /* re-read initial portion */
+	}
+	if (c != EOF)
+		lf.buff[lf.n++] = (char)c; /* 'c' is the first character of the stream */
+	status = lua_load(L, &compat53_getF, &lf, lua_tostring(L, -1), mode);
+	readstatus = ferror(lf.f);
+	if (filename)
+		fclose(lf.f); /* close file (even in case of errors) */
+	if (readstatus) {
+		lua_settop(L, fnameindex); /* ignore results from 'lua_load' */
+		return compat53_errfile(L, "read", fnameindex);
+	}
+	lua_remove(L, fnameindex);
+	return status;
+}
+
+COMPAT53_API int luaL_loadbufferx(lua_State* L, const char* buff, size_t sz, const char* name, const char* mode) {
+	int status = LUA_OK;
+	if (sz > 0 && buff[0] == LUA_SIGNATURE[0]) {
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	}
+	else {
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	}
+	if (status != LUA_OK)
+		return status;
+	return luaL_loadbuffer(L, buff, sz, name);
+}
+
+#if !defined(l_inspectstat) \
+     && (defined(unix) || defined(__unix) || defined(__unix__) || defined(__TOS_AIX__) || defined(_SYSTYPE_BSD) || (defined(__APPLE__) && defined(__MACH__)))
+/* some form of unix; check feature macros in unistd.h for details */
+#include <unistd.h>
+/* check posix version; the relevant include files and macros probably
+ * were available before 2001, but I'm not sure */
+#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L
+#include <sys/wait.h>
+#define l_inspectstat(stat, what)   \
+	if (WIFEXITED(stat)) {         \
+		stat = WEXITSTATUS(stat); \
+	}                              \
+	else if (WIFSIGNALED(stat)) {  \
+		stat = WTERMSIG(stat);    \
+		what = "signal";          \
+	}
+#endif
+#endif
+
+/* provide default (no-op) version */
+#if !defined(l_inspectstat)
+#define l_inspectstat(stat, what) ((void)0)
+#endif
+
+COMPAT53_API int luaL_execresult(lua_State* L, int stat) {
+	const char* what = "exit";
+	if (stat == -1)
+		return luaL_fileresult(L, 0, NULL);
+	else {
+		l_inspectstat(stat, what);
+		if (*what == 'e' && stat == 0)
+			lua_pushboolean(L, 1);
+		else
+			lua_pushnil(L);
+		lua_pushstring(L, what);
+		lua_pushinteger(L, stat);
+		return 3;
+	}
+}
+
+COMPAT53_API void luaL_buffinit(lua_State* L, luaL_Buffer_53* B) {
+	/* make it crash if used via pointer to a 5.1-style luaL_Buffer */
+	B->b.p = NULL;
+	B->b.L = NULL;
+	B->b.lvl = 0;
+	/* reuse the buffer from the 5.1-style luaL_Buffer though! */
+	B->ptr = B->b.buffer;
+	B->capacity = LUAL_BUFFERSIZE;
+	B->nelems = 0;
+	B->L2 = L;
+}
+
+COMPAT53_API char* luaL_prepbuffsize(luaL_Buffer_53* B, size_t s) {
+	if (B->capacity - B->nelems < s) { /* needs to grow */
+		char* newptr = NULL;
+		size_t newcap = B->capacity * 2;
+		if (newcap - B->nelems < s)
+			newcap = B->nelems + s;
+		if (newcap < B->capacity) /* overflow */
+			luaL_error(B->L2, "buffer too large");
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
+		newptr = (char*)lua_newuserdatauv(B->L2, newcap, 0);
+#else
+		newptr = (char*)lua_newuserdata(B->L2, newcap);
+#endif
+		memcpy(newptr, B->ptr, B->nelems);
+		if (B->ptr != B->b.buffer)
+			lua_replace(B->L2, -2); /* remove old buffer */
+		B->ptr = newptr;
+		B->capacity = newcap;
+	}
+	return B->ptr + B->nelems;
+}
+
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53* B, const char* s, size_t l) {
+	memcpy(luaL_prepbuffsize(B, l), s, l);
+	luaL_addsize(B, l);
+}
+
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53* B) {
+	size_t len = 0;
+	const char* s = lua_tolstring(B->L2, -1, &len);
+	if (!s)
+		luaL_error(B->L2, "cannot convert value to string");
+	if (B->ptr != B->b.buffer)
+		lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
+	luaL_addlstring(B, s, len);
+	lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
+}
+
+void luaL_pushresult(luaL_Buffer_53* B) {
+	lua_pushlstring(B->L2, B->ptr, B->nelems);
+	if (B->ptr != B->b.buffer)
+		lua_replace(B->L2, -2); /* remove userdata buffer */
+}
+
+#endif /* Lua 5.1 */
+
+/* definitions for Lua 5.1 and Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+COMPAT53_API int lua_geti(lua_State* L, int index, lua_Integer i) {
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_gettable(L, index);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API int lua_isinteger(lua_State* L, int index) {
+	if (lua_type(L, index) == LUA_TNUMBER) {
+		lua_Number n = lua_tonumber(L, index);
+		lua_Integer i = lua_tointeger(L, index);
+		if (i == n)
+			return 1;
+	}
+	return 0;
+}
+
+COMPAT53_API lua_Integer lua_tointegerx(lua_State* L, int i, int* isnum) {
+	int ok = 0;
+	lua_Number n = lua_tonumberx(L, i, &ok);
+	if (ok) {
+		if (n == (lua_Integer)n) {
+			if (isnum)
+				*isnum = 1;
+			return (lua_Integer)n;
+		}
+	}
+	if (isnum)
+		*isnum = 0;
+	return 0;
+}
+
+static void compat53_reverse(lua_State* L, int a, int b) {
+	for (; a < b; ++a, --b) {
+		lua_pushvalue(L, a);
+		lua_pushvalue(L, b);
+		lua_replace(L, a);
+		lua_replace(L, b);
+	}
+}
+
+COMPAT53_API void lua_rotate(lua_State* L, int idx, int n) {
+	int n_elems = 0;
+	idx = lua_absindex(L, idx);
+	n_elems = lua_gettop(L) - idx + 1;
+	if (n < 0)
+		n += n_elems;
+	if (n > 0 && n < n_elems) {
+		luaL_checkstack(L, 2, "not enough stack slots available");
+		n = n_elems - n;
+		compat53_reverse(L, idx, idx + n - 1);
+		compat53_reverse(L, idx + n, idx + n_elems - 1);
+		compat53_reverse(L, idx, idx + n_elems - 1);
+	}
+}
+
+COMPAT53_API void lua_seti(lua_State* L, int index, lua_Integer i) {
+	luaL_checkstack(L, 1, "not enough stack slots available");
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_insert(L, -2);
+	lua_settable(L, index);
+}
+
+#if !defined(lua_str2number)
+#define lua_str2number(s, p) strtod((s), (p))
+#endif
+
+COMPAT53_API size_t lua_stringtonumber(lua_State* L, const char* s) {
+	char* endptr;
+	lua_Number n = lua_str2number(s, &endptr);
+	if (endptr != s) {
+		while (*endptr != '\0' && isspace((unsigned char)*endptr))
+			++endptr;
+		if (*endptr == '\0') {
+			lua_pushnumber(L, n);
+			return endptr - s + 1;
+		}
+	}
+	return 0;
+}
+
+COMPAT53_API const char* luaL_tolstring(lua_State* L, int idx, size_t* len) {
+	if (!luaL_callmeta(L, idx, "__tostring")) {
+		int t = lua_type(L, idx), tt = 0;
+		char const* name = NULL;
+		switch (t) {
+		case LUA_TNIL:
+			lua_pushliteral(L, "nil");
+			break;
+		case LUA_TSTRING:
+		case LUA_TNUMBER:
+			lua_pushvalue(L, idx);
+			break;
+		case LUA_TBOOLEAN:
+			if (lua_toboolean(L, idx))
+				lua_pushliteral(L, "true");
+			else
+				lua_pushliteral(L, "false");
+			break;
+		default:
+			tt = luaL_getmetafield(L, idx, "__name");
+			name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
+			lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
+			if (tt != LUA_TNIL)
+				lua_replace(L, -2);
+			break;
+		}
+	}
+	else {
+		if (!lua_isstring(L, -1))
+			luaL_error(L, "'__tostring' must return a string");
+	}
+	return lua_tolstring(L, -1, len);
+}
+
+COMPAT53_API void luaL_requiref(lua_State* L, const char* modname, lua_CFunction openf, int glb) {
+	luaL_checkstack(L, 3, "not enough stack slots available");
+	luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
+	if (lua_getfield(L, -1, modname) == LUA_TNIL) {
+		lua_pop(L, 1);
+		lua_pushcfunction(L, openf);
+		lua_pushstring(L, modname);
+		lua_call(L, 1, 1);
+		lua_pushvalue(L, -1);
+		lua_setfield(L, -3, modname);
+	}
+	if (glb) {
+		lua_pushvalue(L, -1);
+		lua_setglobal(L, modname);
+	}
+	lua_replace(L, -2);
+}
+
+#endif /* Lua 5.1 and 5.2 */
+
+#endif /* KEPLER_PROJECT_COMPAT53_C_ */
+
+/*********************************************************************
+ * This file contains parts of Lua 5.2's and Lua 5.3's source code:
+ *
+ * Copyright (C) 1994-2014 Lua.org, PUC-Rio.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *********************************************************************/
+// end of sol/compatibility/compat-5.3.c.h
+
+#endif
+
+#endif /* KEPLER_PROJECT_COMPAT53_H_ */
+
+// end of sol/compatibility/compat-5.3.h
+
+// beginning of sol/compatibility/compat-5.4.h
+
+#ifndef NOT_KEPLER_PROJECT_COMPAT54_H_
+#define NOT_KEPLER_PROJECT_COMPAT54_H_
+
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 504
+
+#if !defined(LUA_ERRGCMM)
+/* So Lua 5.4 actually removes this, which breaks sol2...
+ man, this API is quite unstable...!
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#endif // Lua 5.4 only
+
+#endif // NOT_KEPLER_PROJECT_COMPAT54_H_// end of sol/compatibility/compat-5.4.h
+
+#endif
+
+// end of sol/compatibility.hpp
+
+#include <vector>
+#include <cstdint>
+#include <cstddef>
+
+namespace sol {
+
+	template <typename Allocator = std::allocator<std::byte>>
+	class basic_bytecode : private std::vector<std::byte, Allocator> {
+	private:
+		using base_t = std::vector<std::byte, Allocator>;
+
+	public:
+		using typename base_t::allocator_type;
+		using typename base_t::const_iterator;
+		using typename base_t::const_pointer;
+		using typename base_t::const_reference;
+		using typename base_t::const_reverse_iterator;
+		using typename base_t::difference_type;
+		using typename base_t::iterator;
+		using typename base_t::pointer;
+		using typename base_t::reference;
+		using typename base_t::reverse_iterator;
+		using typename base_t::size_type;
+		using typename base_t::value_type;
+
+		using base_t::base_t;
+		using base_t::operator=;
+
+		using base_t::data;
+		using base_t::empty;
+		using base_t::max_size;
+		using base_t::size;
+
+		using base_t::at;
+		using base_t::operator[];
+		using base_t::back;
+		using base_t::front;
+
+		using base_t::begin;
+		using base_t::cbegin;
+		using base_t::cend;
+		using base_t::end;
+
+		using base_t::crbegin;
+		using base_t::crend;
+		using base_t::rbegin;
+		using base_t::rend;
+
+		using base_t::get_allocator;
+		using base_t::swap;
+
+		using base_t::clear;
+		using base_t::emplace;
+		using base_t::emplace_back;
+		using base_t::erase;
+		using base_t::insert;
+		using base_t::pop_back;
+		using base_t::push_back;
+		using base_t::reserve;
+		using base_t::resize;
+		using base_t::shrink_to_fit;
+
+		string_view as_string_view() const {
+			return string_view(reinterpret_cast<const char*>(this->data()), this->size());
+		}
+	};
+
+	template <typename Container>
+	inline int basic_insert_dump_writer(lua_State*, const void* memory, size_t memory_size, void* userdata_pointer) {
+		using storage_t = Container;
+		const std::byte* p_code = static_cast<const std::byte*>(memory);
+		storage_t& bc = *static_cast<storage_t*>(userdata_pointer);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		bc.insert(bc.cend(), p_code, p_code + memory_size);
+#else
+		try {
+			bc.insert(bc.cend(), p_code, p_code + memory_size);
+		}
+		catch (...) {
+			return -1;
+		}
+#endif
+		return 0;
+	}
+
+	using bytecode = basic_bytecode<>;
+
+	constexpr inline auto bytecode_dump_writer = &basic_insert_dump_writer<bytecode>;
+
+} // namespace sol
+
+// end of sol/bytecode.hpp
+
+// beginning of sol/stack.hpp
+
+// beginning of sol/trampoline.hpp
+
+// beginning of sol/types.hpp
+
+// beginning of sol/error.hpp
+
+#include <stdexcept>
+#include <string>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct direct_error_tag { };
+		const auto direct_error = direct_error_tag {};
+
+		struct error_result {
+			int results;
+			const char* format_string;
+			std::array<const char*, 4> argument_strings;
+
+			error_result() : results(0), format_string(nullptr) {
+			}
+
+			error_result(int results_) : results(results_), format_string(nullptr) {
+			}
+
+			error_result(const char* format_string_, const char* first_message_) : results(0), format_string(format_string_), argument_strings() {
+				argument_strings[0] = first_message_;
+			}
+		};
+
+		inline int handle_errors(lua_State* L, const error_result& er) {
+			if (er.format_string == nullptr) {
+				return er.results;
+			}
+			return luaL_error(L, er.format_string, er.argument_strings[0], er.argument_strings[1], er.argument_strings[2], er.argument_strings[3]);
+		}
+	} // namespace detail
+
+	class error : public std::runtime_error {
+	private:
+		// Because VC++ is upsetting, most of the time!
+		std::string what_reason;
+
+	public:
+		error(const std::string& str) : error(detail::direct_error, "lua: error: " + str) {
+		}
+		error(std::string&& str) : error(detail::direct_error, "lua: error: " + std::move(str)) {
+		}
+		error(detail::direct_error_tag, const std::string& str) : std::runtime_error(""), what_reason(str) {
+		}
+		error(detail::direct_error_tag, std::string&& str) : std::runtime_error(""), what_reason(std::move(str)) {
+		}
+
+		error(const error& e) = default;
+		error(error&& e) = default;
+		error& operator=(const error& e) = default;
+		error& operator=(error&& e) = default;
+
+		virtual const char* what() const noexcept override {
+			return what_reason.c_str();
+		}
+	};
+
+} // namespace sol
+
+// end of sol/error.hpp
+
+// beginning of sol/optional.hpp
+
+// beginning of sol/in_place.hpp
+
+#include <cstddef>
+#include <utility>
+
+namespace sol {
+
+	using in_place_t = std::in_place_t;
+	constexpr std::in_place_t in_place {};
+	constexpr std::in_place_t in_place_of {};
+
+	template <typename T>
+	using in_place_type_t = std::in_place_type_t<T>;
+	template <typename T>
+	constexpr std::in_place_type_t<T> in_place_type {};
+
+	template <size_t I>
+	using in_place_index_t = std::in_place_index_t<I>;
+	template <size_t I>
+	constexpr in_place_index_t<I> in_place_index {};
+
+} // namespace sol
+
+// end of sol/in_place.hpp
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+#include <boost/optional.hpp>
+#else
+// beginning of sol/optional_implementation.hpp
+
+#define SOL_TL_OPTIONAL_VERSION_MAJOR 0
+#define SOL_TL_OPTIONAL_VERSION_MINOR 5
+
+#include <exception>
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+#include <cstdlib>
+#include <optional>
+
+#if (defined(_MSC_VER) && _MSC_VER == 1900)
+#define SOL_TL_OPTIONAL_MSVC2015
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC49
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC54
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC55
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_NO_CONSTRR
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::has_trivial_copy_constructor<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+
+#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
+#ifndef SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+#define SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+namespace sol { namespace detail {
+	template <class T>
+	struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> { };
+#ifdef _GLIBCXX_VECTOR
+	template <class T, class A>
+	struct is_trivially_copy_constructible<std::vector<T, A>> : std::is_trivially_copy_constructible<T> { };
+#endif
+}} // namespace sol::detail
+#endif
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) sol::detail::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#else
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#endif
+
+#if __cplusplus > 201103L
+#define SOL_TL_OPTIONAL_CXX14
+#endif
+
+#if (__cplusplus == 201103L || defined(SOL_TL_OPTIONAL_MSVC2015) || defined(SOL_TL_OPTIONAL_GCC49))
+#define SOL_TL_OPTIONAL_11_CONSTEXPR
+#else
+   /// \exclude
+#define SOL_TL_OPTIONAL_11_CONSTEXPR constexpr
+#endif
+
+namespace sol {
+#ifndef SOL_TL_MONOSTATE_INPLACE_MUTEX
+#define SOL_TL_MONOSTATE_INPLACE_MUTEX
+	/// \brief Used to represent an optional with no data; essentially a bool
+	class monostate { };
+#endif
+
+	template <class T>
+	class optional;
+
+	/// \exclude
+	namespace detail {
+#ifndef SOL_TL_TRAITS_MUTEX
+#define SOL_TL_TRAITS_MUTEX
+		// C++14-style aliases for brevity
+		template <class T>
+		using remove_const_t = typename std::remove_const<T>::type;
+		template <class T>
+		using remove_reference_t = typename std::remove_reference<T>::type;
+		template <class T>
+		using decay_t = typename std::decay<T>::type;
+		template <bool E, class T = void>
+		using enable_if_t = typename std::enable_if<E, T>::type;
+		template <bool B, class T, class F>
+		using conditional_t = typename std::conditional<B, T, F>::type;
+
+		// std::conjunction from C++17
+		template <class...>
+		struct conjunction : std::true_type { };
+		template <class B>
+		struct conjunction<B> : B { };
+		template <class B, class... Bs>
+		struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type { };
+
+#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
+#define SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+#endif
+
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		template <class T>
+		struct is_pointer_to_non_const_member_func : std::false_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&&> : std::true_type { };
+
+		template <class T>
+		struct is_const_or_const_ref : std::false_type { };
+		template <class T>
+		struct is_const_or_const_ref<T const&> : std::true_type { };
+		template <class T>
+		struct is_const_or_const_ref<T const> : std::true_type { };
+#endif
+
+		// std::invoke from C++17
+		// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
+		template <typename Fn, typename... Args,
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		     typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>,
+#endif
+		     typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
+			return std::mem_fn(f)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fn, typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
+			return std::forward<Fn>(f)(std::forward<Args>(args)...);
+		}
+
+		// std::invoke_result from C++17
+		template <class F, class, class... Us>
+		struct invoke_result_impl;
+
+		template <class F, class... Us>
+		struct invoke_result_impl<F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...> {
+			using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+		};
+
+		template <class F, class... Us>
+		using invoke_result = invoke_result_impl<F, void, Us...>;
+
+		template <class F, class... Us>
+		using invoke_result_t = typename invoke_result<F, Us...>::type;
+#endif
+
+		// std::void_t from C++17
+		template <class...>
+		struct voider {
+			using type = void;
+		};
+		template <class... Ts>
+		using void_t = typename voider<Ts...>::type;
+
+		// Trait for checking if a type is a sol::optional
+		template <class T>
+		struct is_optional_impl : std::false_type { };
+		template <class T>
+		struct is_optional_impl<optional<T>> : std::true_type { };
+		template <class T>
+		using is_optional = is_optional_impl<decay_t<T>>;
+
+		// Change void to sol::monostate
+		template <class U>
+		using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
+
+		template <class F, class U, class = invoke_result_t<F, U>>
+		using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
+
+		// Check if invoking F for some Us returns void
+		template <class F, class = void, class... U>
+		struct returns_void_impl;
+		template <class F, class... U>
+		struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> : std::is_void<invoke_result_t<F, U...>> { };
+		template <class F, class... U>
+		using returns_void = returns_void_impl<F, void, U...>;
+
+		template <class T, class... U>
+		using enable_if_ret_void = enable_if_t<returns_void<T&&, U...>::value>;
+
+		template <class T, class... U>
+		using disable_if_ret_void = enable_if_t<!returns_void<T&&, U...>::value>;
+
+		template <class T, class U>
+		using enable_forward_value = detail::enable_if_t<std::is_constructible<T, U&&>::value && !std::is_same<detail::decay_t<U>, in_place_t>::value
+		     && !std::is_same<optional<T>, detail::decay_t<U>>::value>;
+
+		template <class T, class U, class Other>
+		using enable_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && !std::is_constructible<T, optional<U>&>::value
+		     && !std::is_constructible<T, optional<U>&&>::value && !std::is_constructible<T, const optional<U>&>::value
+		     && !std::is_constructible<T, const optional<U>&&>::value && !std::is_convertible<optional<U>&, T>::value
+		     && !std::is_convertible<optional<U>&&, T>::value && !std::is_convertible<const optional<U>&, T>::value
+		     && !std::is_convertible<const optional<U>&&, T>::value>;
+
+		template <class T, class U>
+		using enable_assign_forward = detail::enable_if_t<!std::is_same<optional<T>, detail::decay_t<U>>::value
+		     && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value && std::is_constructible<T, U>::value
+		     && std::is_assignable<T&, U>::value>;
+
+		template <class T, class U, class Other>
+		using enable_assign_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && std::is_assignable<T&, Other>::value
+		     && !std::is_constructible<T, optional<U>&>::value && !std::is_constructible<T, optional<U>&&>::value
+		     && !std::is_constructible<T, const optional<U>&>::value && !std::is_constructible<T, const optional<U>&&>::value
+		     && !std::is_convertible<optional<U>&, T>::value && !std::is_convertible<optional<U>&&, T>::value
+		     && !std::is_convertible<const optional<U>&, T>::value && !std::is_convertible<const optional<U>&&, T>::value
+		     && !std::is_assignable<T&, optional<U>&>::value && !std::is_assignable<T&, optional<U>&&>::value
+		     && !std::is_assignable<T&, const optional<U>&>::value && !std::is_assignable<T&, const optional<U>&&>::value>;
+
+#ifdef _MSC_VER
+		// TODO make a version which works with MSVC
+		template <class T, class U = T>
+		struct is_swappable : std::true_type { };
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable : std::true_type { };
+#else
+		// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
+		namespace swap_adl_tests {
+			// if swap ADL finds this then it would call std::swap otherwise (same
+			// signature)
+			struct tag { };
+
+			template <class T>
+			tag swap(T&, T&);
+			template <class T, std::size_t N>
+			tag swap(T (&a)[N], T (&b)[N]);
+
+			// helper functions to test if an unqualified swap is possible, and if it
+			// becomes std::swap
+			template <class, class>
+			std::false_type can_swap(...) noexcept(false);
+			template <class T, class U, class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
+			std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T&>(), std::declval<U&>())));
+
+			template <class, class>
+			std::false_type uses_std(...);
+			template <class T, class U>
+			std::is_same<decltype(swap(std::declval<T&>(), std::declval<U&>())), tag> uses_std(int);
+
+			template <class T>
+			struct is_std_swap_noexcept
+			: std::integral_constant<bool, std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value> { };
+
+			template <class T, std::size_t N>
+			struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> { };
+
+			template <class T, class U>
+			struct is_adl_swap_noexcept : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> { };
+		} // namespace swap_adl_tests
+
+		template <class T, class U = T>
+		struct is_swappable : std::integral_constant<bool,
+		                           decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value
+		                                && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+		                                     || (std::is_move_assignable<T>::value && std::is_move_constructible<T>::value))> { };
+
+		template <class T, std::size_t N>
+		struct is_swappable<T[N], T[N]> : std::integral_constant<bool,
+		                                       decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value
+		                                            && (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value || is_swappable<T, T>::value)> { };
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable
+		: std::integral_constant<bool,
+		       is_swappable<T, U>::value
+		            && ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_std_swap_noexcept<T>::value)
+		                 || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> { };
+#endif
+
+		// The storage base manages the actual storage, and correctly propagates
+		// trivial destroyion from T. This case is for when T is not trivially
+		// destructible.
+		template <class T, bool = ::std::is_trivially_destructible<T>::value>
+		struct optional_storage_base {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			~optional_storage_base() {
+				if (m_has_value) {
+					m_value.~T();
+					m_has_value = false;
+				}
+			}
+
+			struct dummy { };
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value;
+		};
+
+		// This case is for when T is trivially destructible.
+		template <class T>
+		struct optional_storage_base<T, true> {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			// No destructor, so this class is trivially destructible
+
+			struct dummy { };
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value = false;
+		};
+
+		// This base class provides some handy member functions which can be used in
+		// further derived classes
+		template <class T>
+		struct optional_operations_base : optional_storage_base<T> {
+			using optional_storage_base<T>::optional_storage_base;
+
+			void hard_reset() noexcept {
+				get().~T();
+				this->m_has_value = false;
+			}
+
+			template <class... Args>
+			void construct(Args&&... args) noexcept {
+				new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
+				this->m_has_value = true;
+			}
+
+			template <class Opt>
+			void assign(Opt&& rhs) {
+				if (this->has_value()) {
+					if (rhs.has_value()) {
+						this->m_value = std::forward<Opt>(rhs).get();
+					}
+					else {
+						this->m_value.~T();
+						this->m_has_value = false;
+					}
+				}
+
+				else if (rhs.has_value()) {
+					construct(std::forward<Opt>(rhs).get());
+				}
+			}
+
+			bool has_value() const {
+				return this->m_has_value;
+			}
+
+			SOL_TL_OPTIONAL_11_CONSTEXPR T& get() & {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR const T& get() const& {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR T&& get() && {
+				return std::move(this->m_value);
+			}
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+			constexpr const T&& get() const&& {
+				return std::move(this->m_value);
+			}
+#endif
+		};
+
+		// This class manages conditionally having a trivial copy constructor
+		// This specialization is for when T is trivially copy constructible
+		template <class T, bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
+		struct optional_copy_base : optional_operations_base<T> {
+			using optional_operations_base<T>::optional_operations_base;
+		};
+
+		// This specialization is for when T is not trivially copy constructible
+		template <class T>
+		struct optional_copy_base<T, false> : optional_operations_base<T> {
+			using base_t = optional_operations_base<T>;
+
+			using base_t::base_t;
+
+			optional_copy_base() = default;
+			optional_copy_base(const optional_copy_base& rhs) : base_t() {
+				if (rhs.has_value()) {
+					this->construct(rhs.get());
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+
+			optional_copy_base(optional_copy_base&& rhs) = default;
+			optional_copy_base& operator=(const optional_copy_base& rhs) = default;
+			optional_copy_base& operator=(optional_copy_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T, bool = std::is_trivially_move_constructible<T>::value>
+		struct optional_move_base : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_base;
+#endif
+		template <class T>
+		struct optional_move_base<T, false> : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+
+			optional_move_base() = default;
+			optional_move_base(const optional_move_base& rhs) = default;
+
+			optional_move_base(optional_move_base&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value) {
+				if (rhs.has_value()) {
+					this->construct(std::move(rhs.get()));
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+			optional_move_base& operator=(const optional_move_base& rhs) = default;
+			optional_move_base& operator=(optional_move_base&& rhs) = default;
+		};
+
+		// This class manages conditionally having a trivial copy assignment operator
+		template <class T,
+		     bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) && SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)
+		          && SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
+		struct optional_copy_assign_base : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+		};
+
+		template <class T>
+		struct optional_copy_assign_base<T, false> : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+
+			optional_copy_assign_base() = default;
+			optional_copy_assign_base(const optional_copy_assign_base& rhs) = default;
+
+			optional_copy_assign_base(optional_copy_assign_base&& rhs) = default;
+			optional_copy_assign_base& operator=(const optional_copy_assign_base& rhs) {
+				this->assign(rhs);
+				return *this;
+			}
+			optional_copy_assign_base& operator=(optional_copy_assign_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T,
+		     bool = std::is_trivially_destructible<T>::value&& std::is_trivially_move_constructible<T>::value&& std::is_trivially_move_assignable<T>::value>
+		struct optional_move_assign_base : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_assign_base;
+#endif
+
+		template <class T>
+		struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+
+			optional_move_assign_base() = default;
+			optional_move_assign_base(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base(optional_move_assign_base&& rhs) = default;
+
+			optional_move_assign_base& operator=(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base& operator=(optional_move_assign_base&& rhs) noexcept(
+			     std::is_nothrow_move_constructible<T>::value&& std::is_nothrow_move_assignable<T>::value) {
+				this->assign(std::move(rhs));
+				return *this;
+			}
+		};
+
+		// optional_delete_ctor_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible
+		template <class T, bool EnableCopy = std::is_copy_constructible<T>::value, bool EnableMove = std::is_move_constructible<T>::value>
+		struct optional_delete_ctor_base {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, true, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, true> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		// optional_delete_assign_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible + assignable
+		template <class T, bool EnableCopy = (std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value),
+		     bool EnableMove = (std::is_move_constructible<T>::value && std::is_move_assignable<T>::value)>
+		struct optional_delete_assign_base {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, true, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, true> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+	} // namespace detail
+
+	/// \brief A tag type to represent an empty optional
+	using nullopt_t = std::nullopt_t;
+
+	/// \brief Represents an empty optional
+	/// \synopsis static constexpr nullopt_t nullopt;
+	///
+	/// *Examples*:
+	/// ```
+	/// sol::optional<int> a = sol::nullopt;
+	/// void foo (sol::optional<int>);
+	/// foo(sol::nullopt); //pass an empty optional
+	/// ```
+	using std::nullopt;
+
+	/// @brief An exception for when an optional is accessed through specific methods while it is not engaged.
+	class bad_optional_access : public std::exception {
+	public:
+		/// @brief Default-constructs an optional exception.
+		bad_optional_access() = default;
+		/// @brief Returns a pointer to a null-terminated string containing the reason for the exception.
+		const char* what() const noexcept override {
+			return "Optional has no value";
+		}
+	};
+
+	/// An optional object is an object that contains the storage for another
+	/// object and manages the lifetime of this contained object, if any. The
+	/// contained object may be initialized after the optional object has been
+	/// initialized, and may be destroyed before the optional object has been
+	/// destroyed. The initialization state of the contained object is tracked by
+	/// the optional object.
+	template <class T>
+	class optional : private detail::optional_move_assign_base<T>,
+	                 private detail::optional_delete_ctor_base<T>,
+	                 private detail::optional_delete_assign_base<T> {
+		using base = detail::optional_move_assign_base<T>;
+
+		static_assert(!std::is_same<T, in_place_t>::value, "instantiation of optional with in_place_t is ill-formed");
+		static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value, "instantiation of optional with nullopt_t is ill-formed");
+
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise the return value of
+		/// `std::invoke(std::forward<F>(f), value())` is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`.
+		/// \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept = default;
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value in-place using the given arguments.
+		/// \group in_place
+		/// \synopsis template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+		template <class... Args>
+		constexpr explicit optional(detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>, Args&&... args)
+		: base(in_place, std::forward<Args>(args)...) {
+		}
+
+		/// \group in_place
+		/// \synopsis template <class U, class... Args> \n constexpr explicit optional(in_place_t, std::initializer_list<U>&, Args&&... args);
+		template <class U, class... Args>
+		SOL_TL_OPTIONAL_11_CONSTEXPR explicit optional(detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t>,
+		     std::initializer_list<U> il, Args&&... args) {
+			this->construct(il, std::forward<Args>(args)...);
+		}
+
+#if 0 // SOL_MODIFICATION
+      /// Constructs the stored value with `u`.
+      /// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+
+		/// \exclude
+		template <class U = T, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr explicit optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+#else
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		constexpr optional(T&& u) : base(in_place, std::move(u)) {
+		}
+
+		/// \exclude
+		constexpr optional(const T& u) : base(in_place, u) {
+		}
+#endif // sol2 modification
+
+		/// Converting copy constructor.
+		/// \synopsis template <class U> optional(const optional<U> &rhs);
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<std::is_convertible<const U&, T>::value>* = nullptr>
+		optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<!std::is_convertible<const U&, T>::value>* = nullptr>
+		explicit optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// Converting move constructor.
+		/// \synopsis template <class U> optional(optional<U> &&rhs);
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr>
+		optional(optional<U>&& rhs) {
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr>
+		explicit optional(optional<U>&& rhs) {
+			this->construct(std::move(*rhs));
+		}
+
+		/// Destroys the stored value if there is one.
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Move assignment.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(optional&& rhs) = default;
+
+		/// Assigns the stored value from `u`, destroying the old value if there was
+		/// one.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_assign_forward<T, U>* = nullptr>
+		optional& operator=(U&& u) {
+			if (has_value()) {
+				this->m_value = std::forward<U>(u);
+			}
+			else {
+				this->construct(std::forward<U>(u));
+			}
+
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(const optional<U> & rhs);
+		template <class U, detail::enable_assign_from_other<T, U, const U&>* = nullptr>
+		optional& operator=(const optional<U>& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = *rhs;
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+
+			return *this;
+		}
+
+		// TODO check exception guarantee
+		/// Converting move assignment operator.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(optional<U> && rhs);
+		template <class U, detail::enable_assign_from_other<T, U, U>* = nullptr>
+		optional& operator=(optional<U>&& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = std::move(*rhs);
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// \group emplace
+		/// \synopsis template <class U, class... Args> \n T& emplace(std::initializer_list<U> il, Args &&... args);
+		template <class U, class... Args>
+		detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&> emplace(std::initializer_list<U> il, Args&&... args) {
+			*this = nullopt;
+			this->construct(il, std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept(std::is_nothrow_move_constructible<T>::value&& detail::is_nothrow_swappable<T>::value) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					using std::swap;
+					swap(**this, *rhs);
+				}
+				else {
+					new (std::addressof(rhs.m_value)) T(std::move(this->m_value));
+					this->m_value.T::~T();
+				}
+			}
+			else if (rhs.has_value()) {
+				new (std::addressof(this->m_value)) T(std::move(rhs.m_value));
+				rhs.m_value.T::~T();
+			}
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return std::addressof(this->m_value);
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return std::addressof(this->m_value);
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() & {
+			return this->m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const& {
+			return this->m_value;
+		}
+
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& operator*() && {
+			return std::move(this->m_value);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		constexpr const T&& operator*() const&& {
+			return std::move(this->m_value);
+		}
+#endif
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// \synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() & {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const& {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& value() && {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T&& value() const&& {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+#endif
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T value_or(U&& u) const& {
+			static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be copy constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// \group value_or
+		template <class U>
+		SOL_TL_OPTIONAL_11_CONSTEXPR T value_or(U&& u) && {
+			static_assert(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be move constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+		}
+	}; // namespace sol
+
+	/// \group relop
+	/// \brief Compares two optional objects
+	/// \details If both optionals contain a value, they are compared with `T`s
+	/// relational operators. Otherwise `lhs` and `rhs` are equal only if they are
+	/// both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs`
+	/// is not.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() == rhs.has_value() && (!lhs.has_value() || *lhs == *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() != rhs.has_value() || (lhs.has_value() && *lhs != *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs) {
+		return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
+	}
+
+	/// \group relop_nullopt
+	/// \brief Compares an optional to a `nullopt`
+	/// \details Equivalent to comparing the optional to an empty optional
+	template <class T>
+	inline constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator==(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+
+	/// \group relop_t
+	/// \brief Compares the optional with a value.
+	/// \details If the optional has a value, it is compared with the other value
+	/// using `T`s relational operators. Otherwise, the optional is considered
+	/// less than the value.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs == rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator==(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs == *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs != rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs != *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs < rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs < *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs <= rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs <= *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs > rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs > *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs >= rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs >= *rhs : true;
+	}
+
+	/// \synopsis template <class T>  \n  void swap(optional<T> &lhs, optional<T> &rhs);
+	template <class T, detail::enable_if_t<std::is_move_constructible<T>::value>* = nullptr, detail::enable_if_t<detail::is_swappable<T>::value>* = nullptr>
+	void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+		return lhs.swap(rhs);
+	}
+
+	namespace detail {
+		struct i_am_secret { };
+	} // namespace detail
+
+	template <class T = detail::i_am_secret, class U, class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
+	inline constexpr optional<Ret> make_optional(U&& v) {
+		return optional<Ret>(std::forward<U>(v));
+	}
+
+	template <class T, class... Args>
+	inline constexpr optional<T> make_optional(Args&&... args) {
+		return optional<T>(in_place, std::forward<Args>(args)...);
+	}
+	template <class T, class U, class... Args>
+	inline constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
+		return optional<T>(in_place, il, std::forward<Args>(args)...);
+	}
+
+#if __cplusplus >= 201703L
+	template <class T>
+	optional(T) -> optional<T>;
+#endif
+
+	/// \exclude
+	namespace detail {
+#ifdef SOL_TL_OPTIONAL_CXX14
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+		auto optional_map_impl(Opt&& opt, F&& f) {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return make_optional(monostate {});
+			}
+
+			return optional<monostate>(nullopt);
+		}
+#else
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) -> optional<Ret> {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+
+		auto optional_map_impl(Opt&& opt, F&& f) -> optional<monostate> {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return monostate {};
+			}
+
+			return nullopt;
+		}
+#endif
+	} // namespace detail
+
+	/// Specialization for when `T` is a reference. `optional<T&>` acts similarly
+	/// to a `T*`, but provides more operations and shows intent more clearly.
+	///
+	/// *Examples*:
+	///
+	/// ```
+	/// int i = 42;
+	/// sol::optional<int&> o = i;
+	/// *o == 42; //true
+	/// i = 12;
+	/// *o = 12; //true
+	/// &*o == &i; //true
+	/// ```
+	///
+	/// Assignment has rebind semantics rather than assign-through semantics:
+	///
+	/// ```
+	/// int j = 8;
+	/// o = j;
+	///
+	/// &*o == &j; //true
+	/// ```
+	template <class T>
+	class optional<T&> {
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`. \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T&;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept : m_value(nullptr) {
+		}
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept : m_value(nullptr) {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) noexcept = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		constexpr optional(U&& u) : m_value(std::addressof(u)) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+		}
+
+		/// \exclude
+		template <class U>
+		constexpr explicit optional(const optional<U>& rhs) : optional(*rhs) {
+		}
+
+		/// No-op
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			m_value = nullptr;
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Rebinds this optional to `u`.
+		///
+		/// \requires `U` must be an lvalue reference.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		optional& operator=(U&& u) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+			m_value = std::addressof(u);
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		template <class U>
+		optional& operator=(const optional<U>& rhs) {
+			m_value = std::addressof(rhs.value());
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		///
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) noexcept {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept {
+			std::swap(m_value, rhs.m_value);
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return m_value;
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return m_value;
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() {
+			return *m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const {
+			return *m_value;
+		}
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T& value_or(U&& u) const {
+			static_assert(std::is_convertible<U&&, T&>::value, "T must be convertible from U");
+			return has_value() ? const_cast<T&>(**this) : static_cast<T&>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			m_value = nullptr;
+		}
+
+	private:
+		T* m_value;
+	};
+
+} // namespace sol
+
+namespace std {
+	// TODO SFINAE
+	template <class T>
+	struct hash<::sol::optional<T>> {
+		::std::size_t operator()(const ::sol::optional<T>& o) const {
+			if (!o.has_value())
+				return 0;
+
+			return ::std::hash<::sol::detail::remove_const_t<T>>()(*o);
+		}
+	};
+} // namespace std
+
+// end of sol/optional_implementation.hpp
+
+#endif // Boost vs. Better optional
+
+#include <optional>
+
+namespace sol {
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	template <typename T>
+	using optional = boost::optional<T>;
+	using nullopt_t = boost::none_t;
+	SOL_BOOST_NONE_CONSTEXPR_I_ nullopt_t nullopt = boost::none;
+#endif // Boost vs. Better optional
+
+	namespace meta {
+		template <typename T>
+		using is_optional = any<is_specialization_of<T, optional>, is_specialization_of<T, std::optional>>;
+
+		template <typename T>
+		constexpr inline bool is_optional_v = is_optional<T>::value;
+	} // namespace meta
+
+	namespace detail {
+		template <typename T>
+		struct associated_nullopt {
+			inline static constexpr std::nullopt_t value = std::nullopt;
+		};
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+		template <typename T>
+		struct associated_nullopt<boost::optional<T>> {
+			inline static SOL_BOOST_NONE_CONSTEXPR_I_ boost::none_t value = boost::none;
+		};
+#endif // Boost nullopt
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+		template <typename T>
+		inline SOL_BOOST_NONE_CONSTEXPR_I_ auto associated_nullopt_v = associated_nullopt<T>::value;
+#else
+		template <typename T>
+		inline constexpr auto associated_nullopt_v = associated_nullopt<T>::value;
+#endif // Boost continues to lag behind, to not many people's surprise...
+	} // namespace detail
+} // namespace sol
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+#undef SOL_BOOST_NONE_CONSTEXPR_I_
+#endif
+
+// end of sol/optional.hpp
+
+// beginning of sol/raii.hpp
+
+#include <memory>
+
+namespace sol {
+	namespace detail {
+		struct default_construct {
+			template <typename T, typename... Args>
+			static void construct(T&& obj, Args&&... args) {
+				typedef meta::unqualified_t<T> Tu;
+				std::allocator<Tu> alloc {};
+				std::allocator_traits<std::allocator<Tu>>::construct(alloc, std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+
+			template <typename T, typename... Args>
+			void operator()(T&& obj, Args&&... args) const {
+				construct(std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+		};
+
+		struct default_destroy {
+			template <typename T>
+			static void destroy(T&& obj) {
+				std::allocator<meta::unqualified_t<T>> alloc {};
+				alloc.destroy(obj);
+			}
+
+			template <typename T>
+			void operator()(T&& obj) const {
+				destroy(std::forward<T>(obj));
+			}
+		};
+
+		struct deleter {
+			template <typename T>
+			void operator()(T* p) const {
+				delete p;
+			}
+		};
+
+		struct state_deleter {
+			void operator()(lua_State* L) const {
+				lua_close(L);
+			}
+		};
+
+		template <typename T, typename Dx, typename... Args>
+		inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) {
+			return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
+		}
+
+		template <typename Tag, typename T>
+		struct tagged {
+		private:
+			T value_;
+
+		public:
+			template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler>
+			tagged(Arg&& arg, Args&&... args) : value_(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+			}
+
+			T& value() & {
+				return value_;
+			}
+
+			T const& value() const& {
+				return value_;
+			}
+
+			T&& value() && {
+				return std::move(value_);
+			}
+		};
+	} // namespace detail
+
+	template <typename... Args>
+	struct constructor_list { };
+
+	template <typename... Args>
+	using constructors = constructor_list<Args...>;
+
+	const auto default_constructor = constructors<types<>> {};
+
+	struct no_construction { };
+	const auto no_constructor = no_construction {};
+
+	struct call_construction { };
+	const auto call_constructor = call_construction {};
+
+	template <typename... Functions>
+	struct constructor_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler>
+		constructor_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto initializers(Functions&&... functions) {
+		return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename... Functions>
+	struct factory_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler>
+		factory_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto factories(Functions&&... functions) {
+		return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename Function>
+	struct destructor_wrapper {
+		Function fx;
+		destructor_wrapper(Function f) : fx(std::move(f)) {
+		}
+	};
+
+	template <>
+	struct destructor_wrapper<void> { };
+
+	const destructor_wrapper<void> default_destructor {};
+
+	template <typename Fx>
+	inline auto destructor(Fx&& fx) {
+		return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));
+	}
+
+} // namespace sol
+
+// end of sol/raii.hpp
+
+// beginning of sol/policies.hpp
+
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct policy_base_tag { };
+	} // namespace detail
+
+	template <int Target, int... In>
+	struct static_stack_dependencies : detail::policy_base_tag { };
+	typedef static_stack_dependencies<-1, 1> self_dependency;
+	template <int... In>
+	struct returns_self_with : detail::policy_base_tag { };
+	typedef returns_self_with<> returns_self;
+
+	struct stack_dependencies : detail::policy_base_tag {
+		int target;
+		std::array<int, 64> stack_indices;
+		std::size_t len;
+
+		template <typename... Args>
+		stack_dependencies(int stack_target, Args&&... args) : target(stack_target), stack_indices(), len(sizeof...(Args)) {
+			std::size_t i = 0;
+			(void)detail::swallow { int(), (stack_indices[i++] = static_cast<int>(std::forward<Args>(args)), int())... };
+		}
+
+		int& operator[](std::size_t i) {
+			return stack_indices[i];
+		}
+
+		const int& operator[](std::size_t i) const {
+			return stack_indices[i];
+		}
+
+		std::size_t size() const {
+			return len;
+		}
+	};
+
+	template <typename F, typename... Policies>
+	struct policy_wrapper {
+		typedef std::index_sequence_for<Policies...> indices;
+
+		F value;
+		std::tuple<Policies...> policies;
+
+		template <typename Fx, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<Fx>, policy_wrapper>>> = meta::enabler>
+		policy_wrapper(Fx&& fx, Args&&... args) : value(std::forward<Fx>(fx)), policies(std::forward<Args>(args)...) {
+		}
+
+		policy_wrapper(const policy_wrapper&) = default;
+		policy_wrapper& operator=(const policy_wrapper&) = default;
+		policy_wrapper(policy_wrapper&&) = default;
+		policy_wrapper& operator=(policy_wrapper&&) = default;
+	};
+
+	template <typename F, typename... Args>
+	auto policies(F&& f, Args&&... args) {
+		return policy_wrapper<std::decay_t<F>, std::decay_t<Args>...>(std::forward<F>(f), std::forward<Args>(args)...);
+	}
+
+	namespace detail {
+		template <typename T>
+		using is_policy = meta::is_specialization_of<T, policy_wrapper>;
+
+		template <typename T>
+		inline constexpr bool is_policy_v = is_policy<T>::value;
+	} // namespace detail
+} // namespace sol
+
+// end of sol/policies.hpp
+
+// beginning of sol/ebco.hpp
+
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace sol { namespace detail {
+
+	template <typename T, std::size_t tag = 0, typename = void>
+	struct ebco {
+		T m_value;
+
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) : m_value(v) {};
+		ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : m_value(std::move(v)) {};
+		ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			m_value = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
+			m_value = std::move(v);
+			return *this;
+		};
+		template <typename Arg, typename... Args,
+			typename = std::enable_if_t<
+			     !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+			          ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
+		ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>)
+		: m_value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		T& value() & noexcept {
+			return m_value;
+		}
+
+		T const& value() const& noexcept {
+			return m_value;
+		}
+
+		T&& value() && noexcept {
+			return std::move(m_value);
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T, tag, std::enable_if_t<!std::is_reference_v<T> && std::is_class_v<T> && !std::is_final_v<T>>> : T {
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) : T(v) {};
+		ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : T(std::move(v)) {};
+		template <typename Arg, typename... Args,
+			typename = std::enable_if_t<
+			     !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+			          ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
+		ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>) : T(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			static_cast<T&>(*this) = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
+			static_cast<T&>(*this) = std::move(v);
+			return *this;
+		};
+
+		T& value() & noexcept {
+			return static_cast<T&>(*this);
+		}
+
+		T const& value() const& noexcept {
+			return static_cast<T const&>(*this);
+		}
+
+		T&& value() && noexcept {
+			return std::move(static_cast<T&>(*this));
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&, tag> {
+	private:
+		T* m_ref;
+
+	public:
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(T& v) noexcept : m_ref(std::addressof(v)) {};
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(T& v) noexcept {
+			m_ref = std::addressof(v);
+			return *this;
+		}
+
+		T& value() const noexcept {
+			return *(const_cast<ebco<T&, tag>&>(*this).m_ref);
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&&, tag> {
+		T&& ref;
+
+		ebco() = default;
+		ebco(const ebco&) = delete;
+		ebco(ebco&&) = default;
+		ebco(T&& v) noexcept : ref(v) {};
+
+		ebco& operator=(const ebco&) = delete;
+		ebco& operator=(ebco&&) = delete;
+
+		T& value() & noexcept {
+			return ref;
+		}
+
+		const T& value() const& noexcept {
+			return ref;
+		}
+
+		T&& value() && noexcept {
+			return std::move(ref);
+		}
+	};
+
+}} // namespace sol::detail
+
+// end of sol/ebco.hpp
+
+#include <array>
+#include <initializer_list>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <memory>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol {
+	namespace d {
+		// shortest possible hidden detail namespace
+		// when types are transcribed, this saves
+		// quite a bit of space, actually.
+		// it's a little unfortunate, but here we are?
+		template <typename T>
+		struct u { };
+	} // namespace d
+
+	namespace detail {
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		typedef int (*lua_CFunction_noexcept)(lua_State* L) noexcept;
+#else
+		typedef int (*lua_CFunction_noexcept)(lua_State* L);
+#endif // noexcept function type for lua_CFunction
+
+		template <typename T>
+		struct implicit_wrapper {
+			T& value;
+
+			implicit_wrapper(T* value_) : value(*value_) {
+			}
+
+			implicit_wrapper(T& value_) : value(value_) {
+			}
+
+			operator T&() {
+				return value;
+			}
+
+			operator T*() {
+				return std::addressof(value);
+			}
+		};
+
+		struct yield_tag_t { };
+		inline constexpr yield_tag_t yield_tag {};
+	} // namespace detail
+
+	struct lua_nil_t { };
+	inline constexpr lua_nil_t lua_nil {};
+	inline bool operator==(lua_nil_t, lua_nil_t) {
+		return true;
+	}
+	inline bool operator!=(lua_nil_t, lua_nil_t) {
+		return false;
+	}
+#if SOL_IS_ON(SOL_NIL)
+	using nil_t = lua_nil_t;
+	inline constexpr const nil_t& nil = lua_nil;
+#endif
+
+	namespace detail {
+		struct non_lua_nil_t { };
+	} // namespace detail
+
+	struct metatable_key_t { };
+	inline constexpr metatable_key_t metatable_key {};
+
+	struct global_tag_t {
+	} inline constexpr global_tag {};
+
+	struct env_key_t { };
+	inline constexpr env_key_t env_key {};
+
+	struct no_metatable_t { };
+	inline constexpr no_metatable_t no_metatable {};
+
+	template <typename T>
+	struct yielding_t {
+		T func;
+
+		yielding_t() = default;
+		yielding_t(const yielding_t&) = default;
+		yielding_t(yielding_t&&) = default;
+		yielding_t& operator=(const yielding_t&) = default;
+		yielding_t& operator=(yielding_t&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, yielding_t>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		yielding_t(Arg&& arg) : func(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		yielding_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : func(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename F>
+	inline yielding_t<std::decay_t<F>> yielding(F&& f) {
+		return yielding_t<std::decay_t<F>>(std::forward<F>(f));
+	}
+
+	typedef std::remove_pointer_t<lua_CFunction> lua_CFunction_ref;
+
+	template <typename T>
+	struct non_null { };
+
+	template <typename... Args>
+	struct function_sig { };
+
+	struct upvalue_index {
+		int index;
+		upvalue_index(int idx) : index(lua_upvalueindex(idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct raw_index {
+		int index;
+		raw_index(int i) : index(i) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct absolute_index {
+		int index;
+		absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct ref_index {
+		int index;
+		ref_index(int idx) : index(idx) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct stack_count {
+		int count;
+
+		stack_count(int cnt) : count(cnt) {
+		}
+	};
+
+	struct lightuserdata_value {
+		void* value;
+		lightuserdata_value(void* data) : value(data) {
+		}
+		operator void*() const {
+			return value;
+		}
+	};
+
+	struct userdata_value {
+	private:
+		void* m_value;
+
+	public:
+		userdata_value(void* data) : m_value(data) {
+		}
+
+		void* value() const {
+			return m_value;
+		}
+
+		operator void*() const {
+			return value();
+		}
+	};
+
+	template <typename T>
+	struct light {
+	private:
+		static_assert(!std::is_void_v<T>, "the type for light will never be void");
+		T* m_value;
+
+	public:
+		light(T& x) : m_value(std::addressof(x)) {
+		}
+		light(T* x) : m_value(x) {
+		}
+		explicit light(void* x) : m_value(static_cast<T*>(x)) {
+		}
+
+		T* value() const {
+			return m_value;
+		}
+
+		operator T*() const {
+			return m_value;
+		}
+		operator T&() const {
+			return *m_value;
+		}
+
+		void* void_value() const {
+			return m_value;
+		}
+	};
+
+	template <typename T>
+	auto make_light(T& l) {
+		typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
+		return light<L>(l);
+	}
+
+	template <typename T>
+	struct user : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		using base_t::value;
+
+		operator std::add_pointer_t<std::remove_reference_t<T>>() {
+			return std::addressof(this->base_t::value());
+		}
+
+		operator std::add_pointer_t<std::add_const_t<std::remove_reference_t<T>>>() const {
+			return std::addressof(this->base_t::value());
+		}
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>&() const {
+			return this->base_t::value();
+		}
+	};
+
+	template <typename T>
+	auto make_user(T&& u) {
+		typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
+		return user<U>(std::forward<T>(u));
+	}
+
+	template <typename T>
+	struct metatable_registry_key : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename T>
+	auto meta_registry_key(T&& key) {
+		typedef meta::unqualified_t<T> K;
+		return metatable_registry_key<K>(std::forward<T>(key));
+	}
+
+	template <typename... Upvalues>
+	struct closure {
+		lua_CFunction c_function;
+		std::tuple<Upvalues...> upvalues;
+		closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {
+		}
+	};
+
+	template <>
+	struct closure<> {
+		lua_CFunction c_function;
+		int upvalues;
+		closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {
+		}
+	};
+
+	typedef closure<> c_closure;
+
+	template <typename... Args>
+	closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
+		return closure<Args...>(f, std::forward<Args>(args)...);
+	}
+
+	template <typename Sig, typename... Ps>
+	struct function_arguments {
+		std::tuple<Ps...> arguments;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, function_arguments>> = meta::enabler>
+		function_arguments(Arg&& arg, Args&&... args) : arguments(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function(Args&&... args) {
+		return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function_reference(Args&&... args) {
+		return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	struct as_table_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		as_table_t() = default;
+		as_table_t(const as_table_t&) = default;
+		as_table_t(as_table_t&&) = default;
+		as_table_t& operator=(const as_table_t&) = default;
+		as_table_t& operator=(as_table_t&&) = default;
+		as_table_t(const meta::unqualified_t<T>& obj) noexcept(std::is_nothrow_constructible_v<base_t, const meta::unqualified_t<T>&>) : base_t(obj) {
+		}
+		as_table_t(meta::unqualified_t<T>&& obj) noexcept(std::is_nothrow_constructible_v<base_t, meta::unqualified_t<T>&&>) : base_t(std::move(obj)) {
+		}
+		template <typename Arg, typename... Args,
+		     std::enable_if_t<
+		          !std::is_same_v<as_table_t, meta::unqualified_t<Arg>> && !std::is_same_v<meta::unqualified_t<T>, meta::unqualified_t<Arg>>>* = nullptr>
+		as_table_t(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<base_t, Arg, Args...>)
+		: base_t(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>() const {
+			return this->base_t::value();
+		}
+	};
+
+	template <typename T>
+	struct nested : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using nested_type = T;
+
+		nested() = default;
+		nested(const nested&) = default;
+		nested(nested&&) = default;
+		nested& operator=(const nested&) = default;
+		nested& operator=(nested&&) = default;
+		nested(const meta::unqualified_t<T>& obj) noexcept(std::is_nothrow_constructible_v<base_t, const meta::unqualified_t<T>&>) : base_t(obj) {
+		}
+		nested(meta::unqualified_t<T>&& obj) noexcept(std::is_nothrow_constructible_v<base_t, meta::unqualified_t<T>&&>) : base_t(std::move(obj)) {
+		}
+		template <typename Arg, typename... Args,
+		     std::enable_if_t<
+		          !std::is_same_v<nested, meta::unqualified_t<Arg>> && !std::is_same_v<meta::unqualified_t<T>, meta::unqualified_t<Arg>>>* = nullptr>
+		nested(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<base_t, Arg, Args...>)
+		: base_t(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>() const {
+			return this->base_t::value();
+		}
+	};
+
+	struct nested_tag_t { };
+	constexpr inline nested_tag_t nested_tag {};
+
+	template <typename T>
+	as_table_t<T> as_table_ref(T&& container) {
+		return as_table_t<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	as_table_t<meta::unqualified_t<T>> as_table(T&& container) {
+		return as_table_t<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<T> as_nested_ref(T&& container) {
+		return nested<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<meta::unqualified_t<T>> as_nested(T&& container) {
+		return nested<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	struct as_container_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using type = T;
+
+		as_container_t() = default;
+		as_container_t(const as_container_t&) = default;
+		as_container_t(as_container_t&&) = default;
+		as_container_t& operator=(const as_container_t&) = default;
+		as_container_t& operator=(as_container_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return value();
+		}
+	};
+
+	template <typename T>
+	auto as_container(T&& value) {
+		return as_container_t<T>(std::forward<T>(value));
+	}
+
+	template <typename T>
+	struct push_invoke_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		push_invoke_t() = default;
+		push_invoke_t(const push_invoke_t&) = default;
+		push_invoke_t(push_invoke_t&&) = default;
+		push_invoke_t& operator=(const push_invoke_t&) = default;
+		push_invoke_t& operator=(push_invoke_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename Fx>
+	auto push_invoke(Fx&& fx) {
+		return push_invoke_t<Fx>(std::forward<Fx>(fx));
+	}
+
+	template <typename T>
+	struct forward_as_value_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		forward_as_value_t() = default;
+		forward_as_value_t(const forward_as_value_t&) = default;
+		forward_as_value_t(forward_as_value_t&&) = default;
+		forward_as_value_t& operator=(const forward_as_value_t&) = default;
+		forward_as_value_t& operator=(forward_as_value_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename T>
+	auto pass_as_value(T& value_ref_) {
+		return forward_as_value_t<T>(value_ref_);
+	}
+
+	struct override_value_t { };
+	constexpr inline override_value_t override_value = override_value_t();
+	struct update_if_empty_t { };
+	constexpr inline update_if_empty_t update_if_empty = update_if_empty_t();
+	struct create_if_nil_t { };
+	constexpr inline create_if_nil_t create_if_nil = create_if_nil_t();
+
+	namespace detail {
+		enum insert_mode { none = 0x0, update_if_empty = 0x01, override_value = 0x02, create_if_nil = 0x04 };
+
+		template <typename T, typename...>
+		using is_insert_mode = std::integral_constant<bool,
+		     std::is_same_v<T, override_value_t> || std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, create_if_nil_t>>;
+
+		template <typename T, typename...>
+		using is_not_insert_mode = meta::neg<is_insert_mode<T>>;
+	} // namespace detail
+
+	struct this_state {
+		lua_State* L;
+
+		this_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct this_main_state {
+		lua_State* L;
+
+		this_main_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct new_table {
+		int sequence_hint = 0;
+		int map_hint = 0;
+
+		new_table() = default;
+		new_table(const new_table&) = default;
+		new_table(new_table&&) = default;
+		new_table& operator=(const new_table&) = default;
+		new_table& operator=(new_table&&) = default;
+
+		new_table(int sequence_hint_, int map_hint_ = 0) noexcept : sequence_hint(sequence_hint_), map_hint(map_hint_) {
+		}
+	};
+
+	const new_table create = {};
+
+	enum class lib : unsigned char {
+		// print, assert, and other base functions
+		base,
+		// require and other package functions
+		package,
+		// coroutine functions and utilities
+		coroutine,
+		// string library
+		string,
+		// functionality from the OS
+		os,
+		// all things math
+		math,
+		// the table manipulator and observer functions
+		table,
+		// the debug library
+		debug,
+		// the bit library: different based on which you're using
+		bit32,
+		// input/output library
+		io,
+		// LuaJIT only
+		ffi,
+		// LuaJIT only
+		jit,
+		// library for handling utf8: new to Lua
+		utf8,
+		// do not use
+		count
+	};
+
+	enum class call_syntax { dot = 0, colon = 1 };
+
+	enum class load_mode {
+		any = 0,
+		text = 1,
+		binary = 2,
+	};
+
+	enum class call_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		handler = LUA_ERRERR,
+		gc = LUA_ERRGCMM,
+		syntax = LUA_ERRSYNTAX,
+		file = LUA_ERRFILE,
+	};
+
+	enum class thread_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		handler = LUA_ERRERR,
+		dead = -1,
+	};
+
+	enum class load_status : int {
+		ok = LUA_OK,
+		syntax = LUA_ERRSYNTAX,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		file = LUA_ERRFILE,
+	};
+
+	enum class gc_mode : int {
+		incremental = 0,
+		generational = 1,
+		default_value = incremental,
+	};
+
+	enum class type : int {
+		none = LUA_TNONE,
+		lua_nil = LUA_TNIL,
+#if SOL_IS_ON(SOL_NIL)
+		nil = lua_nil,
+#endif // Objective C/C++ Keyword that's found in OSX SDK and OBJC -- check for all forms to protect
+		string = LUA_TSTRING,
+		number = LUA_TNUMBER,
+		thread = LUA_TTHREAD,
+		boolean = LUA_TBOOLEAN,
+		function = LUA_TFUNCTION,
+		userdata = LUA_TUSERDATA,
+		lightuserdata = LUA_TLIGHTUSERDATA,
+		table = LUA_TTABLE,
+		poly = -0xFFFF
+	};
+
+	inline const std::string& to_string(call_status c) {
+		static const std::array<std::string, 10> names { { "ok",
+			"yielded",
+			"runtime",
+			"memory",
+			"handler",
+			"gc",
+			"syntax",
+			"file",
+			"CRITICAL_EXCEPTION_FAILURE",
+			"CRITICAL_INDETERMINATE_STATE_FAILURE" } };
+		switch (c) {
+		case call_status::ok:
+			return names[0];
+		case call_status::yielded:
+			return names[1];
+		case call_status::runtime:
+			return names[2];
+		case call_status::memory:
+			return names[3];
+		case call_status::handler:
+			return names[4];
+		case call_status::gc:
+			return names[5];
+		case call_status::syntax:
+			return names[6];
+		case call_status::file:
+			return names[7];
+		}
+		if (static_cast<std::ptrdiff_t>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[8];
+		}
+		return names[9];
+	}
+
+	inline bool is_indeterminate_call_failure(call_status c) {
+		switch (c) {
+		case call_status::ok:
+		case call_status::yielded:
+		case call_status::runtime:
+		case call_status::memory:
+		case call_status::handler:
+		case call_status::gc:
+		case call_status::syntax:
+		case call_status::file:
+			return false;
+		}
+		return true;
+	}
+
+	inline const std::string& to_string(load_status c) {
+		static const std::array<std::string, 7> names {
+			{ "ok", "memory", "gc", "syntax", "file", "CRITICAL_EXCEPTION_FAILURE", "CRITICAL_INDETERMINATE_STATE_FAILURE" }
+		};
+		switch (c) {
+		case load_status::ok:
+			return names[0];
+		case load_status::memory:
+			return names[1];
+		case load_status::gc:
+			return names[2];
+		case load_status::syntax:
+			return names[3];
+		case load_status::file:
+			return names[4];
+		}
+		if (static_cast<int>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[5];
+		}
+		return names[6];
+	}
+
+	inline const std::string& to_string(load_mode c) {
+		static const std::array<std::string, 3> names { {
+			"bt",
+			"t",
+			"b",
+		} };
+		return names[static_cast<std::size_t>(c)];
+	}
+
+	enum class meta_function : unsigned {
+		construct,
+		index,
+		new_index,
+		mode,
+		call,
+		call_function = call,
+		metatable,
+		to_string,
+		length,
+		unary_minus,
+		addition,
+		subtraction,
+		multiplication,
+		division,
+		modulus,
+		power_of,
+		involution = power_of,
+		concatenation,
+		equal_to,
+		less_than,
+		less_than_or_equal_to,
+		garbage_collect,
+		floor_division,
+		bitwise_left_shift,
+		bitwise_right_shift,
+		bitwise_not,
+		bitwise_and,
+		bitwise_or,
+		bitwise_xor,
+		pairs,
+		ipairs,
+		next,
+		type,
+		type_info,
+		call_construct,
+		storage,
+		gc_names,
+		static_index,
+		static_new_index,
+	};
+
+	typedef meta_function meta_method;
+
+	inline const std::array<std::string, 37>& meta_function_names() {
+		static const std::array<std::string, 37> names = { { "new",
+			"__index",
+			"__newindex",
+			"__mode",
+			"__call",
+			"__metatable",
+			"__tostring",
+			"__len",
+			"__unm",
+			"__add",
+			"__sub",
+			"__mul",
+			"__div",
+			"__mod",
+			"__pow",
+			"__concat",
+			"__eq",
+			"__lt",
+			"__le",
+			"__gc",
+
+			"__idiv",
+			"__shl",
+			"__shr",
+			"__bnot",
+			"__band",
+			"__bor",
+			"__bxor",
+
+			"__pairs",
+			"__ipairs",
+			"next",
+
+			"__type",
+			"__typeinfo",
+			"__sol.call_new",
+			"__sol.storage",
+			"__sol.gc_names",
+			"__sol.static_index",
+			"__sol.static_new_index" } };
+		return names;
+	}
+
+	inline const std::string& to_string(meta_function mf) {
+		return meta_function_names()[static_cast<std::size_t>(mf)];
+	}
+
+	inline type type_of(lua_State* L, int index) {
+		return static_cast<type>(lua_type(L, index));
+	}
+
+	inline std::string type_name(lua_State* L, type t) {
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	template <typename T>
+	struct is_stateless_lua_reference
+	: std::integral_constant<bool,
+	       (std::is_base_of_v<stateless_stack_reference, T> || std::is_base_of_v<stateless_reference, T>)&&(
+	            !std::is_base_of_v<stack_reference, T> && !std::is_base_of_v<reference, T> && !std::is_base_of_v<main_reference, T>)> { };
+
+	template <typename T>
+	inline constexpr bool is_stateless_lua_reference_v = is_stateless_lua_reference<T>::value;
+
+	template <typename T>
+	struct is_lua_reference
+	: std::integral_constant<bool,
+	       std::is_base_of_v<reference,
+	            T> || std::is_base_of_v<main_reference, T> || std::is_base_of_v<stack_reference, T> || std::is_base_of_v<stateless_stack_reference, T> || std::is_base_of_v<stateless_reference, T>> {
+	};
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value;
+
+	template <typename T>
+	struct is_lua_reference_or_proxy : std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, table_proxy>> { };
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value;
+
+	template <typename T>
+	struct is_transparent_argument
+	: std::integral_constant<bool,
+	       std::is_same_v<meta::unqualified_t<T>,
+	            this_state> || std::is_same_v<meta::unqualified_t<T>, this_main_state> || std::is_same_v<meta::unqualified_t<T>, this_environment> || std::is_same_v<meta::unqualified_t<T>, variadic_args>> {
+	};
+
+	template <typename T>
+	constexpr inline bool is_transparent_argument_v = is_transparent_argument<T>::value;
+
+	template <typename T>
+	struct is_variadic_arguments : meta::any<std::is_same<T, variadic_args>, meta::is_optional<T>> { };
+
+	template <typename T>
+	struct is_container
+	: std::integral_constant<bool,
+	       !std::is_same_v<state_view,
+	            T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> {
+	};
+
+	template <typename T>
+	constexpr inline bool is_container_v = is_container<T>::value;
+
+	template <typename T>
+	struct is_to_stringable : meta::any<meta::supports_to_string_member<meta::unqualified_t<T>>, meta::supports_adl_to_string<meta::unqualified_t<T>>,
+	                               meta::supports_op_left_shift<std::ostream, meta::unqualified_t<T>>> { };
+
+	template <typename T>
+	inline constexpr bool is_to_stringable_v = is_to_stringable<T>::value;
+
+	template <typename T>
+	struct is_callable : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_callable_v = is_callable<T>::value;
+
+	namespace detail {
+		template <typename T, typename = void>
+		struct lua_type_of : std::integral_constant<type, type::userdata> { };
+
+		template <typename C, typename T, typename A>
+		struct lua_type_of<std::basic_string<C, T, A>> : std::integral_constant<type, type::string> { };
+
+		template <typename C, typename T>
+		struct lua_type_of<basic_string_view<C, T>> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <std::size_t N>
+		struct lua_type_of<char8_t[N]> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <std::size_t N>
+		struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <>
+		struct lua_type_of<char8_t> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <>
+		struct lua_type_of<char16_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char32_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const wchar_t*> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <>
+		struct lua_type_of<const char8_t*> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <>
+		struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<bool> : std::integral_constant<type, type::boolean> { };
+
+		template <>
+		struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<lua_value> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<detail::non_lua_nil_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<error> : std::integral_constant<type, type::string> { };
+
+		template <bool b, typename Base>
+		struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lua_table<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_metatable<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename T, typename Base>
+		struct lua_type_of<basic_usertype<T, Base>> : std::integral_constant<type, type::table> { };
+
+		template <>
+		struct lua_type_of<metatable_key_t> : std::integral_constant<type, type::table> { };
+
+		template <typename B>
+		struct lua_type_of<basic_environment<B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<env_key_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<new_table> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<as_table_t<T>> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<std::initializer_list<T>> : std::integral_constant<type, type::table> { };
+
+		template <bool b>
+		struct lua_type_of<basic_reference<b>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> { };
+
+		template <typename... Args>
+		struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> { };
+
+		template <typename A, typename B>
+		struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<const void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> { };
+
+		template <typename T>
+		struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename T>
+		struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> { };
+
+		template <>
+		struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> { };
+
+		template <>
+		struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned>
+		struct lua_type_of<basic_function<Base, aligned>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned, typename Handler>
+		struct lua_type_of<basic_protected_function<Base, aligned, Handler>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_coroutine<Base>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_thread<Base>> : std::integral_constant<type, type::thread> { };
+
+		template <typename Signature>
+		struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <typename T>
+		struct lua_type_of<std::optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_results> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_count> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_main_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_environment> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<type> : std::integral_constant<type, type::poly> { };
+
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, std::is_function_v<T> ? type::function : type::userdata> { };
+#else
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, type::userdata> { };
+#endif
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>>
+		: std::integral_constant<type, type::number> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_function_v<T>>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> { };
+
+		template <>
+		struct lua_type_of<meta_function> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+		template <typename... Tn>
+		struct lua_type_of<std::variant<Tn...>> : std::integral_constant<type, type::poly> { };
+#endif // std::variant deployment sucks on Clang
+
+		template <typename T>
+		struct lua_type_of<nested<T>> : meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> { };
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate : std::integral_constant<C, v> { };
+
+		template <typename C, C v, template <typename...> class V, typename T, typename... Args>
+		struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> { };
+
+		template <typename C, C v, template <typename...> class V, typename List>
+		struct accumulate_list;
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate_list<C, v, V, types<Args...>> : accumulate<C, v, V, Args...> { };
+	} // namespace detail
+
+	template <typename T>
+	struct lua_type_of : detail::lua_type_of<T> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename T>
+	inline constexpr type lua_type_of_v = lua_type_of<T>::value;
+
+	template <typename T>
+	struct lua_size : std::integral_constant<int, 1> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename A, typename B>
+	struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
+
+	template <typename... Args>
+	struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
+
+	template <typename T>
+	inline constexpr int lua_size_v = lua_size<T>::value;
+
+	namespace detail {
+		// MSVC's decltype detection is broken, which breaks other
+		// parts of the code. So we add more workarounds. The moment it's fixed,
+		// we take it away and break everyone that doesn't upgrade.
+		template <typename T>
+		using is_msvc_callable_rigged = meta::any<meta::is_specialization_of<T, push_invoke_t>, meta::is_specialization_of<T, as_table_t>,
+		     meta::is_specialization_of<T, forward_as_value_t>, meta::is_specialization_of<T, as_container_t>, meta::is_specialization_of<T, nested>,
+		     meta::is_specialization_of<T, yielding_t>>;
+
+		template <typename T>
+		inline constexpr bool is_msvc_callable_rigged_v = is_msvc_callable_rigged<T>::value;
+	} // namespace detail
+
+	template <typename T>
+	struct is_lua_primitive
+	: std::integral_constant<bool,
+	       type::userdata
+	                 != lua_type_of_v<
+	                      T> || ((type::userdata == lua_type_of_v<T>)&&meta::meta_detail::has_internal_marker_v<lua_type_of<T>> && !meta::meta_detail::has_internal_marker_v<lua_size<T>>)
+	            || is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> { };
+
+	template <typename T>
+	constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
+
+	template <typename T>
+	struct is_value_semantic_for_function
+#if SOL_IS_ON(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	: std::true_type {
+	};
+#else
+	: std::false_type {
+	};
+#endif
+
+	template <typename T>
+	constexpr inline bool is_value_semantic_for_function_v = is_value_semantic_for_function<T>::value;
+
+	template <typename T>
+	struct is_main_threaded : std::is_base_of<main_reference, T> { };
+
+	template <typename T>
+	inline constexpr bool is_main_threaded_v = is_main_threaded<T>::value;
+
+	template <typename T>
+	struct is_stack_based : std::is_base_of<stack_reference, T> { };
+	template <>
+	struct is_stack_based<variadic_args> : std::true_type { };
+	template <>
+	struct is_stack_based<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<protected_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy_base> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_count> : std::true_type { };
+
+	template <typename T>
+	constexpr inline bool is_stack_based_v = is_stack_based<T>::value;
+
+	template <typename T>
+	struct is_lua_primitive<T*> : std::true_type { };
+	template <>
+	struct is_lua_primitive<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_lua_primitive<protected_function_result> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<user<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
+	template <typename T>
+	struct is_lua_primitive<optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<as_table_t<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<nested<T>> : std::true_type { };
+	template <>
+	struct is_lua_primitive<userdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<lightuserdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy_base> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> { };
+
+	template <typename T>
+	struct is_lua_index : std::is_integral<T> { };
+	template <>
+	struct is_lua_index<raw_index> : std::true_type { };
+	template <>
+	struct is_lua_index<absolute_index> : std::true_type { };
+	template <>
+	struct is_lua_index<ref_index> : std::true_type { };
+	template <>
+	struct is_lua_index<upvalue_index> : std::true_type { };
+
+	template <typename Signature>
+	struct lua_bind_traits : meta::bind_traits<Signature> {
+	private:
+		typedef meta::bind_traits<Signature> base_t;
+
+	public:
+		typedef std::integral_constant<bool, meta::count_for<is_variadic_arguments, typename base_t::args_list>::value != 0> runtime_variadics_t;
+		static const std::size_t true_arity = base_t::arity;
+		static const std::size_t arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+		static const std::size_t true_free_arity = base_t::free_arity;
+		static const std::size_t free_arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::free_args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+	};
+
+	template <typename T>
+	struct is_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_table<basic_table_core<x, T>> : std::true_type { };
+	template <typename T>
+	struct is_table<basic_lua_table<T>> : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_table_v = is_table<T>::value;
+
+	template <typename T>
+	struct is_global_table : std::false_type { };
+	template <typename T>
+	struct is_global_table<basic_table_core<true, T>> : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_global_table_v = is_global_table<T>::value;
+
+	template <typename T>
+	struct is_stack_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_stack_table<basic_table_core<x, T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+	template <typename T>
+	struct is_stack_table<basic_lua_table<T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+
+	template <typename T>
+	inline constexpr bool is_stack_table_v = is_stack_table<T>::value;
+
+	template <typename T>
+	struct is_function : std::false_type { };
+	template <typename T, bool aligned>
+	struct is_function<basic_function<T, aligned>> : std::true_type { };
+	template <typename T, bool aligned, typename Handler>
+	struct is_function<basic_protected_function<T, aligned, Handler>> : std::true_type { };
+
+	template <typename T>
+	using is_lightuserdata = meta::is_specialization_of<T, basic_lightuserdata>;
+
+	template <typename T>
+	inline constexpr bool is_lightuserdata_v = is_lightuserdata<T>::value;
+
+	template <typename T>
+	using is_userdata = meta::is_specialization_of<T, basic_userdata>;
+
+	template <typename T>
+	inline constexpr bool is_userdata_v = is_userdata<T>::value;
+
+	template <typename T>
+	using is_environment = std::integral_constant<bool, is_userdata_v<T> || is_table_v<T> || meta::is_specialization_of_v<T, basic_environment>>;
+
+	template <typename T>
+	inline constexpr bool is_environment_v = is_environment<T>::value;
+
+	template <typename T>
+	using is_table_like = std::integral_constant<bool, is_table_v<T> || is_environment_v<T> || is_userdata_v<T>>;
+
+	template <typename T>
+	inline constexpr bool is_table_like_v = is_table_like<T>::value;
+
+	template <typename T>
+	struct is_automagical
+	: std::integral_constant<bool,
+	       (SOL_IS_ON(SOL_DEFAULT_AUTOMAGICAL_USERTYPES))
+	            || (std::is_array_v<
+	                     meta::unqualified_t<T>> || (!std::is_same_v<meta::unqualified_t<T>, state> && !std::is_same_v<meta::unqualified_t<T>, state_view>))> {
+	};
+
+	template <typename T>
+	inline type type_of() {
+		return lua_type_of<meta::unqualified_t<T>>::value;
+	}
+
+	namespace detail {
+		template <typename T>
+		struct is_non_factory_constructor : std::false_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructors<Args...>> : std::true_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructor_wrapper<Args...>> : std::true_type { };
+
+		template <>
+		struct is_non_factory_constructor<no_construction> : std::true_type { };
+
+		template <typename T>
+		inline constexpr bool is_non_factory_constructor_v = is_non_factory_constructor<T>::value;
+
+		template <typename T>
+		struct is_constructor : is_non_factory_constructor<T> { };
+
+		template <typename... Args>
+		struct is_constructor<factory_wrapper<Args...>> : std::true_type { };
+
+		template <typename T>
+		struct is_constructor<protect_t<T>> : is_constructor<meta::unqualified_t<T>> { };
+
+		template <typename F, typename... Policies>
+		struct is_constructor<policy_wrapper<F, Policies...>> : is_constructor<meta::unqualified_t<F>> { };
+
+		template <typename T>
+		inline constexpr bool is_constructor_v = is_constructor<T>::value;
+
+		template <typename... Args>
+		using any_is_constructor = meta::any<is_constructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_constructor_v = any_is_constructor<Args...>::value;
+
+		template <typename T>
+		struct is_destructor : std::false_type { };
+
+		template <typename Fx>
+		struct is_destructor<destructor_wrapper<Fx>> : std::true_type { };
+
+		template <typename... Args>
+		using any_is_destructor = meta::any<is_destructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_destructor_v = any_is_destructor<Args...>::value;
+	} // namespace detail
+
+	template <typename T>
+	using is_lua_c_function = meta::any<std::is_same<lua_CFunction, T>, std::is_same<detail::lua_CFunction_noexcept, T>, std::is_same<lua_CFunction_ref, T>>;
+
+	template <typename T>
+	inline constexpr bool is_lua_c_function_v = is_lua_c_function<T>::value;
+
+	enum class automagic_flags : unsigned {
+		none = 0x000u,
+		default_constructor = 0x001,
+		destructor = 0x002u,
+		pairs_operator = 0x004u,
+		to_string_operator = 0x008u,
+		call_operator = 0x010u,
+		less_than_operator = 0x020u,
+		less_than_or_equal_to_operator = 0x040u,
+		length_operator = 0x080u,
+		equal_to_operator = 0x100u,
+		all = default_constructor | destructor | pairs_operator | to_string_operator | call_operator | less_than_operator | less_than_or_equal_to_operator
+		     | length_operator | equal_to_operator
+	};
+
+	inline constexpr automagic_flags operator|(automagic_flags left, automagic_flags right) noexcept {
+		return static_cast<automagic_flags>(
+		     static_cast<std::underlying_type_t<automagic_flags>>(left) | static_cast<std::underlying_type_t<automagic_flags>>(right));
+	}
+
+	inline constexpr automagic_flags operator&(automagic_flags left, automagic_flags right) noexcept {
+		return static_cast<automagic_flags>(
+		     static_cast<std::underlying_type_t<automagic_flags>>(left) & static_cast<std::underlying_type_t<automagic_flags>>(right));
+	}
+
+	inline constexpr automagic_flags& operator|=(automagic_flags& left, automagic_flags right) noexcept {
+		left = left | right;
+		return left;
+	}
+
+	inline constexpr automagic_flags& operator&=(automagic_flags& left, automagic_flags right) noexcept {
+		left = left & right;
+		return left;
+	}
+
+	template <typename Left, typename Right>
+	constexpr bool has_flag(Left left, Right right) noexcept {
+		return (left & right) == right;
+	}
+
+	template <typename Left, typename Right>
+	constexpr bool has_any_flag(Left left, Right right) noexcept {
+		return (left & right) != static_cast<Left>(static_cast<std::underlying_type_t<Left>>(0));
+	}
+
+	template <typename Left, typename Right>
+	constexpr auto clear_flags(Left left, Right right) noexcept {
+		return static_cast<Left>(static_cast<std::underlying_type_t<Left>>(left) & ~static_cast<std::underlying_type_t<Right>>(right));
+	}
+
+	struct automagic_enrollments {
+		bool default_constructor = true;
+		bool destructor = true;
+		bool pairs_operator = true;
+		bool to_string_operator = true;
+		bool call_operator = true;
+		bool less_than_operator = true;
+		bool less_than_or_equal_to_operator = true;
+		bool length_operator = true;
+		bool equal_to_operator = true;
+	};
+
+	template <automagic_flags compile_time_defaults = automagic_flags::all>
+	struct constant_automagic_enrollments : public automagic_enrollments { };
+
+} // namespace sol
+
+// end of sol/types.hpp
+
+#include <exception>
+#include <cstring>
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+#include <iostream>
+#endif
+
+namespace sol {
+	// must push a single object to be the error object
+	// NOTE: the VAST MAJORITY of all Lua libraries -- C or otherwise -- expect a string for the type of error
+	// break this convention at your own risk
+	using exception_handler_function = int (*)(lua_State*, optional<const std::exception&>, string_view);
+
+	namespace detail {
+		inline const char (&default_exception_handler_name())[11] {
+			static const char name[11] = "sol.\xE2\x98\xA2\xE2\x98\xA2";
+			return name;
+		}
+
+		// must push at least 1 object on the stack
+		inline int default_exception_handler(lua_State* L, optional<const std::exception&>, string_view what) {
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+			std::cerr << "[sol2] An exception occurred: ";
+			std::cerr.write(what.data(), static_cast<std::streamsize>(what.size()));
+			std::cerr << std::endl;
+#endif
+			lua_pushlstring(L, what.data(), what.size());
+			return 1;
+		}
+
+		inline int call_exception_handler(lua_State* L, optional<const std::exception&> maybe_ex, string_view what) {
+			lua_getglobal(L, default_exception_handler_name());
+			type t = static_cast<type>(lua_type(L, -1));
+			if (t != type::lightuserdata) {
+				lua_pop(L, 1);
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			void* vfunc = lua_touserdata(L, -1);
+			lua_pop(L, 1);
+			if (vfunc == nullptr) {
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			exception_handler_function exfunc = reinterpret_cast<exception_handler_function>(vfunc);
+			return exfunc(L, std::move(maybe_ex), std::move(what));
+		}
+
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) noexcept {
+			return f(L);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) noexcept {
+			return f(L, std::forward<Args>(args)...);
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) noexcept {
+			return trampoline(L, f);
+		}
+#else
+
+		inline int lua_cfunction_trampoline(lua_State* L, lua_CFunction f) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+			return f(L);
+#else
+			try {
+				return f(L);
+			}
+			catch (const char* cs) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+			}
+			catch (const std::string& s) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+			}
+			catch (const std::exception& e) {
+				call_exception_handler(L, optional<const std::exception&>(e), e.what());
+			}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+			}
+#endif // LuaJIT cannot have the catchall, but we must catch std::exceps for it
+			return lua_error(L);
+#endif // Safe exceptions
+		}
+
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) {
+			return lua_cfunction_trampoline(L, f);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) {
+			if constexpr (meta::bind_traits<meta::unqualified_t<Fx>>::is_noexcept) {
+				return f(L, std::forward<Args>(args)...);
+			}
+			else {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+				return f(L, std::forward<Args>(args)...);
+#else
+				try {
+					return f(L, std::forward<Args>(args)...);
+				}
+				catch (const char* cs) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+				}
+				catch (const std::string& s) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+				}
+				catch (const std::exception& e) {
+					call_exception_handler(L, optional<const std::exception&>(e), e.what());
+				}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+				// LuaJIT cannot have the catchall when the safe propagation is on
+				// but LuaJIT will swallow all C++ errors
+				// if we don't at least catch std::exception ones
+				catch (...) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+				}
+#endif
+				return lua_error(L);
+#endif
+			}
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) {
+			return trampoline(L, f);
+		}
+#endif // Exceptions vs. No Exceptions
+
+		template <typename F, F fx>
+		inline int typed_static_trampoline(lua_State* L) {
+#if 0
+			// TODO: you must evaluate the get/check_get of every
+			// argument, to ensure it doesn't throw
+			// (e.g., for the sol_lua_check_access extension point!)
+			// This incluudes properly noexcept-ing all the above
+			// trampolines / safety nets
+			if constexpr (meta::bind_traits<F>::is_noexcept) {
+				return static_trampoline_noexcept<fx>(L);
+			}
+			else
+#endif
+			{ return static_trampoline<fx>(L); }
+		}
+	} // namespace detail
+
+	inline void set_default_exception_handler(lua_State* L, exception_handler_function exf = &detail::default_exception_handler) {
+		static_assert(sizeof(void*) >= sizeof(exception_handler_function),
+		     "void* storage is too small to transport the exception handler: please file a bug on the sol2 issue tracker to get this looked at!");
+		void* storage;
+		std::memcpy(&storage, &exf, sizeof(exception_handler_function));
+		lua_pushlightuserdata(L, storage);
+		lua_setglobal(L, detail::default_exception_handler_name());
+	}
+} // namespace sol
+
+// end of sol/trampoline.hpp
+
+// beginning of sol/stack_core.hpp
+
+// beginning of sol/inheritance.hpp
+
+// beginning of sol/usertype_traits.hpp
+
+// beginning of sol/demangle.hpp
+
+#include <string>
+#include <array>
+#include <cctype>
+#if SOL_IS_ON(SOL_MINGW_CCTYPE_IS_POISONED)
+extern "C" {
+#include <ctype.h>
+}
+#endif // MinGW is on some stuff
+#include <locale>
+
+namespace sol { namespace detail {
+	inline constexpr std::array<string_view, 9> removals { { "{anonymous}",
+		"(anonymous namespace)",
+		"public:",
+		"private:",
+		"protected:",
+		"struct ",
+		"class ",
+		"`anonymous-namespace'",
+		"`anonymous namespace'" } };
+
+#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		// cardinal sins from MINGW
+		using namespace std;
+		std::size_t start = name.find_first_of('[');
+		start = name.find_first_of('=', start);
+		std::size_t end = name.find_last_of(']');
+		if (end == std::string::npos)
+			end = name.size();
+		if (start == std::string::npos)
+			start = 0;
+		if (start < name.size() - 1)
+			start += 1;
+		name = name.substr(start, end - start);
+		start = name.rfind("seperator_mark");
+		if (start != std::string::npos) {
+			name.erase(start - 2, name.length());
+		}
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T, class seperator_mark = int>
+	inline std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__PRETTY_FUNCTION__);
+	}
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		std::size_t start = name.find("get_type_name");
+		if (start == std::string::npos)
+			start = 0;
+		else
+			start += 13;
+		if (start < name.size() - 1)
+			start += 1;
+		std::size_t end = name.find_last_of('>');
+		if (end == std::string::npos)
+			end = name.size();
+		name = name.substr(start, end - start);
+		if (name.find("struct", 0) == 0)
+			name.replace(0, 6, "", 0);
+		if (name.find("class", 0) == 0)
+			name.replace(0, 5, "", 0);
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T>
+	std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__FUNCSIG__);
+	}
+#else
+#error Compiler not supported for demangling
+#endif // compilers
+
+	template <typename T>
+	std::string demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return realname;
+	}
+
+	inline std::string short_demangle_from_type_name(std::string realname) {
+		// This isn't the most complete but it'll do for now...?
+		static const std::array<std::string, 10> ops = {
+			{ "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" }
+		};
+		int level = 0;
+		std::size_t idx = 0;
+		for (idx = static_cast<std::size_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
+			if (level == 0 && realname[idx] == ':') {
+				break;
+			}
+			bool isleft = realname[idx] == '<';
+			bool isright = realname[idx] == '>';
+			if (!isleft && !isright)
+				continue;
+			bool earlybreak = false;
+			for (const auto& op : ops) {
+				std::size_t nisop = realname.rfind(op, idx);
+				if (nisop == std::string::npos)
+					continue;
+				std::size_t nisopidx = idx - op.size() + 1;
+				if (nisop == nisopidx) {
+					idx = static_cast<std::size_t>(nisopidx);
+					earlybreak = true;
+				}
+				break;
+			}
+			if (earlybreak) {
+				continue;
+			}
+			level += isleft ? -1 : 1;
+		}
+		if (idx > 0) {
+			realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
+		}
+		return realname;
+	}
+
+	template <typename T>
+	std::string short_demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return short_demangle_from_type_name(realname);
+	}
+
+	template <typename T>
+	const std::string& demangle() {
+		static const std::string d = demangle_once<T>();
+		return d;
+	}
+
+	template <typename T>
+	const std::string& short_demangle() {
+		static const std::string d = short_demangle_once<T>();
+		return d;
+	}
+}} // namespace sol::detail
+
+// end of sol/demangle.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_traits {
+		static const std::string& name() {
+			static const std::string& n = detail::short_demangle<T>();
+			return n;
+		}
+		static const std::string& qualified_name() {
+			static const std::string& q_n = detail::demangle<T>();
+			return q_n;
+		}
+		static const std::string& metatable() {
+			static const std::string m = std::string("sol.").append(detail::demangle<T>());
+			return m;
+		}
+		static const std::string& user_metatable() {
+			static const std::string u_m = std::string("sol.").append(detail::demangle<T>()).append(".user");
+			return u_m;
+		}
+		static const std::string& user_gc_metatable() {
+			static const std::string u_g_m = std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");
+			return u_g_m;
+		}
+		static const std::string& gc_table() {
+			static const std::string g_t = std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");
+			return g_t;
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype_traits.hpp
+
+// beginning of sol/unique_usertype_traits.hpp
+
+#include <memory>
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		struct unique_fallback {
+			using SOL_INTERNAL_UNSPECIALIZED_MARKER_ = int;
+		};
+
+		template <typename T>
+		struct unique_fallback<std::shared_ptr<T>> {
+		private:
+			using pointer = typename std::pointer_traits<std::shared_ptr<T>>::element_type*;
+
+		public:
+			// rebind is non-void
+			// if and only if unique usertype
+			// is cast-capable
+			template <typename X>
+			using rebind_actual_type = std::shared_ptr<X>;
+
+			static bool is_null(lua_State*, const std::shared_ptr<T>& p) noexcept {
+				return p == nullptr;
+			}
+
+			static pointer get(lua_State*, const std::shared_ptr<T>& p) noexcept {
+				return p.get();
+			}
+		};
+
+		template <typename T, typename D>
+		struct unique_fallback<std::unique_ptr<T, D>> {
+		private:
+			using pointer = typename std::unique_ptr<T, D>::pointer;
+
+		public:
+			static bool is_null(lua_State*, const std::unique_ptr<T, D>& p) noexcept {
+				return p == nullptr;
+			}
+
+			static pointer get(lua_State*, const std::unique_ptr<T, D>& p) noexcept {
+				return p.get();
+			}
+		};
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+		template <typename T, typename = void>
+		struct unique_actual_type;
+
+		template <typename T>
+		struct unique_actual_type<T, meta::void_t<typename T::actual_type>> {
+			using type = typename T::actual_type;
+		};
+
+		template <typename T, typename... Rest, template <typename...> class Templ>
+		struct unique_actual_type<Templ<T, Rest...>> {
+			using type = T;
+		};
+
+	}} // namespace meta::meta_detail
+
+	template <typename T>
+	using unique_usertype_actual_t = typename meta::meta_detail::unique_actual_type<unique_usertype_traits<T>>::type;
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using value_test_t = decltype(T::value);
+
+		template <typename T>
+		using type_test_t = typename T::type;
+
+		template <typename T>
+		using type_element_type_t = typename T::element_type;
+
+		template <typename T, typename = void>
+		struct unique_element_type {
+			using type = typename std::pointer_traits<typename unique_actual_type<T>::type>::element_type;
+		};
+
+		template <typename T>
+		struct unique_element_type<T, std::enable_if_t<meta::is_detected_v<type_element_type_t, T>>> {
+			using type = typename T::element_type;
+		};
+
+		template <typename T>
+		struct unique_element_type<T, std::enable_if_t<meta::is_detected_v<type_test_t, T>>> {
+			using type = typename T::type;
+		};
+
+		template <typename T, typename = void>
+		struct unique_valid : std::integral_constant<bool, !has_internal_marker_v<T>> { };
+
+		template <typename T>
+		struct unique_valid<T, meta::void_t<decltype(T::value)>> : std::integral_constant<bool, T::value> { };
+	}} // namespace meta::meta_detail
+
+	template <typename T>
+	using unique_usertype_element_t = typename meta::meta_detail::unique_element_type<unique_usertype_traits<T>>::type;
+
+	template <typename T, typename Element = void>
+	using unique_usertype_rebind_actual_t = typename unique_usertype_traits<T>::template rebind_actual_type<Element>;
+
+	template <typename T>
+	struct unique_usertype_traits : public detail::unique_fallback<T> { };
+
+	template <typename T>
+	struct is_unique_usertype : std::integral_constant<bool, meta::meta_detail::unique_valid<unique_usertype_traits<T>>::value> { };
+
+	template <typename T>
+	inline constexpr bool is_unique_usertype_v = is_unique_usertype<T>::value;
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using adl_sol_lua_check_access_test_t
+			= decltype(sol_lua_check_access(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_access_v = meta::is_detected_v<adl_sol_lua_check_access_test_t, T>;
+
+		template <typename T>
+		using unique_usertype_get_with_state_test_t
+			= decltype(unique_usertype_traits<T>::get(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<T>>()));
+
+		template <typename T>
+		inline constexpr bool unique_usertype_get_with_state_v = meta::is_detected_v<unique_usertype_get_with_state_test_t, T>;
+
+		template <typename T>
+		using unique_usertype_is_null_with_state_test_t
+			= decltype(unique_usertype_traits<T>::is_null(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<T>>()));
+
+		template <typename T>
+		inline constexpr bool unique_usertype_is_null_with_state_v = meta::is_detected_v<unique_usertype_is_null_with_state_test_t, T>;
+	}} // namespace meta::meta_detail
+
+	namespace detail {
+		template <typename T>
+		constexpr bool unique_is_null_noexcept() noexcept {
+			if constexpr (meta::meta_detail::unique_usertype_is_null_with_state_v<std::remove_cv_t<T>>) {
+				return noexcept(
+				     unique_usertype_traits<T>::is_null(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+			else {
+				return noexcept(unique_usertype_traits<T>::is_null(std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+		}
+
+		template <typename T>
+		bool unique_is_null(lua_State* L_, T& value_) noexcept(unique_is_null_noexcept<std::remove_cv_t<T>>()) {
+			using Tu = std::remove_cv_t<T>;
+			if constexpr (meta::meta_detail::unique_usertype_is_null_with_state_v<Tu>) {
+				return unique_usertype_traits<Tu>::is_null(L_, value_);
+			}
+			else {
+				return unique_usertype_traits<Tu>::is_null(value_);
+			}
+		}
+
+		template <typename T>
+		constexpr bool unique_get_noexcept() noexcept {
+			if constexpr (meta::meta_detail::unique_usertype_get_with_state_v<std::remove_cv_t<T>>) {
+				return noexcept(
+				     unique_usertype_traits<T>::get(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+			else {
+				return noexcept(unique_usertype_traits<T>::get(std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+		}
+
+		template <typename T>
+		auto unique_get(lua_State* L_, T& value_) noexcept(unique_get_noexcept<std::remove_cv_t<T>>()) {
+			using Tu = std::remove_cv_t<T>;
+			if constexpr (meta::meta_detail::unique_usertype_get_with_state_v<Tu>) {
+				return unique_usertype_traits<Tu>::get(L_, value_);
+			}
+			else {
+				return unique_usertype_traits<Tu>::get(value_);
+			}
+		}
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+		template <typename T, typename Element = void>
+		using is_rebind_actual_type_test_t = typename T::template rebind_actual_type<Element>;
+
+		template <typename T, typename Element = void>
+		using is_rebind_actual_type = meta::is_detected<is_rebind_actual_type_test_t, T, Element>;
+
+		template <typename T, typename Element = void>
+		inline constexpr bool is_rebind_actual_type_v = is_rebind_actual_type<T, Element>::value;
+
+		template <typename T, typename Element, bool = is_rebind_actual_type_v<T, Element>>
+		struct is_actual_type_rebindable_for_test : std::false_type { };
+
+		template <typename T, typename Element>
+		struct is_actual_type_rebindable_for_test<T, Element, true>
+		: std::integral_constant<bool, !std::is_void_v<typename T::template rebind_actual_type<Element>>> { };
+	}} // namespace meta::meta_detail
+
+	template <typename T, typename Element = void>
+	using is_actual_type_rebindable_for = typename meta::meta_detail::is_actual_type_rebindable_for_test<unique_usertype_traits<T>, Element>::type;
+
+	template <typename T, typename Element = void>
+	inline constexpr bool is_actual_type_rebindable_for_v = is_actual_type_rebindable_for<T, Element>::value;
+
+} // namespace sol
+
+// end of sol/unique_usertype_traits.hpp
+
+namespace sol {
+	template <typename... Args>
+	struct base_list { };
+	template <typename... Args>
+	using bases = base_list<Args...>;
+
+	typedef bases<> base_classes_tag;
+	const auto base_classes = base_classes_tag();
+
+	template <typename... Args>
+	struct is_to_stringable<base_list<Args...>> : std::false_type { };
+
+	namespace detail {
+
+		inline decltype(auto) base_class_check_key() {
+			static const auto& key = "class_check";
+			return key;
+		}
+
+		inline decltype(auto) base_class_cast_key() {
+			static const auto& key = "class_cast";
+			return key;
+		}
+
+		inline decltype(auto) base_class_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
+			return key;
+		}
+
+		inline decltype(auto) base_class_new_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
+			return key;
+		}
+
+		template <typename T>
+		struct inheritance {
+			typedef typename base<T>::type bases_t;
+
+			static bool type_check_bases(types<>, const string_view&) {
+				return false;
+			}
+
+			template <typename Base, typename... Args>
+			static bool type_check_bases(types<Base, Args...>, const string_view& ti) {
+				return ti == usertype_traits<Base>::qualified_name() || type_check_bases(types<Args...>(), ti);
+			}
+
+			static bool type_check(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(bases_t(), ti);
+			}
+
+			template <typename... Bases>
+			static bool type_check_with(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(types<Bases...>(), ti);
+			}
+
+			static void* type_cast_bases(types<>, T*, const string_view&) {
+				return nullptr;
+			}
+
+			template <typename Base, typename... Args>
+			static void* type_cast_bases(types<Base, Args...>, T* data, const string_view& ti) {
+				// Make sure to convert to T first, and then dynamic cast to the proper type
+				return ti != usertype_traits<Base>::qualified_name() ? type_cast_bases(types<Args...>(), data, ti)
+				                                                     : static_cast<void*>(static_cast<Base*>(data));
+			}
+
+			static void* type_cast(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(bases_t(), data, ti) : data);
+			}
+
+			template <typename... Bases>
+			static void* type_cast_with(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(types<Bases...>(), data, ti) : data);
+			}
+
+			template <typename U>
+			static bool type_unique_cast_bases(types<>, void*, void*, const string_view&) {
+				return 0;
+			}
+
+			template <typename U, typename Base, typename... Args>
+			static int type_unique_cast_bases(types<Base, Args...>, void* source_data, void* target_data, const string_view& ti) {
+				using uu_traits = unique_usertype_traits<U>;
+				using base_ptr = typename uu_traits::template rebind_actual_type<Base>;
+				string_view base_ti = usertype_traits<Base>::qualified_name();
+				if (base_ti == ti) {
+					if (target_data != nullptr) {
+						U* source = static_cast<U*>(source_data);
+						base_ptr* target = static_cast<base_ptr*>(target_data);
+						// perform proper derived -> base conversion
+						*target = *source;
+					}
+					return 2;
+				}
+				return type_unique_cast_bases<U>(types<Args...>(), source_data, target_data, ti);
+			}
+
+			template <typename U>
+			static int type_unique_cast(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				if constexpr (is_actual_type_rebindable_for_v<U>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
+					using maybe_bases_or_empty = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, bases_t>;
+					string_view this_rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(maybe_bases_or_empty(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+
+			template <typename U, typename... Bases>
+			static int type_unique_cast_with(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				using uc_bases_t = types<Bases...>;
+				if constexpr (is_actual_type_rebindable_for_v<U>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
+					using cond_bases_t = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, uc_bases_t>;
+					string_view this_rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(cond_bases_t(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+		};
+
+		using inheritance_check_function = decltype(&inheritance<void>::type_check);
+		using inheritance_cast_function = decltype(&inheritance<void>::type_cast);
+		using inheritance_unique_cast_function = decltype(&inheritance<void>::type_unique_cast<void>);
+	} // namespace detail
+} // namespace sol
+
+// end of sol/inheritance.hpp
+
+// beginning of sol/error_handler.hpp
+
+#include <cstdio>
+
+namespace sol {
+
+	namespace detail {
+		constexpr const char* not_a_number = "not a numeric type";
+		constexpr const char* not_a_number_or_number_string = "not a numeric type or numeric string";
+		constexpr const char* not_a_number_integral = "not a numeric type that fits exactly an integer (number maybe has significant decimals)";
+		constexpr const char* not_a_number_or_number_string_integral
+		     = "not a numeric type or a numeric string that fits exactly an integer (e.g. number maybe has significant decimals)";
+
+		constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+		constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+		constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+		constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+		constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+		constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol2 userdata";
+		constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+		constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+		constexpr const char* protected_function_error = "caught (...) unknown error during protected_function call";
+
+		inline void accumulate_and_mark(const std::string& n, std::string& aux_message, int& marker) {
+			if (marker > 0) {
+				aux_message += ", ";
+			}
+			aux_message += n;
+			++marker;
+		}
+	} // namespace detail
+
+	inline std::string associated_type_name(lua_State* L, int index, type t) {
+		switch (t) {
+		case type::poly:
+			return "anything";
+		case type::userdata: {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 2, "not enough space to push get the type name");
+#endif // make sure stack doesn't overflow
+			if (lua_getmetatable(L, index) == 0) {
+				break;
+			}
+			lua_pushlstring(L, "__name", 6);
+			lua_rawget(L, -2);
+			size_t sz;
+			const char* name = lua_tolstring(L, -1, &sz);
+			std::string tn(name, static_cast<std::string::size_type>(sz));
+			lua_pop(L, 2);
+			return tn;
+		}
+		default:
+			break;
+		}
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	inline int push_type_panic_string(lua_State* L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept {
+		const char* err = message.size() == 0
+		     ? (aux_message.size() == 0 ? "stack index %d, expected %s, received %s" : "stack index %d, expected %s, received %s: %s")
+		     : "stack index %d, expected %s, received %s: %s %s";
+		const char* type_name = expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected));
+		{
+			std::string actual_name = associated_type_name(L, index, actual);
+			lua_pushfstring(L, err, index, type_name, actual_name.c_str(), message.data(), aux_message.data());
+		}
+		return 1;
+	}
+
+	inline int type_panic_string(lua_State* L, int index, type expected, type actual, string_view message = "") noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message, "");
+		return lua_error(L);
+	}
+
+	inline int type_panic_c_str(lua_State* L, int index, type expected, type actual, const char* message = nullptr) noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message == nullptr ? "" : message, "");
+		return lua_error(L);
+	}
+
+	struct type_panic_t {
+		int operator()(lua_State* L, int index, type expected, type actual) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, message.data());
+		}
+	};
+
+	const type_panic_t type_panic = {};
+
+	struct constructor_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(type check failed in constructor)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename F = void>
+	struct argument_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(bad argument to variable or function call)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename R, typename... Args>
+	struct argument_handler<types<R, Args...>> {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			{
+				std::string aux_message = "(bad argument into '";
+				aux_message += detail::demangle<R>();
+				aux_message += "(";
+				int marker = 0;
+				(void)detail::swallow { int(), (detail::accumulate_and_mark(detail::demangle<Args>(), aux_message, marker), int())... };
+				aux_message += ")')";
+				push_type_panic_string(L, index, expected, actual, message, aux_message);
+			}
+			return lua_error(L);
+		}
+	};
+
+	// Specify this function as the handler for lua::check if you know there's nothing wrong
+	inline int no_panic(lua_State*, int, type, type, const char* = nullptr) noexcept {
+		return 0;
+	}
+
+	inline void type_error(lua_State* L, int expected, int actual) noexcept(false) {
+		luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
+	}
+
+	inline void type_error(lua_State* L, type expected, type actual) noexcept(false) {
+		type_error(L, static_cast<int>(expected), static_cast<int>(actual));
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected, type actual) noexcept(false) {
+		if (expected != type::poly && expected != actual) {
+			type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected) {
+		type actual = type_of(L, index);
+		type_assert(L, index, expected, actual);
+	}
+
+} // namespace sol
+
+// end of sol/error_handler.hpp
+
+// beginning of sol/reference.hpp
+
+// beginning of sol/stack_reference.hpp
+
+namespace sol {
+	namespace detail {
+		inline bool xmovable(lua_State* leftL, lua_State* rightL) {
+			if (rightL == nullptr || leftL == nullptr || leftL == rightL) {
+				return false;
+			}
+			const void* leftregistry = lua_topointer(leftL, LUA_REGISTRYINDEX);
+			const void* rightregistry = lua_topointer(rightL, LUA_REGISTRYINDEX);
+			return leftregistry == rightregistry;
+		}
+	} // namespace detail
+
+	class stateless_stack_reference {
+	private:
+		friend class stack_reference;
+
+		int m_index = 0;
+
+		int registry_index() const noexcept {
+			return LUA_NOREF;
+		}
+
+	public:
+		stateless_stack_reference() noexcept = default;
+		stateless_stack_reference(lua_nil_t) noexcept : stateless_stack_reference() {};
+		stateless_stack_reference(lua_State* L_, int index_) noexcept : stateless_stack_reference(absolute_index(L_, index_)) {
+		}
+		stateless_stack_reference(lua_State*, absolute_index index_) noexcept : stateless_stack_reference(index_) {
+		}
+		stateless_stack_reference(lua_State*, raw_index index_) noexcept : stateless_stack_reference(index_) {
+		}
+		stateless_stack_reference(absolute_index index_) noexcept : m_index(index_) {
+		}
+		stateless_stack_reference(raw_index index_) noexcept : m_index(index_) {
+		}
+		stateless_stack_reference(lua_State*, ref_index) noexcept = delete;
+		stateless_stack_reference(ref_index) noexcept = delete;
+		stateless_stack_reference(const reference&) noexcept = delete;
+		stateless_stack_reference(const stateless_stack_reference&) noexcept = default;
+		stateless_stack_reference(stateless_stack_reference&& o) noexcept = default;
+		stateless_stack_reference& operator=(stateless_stack_reference&&) noexcept = default;
+		stateless_stack_reference& operator=(const stateless_stack_reference&) noexcept = default;
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, m_index);
+			return 1;
+		}
+
+		void pop(lua_State* L_, int pop_count = 1) const noexcept {
+			lua_pop(L_, pop_count);
+		}
+
+		int stack_index() const noexcept {
+			return m_index;
+		}
+
+		const void* pointer(lua_State* L_) const noexcept {
+			const void* pointer_id = lua_topointer(L_, stack_index());
+			return pointer_id;
+		}
+
+		type get_type(lua_State* L_) const noexcept {
+			int untyped_value = lua_type(L_, stack_index());
+			return static_cast<type>(untyped_value);
+		}
+
+		bool valid(lua_State* L) const noexcept {
+			type t = get_type(L);
+			return t != type::lua_nil && t != type::none;
+		}
+
+		void reset(lua_State*) noexcept {
+			m_index = 0;
+		}
+
+		void reset(lua_State* L_, int index_) noexcept {
+			m_index = absolute_index(L_, index_);
+		}
+
+		void abandon(lua_State* = nullptr) noexcept {
+			m_index = 0;
+		}
+
+		stateless_stack_reference copy(lua_State* L_) const noexcept {
+			return stateless_stack_reference(L_, raw_index(m_index));
+		}
+
+		void copy_assign(lua_State*, const stateless_stack_reference& right) noexcept {
+			m_index = right.m_index;
+		}
+
+		bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
+			return lua_compare(L_, this->stack_index(), r.stack_index(), LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, lua_nil_t) const noexcept {
+			return valid(L_);
+		}
+	};
+
+	class stack_reference : public stateless_stack_reference {
+	private:
+		lua_State* luastate = nullptr;
+
+	public:
+		stack_reference() noexcept = default;
+		stack_reference(lua_nil_t) noexcept : stack_reference() {};
+		stack_reference(lua_State* L, lua_nil_t) noexcept : stateless_stack_reference(L, 0), luastate(L) {
+		}
+		stack_reference(lua_State* L, int i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, absolute_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, raw_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, ref_index i) noexcept = delete;
+		stack_reference(lua_State* L, const reference& r) noexcept = delete;
+		stack_reference(lua_State* L, const stack_reference& r) noexcept : luastate(L) {
+			if (!r.valid()) {
+				m_index = 0;
+				return;
+			}
+			int i = r.stack_index();
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+				lua_pushvalue(r.lua_state(), r.stack_index());
+				lua_xmove(r.lua_state(), luastate, 1);
+				i = absolute_index(luastate, -1);
+			}
+			m_index = i;
+		}
+		stack_reference(stack_reference&& o) noexcept = default;
+		stack_reference& operator=(stack_reference&&) noexcept = default;
+		stack_reference(const stack_reference&) noexcept = default;
+		stack_reference& operator=(const stack_reference&) noexcept = default;
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		int push(lua_State* L_) const noexcept {
+			return stateless_stack_reference::push(L_);
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* L_, int pop_count_ = 1) const noexcept {
+			stateless_stack_reference::pop(L_, pop_count_);
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_stack_reference::pointer(lua_state());
+		}
+
+		type get_type() const noexcept {
+			return stateless_stack_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+
+		bool valid() const noexcept {
+			return stateless_stack_reference::valid(lua_state());
+		}
+
+		void abandon() {
+			stateless_stack_reference::abandon(lua_state());
+		}
+	};
+
+	inline bool operator==(const stack_reference& l, const stack_reference& r) {
+		return lua_compare(l.lua_state(), l.stack_index(), r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	inline bool operator!=(const stack_reference& l, const stack_reference& r) {
+		return !operator==(l, r);
+	}
+
+	inline bool operator==(const stack_reference& lhs, const lua_nil_t&) {
+		return !lhs.valid();
+	}
+
+	inline bool operator==(const lua_nil_t&, const stack_reference& rhs) {
+		return !rhs.valid();
+	}
+
+	inline bool operator!=(const stack_reference& lhs, const lua_nil_t&) {
+		return lhs.valid();
+	}
+
+	inline bool operator!=(const lua_nil_t&, const stack_reference& rhs) {
+		return rhs.valid();
+	}
+
+	inline bool operator==(const stateless_stack_reference& l, const stateless_stack_reference& r) {
+		return l.stack_index() == r.stack_index();
+	}
+
+	inline bool operator!=(const stateless_stack_reference& l, const stateless_stack_reference& r) {
+		return l.stack_index() != r.stack_index();
+	}
+
+	struct stateless_stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		stateless_stack_reference_equals(lua_State* L_) noexcept : m_L(L_) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return m_L;
+		}
+
+		bool operator()(const stateless_stack_reference& lhs, const stateless_stack_reference& rhs) const {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+		bool operator()(lua_nil_t lhs, const stateless_stack_reference& rhs) const {
+			return rhs.equals(lua_state(), lhs);
+		}
+
+		bool operator()(const stateless_stack_reference& lhs, lua_nil_t rhs) const {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+	private:
+		lua_State* m_L;
+	};
+
+	struct stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		bool operator()(const lua_nil_t& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const lua_nil_t& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+	};
+
+	struct stateless_stack_reference_hash {
+		using argument_type = stateless_stack_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		stateless_stack_reference_hash(lua_State* L_) noexcept : m_L(L_) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return m_L;
+		}
+
+		result_type operator()(const argument_type& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer(lua_state()));
+		}
+
+	private:
+		lua_State* m_L;
+	};
+
+	struct stack_reference_hash {
+		using argument_type = stack_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		result_type operator()(const argument_type& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_reference.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline const char (&default_main_thread_name())[9] {
+			static const char name[9] = "sol.\xF0\x9F\x93\x8C";
+			return name;
+		}
+	} // namespace detail
+
+	namespace stack {
+		inline void remove(lua_State* L_, int rawindex, int count) {
+			if (count < 1)
+				return;
+			int top = lua_gettop(L_);
+			if (top < 1) {
+				return;
+			}
+			if (rawindex == -count || top == rawindex) {
+				// Slice them right off the top
+				lua_pop(L_, static_cast<int>(count));
+				return;
+			}
+
+			// Remove each item one at a time using stack operations
+			// Probably slower, maybe, haven't benchmarked,
+			// but necessary
+			int index = lua_absindex(L_, rawindex);
+			if (index < 0) {
+				index = lua_gettop(L_) + (index + 1);
+			}
+			int last = index + count;
+			for (int i = index; i < last; ++i) {
+				lua_remove(L_, index);
+			}
+		}
+
+		struct push_popper_at {
+			lua_State* L;
+			int index;
+			int count;
+			push_popper_at(lua_State* L_, int index_ = -1, int count_ = 1) : L(L_), index(index_), count(count_) {
+			}
+			~push_popper_at() {
+				remove(L, index, count);
+			}
+		};
+
+		template <bool top_level>
+		struct push_popper_n {
+			lua_State* L;
+			int pop_count;
+			push_popper_n(lua_State* L_, int pop_count_) : L(L_), pop_count(pop_count_) {
+			}
+			push_popper_n(const push_popper_n&) = delete;
+			push_popper_n(push_popper_n&&) = default;
+			push_popper_n& operator=(const push_popper_n&) = delete;
+			push_popper_n& operator=(push_popper_n&&) = default;
+			~push_popper_n() {
+				lua_pop(L, pop_count);
+			}
+		};
+
+		template <>
+		struct push_popper_n<true> {
+			push_popper_n(lua_State*, int) {
+			}
+		};
+
+		template <bool, typename T, typename = void>
+		struct push_popper {
+			using Tu = meta::unqualified_t<T>;
+			T m_object;
+			int m_index;
+
+			push_popper(T object_) noexcept : m_object(object_), m_index(lua_absindex(m_object.lua_state(), -m_object.push())) {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return m_index;
+			}
+
+			~push_popper() {
+				m_object.pop();
+			}
+		};
+
+		template <typename T, typename C>
+		struct push_popper<true, T, C> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) noexcept {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return -1;
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <typename T>
+		struct push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) noexcept {
+			}
+
+			int index_of(const Tu& object_) const noexcept {
+				return object_.stack_index();
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <bool, typename T, typename = void>
+		struct stateless_push_popper {
+			using Tu = meta::unqualified_t<T>;
+			lua_State* m_L;
+			T m_object;
+			int m_index;
+
+			stateless_push_popper(lua_State* L_, T object_) noexcept : m_L(L_), m_object(object_), m_index(lua_absindex(m_L, -m_object.push(m_L))) {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return m_index;
+			}
+
+			~stateless_push_popper() {
+				m_object.pop(m_L);
+			}
+		};
+
+		template <typename T, typename C>
+		struct stateless_push_popper<true, T, C> {
+			using Tu = meta::unqualified_t<T>;
+
+			stateless_push_popper(lua_State*, T) noexcept {
+			}
+
+			int index_of(lua_State*, const Tu&) const noexcept {
+				return -1;
+			}
+
+			~stateless_push_popper() {
+			}
+		};
+
+		template <typename T>
+		struct stateless_push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+			using Tu = meta::unqualified_t<T>;
+			lua_State* m_L;
+
+			stateless_push_popper(lua_State* L_, T) noexcept : m_L(L_) {
+			}
+
+			int index_of(const Tu& object_) const noexcept {
+				return object_.stack_index();
+			}
+
+			~stateless_push_popper() {
+			}
+		};
+
+		template <bool top_level = false, typename T>
+		push_popper<top_level, T> push_pop(T&& x) {
+			return push_popper<top_level, T>(std::forward<T>(x));
+		}
+
+		template <bool top_level = false, typename T>
+		stateless_push_popper<top_level, T> push_pop(lua_State* L_, T&& object_) {
+			return stateless_push_popper<top_level, T>(L_, std::forward<T>(object_));
+		}
+
+		template <typename T>
+		push_popper_at push_pop_at(T&& object_) {
+			int push_count = object_.push();
+			lua_State* L = object_.lua_state();
+			return push_popper_at(L, lua_absindex(L, -push_count), push_count);
+		}
+
+		template <bool top_level = false>
+		push_popper_n<top_level> pop_n(lua_State* L_, int pop_count_) {
+			return push_popper_n<top_level>(L_, pop_count_);
+		}
+	} // namespace stack
+
+	inline lua_State* main_thread(lua_State* L_, lua_State* backup_if_unsupported_ = nullptr) {
+#if SOL_LUA_VERSION_I_ < 502
+		if (L_ == nullptr)
+			return backup_if_unsupported_;
+		lua_getglobal(L_, detail::default_main_thread_name());
+		auto pp = stack::pop_n(L_, 1);
+		if (type_of(L_, -1) == type::thread) {
+			return lua_tothread(L_, -1);
+		}
+		return backup_if_unsupported_;
+#else
+		if (L_ == nullptr)
+			return backup_if_unsupported_;
+		lua_rawgeti(L_, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
+		lua_State* Lmain = lua_tothread(L_, -1);
+		lua_pop(L_, 1);
+		return Lmain;
+#endif // Lua 5.2+ has the main thread unqualified_getter
+	}
+
+	namespace detail {
+		struct no_safety_tag {
+		} inline constexpr no_safety {};
+
+		template <bool b>
+		inline lua_State* pick_main_thread(lua_State* L_, lua_State* backup_if_unsupported = nullptr) {
+			(void)L_;
+			(void)backup_if_unsupported;
+			if (b) {
+				return main_thread(L_, backup_if_unsupported);
+			}
+			return L_;
+		}
+	} // namespace detail
+
+	class stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+
+		int ref = LUA_NOREF;
+
+		int copy_ref(lua_State* L_) const noexcept {
+			if (ref == LUA_NOREF)
+				return LUA_NOREF;
+			push(L_);
+			return luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		lua_State* copy_assign_ref(lua_State* L_, lua_State* rL, const stateless_reference& r) {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = r.copy_ref(L_);
+			return rL;
+		}
+
+		lua_State* move_assign(lua_State* L_, lua_State* rL, stateless_reference&& r) {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			return rL;
+		}
+
+	protected:
+		int stack_index() const noexcept {
+			return -1;
+		}
+
+		stateless_reference(lua_State* L_, global_tag_t) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushglobaltable(L_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(int raw_ref_index) noexcept : ref(raw_ref_index) {
+		}
+
+	public:
+		stateless_reference() noexcept = default;
+		stateless_reference(lua_nil_t) noexcept : stateless_reference() {
+		}
+		stateless_reference(const stack_reference& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(stack_reference&& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(lua_State* L_, const stateless_reference& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L_ == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.copy_ref(L_);
+		}
+
+		stateless_reference(lua_State* L_, stateless_reference&& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L_ == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+		}
+
+		stateless_reference(lua_State* L_, const stack_reference& r) noexcept {
+			if (L_ == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (L_ != r.lua_state() && !detail::xmovable(L_, r.lua_state())) {
+				return;
+			}
+			r.push(L_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(lua_State* L_, const stateless_stack_reference& r) noexcept : stateless_reference(L_, r.stack_index()) {
+		}
+
+		stateless_reference(lua_State* L_, int index = -1) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State* L_, absolute_index index_) noexcept : stateless_reference(L_, index_.index) {
+		}
+		stateless_reference(lua_State* L_, ref_index index_) noexcept {
+			lua_rawgeti(L_, LUA_REGISTRYINDEX, index_.index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State*, lua_nil_t) noexcept {
+		}
+
+		~stateless_reference() noexcept = default;
+
+		stateless_reference(const stateless_reference& o) noexcept = delete;
+		stateless_reference& operator=(const stateless_reference& r) noexcept = delete;
+
+		stateless_reference(stateless_reference&& o) noexcept : ref(o.ref) {
+			o.ref = LUA_NOREF;
+		}
+
+		stateless_reference& operator=(stateless_reference&& o) noexcept {
+			ref = o.ref;
+			o.ref = LUA_NOREF;
+			return *this;
+		}
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L_, LUA_REGISTRYINDEX, ref);
+			return 1;
+		}
+
+		void pop(lua_State* L_, int n = 1) const noexcept {
+			lua_pop(L_, n);
+		}
+
+		int registry_index() const noexcept {
+			return ref;
+		}
+
+		void reset(lua_State* L_) noexcept {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = LUA_NOREF;
+		}
+
+		void reset(lua_State* L_, int index_) noexcept {
+			reset(L_);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		bool valid(lua_State*) const noexcept {
+			return !(ref == LUA_NOREF || ref == LUA_REFNIL);
+		}
+
+		const void* pointer(lua_State* L_) const noexcept {
+			int si = push(L_);
+			const void* vp = lua_topointer(L_, -si);
+			lua_pop(L_, si);
+			return vp;
+		}
+
+		type get_type(lua_State* L_) const noexcept {
+			int p = push(L_);
+			int result = lua_type(L_, -1);
+			pop(L_, p);
+			return static_cast<type>(result);
+		}
+
+		void abandon(lua_State* = nullptr) {
+			ref = LUA_NOREF;
+		}
+
+		void deref(lua_State* L_) const noexcept {
+			luaL_unref(L_, LUA_REGISTRYINDEX, ref);
+		}
+
+		stateless_reference copy(lua_State* L_) const noexcept {
+			if (!valid(L_)) {
+				return {};
+			}
+			return stateless_reference(copy_ref(L_));
+		}
+
+		void copy_assign(lua_State* L_, const stateless_reference& right) noexcept {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			if (!right.valid(L_)) {
+				return;
+			}
+			ref = right.copy_ref(L_);
+		}
+
+		bool equals(lua_State* L_, const stateless_reference& r) const noexcept {
+			auto ppl = stack::push_pop(L_, *this);
+			auto ppr = stack::push_pop(L_, r);
+			return lua_compare(L_, -1, -2, LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
+			auto ppl = stack::push_pop(L_, *this);
+			return lua_compare(L_, -1, r.stack_index(), LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, lua_nil_t) const noexcept {
+			return valid(L_);
+		}
+	};
+
+	template <bool main_only = false>
+	class basic_reference : public stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+		lua_State* luastate = nullptr; // non-owning
+
+		template <bool r_main_only>
+		void copy_assign_complex(const basic_reference<r_main_only>& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.copy_ref();
+		}
+
+		template <bool r_main_only>
+		void move_assign(basic_reference<r_main_only>&& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+	protected:
+		basic_reference(lua_State* L_, global_tag_t) noexcept : basic_reference(detail::pick_main_thread<main_only>(L_, L_), global_tag, global_tag) {
+		}
+
+		basic_reference(lua_State* L_, global_tag_t, global_tag_t) noexcept : stateless_reference(L_, global_tag), luastate(L_) {
+		}
+
+		basic_reference(lua_State* oL, const basic_reference<!main_only>& o) noexcept : stateless_reference(oL, o), luastate(oL) {
+		}
+
+		void deref() const noexcept {
+			return stateless_reference::deref(lua_state());
+		}
+
+		int copy_ref() const noexcept {
+			return copy_ref(lua_state());
+		}
+
+		int copy_ref(lua_State* L_) const noexcept {
+			return stateless_reference::copy_ref(L_);
+		}
+
+	public:
+		basic_reference() noexcept = default;
+		basic_reference(lua_nil_t) noexcept : basic_reference() {
+		}
+		basic_reference(const stack_reference& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		basic_reference(stack_reference&& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		template <bool r_main_only>
+		basic_reference(lua_State* L_, const basic_reference<r_main_only>& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.copy_ref();
+		}
+
+		template <bool r_main_only>
+		basic_reference(lua_State* L_, basic_reference<r_main_only>&& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+		basic_reference(lua_State* L_, const stack_reference& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (lua_state() == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (lua_state() != r.lua_state() && !detail::xmovable(lua_state(), r.lua_state())) {
+				return;
+			}
+			r.push(lua_state());
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, int index = -1) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			// use L_ to stick with that state's execution stack
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, ref_index index) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, index.index);
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, lua_nil_t) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+		}
+
+		~basic_reference() noexcept {
+			if (lua_state() == nullptr || ref == LUA_NOREF)
+				return;
+			deref();
+		}
+
+		basic_reference(const basic_reference& o) noexcept : stateless_reference(o.copy_ref()), luastate(o.lua_state()) {
+		}
+
+		basic_reference(basic_reference&& o) noexcept : stateless_reference(std::move(o)), luastate(o.lua_state()) {
+			o.luastate = nullptr;
+		}
+
+		basic_reference(const basic_reference<!main_only>& o) noexcept
+		: basic_reference(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state()), o) {
+		}
+
+		basic_reference(basic_reference<!main_only>&& o) noexcept
+		: stateless_reference(std::move(o)), luastate(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state())) {
+			o.luastate = nullptr;
+			o.ref = LUA_NOREF;
+		}
+
+		basic_reference& operator=(basic_reference&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference& r) noexcept {
+			copy_assign_complex(r);
+			return *this;
+		}
+
+		basic_reference& operator=(basic_reference<!main_only>&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference<!main_only>& r) noexcept {
+			copy_assign_complex(r);
+			return *this;
+		}
+
+		basic_reference& operator=(const lua_nil_t&) noexcept {
+			reset();
+			return *this;
+		}
+
+		template <typename Super>
+		basic_reference& operator=(proxy_base<Super>&& r);
+
+		template <typename Super>
+		basic_reference& operator=(const proxy_base<Super>& r);
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		void reset() noexcept {
+			stateless_reference::reset(luastate);
+			luastate = nullptr;
+		}
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			if (lua_state() == nullptr) {
+				lua_pushnil(L_);
+				return 1;
+			}
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, ref);
+			if (L_ != lua_state()) {
+				lua_xmove(lua_state(), L_, 1);
+			}
+			return 1;
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* L_, int n = 1) const noexcept {
+			stateless_reference::pop(L_, n);
+		}
+
+		int registry_index() const noexcept {
+			return stateless_reference::registry_index();
+		}
+
+		bool valid() const noexcept {
+			return stateless_reference::valid(lua_state());
+		}
+
+		bool valid(lua_State* L_) const noexcept {
+			return stateless_reference::valid(L_);
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_reference::pointer(lua_state());
+		}
+
+		explicit operator bool() const noexcept {
+			return valid();
+		}
+
+		type get_type() const noexcept {
+			return stateless_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+	};
+
+	template <bool lb, bool rb>
+	inline bool operator==(const basic_reference<lb>& l, const basic_reference<rb>& r) noexcept {
+		auto ppl = stack::push_pop(l);
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
+	}
+
+	template <bool lb, bool rb>
+	inline bool operator!=(const basic_reference<lb>& l, const basic_reference<rb>& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& l, const stack_reference& r) noexcept {
+		auto ppl = stack::push_pop(l);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& l, const stack_reference& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool rb>
+	inline bool operator==(const stack_reference& l, const basic_reference<rb>& r) noexcept {
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool rb>
+	inline bool operator!=(const stack_reference& l, const basic_reference<rb>& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
+		return !lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator==(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
+		return !rhs.valid();
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
+		return lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator!=(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
+		return rhs.valid();
+	}
+
+	inline bool operator==(const stateless_reference& l, const stateless_reference& r) noexcept {
+		return l.registry_index() == r.registry_index();
+	}
+
+	inline bool operator!=(const stateless_reference& l, const stateless_reference& r) noexcept {
+		return l.registry_index() != r.registry_index();
+	}
+
+	inline bool operator==(const stateless_reference& lhs, const lua_nil_t&) noexcept {
+		return lhs.registry_index() == LUA_REFNIL;
+	}
+
+	inline bool operator==(const lua_nil_t&, const stateless_reference& rhs) noexcept {
+		return rhs.registry_index() == LUA_REFNIL;
+	}
+
+	inline bool operator!=(const stateless_reference& lhs, const lua_nil_t&) noexcept {
+		return lhs.registry_index() != LUA_REFNIL;
+	}
+
+	inline bool operator!=(const lua_nil_t&, const stateless_reference& rhs) noexcept {
+		return rhs.registry_index() != LUA_REFNIL;
+	}
+
+	struct stateless_reference_equals : public stateless_stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		stateless_reference_equals(lua_State* L_) noexcept : stateless_stack_reference_equals(L_) {
+		}
+
+		bool operator()(const lua_nil_t& lhs, const stateless_reference& rhs) const noexcept {
+			return rhs.equals(lua_state(), lhs);
+		}
+
+		bool operator()(const stateless_reference& lhs, const lua_nil_t& rhs) const noexcept {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+		bool operator()(const stateless_reference& lhs, const stateless_reference& rhs) const noexcept {
+			return lhs.equals(lua_state(), rhs);
+		}
+	};
+
+	struct reference_equals : public stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		template <bool rb>
+		bool operator()(const lua_nil_t& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const lua_nil_t& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb, bool rb>
+		bool operator()(const basic_reference<lb>& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const stack_reference& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool rb>
+		bool operator()(const stack_reference& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+	};
+
+	struct stateless_reference_hash : public stateless_stack_reference_hash {
+		using argument_type = stateless_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		stateless_reference_hash(lua_State* L_) noexcept : stateless_stack_reference_hash(L_) {
+		}
+
+		result_type operator()(const stateless_reference& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer(lua_state()));
+		}
+	};
+
+	struct reference_hash : public stack_reference_hash {
+		using argument_type = reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		template <bool lb>
+		result_type operator()(const basic_reference<lb>& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/reference.hpp
+
+// beginning of sol/tie.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		struct is_speshul : std::false_type { };
+	} // namespace detail
+
+	template <typename T>
+	struct tie_size : std::tuple_size<T> { };
+
+	template <typename T>
+	struct is_tieable : std::integral_constant<bool, (::sol::tie_size<T>::value > 0)> { };
+
+	template <typename... Tn>
+	struct tie_t : public std::tuple<std::add_lvalue_reference_t<Tn>...> {
+	private:
+		typedef std::tuple<std::add_lvalue_reference_t<Tn>...> base_t;
+
+		template <typename T>
+		void set(std::false_type, T&& target) {
+			std::get<0>(*this) = std::forward<T>(target);
+		}
+
+		template <typename T>
+		void set(std::true_type, T&& target) {
+			typedef tie_size<meta::unqualified_t<T>> value_size;
+			typedef tie_size<std::tuple<Tn...>> tie_size;
+			typedef meta::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
+			typedef std::make_index_sequence<indices_size::value> indices;
+			set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::true_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow { 0, (get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)..., 0 };
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::false_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow { 0, (get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)..., 0 };
+		}
+
+	public:
+		using base_t::base_t;
+
+		template <typename T>
+		tie_t& operator=(T&& value) {
+			typedef is_tieable<meta::unqualified_t<T>> tieable;
+			set(tieable(), std::forward<T>(value));
+			return *this;
+		}
+	};
+
+	template <typename... Tn>
+	struct tie_size<tie_t<Tn...>> : std::tuple_size<std::tuple<Tn...>> { };
+
+	namespace adl_barrier_detail {
+		template <typename... Tn>
+		inline tie_t<std::remove_reference_t<Tn>...> tie(Tn&&... argn) {
+			return tie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);
+		}
+	} // namespace adl_barrier_detail
+
+	using namespace adl_barrier_detail;
+
+} // namespace sol
+
+// end of sol/tie.hpp
+
+// beginning of sol/stack_guard.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline void stack_fail(int, int) {
+#if SOL_IS_ON(SOL_EXCEPTIONS)
+			throw error(detail::direct_error, "imbalanced stack after operation finish");
+#else
+			// Lol, what do you want, an error printout? :3c
+			// There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
+			// hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
+#endif // No Exceptions
+		}
+	} // namespace detail
+
+	struct stack_guard {
+		lua_State* L;
+		int top;
+		std::function<void(int, int)> on_mismatch;
+
+		stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {
+		}
+		stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {
+		}
+		bool check_stack(int modification = 0) const {
+			int bottom = lua_gettop(L) + modification;
+			if (top == bottom) {
+				return true;
+			}
+			on_mismatch(top, bottom);
+			return false;
+		}
+		~stack_guard() {
+			check_stack();
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_guard.hpp
+
+#include <vector>
+#include <bitset>
+#include <forward_list>
+#include <string>
+#include <limits>
+#include <algorithm>
+#include <sstream>
+#include <optional>
+#include <type_traits>
+
+namespace sol {
+	namespace detail {
+		struct with_function_tag { };
+		struct as_reference_tag { };
+		template <typename T>
+		struct as_pointer_tag { };
+		template <typename T>
+		struct as_value_tag { };
+		template <typename T>
+		struct as_unique_tag { };
+		template <typename T>
+		struct as_table_tag { };
+
+		template <typename Tag>
+		inline constexpr bool is_tagged_v
+		     = meta::is_specialization_of_v<Tag,
+		            detail::
+		                 as_pointer_tag> || meta::is_specialization_of_v<Tag, as_value_tag> || meta::is_specialization_of_v<Tag, as_unique_tag> || meta::is_specialization_of_v<Tag, as_table_tag> || std::is_same_v<Tag, as_reference_tag> || std::is_same_v<Tag, with_function_tag>;
+
+		using lua_reg_table = luaL_Reg[64];
+
+		using unique_destructor = void (*)(void*);
+		using unique_tag = detail::inheritance_unique_cast_function;
+
+		inline void* alloc_newuserdata(lua_State* L, std::size_t bytesize) {
+#if SOL_LUA_VERSION_I_ >= 504
+			return lua_newuserdatauv(L, bytesize, 1);
+#else
+			return lua_newuserdata(L, bytesize);
+#endif
+		}
+
+		constexpr std::uintptr_t align(std::size_t alignment, std::uintptr_t ptr, std::size_t& space) {
+			// this handles arbitrary alignments...
+			// make this into a power-of-2-only?
+			// actually can't: this is a C++14-compatible framework,
+			// power of 2 alignment is C++17
+			std::uintptr_t offby = static_cast<std::uintptr_t>(ptr % alignment);
+			std::uintptr_t padding = (alignment - offby) % alignment;
+			ptr += padding;
+			space -= padding;
+			return ptr;
+		}
+
+		inline void* align(std::size_t alignment, void* ptr, std::size_t& space) {
+			return reinterpret_cast<void*>(align(alignment, reinterpret_cast<std::uintptr_t>(ptr), space));
+		}
+
+		constexpr std::uintptr_t align_one(std::size_t alignment, std::size_t size, std::uintptr_t ptr) {
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(alignment, ptr, space) + size;
+		}
+
+		template <typename... Args>
+		constexpr std::size_t aligned_space_for(std::uintptr_t ptr) {
+			std::uintptr_t end = ptr;
+			((end = align_one(alignof(Args), sizeof(Args), end)), ...);
+			return static_cast<std::size_t>(end - ptr);
+		}
+
+		template <typename... Args>
+		constexpr std::size_t aligned_space_for() {
+			static_assert(sizeof...(Args) > 0);
+
+			constexpr std::size_t max_arg_alignment = (std::max)({ alignof(Args)... });
+			if constexpr (max_arg_alignment <= alignof(std::max_align_t)) {
+				// If all types are `good enough`, simply calculate alignment in case of the worst allocator
+				std::size_t worst_required_size = 0;
+				for (std::size_t ptr = 0; ptr < max_arg_alignment; ptr++) {
+					worst_required_size = (std::max)(worst_required_size, aligned_space_for<Args...>(ptr));
+				}
+				return worst_required_size;
+			}
+			else {
+				// For over-aligned types let's assume that every Arg in Args starts at the worst aligned address
+				return (aligned_space_for<Args>(0x1) + ...);
+			}
+		}
+
+		inline void* align_usertype_pointer(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<void*>::value > 1)
+#endif
+			     >;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<void*>::value, ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_destructor(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<unique_destructor>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_pointer(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(void*));
+			}
+			if (!use_align::value) {
+				return static_cast<void*>(static_cast<void**>(ptr) + 1);
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_destructor>::value, ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_tag(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<unique_tag>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_destructor(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_destructor));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_tag>::value, ptr, space);
+		}
+
+		template <typename T, bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_tag(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_tag));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, ptr, space);
+		}
+
+		template <typename T>
+		void* align_user(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, ptr, space);
+		}
+
+		template <typename T>
+		T** usertype_allocate_pointer(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(alloc_newuserdata(L, sizeof(T*)));
+				return pointerpointer;
+			}
+			constexpr std::size_t initial_size = aligned_space_for<T*>();
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = alloc_newuserdata(L, initial_size);
+			void* adjusted = align(std::alignment_of<T*>::value, unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				// trash allocator can burn in hell
+				lua_pop(L, 1);
+				// luaL_error(L, "if you are the one that wrote this allocator you should feel bad for doing a
+				// worse job than malloc/realloc and should go read some books, yeah?");
+				luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T*>().data());
+			}
+			return static_cast<T**>(adjusted);
+		}
+
+		inline bool attempt_alloc(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t value_align,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& data_adjusted) {
+			void* adjusted = alloc_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			// subtract size of what we're going to allocate there
+			allocated_size -= ptr_size;
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			data_adjusted = align(value_align, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		inline bool attempt_alloc_unique(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t real_align,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& dx_adjusted, void*& id_adjusted, void*& data_adjusted) {
+			void* adjusted = alloc_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= ptr_size;
+
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			dx_adjusted = align(std::alignment_of_v<unique_destructor>, adjusted, allocated_size);
+			if (dx_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_destructor);
+
+			adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor));
+
+			id_adjusted = align(std::alignment_of_v<unique_tag>, adjusted, allocated_size);
+			if (id_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_tag);
+
+			adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag));
+			data_adjusted = align(real_align, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		template <typename T>
+		T* usertype_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(alloc_newuserdata(L, sizeof(T*) + sizeof(T)));
+				T*& pointerreference = *pointerpointer;
+				T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
+				pointerreference = allocationtarget;
+				return allocationtarget;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T*, T>();
+
+			void* pointer_adjusted;
+			void* data_adjusted;
+			bool result
+			     = attempt_alloc(L, std::alignment_of_v<T*>, sizeof(T*), std::alignment_of_v<T>, initial_size, pointer_adjusted, data_adjusted);
+			if (!result) {
+				if (pointer_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else {
+					luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				return nullptr;
+			}
+
+			T** pointerpointer = reinterpret_cast<T**>(pointer_adjusted);
+			T*& pointerreference = *pointerpointer;
+			T* allocationtarget = reinterpret_cast<T*>(data_adjusted);
+			pointerreference = allocationtarget;
+			return allocationtarget;
+		}
+
+		template <typename T, typename Real>
+		Real* usertype_unique_allocate(lua_State* L, T**& pref, unique_destructor*& dx, unique_tag*& id) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1
+			          || std::alignment_of<Real>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				pref = static_cast<T**>(alloc_newuserdata(L, sizeof(T*) + sizeof(detail::unique_destructor) + sizeof(unique_tag) + sizeof(Real)));
+				dx = static_cast<detail::unique_destructor*>(static_cast<void*>(pref + 1));
+				id = static_cast<unique_tag*>(static_cast<void*>(dx + 1));
+				Real* mem = static_cast<Real*>(static_cast<void*>(id + 1));
+				return mem;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>();
+
+			void* pointer_adjusted;
+			void* dx_adjusted;
+			void* id_adjusted;
+			void* data_adjusted;
+			bool result = attempt_alloc_unique(L,
+			     std::alignment_of_v<T*>,
+			     sizeof(T*),
+			     std::alignment_of_v<Real>,
+			     initial_size,
+			     pointer_adjusted,
+			     dx_adjusted,
+			     id_adjusted,
+			     data_adjusted);
+			if (!result) {
+				if (pointer_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else if (dx_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (deleter section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else {
+					luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				return nullptr;
+			}
+
+			pref = static_cast<T**>(pointer_adjusted);
+			dx = static_cast<detail::unique_destructor*>(dx_adjusted);
+			id = static_cast<unique_tag*>(id_adjusted);
+			Real* mem = static_cast<Real*>(data_adjusted);
+			return mem;
+		}
+
+		template <typename T>
+		T* user_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T* pointer = static_cast<T*>(alloc_newuserdata(L, sizeof(T)));
+				return pointer;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T>();
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = alloc_newuserdata(L, allocated_size);
+			void* adjusted = align(std::alignment_of_v<T>, unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				lua_pop(L, 1);
+				luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T>().data());
+			}
+			return static_cast<T*>(adjusted);
+		}
+
+		template <typename T>
+		int usertype_alloc_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_pointer(memory);
+			T** pdata = static_cast<T**>(memory);
+			T* data = *pdata;
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
+			return 0;
+		}
+
+		template <typename T>
+		int unique_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_unique_destructor(memory);
+			unique_destructor& dx = *static_cast<unique_destructor*>(memory);
+			memory = align_usertype_unique_tag<true>(memory);
+			(dx)(memory);
+			return 0;
+		}
+
+		template <typename T>
+		int user_alloc_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			void* aligned_memory = align_user<T>(memory);
+			T* typed_memory = static_cast<T*>(aligned_memory);
+			std::allocator<T> alloc;
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, typed_memory);
+			return 0;
+		}
+
+		template <typename T, typename Real>
+		void usertype_unique_alloc_destroy(void* memory) {
+			void* aligned_memory = align_usertype_unique<Real, true>(memory);
+			Real* typed_memory = static_cast<Real*>(aligned_memory);
+			std::allocator<Real> alloc;
+			std::allocator_traits<std::allocator<Real>>::destroy(alloc, typed_memory);
+		}
+
+		template <typename T>
+		int cannot_destroy(lua_State* L) {
+			return luaL_error(L,
+			     "cannot call the destructor for '%s': it is either hidden (protected/private) or removed with '= "
+			     "delete' and thusly this type is being destroyed without properly destroying, invoking undefined "
+			     "behavior: please bind a usertype and specify a custom destructor to define the behavior properly",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		void reserve(T&, std::size_t) {
+		}
+
+		template <typename T, typename Al>
+		void reserve(std::vector<T, Al>& vec, std::size_t hint) {
+			vec.reserve(hint);
+		}
+
+		template <typename T, typename Tr, typename Al>
+		void reserve(std::basic_string<T, Tr, Al>& str, std::size_t hint) {
+			str.reserve(hint);
+		}
+
+		inline bool property_always_true(meta_function) {
+			return true;
+		}
+
+		struct properties_enrollment_allowed {
+			int& times_through;
+			std::bitset<64>& properties;
+			automagic_enrollments& enrollments;
+
+			properties_enrollment_allowed(int& times_through_, std::bitset<64>& properties_, automagic_enrollments& enrollments_)
+			: times_through(times_through_), properties(properties_), enrollments(enrollments_) {
+			}
+
+			bool operator()(meta_function mf) const {
+				bool p = properties[static_cast<std::size_t>(mf)];
+				if (times_through > 0) {
+					return p;
+				}
+				switch (mf) {
+				case meta_function::length:
+					return enrollments.length_operator && !p;
+				case meta_function::pairs:
+					return enrollments.pairs_operator && !p;
+				case meta_function::call:
+					return enrollments.call_operator && !p;
+				case meta_function::less_than:
+					return enrollments.less_than_operator && !p;
+				case meta_function::less_than_or_equal_to:
+					return enrollments.less_than_or_equal_to_operator && !p;
+				case meta_function::equal_to:
+					return enrollments.equal_to_operator && !p;
+				default:
+					break;
+				}
+				return !p;
+			}
+		};
+
+		struct indexed_insert {
+			lua_reg_table& registration_table;
+			int& index;
+
+			indexed_insert(lua_reg_table& registration_table_, int& index_ref_) : registration_table(registration_table_), index(index_ref_) {
+			}
+			void operator()(meta_function meta_function_name_, lua_CFunction c_function_) {
+				registration_table[index] = luaL_Reg { to_string(meta_function_name_).c_str(), c_function_ };
+				++index;
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_getter;
+		template <typename T, typename P, bool global = false, bool raw = false, typename = void>
+		struct probe_field_getter;
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_setter;
+
+		template <typename T, typename = void>
+		struct unqualified_getter;
+		template <typename T, typename = void>
+		struct qualified_getter;
+
+		template <typename T, typename = void>
+		struct qualified_interop_getter;
+		template <typename T, typename = void>
+		struct unqualified_interop_getter;
+
+		template <typename T, typename = void>
+		struct popper;
+
+		template <typename T, typename = void>
+		struct unqualified_pusher;
+
+		template <typename T, type t, typename = void>
+		struct unqualified_checker;
+		template <typename T, type t, typename = void>
+		struct qualified_checker;
+
+		template <typename T, typename = void>
+		struct unqualified_check_getter;
+		template <typename T, typename = void>
+		struct qualified_check_getter;
+
+		struct probe {
+			bool success;
+			int levels;
+
+			probe(bool s, int l) : success(s), levels(l) {
+			}
+
+			operator bool() const {
+				return success;
+			};
+		};
+
+		struct record {
+			int last;
+			int used;
+
+			record() noexcept : last(), used() {
+			}
+			void use(int count) noexcept {
+				last = count;
+				used += count;
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function>
+			Function* get_function_pointer(lua_State*, int, record&) noexcept;
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept;
+		} // namespace stack_detail
+
+	} // namespace stack
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using adl_sol_lua_get_test_t = decltype(sol_lua_get(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_get_test_t
+			= decltype(sol_lua_interop_get(types<T>(), static_cast<lua_State*>(nullptr), -1, static_cast<void*>(nullptr), std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_test_t = decltype(sol_lua_check(types<T>(), static_cast<lua_State*>(nullptr), -1, &no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_check_test_t
+			= decltype(sol_lua_interop_check(types<T>(), static_cast<lua_State*>(nullptr), -1, type::none, &no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_get_test_t
+			= decltype(sol_lua_check_get(types<T>(), static_cast<lua_State*>(nullptr), -1, &no_panic, std::declval<stack::record&>()));
+
+		template <typename... Args>
+		using adl_sol_lua_push_test_t = decltype(sol_lua_push(static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T, typename... Args>
+		using adl_sol_lua_push_exact_test_t = decltype(sol_lua_push(types<T>(), static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_get_v = meta::is_detected_v<adl_sol_lua_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_get_v = meta::is_detected_v<adl_sol_lua_interop_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_v = meta::is_detected_v<adl_sol_lua_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_check_v = meta::is_detected_v<adl_sol_lua_interop_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_get_v = meta::is_detected_v<adl_sol_lua_check_get_test_t, T>;
+
+		template <typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_v = meta::is_detected_v<adl_sol_lua_push_test_t, Args...>;
+
+		template <typename T, typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_exact_v = meta::is_detected_v<adl_sol_lua_push_exact_test_t, T, Args...>;
+	}} // namespace meta::meta_detail
+
+	namespace stack {
+		namespace stack_detail {
+			constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+			constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+			constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+			constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+			constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+			constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol2 userdata";
+			constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+			constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+
+			template <typename T>
+			struct strip {
+				typedef T type;
+			};
+			template <typename T>
+			struct strip<std::reference_wrapper<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<user<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<non_null<T>> {
+				typedef T type;
+			};
+			template <typename T>
+			using strip_t = typename strip<T>::type;
+
+			template <typename C>
+			static int get_size_hint(C& c) {
+				return static_cast<int>(c.size());
+			}
+
+			template <typename V, typename Al>
+			static int get_size_hint(const std::forward_list<V, Al>&) {
+				// forward_list makes me sad
+				return static_cast<int>(32);
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_unqualified_get(lua_State* L, int index, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<Tu>) {
+					return sol_lua_get(types<Tu>(), L, index, tracking);
+				}
+				else {
+					unqualified_getter<Tu> g {};
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_get(lua_State* L, int index, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+					return sol_lua_get(types<T>(), L, index, tracking);
+				}
+				else {
+					qualified_getter<T> g {};
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unqualified_interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<Tu>) {
+					return sol_lua_interop_get(types<Tu>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)unadjusted_pointer;
+					(void)tracking;
+					using Ti = stack_detail::strip_t<Tu>;
+					return std::pair<bool, Ti*> { false, nullptr };
+				}
+			}
+
+			template <typename T>
+			decltype(auto) interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<T>) {
+					return sol_lua_interop_get(types<T>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					return unqualified_interop_get<T>(L, index, unadjusted_pointer, tracking);
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool unqualified_interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<Tu>) {
+					return sol_lua_interop_check(types<Tu>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)index_type;
+					(void)handler;
+					(void)tracking;
+					return false;
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<T>) {
+					return sol_lua_interop_check(types<T>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return unqualified_interop_check<T>(L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+			}
+
+			using undefined_method_func = void (*)(stack_reference);
+
+			struct undefined_metatable {
+				lua_State* L;
+				const char* key;
+				undefined_method_func on_new_table;
+
+				undefined_metatable(lua_State* l, const char* k, undefined_method_func umf) : L(l), key(k), on_new_table(umf) {
+				}
+
+				void operator()() const {
+					if (luaL_newmetatable(L, key) == 1) {
+						on_new_table(stack_reference(L, -1));
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		inline bool maybe_indexable(lua_State* L, int index = -1) {
+			type t = type_of(L, index);
+			return t == type::userdata || t == type::table;
+		}
+
+		inline int top(lua_State* L) {
+			return lua_gettop(L);
+		}
+
+		inline bool is_main_thread(lua_State* L) {
+			int ismainthread = lua_pushthread(L);
+			lua_pop(L, 1);
+			return ismainthread == 1;
+		}
+
+		inline void coroutine_create_guard(lua_State* L) {
+			if (is_main_thread(L)) {
+				return;
+			}
+			int stacksize = lua_gettop(L);
+			if (stacksize < 1) {
+				return;
+			}
+			if (type_of(L, 1) != type::function) {
+				return;
+			}
+			// well now we're screwed...
+			// we can clean the stack and pray it doesn't destroy anything?
+			lua_pop(L, stacksize);
+		}
+
+		inline void clear(lua_State* L, int table_index) {
+			lua_pushnil(L);
+			while (lua_next(L, table_index) != 0) {
+				// remove value
+				lua_pop(L, 1);
+				// duplicate key to protect form rawset
+				lua_pushvalue(L, -1);
+				// push new value
+				lua_pushnil(L);
+				// table_index%[key] = nil
+				lua_rawset(L, table_index);
+			}
+		}
+
+		inline void clear(reference& r) {
+			auto pp = push_pop<false>(r);
+			int stack_index = pp.index_of(r);
+			clear(r.lua_state(), stack_index);
+		}
+
+		inline void clear(stack_reference& r) {
+			clear(r.lua_state(), r.stack_index());
+		}
+
+		inline void clear(lua_State* L_, stateless_reference& r) {
+			r.push(L_);
+			int stack_index = absolute_index(L_, -1);
+			clear(L_, stack_index);
+			r.pop(L_);
+		}
+
+		inline void clear(lua_State* L_, stateless_stack_reference& r) {
+			clear(L_, r.stack_index());
+		}
+
+		template <typename T, typename... Args>
+		int push(lua_State* L, T&& t, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, T, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, T, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<T, Args...>) {
+				return sol_lua_push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				return p.push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+		}
+
+		// overload allows to use a pusher of a specific type, but pass in any kind of args
+		template <typename T, typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
+		int push(lua_State* L, Arg&& arg, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, Arg, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, Arg, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<Arg, Args...> && !detail::is_tagged_v<Tu>) {
+				return sol_lua_push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, typename... Args>
+		int push_userdata(lua_State* L, T&& t, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_userdata(lua_State* L, Arg&& arg, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		namespace stack_detail {
+
+			template <typename T, typename Arg, typename... Args>
+			int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+				// clang-format off
+				using use_reference_tag =
+				meta::all<
+					meta::neg<is_value_semantic_for_function<T>>
+#if SOL_IS_OFF(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+					, std::is_lvalue_reference<T>,
+					meta::neg<std::is_const<std::remove_reference_t<T>>>,
+					meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
+					meta::neg<is_unique_usertype<meta::unqualified_t<T>>>
+#endif
+				>;
+				// clang-format on
+				using Tr = meta::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::unqualified_t<T>>;
+				return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+
+		} // namespace stack_detail
+
+		template <typename T, typename... Args>
+		int push_reference(lua_State* L, T&& t, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		inline int multi_push(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = push(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		inline int multi_push_reference(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push_reference(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = stack::push_reference(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push_reference(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<Tu>) {
+				return sol_lua_check(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_checker<Tu, lua_type_of_v<Tu>> c{};
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool unqualified_check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return unqualified_check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<T>) {
+				return sol_lua_check(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				using Tu = meta::unqualified_t<T>;
+				qualified_checker<T, lua_type_of_v<Tu>> c{};
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, type, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check_usertype(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check_usertype<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<Tu>) {
+				return sol_lua_check_get(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_check_getter<Tu> cg {};
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return unqualified_check_get<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				qualified_check_getter<T> cg {};
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check_get<T>(L, index, handler);
+		}
+
+		namespace stack_detail {
+
+			template <typename Handler>
+			bool check_types(lua_State*, int, Handler&&, record&) {
+				return true;
+			}
+
+			template <typename T, typename... Args, typename Handler>
+			bool check_types(lua_State* L, int firstargument, Handler&& handler, record& tracking) {
+				if (!stack::check<T>(L, firstargument + tracking.used, handler, tracking))
+					return false;
+				return check_types<Args...>(L, firstargument, std::forward<Handler>(handler), tracking);
+			}
+
+			template <typename... Args, typename Handler>
+			bool check_types(types<Args...>, lua_State* L, int index, Handler&& handler, record& tracking) {
+				return check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+			}
+
+		} // namespace stack_detail
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack_detail::check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args>
+		bool multi_check(lua_State* L, int index) {
+			return multi_check<Args...>(L, index);
+		}
+
+		template <typename T>
+		auto unqualified_get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_unqualified_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+				auto op = unqualified_check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return unqualified_get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		auto get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_get<T>(L, index, tracking);
+				}
+				auto op = check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index, record& tracking) {
+			using UT = meta::conditional_t<std::is_pointer<T>::value, detail::as_pointer_tag<std::remove_pointer_t<T>>, detail::as_value_tag<T>>;
+			return get<UT>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index = -lua_size_v<meta::unqualified_t<T>>) {
+			record tracking {};
+			return get_usertype<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) pop(lua_State* L) {
+			return popper<T> {}.pop(L);
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key, int tableindex) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key) {
+			get_field<global, true>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			get_field<global, true>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <typename T, typename F>
+		void modify_unique_usertype_as(const stack_reference& obj, F&& f) {
+			void* raw = lua_touserdata(obj.lua_state(), obj.stack_index());
+			void* ptr_memory = detail::align_usertype_pointer(raw);
+			void* uu_memory = detail::align_usertype_unique<T>(raw);
+			T& uu = *static_cast<T*>(uu_memory);
+			f(uu);
+			*static_cast<void**>(ptr_memory) = static_cast<void*>(detail::unique_get(obj.lua_state(), uu));
+		}
+
+		template <typename F>
+		void modify_unique_usertype(const stack_reference& obj, F&& f) {
+			using bt = meta::bind_traits<meta::unqualified_t<F>>;
+			using T = typename bt::template arg_at<0>;
+			using Tu = meta::unqualified_t<T>;
+			modify_unique_usertype_as<Tu>(obj, std::forward<F>(f));
+		}
+
+		namespace stack_detail {
+			template <typename T, typename Handler>
+			decltype(auto) check_get_arg(lua_State* L_, int index_, Handler&& handler_, record& tracking_) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_check_access_v<T>) {
+					sol_lua_check_access(types<meta::unqualified_t<T>>(), L_, index_, tracking_);
+				}
+				return check_get<T>(L_, index_, std::forward<Handler>(handler_), tracking_);
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_get_arg(lua_State* L_, int index_, record& tracking_) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_check_access_v<T>) {
+					sol_lua_check_access(types<meta::unqualified_t<T>>(), L_, index_, tracking_);
+				}
+				return unchecked_get<T>(L_, index_, tracking_);
+			}
+		} // namespace stack_detail
+
+	} // namespace stack
+
+	namespace detail {
+
+		template <typename T>
+		lua_CFunction make_destructor(std::true_type) {
+			if constexpr (is_unique_usertype_v<T>) {
+				return &unique_destroy<T>;
+			}
+			else if constexpr (!std::is_pointer_v<T>) {
+				return &usertype_alloc_destroy<T>;
+			}
+			else {
+				return &cannot_destroy<T>;
+			}
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor(std::false_type) {
+			return &cannot_destroy<T>;
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor() {
+			return make_destructor<T>(std::is_destructible<T>());
+		}
+
+		struct no_comp {
+			template <typename A, typename B>
+			bool operator()(A&&, B&&) const {
+				return false;
+			}
+		};
+
+		template <typename T>
+		int is_check(lua_State* L) {
+			return stack::push(L, stack::check<T>(L, 1, &no_panic));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::true_type, lua_State* L) {
+			decltype(auto) ts = stack::get<T>(L, 1).to_string();
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::false_type, lua_State* L) {
+			return luaL_error(L,
+			     "cannot perform to_string on '%s': no 'to_string' overload in namespace, 'to_string' member "
+			     "function, or operator<<(ostream&, ...) present",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::true_type, lua_State* L) {
+			using namespace std;
+			decltype(auto) ts = to_string(stack::get<T>(L, 1));
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::false_type, lua_State* L) {
+			return member_default_to_string<T>(meta::supports_to_string_member<T>(), L);
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::true_type, lua_State* L) {
+			std::ostringstream oss;
+			oss << stack::unqualified_get<T>(L, 1);
+			return stack::push(L, oss.str());
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::false_type, lua_State* L) {
+			return adl_default_to_string<T>(meta::supports_adl_to_string<T>(), L);
+		}
+
+		template <typename T>
+		int default_to_string(lua_State* L) {
+			return oss_default_to_string<T>(meta::supports_op_left_shift<std::ostream, T>(), L);
+		}
+
+		template <typename T>
+		int default_size(lua_State* L) {
+			decltype(auto) self = stack::unqualified_get<T>(L, 1);
+			return stack::push(L, self.size());
+		}
+
+		template <typename T, typename Op>
+		int comparsion_operator_wrap(lua_State* L) {
+			if constexpr (std::is_void_v<T>) {
+				return stack::push(L, false);
+			}
+			else {
+				auto maybel = stack::unqualified_check_get<T>(L, 1);
+				if (!maybel) {
+					return stack::push(L, false);
+				}
+				auto mayber = stack::unqualified_check_get<T>(L, 2);
+				if (!mayber) {
+					return stack::push(L, false);
+				}
+				decltype(auto) l = *maybel;
+				decltype(auto) r = *mayber;
+				if constexpr (std::is_same_v<no_comp, Op>) {
+					std::equal_to<> op;
+					return stack::push(L, op(detail::ptr(l), detail::ptr(r)));
+				}
+				else {
+					if constexpr (std::is_same_v<std::equal_to<>, Op> // clang-format hack
+					     || std::is_same_v<std::less_equal<>, Op>     //
+					     || std::is_same_v<std::less_equal<>, Op>) {  //
+						if (detail::ptr(l) == detail::ptr(r)) {
+							return stack::push(L, true);
+						}
+					}
+					Op op;
+					return stack::push(L, op(detail::deref(l), detail::deref(r)));
+				}
+			}
+		}
+
+		template <typename T, typename IFx, typename Fx>
+		void insert_default_registrations(IFx&& ifx, Fx&& fx);
+
+		template <typename T, bool, bool>
+		struct get_is_primitive : is_lua_primitive<T> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, false>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<T>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, false, true>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<meta::unqualified_t<T>>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, true> : get_is_primitive<T, true, false> { };
+
+	} // namespace detail
+
+	template <typename T>
+	struct is_proxy_primitive
+	: detail::get_is_primitive<T, meta::meta_detail::is_adl_sol_lua_get_v<T>, meta::meta_detail::is_adl_sol_lua_get_v<meta::unqualified_t<T>>> { };
+
+} // namespace sol
+
+// end of sol/stack_core.hpp
+
+// beginning of sol/stack_check.hpp
+
+// beginning of sol/stack_check_unqualified.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans
+
+namespace sol { namespace stack {
+	template <typename Handler>
+	bool loose_table_check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+		tracking.use(1);
+		type t = type_of(L_, index);
+		if (t == type::table) {
+			return true;
+		}
+		if (t != type::userdata) {
+			handler(L_, index, type::table, t, "value is not a table or a userdata that can behave like one");
+			return false;
+		}
+		return true;
+	}
+
+	namespace stack_detail {
+		inline bool impl_check_metatable(lua_State* L_, int index, const std::string& metakey, bool poptable) {
+			luaL_getmetatable(L_, &metakey[0]);
+			const type expectedmetatabletype = static_cast<type>(lua_type(L_, -1));
+			if (expectedmetatabletype != type::lua_nil) {
+				if (lua_rawequal(L_, -1, index) == 1) {
+					lua_pop(L_, 1 + static_cast<int>(poptable));
+					return true;
+				}
+			}
+			lua_pop(L_, 1);
+			return false;
+		}
+
+		template <typename T, bool poptable = true>
+		inline bool check_metatable(lua_State* L_, int index = -2) {
+			return impl_check_metatable(L_, index, usertype_traits<T>::metatable(), poptable);
+		}
+
+		template <type expected, int (*check_func)(lua_State*, int)>
+		struct basic_check {
+			template <typename Handler>
+			static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+				tracking.use(1);
+				bool success = check_func(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State*, int, type, Handler&&, record&) {
+			return false;
+		}
+	};
+
+	template <typename T, typename>
+	struct qualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, type index_type, Handler&& handler, record& tracking) {
+			return stack_detail::unqualified_interop_check<T>(L_, index, index_type, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename T, type expected, typename>
+	struct unqualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				bool success = lua_isboolean(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (meta::any_same_v<T,
+				                   char
+#if SOL_IS_ON(SOL_CHAR8_T)
+				                   ,
+				                   char8_t
+#endif
+				                   ,
+				                   char16_t,
+				                   char32_t>) {
+				return stack::check<std::basic_string<T>>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VERSION_I_ >= 503
+				// Lua 5.3 and greater checks for numeric precision
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+				// imprecise, sloppy conversions
+				int isnum = 0;
+				lua_tointegerx(L_, index, &isnum);
+				const bool success = isnum != 0;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string_integral);
+				}
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				// this check is precise, do not convert
+				if (lua_isinteger(L_, index) == 1) {
+					return true;
+				}
+				const bool success = false;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_integral);
+				}
+#else
+				// Numerics are neither safe nor string-convertible
+				type t = type_of(L_, index);
+				const bool success = t == type::number;
+#endif
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number);
+				}
+				return success;
+#else
+				// Lua 5.2 and below checks
+#if SOL_IS_OFF(SOL_STRINGS_ARE_NUMBERS)
+				// must pre-check, because it will convert
+				type t = type_of(L_, index);
+				if (t != type::number) {
+					// expected type, actual type
+					handler(L_, index, type::number, t, detail::not_a_number);
+					return false;
+				}
+#endif // Do not allow strings to be numbers
+
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				int isnum = 0;
+				const lua_Number v = lua_tonumberx(L_, index, &isnum);
+				const bool success = isnum != 0 && static_cast<lua_Number>(llround(v)) == v;
+#else
+				const bool success = true;
+#endif // Safe numerics and number precision checking
+				if (!success) {
+					// Use defines to provide a better error message!
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string);
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+					handler(L_, index, type::number, t, detail::not_a_number_or_number_string);
+#else
+					handler(L_, index, type::number, t, detail::not_a_number);
+#endif
+				}
+				return success;
+#endif
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+				bool success = lua_isnumber(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string);
+				}
+				return success;
+#else
+				type t = type_of(L_, index);
+				bool success = t == type::number;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, t, detail::not_a_number);
+				}
+				return success;
+#endif // Strings are Numbers
+			}
+			else if constexpr (meta::any_same_v<T, type, this_state, this_main_state, this_environment, variadic_args>) {
+				(void)L_;
+				(void)index;
+				(void)handler;
+				tracking.use(0);
+				return true;
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using element = unique_usertype_element_t<T>;
+				using actual = unique_usertype_actual_t<T>;
+				const type indextype = type_of(L_, index);
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a userdata");
+					return false;
+				}
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L_);
+				if (stack_detail::check_metatable<d::u<element>>(L_, metatableindex)) {
+					void* memory = lua_touserdata(L_, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					bool success = &detail::usertype_unique_alloc_destroy<element, actual> == pdx;
+					if (!success) {
+						memory = detail::align_usertype_unique_tag<true>(memory);
+#if 0
+						// New version, one day
+#else
+						const char*& name_tag = *static_cast<const char**>(memory);
+						success = usertype_traits<T>::qualified_name() == name_tag;
+#endif
+						if (!success) {
+							handler(L_, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+						}
+					}
+					return success;
+				}
+				lua_pop(L_, 1);
+				handler(L_, index, type::userdata, indextype, "unrecognized userdata (not pushed by sol?)");
+				return false;
+			}
+			else if constexpr (meta::any_same_v<T, lua_nil_t, std::nullopt_t, nullopt_t>) {
+				bool success = lua_isnil(L_, index);
+				if (success) {
+					tracking.use(1);
+					return success;
+				}
+				tracking.use(0);
+				success = lua_isnone(L_, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t == type::table || t == type::none || t == type::lua_nil || t == type::userdata) {
+					return true;
+				}
+				handler(L_, index, type::table, t, "value cannot not have a valid environment");
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, detail::non_lua_nil_t>) {
+				return !stack::unqualified_check<lua_nil_t>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_lua_table>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t != type::table) {
+					handler(L_, index, type::table, t, "value is not a table");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_bytecode>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t != type::function) {
+					handler(L_, index, type::function, t, "value is not a function that can be dumped");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_environment>) {
+				tracking.use(1);
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				type t = type_of(L_, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L_, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L_, 1);
+					handler(L_, index, type::table, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				tracking.use(1);
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				type t = type_of(L_, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L_, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L_, 1);
+					handler(L_, index, expected, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*> || std::is_same_v<T, luaL_Stream>) {
+				if (lua_getmetatable(L_, index) == 0) {
+					type t = type_of(L_, index);
+					handler(L_, index, expected, t, "value is not a valid luaL_Stream (has no metatable/is not a valid value)");
+					return false;
+				}
+				luaL_getmetatable(L_, LUA_FILEHANDLE);
+				if (type_of(L_, index) != type::table) {
+					type t = type_of(L_, index);
+					lua_pop(L_, 1);
+					handler(L_,
+						index,
+						expected,
+						t,
+						"value is not a valid luaL_Stream (there is no metatable for luaL_Stream -- did you forget to "
+						"my_lua_state.open_libraries(sol::lib::state) or equivalent?)");
+					return false;
+				}
+				int is_stream_table = lua_compare(L_, -1, -2, LUA_OPEQ);
+				lua_pop(L_, 2);
+				if (is_stream_table == 0) {
+					type t = type_of(L_, index);
+					handler(L_, index, expected, t, "value is not a valid luaL_Stream (incorrect metatable)");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				(void)handler;
+				type t = type_of(L_, index);
+				if (t == type::none) {
+					tracking.use(0);
+					return true;
+				}
+				if (t == type::lua_nil) {
+					tracking.use(1);
+					return true;
+				}
+				return stack::unqualified_check<ValueType>(L_, index, &no_panic, tracking);
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::check_function_pointer<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+#endif
+			else if constexpr (expected == type::userdata) {
+				if constexpr (meta::any_same_v<T, userdata_value> || meta::is_specialization_of_v<T, basic_userdata>) {
+					tracking.use(1);
+					type t = type_of(L_, index);
+					bool success = t == type::userdata;
+					if (!success) {
+						// expected type, actual type
+						handler(L_, index, type::userdata, t, "");
+					}
+					return success;
+				}
+				else if constexpr (meta::is_specialization_of_v<T, user>) {
+					unqualified_checker<lightuserdata_value, type::userdata> c;
+					(void)c;
+					return c.check(L_, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					if constexpr (std::is_pointer_v<T>) {
+						return check_usertype<T>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+					else if constexpr (meta::is_specialization_of_v<T, std::reference_wrapper>) {
+						using T_internal = typename T::type;
+						return stack::check<T_internal>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+					else {
+						return check_usertype<T>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+				}
+			}
+			else if constexpr (expected == type::poly) {
+				tracking.use(1);
+				bool success = is_lua_reference_v<T> || !lua_isnone(L_, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::poly, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::lightuserdata) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				bool success = t == type::userdata || t == type::lightuserdata;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::lightuserdata, t, "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::function) {
+				if constexpr (meta::any_same_v<T, lua_CFunction, std::remove_pointer_t<lua_CFunction>, c_closure>) {
+					tracking.use(1);
+					bool success = lua_iscfunction(L_, index) == 1;
+					if (!success) {
+						// expected type, actual type
+						handler(L_, index, expected, type_of(L_, index), "");
+					}
+					return success;
+				}
+				else {
+					tracking.use(1);
+					type t = type_of(L_, index);
+					if (t == type::lua_nil || t == type::none || t == type::function) {
+						// allow for lua_nil to be returned
+						return true;
+					}
+					if (t != type::userdata && t != type::table) {
+						handler(L_, index, type::function, t, "must be a function or table or a userdata");
+						return false;
+					}
+					// Do advanced check for call-style userdata?
+					static const auto& callkey = to_string(meta_function::call);
+					if (lua_getmetatable(L_, index) == 0) {
+						// No metatable, no __call key possible
+						handler(L_, index, type::function, t, "value is not a function and does not have overriden metatable");
+						return false;
+					}
+					if (lua_isnoneornil(L_, -1)) {
+						lua_pop(L_, 1);
+						handler(L_, index, type::function, t, "value is not a function and does not have valid metatable");
+						return false;
+					}
+					lua_getfield(L_, -1, &callkey[0]);
+					if (lua_isnoneornil(L_, -1)) {
+						lua_pop(L_, 2);
+						handler(L_, index, type::function, t, "value's metatable does not have __call overridden in metatable, cannot call this type");
+						return false;
+					}
+					// has call, is definitely a function
+					lua_pop(L_, 2);
+					return true;
+				}
+			}
+			else if constexpr (expected == type::table) {
+				return stack::loose_table_check(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				tracking.use(1);
+				const type indextype = type_of(L_, index);
+				bool success = expected == indextype;
+				if (!success) {
+					// expected type, actual type, message
+					handler(L_, index, expected, indextype, "");
+				}
+				return success;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<non_null<T>, type::userdata> : unqualified_checker<T, lua_type_of_v<T>> { };
+
+	template <typename T>
+	struct unqualified_checker<detail::as_value_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L_, index);
+			return check(types<T>(), L_, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename U, typename Handler>
+		static bool check(types<U>, lua_State* L_, int index, type indextype, Handler&& handler, record& tracking) {
+			if constexpr (
+				std::is_same_v<T,
+				     lightuserdata_value> || std::is_same_v<T, userdata_value> || std::is_same_v<T, userdata> || std::is_same_v<T, lightuserdata>) {
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				return true;
+			}
+			else {
+#if SOL_IS_ON(SOL_USE_INTEROP)
+				if (stack_detail::interop_check<U>(L_, index, indextype, handler, tracking)) {
+					return true;
+				}
+#endif // interop extensibility
+				tracking.use(1);
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				if (lua_iscfunction(L_, index) != 0) {
+					// a potential match...
+					return true;
+				}
+#endif
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L_);
+				if (stack_detail::check_metatable<U>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<U*>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<d::u<U>>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<as_container_t<U>>(L_, metatableindex))
+					return true;
+				bool success = false;
+				bool has_derived = derive<T>::value || weak_derive<T>::value;
+				if (has_derived) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L_, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+					auto pn = stack::pop_n(L_, 1);
+					lua_pushstring(L_, &detail::base_class_check_key()[0]);
+					lua_rawget(L_, metatableindex);
+					if (type_of(L_, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L_, -1);
+						detail::inheritance_check_function ic = reinterpret_cast<detail::inheritance_check_function>(basecastdata);
+						success = ic(usertype_traits<T>::qualified_name());
+					}
+				}
+				lua_pop(L_, 1);
+				if (!success) {
+					handler(L_, index, type::userdata, indextype, "value at this index does not properly reflect the desired type");
+					return false;
+				}
+				return true;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<detail::as_pointer_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, type indextype, Handler&& handler, record& tracking) {
+			if (indextype == type::lua_nil) {
+				tracking.use(1);
+				return true;
+			}
+			return check_usertype<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L_, index);
+			return check(L_, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_checker<std::tuple<Args...>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<Args...>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_checker<std::pair<A, B>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<A, B>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+
+	template <typename... Tn>
+	struct unqualified_checker<std::variant<Tn...>, type::poly> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, 0>, lua_State* L_, int index, Handler&& handler, record& tracking) {
+			if constexpr (V_is_empty::value) {
+				if (lua_isnone(L_, index)) {
+					return true;
+				}
+			}
+			tracking.use(1);
+			handler(L_, index, type::poly, type_of(L_, index), "value does not fit any type present in the variant");
+			return false;
+		}
+
+		template <std::size_t I, typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, I>, lua_State* L_, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L_, index, &no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return true;
+			}
+			return is_one(std::integral_constant<std::size_t, I - 1>(), L_, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return is_one(std::integral_constant<std::size_t, V_size::value>(), L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#endif // variant shenanigans
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_unqualified.hpp
+
+// beginning of sol/stack_check_qualified.hpp
+
+namespace sol { namespace stack {
+
+	template <typename X, type expected, typename>
+	struct qualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using no_cv_X = meta::unqualified_t<X>;
+			if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<no_cv_X>) {
+				using element = unique_usertype_element_t<no_cv_X>;
+				if constexpr (is_actual_type_rebindable_for_v<no_cv_X>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<no_cv_X>;
+					// we have a unique pointer type that can be
+					// rebound to a base/derived type
+					const type indextype = type_of(L, index);
+					tracking.use(1);
+					if (indextype != type::userdata) {
+						handler(L, index, type::userdata, indextype, "value is not a userdata");
+						return false;
+					}
+					void* memory = lua_touserdata(L, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					if (&detail::usertype_unique_alloc_destroy<element, no_cv_X> == pdx) {
+						return true;
+					}
+					if constexpr (derive<element>::value) {
+						memory = detail::align_usertype_unique_tag<true, false>(memory);
+						detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+						string_view ti = usertype_traits<element>::qualified_name();
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						if (ic(nullptr, nullptr, ti, rebind_ti) != 0) {
+							return true;
+						}
+					}
+					handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+					return false;
+				}
+				else {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_container_v<no_cv_X>) {
+				if (type_of(L, index) == type::userdata) {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return stack::unqualified_check<nested<X>>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && meta::is_specialization_of_v<X, nested>) {
+				using NestedX = typename meta::unqualified_t<X>::nested_type;
+				return stack::check<NestedX>(L, index, ::std::forward<Handler>(handler), tracking);
+			}
+			else {
+				return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_check_qualified.hpp
+
+// end of sol/stack_check.hpp
+
+// beginning of sol/stack_get.hpp
+
+// beginning of sol/stack_get_unqualified.hpp
+
+// beginning of sol/overload.hpp
+
+#include <utility>
+
+namespace sol {
+	template <typename... Functions>
+	struct overload_set {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<overload_set, meta::unqualified_t<Arg>>> = meta::enabler>
+		overload_set(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+		overload_set(const overload_set&) = default;
+		overload_set(overload_set&&) = default;
+		overload_set& operator=(const overload_set&) = default;
+		overload_set& operator=(overload_set&&) = default;
+	};
+
+	template <typename... Args>
+	decltype(auto) overload(Args&&... args) {
+		return overload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/overload.hpp
+
+// beginning of sol/unicode.hpp
+
+#include <array>
+#include <cstring>
+
+namespace sol {
+	// Everything here was lifted pretty much straight out of
+	// ogonek, because fuck figuring it out=
+	namespace unicode {
+		enum class error_code {
+			ok = 0,
+			invalid_code_point,
+			invalid_code_unit,
+			invalid_leading_surrogate,
+			invalid_trailing_surrogate,
+			sequence_too_short,
+			overlong_sequence,
+		};
+
+		inline const string_view& to_string(error_code ec) {
+			static const string_view storage[7] = { "ok",
+				"invalid code points",
+				"invalid code unit",
+				"invalid leading surrogate",
+				"invalid trailing surrogate",
+				"sequence too short",
+				"overlong sequence" };
+			return storage[static_cast<std::size_t>(ec)];
+		}
+
+		template <typename It>
+		struct decoded_result {
+			error_code error;
+			char32_t codepoint;
+			It next;
+		};
+
+		template <typename C>
+		struct encoded_result {
+			error_code error;
+			std::size_t code_units_size;
+			std::array<C, 4> code_units;
+		};
+
+		struct unicode_detail {
+			// codepoint related
+			static constexpr char32_t last_code_point = 0x10FFFF;
+
+			static constexpr char32_t first_lead_surrogate = 0xD800;
+			static constexpr char32_t last_lead_surrogate = 0xDBFF;
+
+			static constexpr char32_t first_trail_surrogate = 0xDC00;
+			static constexpr char32_t last_trail_surrogate = 0xDFFF;
+
+			static constexpr char32_t first_surrogate = first_lead_surrogate;
+			static constexpr char32_t last_surrogate = last_trail_surrogate;
+
+			static constexpr bool is_lead_surrogate(char32_t u) {
+				return u >= first_lead_surrogate && u <= last_lead_surrogate;
+			}
+			static constexpr bool is_trail_surrogate(char32_t u) {
+				return u >= first_trail_surrogate && u <= last_trail_surrogate;
+			}
+			static constexpr bool is_surrogate(char32_t u) {
+				return u >= first_surrogate && u <= last_surrogate;
+			}
+
+			// utf8 related
+			static constexpr auto last_1byte_value = 0x7Fu;
+			static constexpr auto last_2byte_value = 0x7FFu;
+			static constexpr auto last_3byte_value = 0xFFFFu;
+
+			static constexpr auto start_2byte_mask = 0x80u;
+			static constexpr auto start_3byte_mask = 0xE0u;
+			static constexpr auto start_4byte_mask = 0xF0u;
+
+			static constexpr auto continuation_mask = 0xC0u;
+			static constexpr auto continuation_signature = 0x80u;
+
+			static constexpr bool is_invalid(unsigned char b) {
+				return b == 0xC0 || b == 0xC1 || b > 0xF4;
+			}
+
+			static constexpr bool is_continuation(unsigned char b) {
+				return (b & unicode_detail::continuation_mask) == unicode_detail::continuation_signature;
+			}
+
+			static constexpr bool is_overlong(char32_t u, std::size_t bytes) {
+				return u <= unicode_detail::last_1byte_value || (u <= unicode_detail::last_2byte_value && bytes > 2)
+				     || (u <= unicode_detail::last_3byte_value && bytes > 3);
+			}
+
+			static constexpr int sequence_length(unsigned char b) {
+				return (b & start_2byte_mask) == 0                ? 1
+				     : (b & start_3byte_mask) != start_3byte_mask ? 2
+				     : (b & start_4byte_mask) != start_4byte_mask ? 3
+				                                                  : 4;
+			}
+
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1) {
+				return (static_cast<char32_t>((b0 & 0x1Fu) << 6u) | static_cast<char32_t>(b1 & 0x3Fu));
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2) {
+				return static_cast<char32_t>((b0 & 0x0Fu) << 12u) | static_cast<char32_t>((b1 & 0x3Fu) << 6u) | static_cast<char32_t>(b2 & 0x3Fu);
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2, unsigned char b3) {
+				return static_cast<char32_t>(static_cast<char32_t>((b0 & 0x07u) << 18u) | static_cast<char32_t>((b1 & 0x3F) << 12)
+				     | static_cast<char32_t>((b2 & 0x3Fu) << 6u) | static_cast<char32_t>(b3 & 0x3Fu));
+			}
+
+			// utf16 related
+			static constexpr char32_t last_bmp_value = 0xFFFF;
+			static constexpr char32_t normalizing_value = 0x10000;
+			static constexpr int lead_surrogate_bitmask = 0xFFC00;
+			static constexpr int trail_surrogate_bitmask = 0x3FF;
+			static constexpr int lead_shifted_bits = 10;
+			static constexpr char32_t replacement = 0xFFFD;
+
+			static char32_t combine_surrogates(char16_t lead, char16_t trail) {
+				auto hi = lead - first_lead_surrogate;
+				auto lo = trail - first_trail_surrogate;
+				return normalizing_value + ((hi << lead_shifted_bits) | lo);
+			}
+		};
+
+		inline encoded_result<char> code_point_to_utf8(char32_t codepoint) {
+			encoded_result<char> er;
+			er.error = error_code::ok;
+			if (codepoint <= unicode_detail::last_1byte_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char, 4> { { static_cast<char>(codepoint) } };
+			}
+			else if (codepoint <= unicode_detail::last_2byte_value) {
+				er.code_units_size = 2;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xC0 | ((codepoint & 0x7C0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			else if (codepoint <= unicode_detail::last_3byte_value) {
+				er.code_units_size = 3;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xE0 | ((codepoint & 0xF000) >> 12)),
+					static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			else {
+				er.code_units_size = 4;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xF0 | ((codepoint & 0x1C0000) >> 18)),
+					static_cast<char>(0x80 | ((codepoint & 0x3F000) >> 12)),
+					static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			return er;
+		}
+
+		inline encoded_result<char16_t> code_point_to_utf16(char32_t codepoint) {
+			encoded_result<char16_t> er;
+
+			if (codepoint <= unicode_detail::last_bmp_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char16_t, 4> { { static_cast<char16_t>(codepoint) } };
+				er.error = error_code::ok;
+			}
+			else {
+				auto normal = codepoint - unicode_detail::normalizing_value;
+				auto lead = unicode_detail::first_lead_surrogate + ((normal & unicode_detail::lead_surrogate_bitmask) >> unicode_detail::lead_shifted_bits);
+				auto trail = unicode_detail::first_trail_surrogate + (normal & unicode_detail::trail_surrogate_bitmask);
+				er.code_units = std::array<char16_t, 4> { { static_cast<char16_t>(lead), static_cast<char16_t>(trail) } };
+				er.code_units_size = 2;
+				er.error = error_code::ok;
+			}
+			return er;
+		}
+
+		inline encoded_result<char32_t> code_point_to_utf32(char32_t codepoint) {
+			encoded_result<char32_t> er;
+			er.code_units_size = 1;
+			er.code_units[0] = codepoint;
+			er.error = error_code::ok;
+			return er;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf8_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			unsigned char b0 = static_cast<unsigned char>(*it);
+			std::size_t length = static_cast<std::size_t>(unicode_detail::sequence_length(b0));
+
+			if (length == 1) {
+				dr.codepoint = static_cast<char32_t>(b0);
+				dr.error = error_code::ok;
+				++it;
+				dr.next = it;
+				return dr;
+			}
+
+			if (unicode_detail::is_invalid(b0) || unicode_detail::is_continuation(b0)) {
+				dr.error = error_code::invalid_code_unit;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			std::array<unsigned char, 4> b;
+			b[0] = b0;
+			for (std::size_t i = 1; i < length; ++i) {
+				b[i] = static_cast<unsigned char>(*it);
+				if (!unicode_detail::is_continuation(b[i])) {
+					dr.error = error_code::invalid_code_unit;
+					dr.next = it;
+					return dr;
+				}
+				++it;
+			}
+
+			char32_t decoded;
+			switch (length) {
+			case 2:
+				decoded = unicode_detail::decode(b[0], b[1]);
+				break;
+			case 3:
+				decoded = unicode_detail::decode(b[0], b[1], b[2]);
+				break;
+			default:
+				decoded = unicode_detail::decode(b[0], b[1], b[2], b[3]);
+				break;
+			}
+
+			if (unicode_detail::is_overlong(decoded, length)) {
+				dr.error = error_code::overlong_sequence;
+				return dr;
+			}
+			if (unicode_detail::is_surrogate(decoded) || decoded > unicode_detail::last_code_point) {
+				dr.error = error_code::invalid_code_point;
+				return dr;
+			}
+
+			// then everything is fine
+			dr.codepoint = decoded;
+			dr.error = error_code::ok;
+			dr.next = it;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf16_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			char16_t lead = static_cast<char16_t>(*it);
+
+			if (!unicode_detail::is_surrogate(lead)) {
+				++it;
+				dr.codepoint = static_cast<char32_t>(lead);
+				dr.next = it;
+				dr.error = error_code::ok;
+				return dr;
+			}
+			if (!unicode_detail::is_lead_surrogate(lead)) {
+				dr.error = error_code::invalid_leading_surrogate;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			auto trail = *it;
+			if (!unicode_detail::is_trail_surrogate(trail)) {
+				dr.error = error_code::invalid_trailing_surrogate;
+				dr.next = it;
+				return dr;
+			}
+
+			dr.codepoint = unicode_detail::combine_surrogates(lead, trail);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf32_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+			dr.codepoint = static_cast<char32_t>(*it);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+	} // namespace unicode
+} // namespace sol
+// end of sol/unicode.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cstdlib>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // Apple clang screwed up
+
+namespace sol { namespace stack {
+
+	namespace stack_detail {
+		template <typename Ch>
+		struct count_code_units_utf {
+			std::size_t needed_size;
+
+			count_code_units_utf() : needed_size(0) {
+			}
+
+			void operator()(const unicode::encoded_result<Ch> er) {
+				needed_size += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename ErCh>
+		struct copy_code_units_utf {
+			Ch* target_;
+
+			copy_code_units_utf(Ch* target) : target_(target) {
+			}
+
+			void operator()(const unicode::encoded_result<ErCh> er) {
+				std::memcpy(target_, er.code_units.data(), er.code_units_size * sizeof(ErCh));
+				target_ += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename F>
+		inline void convert(const char* strb, const char* stre, F&& f) {
+			char32_t cp = 0;
+			for (const char* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf8_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+					++strtarget;
+				}
+				else {
+					cp = dr.codepoint;
+					strtarget = dr.next;
+				}
+				if constexpr (std::is_same_v<Ch, char32_t>) {
+					auto er = unicode::code_point_to_utf32(cp);
+					f(er);
+				}
+				else {
+					auto er = unicode::code_point_to_utf16(cp);
+					f(er);
+				}
+			}
+		}
+
+		template <typename BaseCh, typename S>
+		inline S get_into(lua_State* L, int index, record& tracking) {
+			using Ch = typename S::value_type;
+			tracking.use(1);
+			size_t len;
+			auto utf8p = lua_tolstring(L, index, &len);
+			if (len < 1)
+				return S();
+			const char* strb = utf8p;
+			const char* stre = utf8p + len;
+			stack_detail::count_code_units_utf<BaseCh> count_units;
+			convert<BaseCh>(strb, stre, count_units);
+			S r(count_units.needed_size, static_cast<Ch>(0));
+			r.resize(count_units.needed_size);
+			Ch* target = &r[0];
+			stack_detail::copy_code_units_utf<Ch, BaseCh> copy_units(target);
+			convert<BaseCh>(strb, stre, copy_units);
+			return r;
+		}
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				return lua_toboolean(L, index) != 0;
+			}
+			else if constexpr (std::is_enum_v<T>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tointegerx(L, index, nullptr));
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VERSION_I_ >= 503
+				if (lua_isinteger(L, index) != 0) {
+					return static_cast<T>(lua_tointeger(L, index));
+				}
+#endif
+				return static_cast<T>(llround(lua_tonumber(L, index)));
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tonumber(L, index));
+			}
+			else if constexpr (is_lua_reference_v<T>) {
+				if constexpr (is_global_table_v<T>) {
+					tracking.use(1);
+					return T(L, global_tag);
+				}
+				else {
+					tracking.use(1);
+					return T(L, index);
+				}
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using actual = unique_usertype_actual_t<T>;
+
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				void* aligned_memory = detail::align_usertype_unique<actual>(memory);
+				actual* typed_memory = static_cast<actual*>(aligned_memory);
+				return *typed_memory;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				return unqualified_check_getter<ValueType>::template get_using<T>(L, index, &no_panic, tracking);
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return pstream;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return *pstream;
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::get_function_pointer<std::remove_pointer_t<T>>(L, index, tracking);
+			}
+#endif
+			else {
+				return stack_detail::unchecked_unqualified_get<detail::as_value_tag<T>>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename X, typename>
+	struct qualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<X>;
+			static constexpr bool is_userdata_of_some_kind
+				= !std::is_reference_v<
+				       X> && is_container_v<Tu> && std::is_default_constructible_v<Tu> && !is_lua_primitive_v<Tu> && !is_transparent_argument_v<Tu>;
+			if constexpr (is_userdata_of_some_kind) {
+				if (type_of(L, index) == type::userdata) {
+					return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking));
+				}
+				else {
+					return stack_detail::unchecked_unqualified_get<sol::nested<Tu>>(L, index, tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<Tu> && !is_actual_type_rebindable_for_v<Tu>) {
+				using element = unique_usertype_element_t<Tu>;
+				using actual = unique_usertype_actual_t<Tu>;
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique_destructor(memory);
+				detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+				if (&detail::usertype_unique_alloc_destroy<element, Tu> == pdx) {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					actual* mem = static_cast<actual*>(memory);
+					return static_cast<actual>(*mem);
+				}
+				actual r {};
+				if constexpr (!derive<element>::value) {
+#if SOL_IS_ON(SOL_DEBUG_BUILD)
+					// In debug mode we would rather abort you for this grave failure rather
+					// than let you deref a null pointer and fuck everything over
+					std::abort();
+#endif
+					return static_cast<actual>(std::move(r));
+				}
+				else {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					string_view ti = usertype_traits<element>::qualified_name();
+					int cast_operation;
+					if constexpr (is_actual_type_rebindable_for_v<Tu>) {
+						using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					else {
+						string_view rebind_ti("");
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					switch (cast_operation) {
+					case 1: {
+						// it's a perfect match,
+						// alias memory directly
+						actual* mem = static_cast<actual*>(memory);
+						return static_cast<actual>(*mem);
+					}
+					case 2:
+						// it's a base match, return the
+						// aliased creation
+						return static_cast<actual>(std::move(r));
+					default:
+						// uh oh..
+						break;
+					}
+#if SOL_IS_ON(SOL_DEBUG_BUILD)
+					// In debug mode we would rather abort you for this grave failure rather
+					// than let you deref a null pointer and fuck everything over
+					std::abort();
+#endif
+					return static_cast<actual>(r);
+				}
+			}
+			else {
+				return stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_table_t<T>> {
+		using Tu = meta::unqualified_t<T>;
+
+		template <typename V>
+		static void push_back_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			cont.push_back(stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void push_back_at_end(std::false_type, types<V> t, lua_State* L, T& cont, std::size_t idx) {
+			insert_at_end(meta::has_insert<Tu>(), t, L, cont, idx);
+		}
+
+		template <typename V>
+		static void insert_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			using std::cend;
+			cont.insert(cend(cont), stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void insert_at_end(std::false_type, types<V>, lua_State* L, T& cont, std::size_t idx) {
+			cont[idx] = stack::get<V>(L, -lua_size<V>::value);
+		}
+
+		static bool max_size_check(std::false_type, T&, std::size_t) {
+			return false;
+		}
+
+		static bool max_size_check(std::true_type, T& cont, std::size_t idx) {
+			return idx >= cont.max_size();
+		}
+
+		static T get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::is_associative<Tu>(), L, relindex, tracking);
+		}
+
+		static T get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename Tu::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static T get(types<V> t, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+			// the W4 flag is really great,
+			// so great that it can tell my for loops (twice nested)
+			// below never actually terminate
+			// without hitting where the gotos have infested
+
+			// so now I would get the error W4XXX unreachable
+			// me that the return cont at the end of this function
+			// which is fair until other compilers complain
+			// that there isn't a return and that based on
+			// SOME MAGICAL FORCE
+			// control flow falls off the end of a non-void function
+			// so it needs to be there for the compilers that are
+			// too flimsy to analyze the basic blocks...
+			// (I'm sure I should file a bug but those compilers are already
+			// in the wild; it doesn't matter if I fix them,
+			// someone else is still going to get some old-ass compiler
+			// and then bother me about the unclean build for the 30th
+			// time)
+
+			// "Why not an IIFE?"
+			// Because additional lambdas / functions which serve as
+			// capture-all-and-then-invoke bloat binary sizes
+			// by an actually detectable amount
+			// (one user uses sol2 pretty heavily and 22 MB of binary size
+			// was saved by reducing reliance on lambdas in templates)
+
+			// This would really be solved by having break N;
+			// be a real, proper thing...
+			// but instead, we have to use labels and gotos
+			// and earn the universal vitriol of the dogmatic
+			// programming community
+
+			// all in all: W4 is great!~
+
+			int index = lua_absindex(L, relindex);
+			T cont;
+			std::size_t idx = 0;
+#if SOL_LUA_VERSION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration
+			// thanks to the Lua API changes in 5.3
+			// Questionable in 5.4
+			for (lua_Integer i = 0;; i += lua_size<V>::value) {
+				if (max_size_check(meta::has_max_size<Tu>(), cont, idx)) {
+					// see above comment
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushinteger(L, static_cast<lua_Integer>(i + vi));
+					if (lua_keyin(L, index) == 0) {
+						// it's time to stop
+						isnil = true;
+					}
+					else {
+						// we have a key, have to get the value
+						lua_geti(L, index, i + vi);
+					}
+#else
+					type vt = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = vt == type::none || vt == type::lua_nil;
+#endif
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+						lua_pop(L, vi);
+#else
+						lua_pop(L, (vi + 1));
+#endif
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil) {
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+#else
+					lua_pop(L, lua_size<V>::value);
+#endif
+					continue;
+				}
+
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+				lua_pop(L, lua_size<V>::value);
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					// see above comment
+					goto done;
+				}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 2, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type vt = type_of(L, -1);
+					isnil = vt == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		static T get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename Tu::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		template <typename K, typename V>
+		static T get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			T associative;
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T, typename Al>
+	struct unqualified_getter<as_table_t<std::forward_list<T, Al>>> {
+		typedef std::forward_list<T, Al> C;
+
+		static C get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::has_key_value_pair<C>(), L, relindex, tracking);
+		}
+
+		static C get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename T::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		static C get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename C::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static C get(types<V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			int index = lua_absindex(L, relindex);
+			C cont;
+			auto at = cont.cbefore_begin();
+			std::size_t idx = 0;
+#if SOL_LUA_VERSION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					type t = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type t = type_of(L, -1);
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		template <typename K, typename V>
+		static C get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			C associative;
+			auto at = associative.cbefore_begin();
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				at = associative.emplace_after(at, std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<nested<T>> {
+		static T get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_container_v<Tu>) {
+				if constexpr (meta::is_associative<Tu>::value) {
+					typedef typename T::value_type P;
+					typedef typename P::first_type K;
+					typedef typename P::second_type V;
+					unqualified_getter<as_table_t<T>> g{};
+					return g.get(types<K, nested<V>>(), L, index, tracking);
+				}
+				else {
+					typedef typename T::value_type V;
+					unqualified_getter<as_table_t<T>> g{};
+					return g.get(types<nested<V>>(), L, index, tracking);
+				}
+			}
+			else {
+				unqualified_getter<Tu> g{};
+				return g.get(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T>(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>*> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T*>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<userdata_value> {
+		static userdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return userdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lightuserdata_value> {
+		static lightuserdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lightuserdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<light<T>> {
+		static light<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			return light<T>(static_cast<T*>(memory));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T>> {
+		static std::add_lvalue_reference_t<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T>(memory);
+			return *static_cast<std::remove_reference_t<T>*>(memory);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T*>(memory);
+			return static_cast<T*>(memory);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<type> {
+		static type get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return static_cast<type>(lua_type(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::string> {
+		static std::string get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			std::size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return std::string(str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const char*> {
+		static const char* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			return lua_tolstring(L, index, &sz);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char> {
+		static char get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return len > 0 ? str[0] : '\0';
+		}
+	};
+
+	template <typename Traits>
+	struct unqualified_getter<basic_string_view<char, Traits>> {
+		static string_view get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			const char* str = lua_tolstring(L, index, &sz);
+			return basic_string_view<char, Traits>(str, sz);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<wchar_t, Traits, Al>> {
+		using S = std::basic_string<wchar_t, Traits, Al>;
+		static S get(lua_State* L, int index, record& tracking) {
+			using Ch = meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t>;
+			return stack_detail::get_into<Ch, S>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char16_t, Traits, Al>> {
+		static std::basic_string<char16_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char16_t, std::basic_string<char16_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char32_t, Traits, Al>> {
+		static std::basic_string<char32_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char32_t, std::basic_string<char32_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char16_t> {
+		static char16_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf16(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char32_t> {
+		static char32_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf32(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<wchar_t> {
+		static wchar_t get(lua_State* L, int index, record& tracking) {
+			typedef meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t> Ch;
+			unqualified_getter<Ch> g;
+			(void)g;
+			auto c = g.get(L, index, tracking);
+			return static_cast<wchar_t>(c);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<meta_function> {
+		static meta_function get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			const char* name = unqualified_getter<const char*> {}.get(L, index, tracking);
+			const auto& mfnames = meta_function_names();
+			for (std::size_t i = 0; i < mfnames.size(); ++i)
+				if (mfnames[i] == name)
+					return static_cast<meta_function>(i);
+			return meta_function::construct;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_nil_t> {
+		static lua_nil_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return lua_nil;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::nullptr_t> {
+		static std::nullptr_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullptr;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<nullopt_t> {
+		static nullopt_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullopt;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_state> {
+		static this_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_state(L);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_main_state> {
+		static this_main_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_main_state(main_thread(L, L));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_CFunction> {
+		static lua_CFunction get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_tocfunction(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<c_closure> {
+		static c_closure get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return c_closure(lua_tocfunction(L, index), -1);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<error> {
+		static error get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz = 0;
+			const char* err = lua_tolstring(L, index, &sz);
+			if (err == nullptr) {
+				return error(detail::direct_error, "");
+			}
+			return error(detail::direct_error, std::string(err, sz));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<void*> {
+		static void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const void*> {
+		static const void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_value_tag<T>> {
+		static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
+			void* memory = lua_touserdata(L, index);
+#if SOL_IS_ON(SOL_USE_INTEROP)
+			auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking);
+			if (ugr.first) {
+				return ugr.second;
+			}
+#endif // interop extensibility
+			tracking.use(1);
+			void* rawdata = detail::align_usertype_pointer(memory);
+			void** pudata = static_cast<void**>(rawdata);
+			void* udata = *pudata;
+			return get_no_lua_nil_from(L, udata, index, tracking);
+		}
+
+		static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) {
+			bool has_derived = derive<T>::value || weak_derive<T>::value;
+			if (has_derived) {
+				if (lua_getmetatable(L, index) == 1) {
+					lua_getfield(L, -1, &detail::base_class_cast_key()[0]);
+					if (type_of(L, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L, -1);
+						detail::inheritance_cast_function ic = reinterpret_cast<detail::inheritance_cast_function>(basecastdata);
+						// use the casting function to properly adjust the pointer for the desired T
+						udata = ic(udata, usertype_traits<T>::qualified_name());
+					}
+					lua_pop(L, 2);
+				}
+			}
+			if constexpr (std::is_function_v<T>) {
+				T* func = reinterpret_cast<T*>(udata);
+				return func;
+			}
+			else {
+				T* obj = static_cast<T*>(udata);
+				return obj;
+			}
+		}
+
+		static T& get(lua_State* L, int index, record& tracking) {
+			return *get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_pointer_tag<T>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			type t = type_of(L, index);
+			if (t == type::lua_nil) {
+				tracking.use(1);
+				return nullptr;
+			}
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<non_null<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T&> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<std::reference_wrapper<T>> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<T&> g{};
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T*> {
+		static T* get(lua_State* L, int index, record& tracking) {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			if constexpr (std::is_function_v<T>) {
+				return stack_detail::get_function_pointer<T>(L, index, tracking);
+			}
+			else {
+				unqualified_getter<detail::as_pointer_tag<T>> g{};
+				return g.get(L, index, tracking);
+			}
+#else
+			unqualified_getter<detail::as_pointer_tag<T>> g{};
+			return g.get(L, index, tracking);
+#endif
+		}
+	};
+
+	template <typename... Tn>
+	struct unqualified_getter<std::tuple<Tn...>> {
+		typedef std::tuple<decltype(stack::get<Tn>(nullptr, 0))...> R;
+
+		template <typename... Args>
+		static R apply(std::index_sequence<>, lua_State*, int, record&, Args&&... args) {
+			// Fuck you too, VC++
+			return R { std::forward<Args>(args)... };
+		}
+
+		template <std::size_t I, std::size_t... Ix, typename... Args>
+		static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, Args&&... args) {
+			// Fuck you too, VC++
+			typedef std::tuple_element_t<I, std::tuple<Tn...>> T;
+			return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<Args>(args)..., stack::get<T>(L, index + tracking.used, tracking));
+		}
+
+		static R get(lua_State* L, int index, record& tracking) {
+			return apply(std::make_index_sequence<sizeof...(Tn)>(), L, index, tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_getter<std::pair<A, B>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))> { stack::get<A>(L, index, tracking),
+				stack::get<B>(L, index + tracking.used, tracking) };
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+
+	template <typename... Tn>
+	struct unqualified_getter<std::variant<Tn...>> {
+		using V = std::variant<Tn...>;
+
+		static V get_one(std::integral_constant<std::size_t, std::variant_size_v<V>>, lua_State* L, int index, record& tracking) {
+			(void)L;
+			(void)index;
+			(void)tracking;
+			if constexpr (std::variant_size_v<V> == 0) {
+				return V();
+			}
+			else {
+				// using T = std::variant_alternative_t<0, V>;
+				std::abort();
+				// return V(std::in_place_index<0>, stack::get<T>(L, index, tracking));
+			}
+		}
+
+		template <std::size_t I>
+		static V get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, record& tracking) {
+			typedef std::variant_alternative_t<I, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L, index, &no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return V(std::in_place_index<I>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I + 1>(), L, index, tracking);
+		}
+
+		static V get(lua_State* L, int index, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, 0>(), L, index, tracking);
+		}
+	};
+#endif // variant
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_unqualified.hpp
+
+// beginning of sol/stack_get_qualified.hpp
+
+namespace sol { namespace stack {
+
+	// There are no more enable_ifs that can be used here,
+	// so this is just for posterity, I guess?
+	// maybe I'll fill this file in later.
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_qualified.hpp
+
+// end of sol/stack_get.hpp
+
+// beginning of sol/stack_check_get.hpp
+
+// beginning of sol/stack_check_get_unqualified.hpp
+
+#include <cstdlib>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol { namespace stack {
+	template <typename T, typename>
+	struct unqualified_check_getter {
+		typedef decltype(stack_detail::unchecked_unqualified_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Optional, typename Handler>
+		static Optional get_using(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (!meta::meta_detail::is_adl_sol_lua_check_v<T> && !meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+				if constexpr (is_lua_reference_v<T>) {
+					if constexpr (is_global_table_v<T>) {
+						(void)L;
+						(void)index;
+						(void)handler;
+						tracking.use(1);
+						return true;
+					}
+					else {
+						// actually check if it's none here, otherwise
+						// we'll have a none object inside an optional!
+						bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, &no_panic);
+						if (!success) {
+							// expected type, actual type
+							tracking.use(static_cast<int>(success));
+							handler(L, index, type::poly, type_of(L, index), "");
+							return detail::associated_nullopt_v<Optional>;
+						}
+						return stack_detail::unchecked_get<T>(L, index, tracking);
+					}
+				}
+				else if constexpr ((std::is_integral_v<T> || std::is_same_v<T, lua_Integer>)&&!std::is_same_v<T, bool>) {
+#if SOL_LUA_VERSION_I_ >= 503
+					if (lua_isinteger(L, index) != 0) {
+						tracking.use(1);
+						return static_cast<T>(lua_tointeger(L, index));
+					}
+#endif
+					int isnum = 0;
+					const lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum != 0) {
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+						const auto integer_value = llround(value);
+						if (static_cast<lua_Number>(integer_value) == value) {
+							tracking.use(1);
+							return static_cast<T>(integer_value);
+						}
+#else
+						tracking.use(1);
+						return static_cast<T>(value);
+#endif
+					}
+					const type t = type_of(L, index);
+					tracking.use(static_cast<int>(t != type::none));
+					handler(L, index, type::number, t, "not an integer");
+					return detail::associated_nullopt_v<Optional>;
+				}
+				else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+					int isnum = 0;
+					lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid floating point number");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else if constexpr (std::is_enum_v<T> && !meta::any_same_v<T, meta_function, type>) {
+					int isnum = 0;
+					lua_Integer value = lua_tointegerx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid enumeration value");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else {
+					if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+						tracking.use(static_cast<int>(!lua_isnone(L, index)));
+						return detail::associated_nullopt_v<Optional>;
+					}
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+			}
+			else {
+				if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return detail::associated_nullopt_v<Optional>;
+				}
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+		}
+
+		template <typename Handler>
+		static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_using<optional<R>>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+	template <typename... Tn, typename C>
+	struct unqualified_check_getter<std::variant<Tn...>, C> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static optional<V> get_empty(std::true_type, lua_State*, int, Handler&&, record&) {
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_empty(std::false_type, lua_State* L, int index, Handler&& handler, record&) {
+			// This should never be reached...
+			// please check your code and understand what you did to bring yourself here
+			// maybe file a bug report, or 5
+			handler(
+				L, index, type::poly, type_of(L, index), "this variant code should never be reached: if it has, you have done something so terribly wrong");
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, 0>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_empty(V_is_empty(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <std::size_t I, typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			if (stack::check<T>(L, index, &no_panic, tracking)) {
+				return V(std::in_place_index<I - 1>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I - 1>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static optional<V> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, V_size::value>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+#endif // standard variant
+}}     // namespace sol::stack
+
+// end of sol/stack_check_get_unqualified.hpp
+
+// beginning of sol/stack_check_get_qualified.hpp
+
+namespace sol { namespace stack {
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+	namespace stack_detail {
+		template <typename OptionalType, typename T, typename Handler>
+		OptionalType get_optional(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+
+			if constexpr (is_lua_reference_v<T>) {
+				if constexpr (is_global_table_v<Tu>) {
+					(void)L;
+					(void)index;
+					(void)handler;
+					tracking.use(1);
+					return true;
+				}
+				else {
+					// actually check if it's none here, otherwise
+					// we'll have a none object inside an optional!
+					bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, &no_panic);
+					if (!success) {
+						// expected type, actual type
+						tracking.use(static_cast<int>(success));
+						handler(L, index, type::poly, type_of(L, index), "");
+						return {};
+					}
+					return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
+				}
+			}
+			else if constexpr (!std::is_reference_v<T> && is_unique_usertype_v<Tu> && !is_actual_type_rebindable_for_v<Tu>) {
+				// we can take shortcuts here to save on separate checking, and just return nullopt!
+				using element = unique_usertype_element_t<Tu>;
+				using actual = unique_usertype_actual_t<Tu>;
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique_destructor(memory);
+				detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+				if (&detail::usertype_unique_alloc_destroy<element, Tu> == pdx) {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					actual* mem = static_cast<actual*>(memory);
+					return static_cast<actual>(*mem);
+				}
+				if constexpr (!derive<element>::value) {
+					return OptionalType();
+				}
+				else {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					string_view ti = usertype_traits<element>::qualified_name();
+					int cast_operation;
+					actual r {};
+					if constexpr (is_actual_type_rebindable_for_v<Tu>) {
+						using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					else {
+						string_view rebind_ti("");
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					switch (cast_operation) {
+					case 1: {
+						// it's a perfect match,
+						// alias memory directly
+						actual* mem = static_cast<actual*>(memory);
+						return OptionalType(*mem);
+					}
+					case 2:
+						// it's a base match, return the
+						// aliased creation
+						return OptionalType(std::move(r));
+					default:
+						break;
+					}
+					return OptionalType();
+				}
+			}
+			else {
+				if (!check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return OptionalType();
+				}
+				return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
+			}
+		}
+	} // namespace stack_detail
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#endif
+
+	template <typename T, typename>
+	struct qualified_check_getter {
+		typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Handler>
+		optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack_detail::get_optional<optional<R>, T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename Optional>
+	struct qualified_getter<Optional, std::enable_if_t<meta::is_optional_v<Optional>>> {
+		static Optional get(lua_State* L, int index, record& tracking) {
+			using T = typename meta::unqualified_t<Optional>::value_type;
+			return stack_detail::get_optional<Optional, T>(L, index, &no_panic, tracking);
+		}
+	};
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_get_qualified.hpp
+
+// end of sol/stack_check_get.hpp
+
+// beginning of sol/stack_push.hpp
+
+#include <memory>
+#include <type_traits>
+#include <cassert>
+#include <limits>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // Can use variant
+
+// beginning of sol/debug.hpp
+
+#include <iostream>
+
+namespace sol { namespace detail { namespace debug {
+	inline std::string dump_types(lua_State* L) {
+		std::string visual;
+		std::size_t size = lua_gettop(L) + 1;
+		for (std::size_t i = 1; i < size; ++i) {
+			if (i != 1) {
+				visual += " | ";
+			}
+			visual += type_name(L, stack::get<type>(L, static_cast<int>(i)));
+		}
+		return visual;
+	}
+
+	inline void print_stack(lua_State* L) {
+		std::cout << dump_types(L) << std::endl;
+	}
+
+	inline void print_section(const std::string& message, lua_State* L) {
+		std::cout << "-- " << message << " -- [ " << dump_types(L) << " ]" << std::endl;
+	}
+}}} // namespace sol::detail::debug
+
+// end of sol/debug.hpp
+
+namespace sol { namespace stack {
+	namespace stack_detail {
+		template <typename T>
+		inline bool integer_value_fits(const T& value) {
+			// We check if we can rely on casts or a lack of padding bits to satisfy
+			// the requirements here
+			// If it lacks padding bits, we can jump back and forth between lua_Integer and whatever type without
+			// loss of information
+			constexpr bool is_same_signedness
+				= (std::is_signed_v<T> && std::is_signed_v<lua_Integer>) || (std::is_unsigned_v<T> && std::is_unsigned_v<lua_Integer>);
+			constexpr bool probaby_fits_within_lua_Integer = sizeof(T) == sizeof(lua_Integer)
+#if SOL_IS_ON(SOL_ALL_INTEGER_VALUES_FIT)
+				&& ((std::has_unique_object_representations_v<T> && std::has_unique_object_representations_v<lua_Integer>) ? true : is_same_signedness)
+#else
+				&& is_same_signedness
+#endif
+				;
+			if constexpr (sizeof(T) < sizeof(lua_Integer) || probaby_fits_within_lua_Integer) {
+				(void)value;
+				return true;
+			}
+			else {
+				auto u_min = static_cast<std::intmax_t>((std::numeric_limits<lua_Integer>::min)());
+				auto u_max = static_cast<std::uintmax_t>((std::numeric_limits<lua_Integer>::max)());
+				auto t_min = static_cast<std::intmax_t>((std::numeric_limits<T>::min)());
+				auto t_max = static_cast<std::uintmax_t>((std::numeric_limits<T>::max)());
+				return (u_min <= t_min || value >= static_cast<T>(u_min)) && (u_max >= t_max || value <= static_cast<T>(u_max));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::true_type, lua_State* L, const T& value) {
+			if constexpr (meta::any_same_v<std::underlying_type_t<T>,
+				              char
+#if SOL_IS_ON(SOL_CHAR8_T)
+				              ,
+				              char8_t
+#endif
+				              ,
+				              char16_t,
+				              char32_t>) {
+				if constexpr (std::is_signed_v<T>) {
+					return stack::push(L, static_cast<std::int_least32_t>(value));
+				}
+				else {
+					return stack::push(L, static_cast<std::uint_least32_t>(value));
+				}
+			}
+			else {
+				return stack::push(L, static_cast<std::underlying_type_t<T>>(value));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::false_type, lua_State*, const T&) {
+			return 0;
+		}
+	} // namespace stack_detail
+
+	inline int push_environment_of(lua_State* L, int target_index = -1) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+		luaL_checkstack(L, 1, detail::not_enough_stack_space_environment);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VERSION_I_ < 502
+		// Use lua_getfenv
+		lua_getfenv(L, target_index);
+#else
+
+		if (lua_iscfunction(L, target_index) != 0) {
+			const char* maybe_upvalue_name = lua_getupvalue(L, target_index, 1);
+			if (maybe_upvalue_name != nullptr) {
+				// it worked, take this one
+				return 1;
+			}
+		}
+		// Nominally, we search for the `"_ENV"` value.
+		// If we don't find it.... uh, well. We've got a problem?
+		for (int upvalue_index = 1;; ++upvalue_index) {
+			const char* maybe_upvalue_name = lua_getupvalue(L, target_index, upvalue_index);
+			if (maybe_upvalue_name == nullptr) {
+				push(L, lua_nil);
+				break;
+			}
+
+			string_view upvalue_name(maybe_upvalue_name);
+			if (upvalue_name == "_ENV") {
+				// Keep this one!
+				break;
+			}
+			// Discard what we received, loop back around
+			lua_pop(L, 1);
+		}
+#endif
+		return 1;
+	}
+
+	template <typename T>
+	int push_environment_of(const T& target) {
+		lua_State* target_L = target.lua_state();
+		int target_index = absolute_index(target_L, -target.push());
+		int env_count = push_environment_of(target_L, target_index);
+		sol_c_assert(env_count == 1);
+		lua_rotate(target_L, target_index, 1);
+		lua_pop(target_L, 1);
+		return env_count;
+	}
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_value_tag<T>> {
+		template <typename F, typename... Args>
+		static int push_fx(lua_State* L, F&& f, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // Basically, we store all user-data like this:
+       // If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new
+       // data in the first sizeof(T*) bytes, and then however many bytes it takes to
+       // do the actual object. Things that are std::ref or plain T* are stored as
+       // just the sizeof(T*), and nothing else.
+			T* obj = detail::usertype_allocate<T>(L);
+			f();
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, obj, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename K, typename... Args>
+		static int push_keyed(lua_State* L, K&& k, Args&&... args) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<T>);
+			return push_fx(L, fx, std::forward<Args>(args)...);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L) {
+			return push_keyed(L, usertype_traits<T>::metatable());
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_pointer_tag<T>> {
+		typedef meta::unqualified_t<T> U;
+
+		template <typename F>
+		static int push_fx(lua_State* L, F&& f, T* obj) {
+			if (obj == nullptr)
+				return stack::push(L, lua_nil);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			T** pref = detail::usertype_allocate_pointer<T>(L);
+			f();
+			*pref = obj;
+			return 1;
+		}
+
+		template <typename K>
+		static int push_keyed(lua_State* L, K&& k, T* obj) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<U*>);
+			return push_fx(L, fx, obj);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<U*>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::as_reference_tag> {
+		template <typename T>
+		static int push(lua_State* L, T&& obj) {
+			return stack::push(L, detail::ptr(obj));
+		}
+	};
+
+	namespace stack_detail {
+		template <typename T>
+		struct uu_pusher {
+			using element = unique_usertype_element_t<T>;
+			using actual = unique_usertype_actual_t<T>;
+
+			template <typename Arg, typename... Args>
+			static int push(lua_State* L, Arg&& arg, Args&&... args) {
+				if constexpr (std::is_base_of_v<actual, meta::unqualified_t<Arg>>) {
+					if (detail::unique_is_null(L, arg)) {
+						return stack::push(L, lua_nil);
+					}
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+				else {
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+			}
+
+			template <typename... Args>
+			static int push_deep(lua_State* L, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+				element** pointer_to_memory = nullptr;
+				detail::unique_destructor* fx = nullptr;
+				detail::unique_tag* id = nullptr;
+				actual* typed_memory = detail::usertype_unique_allocate<element, actual>(L, pointer_to_memory, fx, id);
+				if (luaL_newmetatable(L, &usertype_traits<d::u<std::remove_cv_t<element>>>::metatable()[0]) == 1) {
+					detail::lua_reg_table registration_table {};
+					int index = 0;
+					detail::indexed_insert insert_callable(registration_table, index);
+					detail::insert_default_registrations<element>(insert_callable, detail::property_always_true);
+					registration_table[index] = { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+					luaL_setfuncs(L, registration_table, 0);
+				}
+				lua_setmetatable(L, -2);
+				*fx = detail::usertype_unique_alloc_destroy<element, actual>;
+				*id = &detail::inheritance<element>::template type_unique_cast<actual>;
+				detail::default_construct::construct(typed_memory, std::forward<Args>(args)...);
+				*pointer_to_memory = detail::unique_get<T>(L, *typed_memory);
+				return 1;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_unique_tag<T>> {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			stack_detail::uu_pusher<T> p;
+			(void)p;
+			return p.push(L, std::forward<Args>(args)...);
+		}
+	};
+
+	template <typename T, typename>
+	struct unqualified_pusher {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_lua_reference_v<Tu>) {
+				using int_arr = int[];
+				int_arr p { (std::forward<Args>(args).push(L))... };
+				return p[0];
+			}
+			else if constexpr (std::is_same_v<Tu, bool>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushboolean(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_integral_v<Tu> || std::is_same_v<Tu, lua_Integer>) {
+				const Tu& value(std::forward<Args>(args)...);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_integral);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VERSION_I_ >= 503
+				if (stack_detail::integer_value_fits<Tu>(value)) {
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+				}
+#endif // Lua 5.3 and above
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				if (static_cast<T>(llround(static_cast<lua_Number>(value))) != value) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+					// Is this really worth it?
+					sol_m_assert(false, "integer value will be misrepresented in lua");
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+#else
+					throw error(detail::direct_error, "integer value will be misrepresented in lua");
+#endif // No Exceptions
+				}
+#endif // Safe Numerics and Number Precision Check
+				lua_pushnumber(L, static_cast<lua_Number>(value));
+				return 1;
+			}
+			else if constexpr (std::is_floating_point_v<Tu> || std::is_same_v<Tu, lua_Number>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_floating);
+#endif // make sure stack doesn't overflow
+				lua_pushnumber(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream*>) {
+				luaL_Stream* source { std::forward<Args>(args)... };
+				luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source->f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
+				stream->closef = source->closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream>) {
+				luaL_Stream& source(std::forward<Args>(args)...);
+				luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source.f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
+				stream->closef = source.closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_enum_v<Tu>) {
+				return stack_detail::msvc_is_ass_with_if_constexpr_push_enum(std::true_type(), L, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_pointer_v<Tu>) {
+				return stack::push<detail::as_pointer_tag<std::remove_pointer_t<T>>>(L, std::forward<Args>(args)...);
+			}
+			else if constexpr (is_unique_usertype_v<Tu>) {
+				return stack::push<detail::as_unique_tag<T>>(L, std::forward<Args>(args)...);
+			}
+			else {
+				return stack::push<detail::as_value_tag<T>>(L, std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::reference_wrapper<T>> {
+		static int push(lua_State* L, const std::reference_wrapper<T>& t) {
+			return stack::push(L, std::addressof(detail::deref(t.get())));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_table_tag<T>> {
+		using has_kvp = meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+		static int push(lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		static int push(lua_State* L, const T& tablecont, nested_tag_t) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::true_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::false_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		template <bool is_nested>
+		static int push(std::true_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, static_cast<int>(cont.size()), 0);
+			int tableindex = lua_gettop(L);
+			for (const auto& pair : cont) {
+				if (is_nested) {
+					set_field(L, pair.first, as_nested_ref(pair.second), tableindex);
+				}
+				else {
+					set_field(L, pair.first, pair.second, tableindex);
+				}
+			}
+			return 1;
+		}
+
+		template <bool is_nested>
+		static int push(std::false_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, stack_detail::get_size_hint(cont), 0);
+			int tableindex = lua_gettop(L);
+			std::size_t index = 1;
+			for (const auto& i : cont) {
+#if SOL_LUA_VERSION_I_ >= 503
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				for (int pi = 0; pi < p; ++pi) {
+					lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
+				}
+#else
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushinteger(L, static_cast<lua_Integer>(index));
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				if (p == 1) {
+					++index;
+					lua_settable(L, tableindex);
+				}
+				else {
+					int firstindex = tableindex + 1 + 1;
+					for (int pi = 0; pi < p; ++pi) {
+						stack::push(L, index);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+						luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+						lua_pushvalue(L, firstindex);
+						lua_settable(L, tableindex);
+						++index;
+						++firstindex;
+					}
+					lua_pop(L, 1 + p);
+				}
+#endif // Lua Version 5.3 and others
+			}
+			// TODO: figure out a better way to do this...?
+			// set_field(L, -1, cont.size());
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<as_table_t<T>> {
+		static int push(lua_State* L, const as_table_t<T>& value_) {
+			using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, value_.value());
+			}
+			else {
+				return stack::push(L, value_.value());
+			}
+		}
+
+		static int push(lua_State* L, const T& value_) {
+			using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, value_);
+			}
+			else {
+				return stack::push(L, value_);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<nested<T>> {
+		static int push(lua_State* L, const T& nested_value) noexcept {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			using inner_t = std::remove_pointer_t<Tu>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, nested_value, nested_tag);
+			}
+			else {
+				return stack::push<Tu>(L, nested_value);
+			}
+		}
+
+		static int push(lua_State* L, const nested<T>& nested_wrapper_) noexcept {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			using inner_t = std::remove_pointer_t<Tu>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, nested_wrapper_.value(), nested_tag);
+			}
+			else {
+				return stack::push<Tu>(L, nested_wrapper_.value());
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::initializer_list<T>> {
+		static int push(lua_State* L, const std::initializer_list<T>& il) noexcept {
+			unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p {};
+			return p.push(L, il);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_nil_t> {
+		static int push(lua_State* L, lua_nil_t) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushnil(L);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<stack_count> {
+		static int push(lua_State*, stack_count st) noexcept {
+			return st.count;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<metatable_key_t> {
+		static int push(lua_State* L, metatable_key_t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, to_string(meta_function::metatable).c_str(), 4);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_CFunction> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::lua_CFunction_noexcept> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+#endif // noexcept function type
+
+	template <>
+	struct unqualified_pusher<c_closure> {
+		static int push(lua_State* L, c_closure cc) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, cc.c_function, cc.upvalues);
+			return 1;
+		}
+	};
+
+	template <typename Arg, typename... Args>
+	struct unqualified_pusher<closure<Arg, Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
+			using f_tuple = decltype(std::forward<T>(c).upvalues);
+			int pushcount = multi_push(L, std::get<I>(std::forward<f_tuple>(std::forward<T>(c).upvalues))...);
+			return stack::push(L, c_closure(c.c_function, pushcount));
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& c) {
+			return push(std::make_index_sequence<1 + sizeof...(Args)>(), L, std::forward<T>(c));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<void*> {
+		static int push(lua_State* L, void* userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const void*> {
+		static int push(lua_State* L, const void* userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, const_cast<void*>(userdata));
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lightuserdata_value> {
+		static int push(lua_State* L, lightuserdata_value userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<light<T>> {
+		static int push(lua_State* L, light<T> l) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, static_cast<void*>(l.value()));
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<user<T>> {
+		template <bool with_meta = true, typename Key, typename... Args>
+		static int push_with(lua_State* L, Key&& name, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // A dumb pusher
+			T* data = detail::user_allocate<T>(L);
+			if (with_meta) {
+				// Make sure we have a plain GC set for this data
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				if (luaL_newmetatable(L, name) != 0) {
+					lua_CFunction cdel = detail::user_alloc_destroy<T>;
+					lua_pushcclosure(L, cdel, 0);
+					lua_setfield(L, -2, "__gc");
+				}
+				lua_setmetatable(L, -2);
+			}
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, data, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, metatable_key_t>) {
+				const auto name = &arg[0];
+				return push_with<true>(L, name, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Arg>, no_metatable_t>) {
+				(void)arg;
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with<false>(L, name, std::forward<Args>(args)...);
+			}
+			else {
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with(L, name, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, u.value);
+		}
+
+		static int push(lua_State* L, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, std::move(u.value()));
+		}
+
+		static int push(lua_State* L, no_metatable_t, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, u.value());
+		}
+
+		static int push(lua_State* L, no_metatable_t, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, std::move(u.value()));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<userdata_value> {
+		static int push(lua_State* L, userdata_value data) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			void** ud = detail::usertype_allocate_pointer<void>(L);
+			*ud = data.value();
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, len);
+			return 1;
+		}
+
+		static int push(lua_State* L, const char* str) {
+			if (str == nullptr)
+				return stack::push(L, lua_nil);
+			return push_sized(L, str, std::char_traits<char>::length(str));
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			return push_sized(L, strb, static_cast<std::size_t>(stre - strb));
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			return push_sized(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push_sized(L, str, len);
+		}
+
+		static int push(lua_State* L, const char* str) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char[N]> {
+		static int push(lua_State* L, const char (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, std::char_traits<char>::length(str));
+			return 1;
+		}
+
+		static int push(lua_State* L, const char (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, sz);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char> {
+		static int push(lua_State* L, char c) {
+			const char str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char*>(str), 1u);
+		}
+	};
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+	template <>
+	struct unqualified_pusher<const char8_t*> {
+		static int push_sized(lua_State* L, const char8_t* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, reinterpret_cast<const char*>(str), len);
+			return 1;
+		}
+
+		static int push(lua_State* L, const char8_t* str) {
+			if (str == nullptr)
+				return stack::push(L, lua_nil);
+			return push_sized(L, str, std::char_traits<char>::length(reinterpret_cast<const char*>(str)));
+		}
+
+		static int push(lua_State* L, const char8_t* strb, const char8_t* stre) {
+			return push_sized(L, strb, static_cast<std::size_t>(stre - strb));
+		}
+
+		static int push(lua_State* L, const char8_t* str, std::size_t len) {
+			return push_sized(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char8_t*> {
+		static int push_sized(lua_State* L, const char8_t* str, std::size_t len) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push_sized(L, str, len);
+		}
+
+		static int push(lua_State* L, const char8_t* str) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char8_t* strb, const char8_t* stre) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char8_t* str, std::size_t len) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char8_t[N]> {
+		static int push(lua_State* L, const char8_t (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			const char* str_as_char = reinterpret_cast<const char*>(static_cast<const char8_t*>(str));
+			lua_pushlstring(L, str_as_char, std::char_traits<char>::length(str_as_char));
+			return 1;
+		}
+
+		static int push(lua_State* L, const char8_t (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, sz);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char8_t> {
+		static int push(lua_State* L, char8_t c) {
+			const char8_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char8_t*>(str), 1u);
+		}
+	};
+#endif // char8_t
+
+	template <typename Ch, typename Traits, typename Al>
+	struct unqualified_pusher<std::basic_string<Ch, Traits, Al>> {
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), str.size());
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), str.size());
+				return 1;
+			}
+		}
+
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str, std::size_t sz) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), sz);
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), sz);
+				return 1;
+			}
+		}
+	};
+
+	template <typename Ch, typename Traits>
+	struct unqualified_pusher<basic_string_view<Ch, Traits>> {
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv) {
+			return stack::push(L, sv.data(), sv.length());
+		}
+
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv, std::size_t n) {
+			return stack::push(L, sv.data(), n);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<meta_function> {
+		static int push(lua_State* L, meta_function m) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name);
+#endif // make sure stack doesn't overflow
+			const std::string& str = to_string(m);
+			lua_pushlstring(L, str.c_str(), str.size());
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<absolute_index> {
+		static int push(lua_State* L, absolute_index ai) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ai);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<raw_index> {
+		static int push(lua_State* L, raw_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<ref_index> {
+		static int push(lua_State* L, ref_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L, LUA_REGISTRYINDEX, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const wchar_t*> {
+		static int push(lua_State* L, const wchar_t* wstr) {
+			return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
+		}
+
+		static int push(lua_State* L, const wchar_t* wstr, std::size_t sz) {
+			return push(L, wstr, wstr + sz);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			if constexpr (sizeof(wchar_t) == 2) {
+				const char16_t* sb = reinterpret_cast<const char16_t*>(strb);
+				const char16_t* se = reinterpret_cast<const char16_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+			else {
+				const char32_t* sb = reinterpret_cast<const char32_t*>(strb);
+				const char32_t* se = reinterpret_cast<const char32_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t*> {
+		static int push(lua_State* L, const wchar_t* str) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const wchar_t* str, std::size_t len) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char16_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char16_t* strb, const char16_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* utf8data = er.code_units.data();
+				std::memcpy(target, utf8data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char16_t* u16str) {
+			return push(L, u16str, std::char_traits<char16_t>::length(u16str));
+		}
+
+		static int push(lua_State* L, const char16_t* u16str, std::size_t sz) {
+			return push(L, u16str, u16str + sz);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = static_cast<std::size_t>(static_cast<std::size_t>(stre - strb) * static_cast<std::size_t>(4));
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t*> {
+		static int push(lua_State* L, const char16_t* str) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char16_t* str, std::size_t len) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char32_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char32_t* strb, const char32_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* data = er.code_units.data();
+				std::memcpy(target, data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char32_t* u32str) {
+			return push(L, u32str, u32str + std::char_traits<char32_t>::length(u32str));
+		}
+
+		static int push(lua_State* L, const char32_t* u32str, std::size_t sz) {
+			return push(L, u32str, u32str + sz);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = static_cast<std::size_t>(static_cast<std::size_t>(stre - strb) * static_cast<std::size_t>(4));
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t*> {
+		static int push(lua_State* L, const char32_t* str) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char32_t* str, std::size_t len) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<wchar_t[N]> {
+		static int push(lua_State* L, const wchar_t (&str)[N]) {
+			return push(L, str, std::char_traits<wchar_t>::length(str));
+		}
+
+		static int push(lua_State* L, const wchar_t (&str)[N], std::size_t sz) {
+			const wchar_t* str_ptr = static_cast<const wchar_t*>(str);
+			return stack::push<const wchar_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char16_t[N]> {
+		static int push(lua_State* L, const char16_t (&str)[N]) {
+			return push(L, str, std::char_traits<char16_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char16_t (&str)[N], std::size_t sz) {
+			const char16_t* str_ptr = static_cast<const char16_t*>(str);
+			return stack::push<const char16_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char32_t[N]> {
+		static int push(lua_State* L, const char32_t (&str)[N]) {
+			return push(L, str, std::char_traits<char32_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char32_t (&str)[N], std::size_t sz) {
+			const char32_t* str_ptr = static_cast<const char32_t*>(str);
+			return stack::push<const char32_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t> {
+		static int push(lua_State* L, wchar_t c) {
+			const wchar_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const wchar_t*>(str), 1u);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t> {
+		static int push(lua_State* L, char16_t c) {
+			const char16_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char16_t*>(str), 1u);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t> {
+		static int push(lua_State* L, char32_t c) {
+			const char32_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char32_t*>(str), 1u);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_pusher<std::tuple<Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, static_cast<int>(sizeof...(I)), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			int pushcount = 0;
+			(void)detail::swallow { 0, (pushcount += stack::push(L, std::get<I>(std::forward<T>(t))), 0)... };
+			return pushcount;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			return push(std::index_sequence_for<Args...>(), L, std::forward<T>(t));
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_pusher<std::pair<A, B>> {
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			int pushcount = stack::push(L, std::get<0>(std::forward<T>(t)));
+			pushcount += stack::push(L, std::get<1>(std::forward<T>(t)));
+			return pushcount;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<T, std::enable_if_t<meta::is_optional_v<T>>> {
+		using ValueType = typename meta::unqualified_t<T>::value_type;
+
+		template <typename Optional>
+		static int push(lua_State* L, Optional&& op) {
+			using QualifiedValueType = meta::conditional_t<std::is_lvalue_reference_v<Optional>, ValueType&, ValueType&&>;
+			if (!op) {
+				return stack::push(L, nullopt);
+			}
+			return stack::push(L, static_cast<QualifiedValueType>(op.value()));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<forward_as_value_t<T>> {
+		static int push(lua_State* L, const forward_as_value_t<T>& value_) {
+			return stack::push<T>(L, value_.value());
+		}
+
+		static int push(lua_State* L, forward_as_value_t<T>&& value_) {
+			return stack::push<T>(L, std::move(value_).value());
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<nullopt_t> {
+		static int push(lua_State* L, nullopt_t) noexcept {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::nullptr_t> {
+		static int push(lua_State* L, std::nullptr_t) noexcept {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_state> {
+		static int push(lua_State*, const this_state&) noexcept {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_main_state> {
+		static int push(lua_State*, const this_main_state&) noexcept {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<new_table> {
+		static int push(lua_State* L, const new_table& nt) {
+			lua_createtable(L, nt.sequence_hint, nt.map_hint);
+			return 1;
+		}
+	};
+
+	template <typename Allocator>
+	struct unqualified_pusher<basic_bytecode<Allocator>> {
+		template <typename T>
+		static int push(lua_State* L, T&& bc, const char* bytecode_name) {
+			const auto first = bc.data();
+			const auto bcsize = bc.size();
+			// pushes either the function, or an error
+			// if it errors, shit goes south, and people can test that upstream
+			(void)luaL_loadbuffer(
+				L, reinterpret_cast<const char*>(first), static_cast<std::size_t>(bcsize * (sizeof(*first) / sizeof(const char))), bytecode_name);
+			return 1;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& bc) {
+			return push(L, std::forward<bc>(bc), "bytecode");
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+	namespace stack_detail {
+
+		struct push_function {
+			lua_State* L;
+
+			push_function(lua_State* L_) noexcept : L(L_) {
+			}
+
+			template <typename T>
+			int operator()(T&& value) const {
+				return stack::push<T>(L, std::forward<T>(value));
+			}
+		};
+
+	} // namespace stack_detail
+
+	template <typename... Tn>
+	struct unqualified_pusher<std::variant<Tn...>> {
+		static int push(lua_State* L, const std::variant<Tn...>& v) {
+			return std::visit(stack_detail::push_function(L), v);
+		}
+
+		static int push(lua_State* L, std::variant<Tn...>&& v) {
+			return std::visit(stack_detail::push_function(L), std::move(v));
+		}
+	};
+#endif // Variant because Clang is terrible
+
+}} // namespace sol::stack
+
+// end of sol/stack_push.hpp
+
+// beginning of sol/stack_pop.hpp
+
+#include <utility>
+#include <tuple>
+
+namespace sol { namespace stack {
+	template <typename T, typename>
+	struct popper {
+		inline static decltype(auto) pop(lua_State* L) {
+			if constexpr (is_stack_based_v<meta::unqualified_t<T>>) {
+				static_assert(!is_stack_based_v<meta::unqualified_t<T>>,
+					"You cannot pop something that lives solely on the stack: it will not remain on the stack when popped and thusly will go out of "
+					"scope!");
+			}
+			else {
+				record tracking {};
+				decltype(auto) r = get<T>(L, -lua_size<T>::value, tracking);
+				lua_pop(L, tracking.used);
+				return r;
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_pop.hpp
+
+// beginning of sol/stack_field.hpp
+
+namespace sol { namespace stack {
+
+	namespace stack_detail {
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_get_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_get_direct_v = (is_get_direct_tableless_v<T, global, raw>) // cf-hack
+			|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
+			|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#if SOL_LUA_VERSION_I_ >= 503
+			|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#endif // integer keys 5.3 or better
+#if SOL_LUA_VERSION_I_ >= 502
+			|| (!global && raw && std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>)
+#endif // void pointer keys 5.2 or better
+			;
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_set_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_set_direct_v = (is_set_direct_tableless_v<T, global, raw>) // cf-hack
+			|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
+			|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))     // cf-hack
+#if SOL_LUA_VERSION_I_ >= 503
+			|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#endif // integer keys 5.3 or better
+#if SOL_LUA_VERSION_I_ >= 502
+			|| (!global && raw && (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>))
+#endif // void pointer keys 5.2 or better
+			;
+	} // namespace stack_detail
+
+	template <typename T, bool global, bool raw, typename>
+	struct field_getter {
+		static inline constexpr int default_table_index
+			= meta::conditional_t<stack_detail::is_get_direct_v<T, global, raw>, std::integral_constant<int, -1>, std::integral_constant<int, -2>>::value;
+
+		template <typename Key>
+		void get(lua_State* L, Key&& key, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t> || std::is_same_v<T, create_if_nil_t>) {
+				(void)L;
+				(void)key;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				(void)key;
+#if SOL_LUA_VERSION_I_ < 502
+				// Use lua_setfenv
+				lua_getfenv(L, tableindex);
+#else
+				// Use upvalues as explained in Lua 5.2 and beyond's manual
+				if (lua_getupvalue(L, tableindex, 1) == nullptr) {
+					push(L, lua_nil);
+				}
+#endif
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				if (lua_getmetatable(L, tableindex) == 0)
+					push(L, lua_nil);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_rawgeti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VERSION_I_ >= 502
+				else if constexpr (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>) {
+					lua_rawgetp(L, tableindex, key);
+				}
+#endif // Lua 5.2.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_rawget(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_or_string_v<T>) {
+					if constexpr (global) {
+						(void)tableindex;
+						lua_getglobal(L, &key[0]);
+					}
+					else {
+						lua_getfield(L, tableindex, &key[0]);
+					}
+				}
+				else if constexpr (std::is_same_v<T, meta_function>) {
+					const auto& real_key = to_string(key);
+					lua_getfield(L, tableindex, &real_key[0]);
+				}
+#if SOL_LUA_VERSION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_geti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_gettable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_getter<std::tuple<Args...>, b, raw, C> {
+		template <std::size_t... I, typename Keys>
+		void apply(std::index_sequence<0, I...>, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			void(detail::swallow { (get_field<false, raw>(L, std::get<I>(std::forward<Keys>(keys))), 0)... });
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), lua_absindex(L, -1));
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_getter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)));
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+	};
+
+	template <typename T, bool global, bool raw, typename>
+	struct field_setter {
+		static constexpr int default_table_index
+			= meta::conditional_t<stack_detail::is_set_direct_v<T, global, raw>, std::integral_constant<int, -2>, std::integral_constant<int, -3>>::value;
+
+		template <typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t>) {
+				(void)L;
+				(void)key;
+				(void)value;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				push(L, std::forward<Value>(value));
+				lua_setmetatable(L, tableindex);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_rawseti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VERSION_I_ >= 502
+				else if constexpr (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>) {
+					push(L, std::forward<Value>(value));
+					lua_rawsetp(L, tableindex, std::forward<Key>(key));
+				}
+#endif // Lua 5.2.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_rawset(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_or_string_v<T>) {
+					if constexpr (global) {
+						push(L, std::forward<Value>(value));
+						lua_setglobal(L, &key[0]);
+						(void)tableindex;
+					}
+					else {
+						push(L, std::forward<Value>(value));
+						lua_setfield(L, tableindex, &key[0]);
+					}
+				}
+#if SOL_LUA_VERSION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_seti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_settable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_setter<std::tuple<Args...>, b, raw, C> {
+		template <bool g, std::size_t I, typename Keys, typename Value>
+		void apply(std::index_sequence<I>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I < 1 ? set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value), tableindex)
+				 : set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value));
+		}
+
+		template <bool g, std::size_t I0, std::size_t I1, std::size_t... I, typename Keys, typename Value>
+		void apply(std::index_sequence<I0, I1, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I0 < 1 ? get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), tableindex)
+				  : get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), -1);
+			apply<false>(std::index_sequence<I1, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), -1);
+		}
+
+		template <bool g, std::size_t I0, std::size_t... I, typename Keys, typename Value>
+		void top_apply(std::index_sequence<I0, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			apply<g>(std::index_sequence<I0, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+		}
+
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -3) {
+			top_apply<b>(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_setter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -1) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			set_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)), std::forward<Value>(value), lua_gettop(L));
+			lua_pop(L, 1);
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_field.hpp
+
+// beginning of sol/stack_probe.hpp
+
+namespace sol { namespace stack {
+	template <typename T, typename P, bool b, bool raw, typename>
+	struct probe_field_getter {
+		template <typename Key>
+		probe get(lua_State* L, Key&& key, int tableindex = -2) {
+			if constexpr (!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+			}
+			get_field<b, raw>(L, std::forward<Key>(key), tableindex);
+			return probe(check<P>(L), 1);
+		}
+	};
+
+	template <typename A, typename B, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::pair<A, B>, P, b, raw, C> {
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if (!b && !maybe_indexable(L, tableindex)) {
+				return probe(false, 0);
+			}
+			get_field<b, raw>(L, std::get<0>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, 1);
+			}
+			get_field<false, raw>(L, std::get<1>(keys), tableindex);
+			return probe(check<P>(L), 2);
+		}
+	};
+
+	template <typename... Args, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::tuple<Args...>, P, b, raw, C> {
+		template <std::size_t I, typename Keys>
+		probe apply(std::index_sequence<I>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<(I < 1) && b, raw>(L, std::get<I>(keys), tableindex);
+			return probe(check<P>(L), sofar);
+		}
+
+		template <std::size_t I, std::size_t I1, std::size_t... In, typename Keys>
+		probe apply(std::index_sequence<I, I1, In...>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field < I<1 && b, raw>(L, std::get<I>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, sofar);
+			}
+			return apply(std::index_sequence<I1, In...>(), sofar + 1, L, std::forward<Keys>(keys), -1);
+		}
+
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if constexpr (!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+			else {
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_probe.hpp
+
+#include <cstring>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		using typical_chunk_name_t = char[SOL_ID_SIZE_I_];
+		using typical_file_chunk_name_t = char[SOL_FILE_ID_SIZE_I_];
+
+		inline const std::string& default_chunk_name() {
+			static const std::string name = "";
+			return name;
+		}
+
+		template <std::size_t N>
+		const char* make_chunk_name(const string_view& code, const std::string& chunkname, char (&basechunkname)[N]) {
+			if (chunkname.empty()) {
+				auto it = code.cbegin();
+				auto e = code.cend();
+				std::size_t i = 0;
+				static const std::size_t n = N - 4;
+				for (i = 0; i < n && it != e; ++i, ++it) {
+					basechunkname[i] = *it;
+				}
+				if (it != e) {
+					for (std::size_t c = 0; c < 3; ++i, ++c) {
+						basechunkname[i] = '.';
+					}
+				}
+				basechunkname[i] = '\0';
+				return &basechunkname[0];
+			}
+			else {
+				return chunkname.c_str();
+			}
+		}
+
+		inline void clear_entries(stack_reference r) {
+			stack::push(r.lua_state(), lua_nil);
+			while (lua_next(r.lua_state(), -2)) {
+				absolute_index key(r.lua_state(), -2);
+				auto pn = stack::pop_n(r.lua_state(), 1);
+				stack::set_field<false, true>(r.lua_state(), key, lua_nil, r.stack_index());
+			}
+		}
+
+		inline void clear_entries(const reference& registry_reference) {
+			auto pp = stack::push_pop(registry_reference);
+			stack_reference ref(registry_reference.lua_state(), -1);
+			clear_entries(ref);
+		}
+	} // namespace detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T>
+			inline int push_as_upvalues(lua_State* L, T& item) {
+				typedef std::decay_t<T> TValue;
+				static const std::size_t itemsize = sizeof(TValue);
+				static const std::size_t voidsize = sizeof(void*);
+				static const std::size_t voidsizem1 = voidsize - 1;
+				static const std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
+				typedef std::array<void*, data_t_count> data_t;
+
+				data_t data { {} };
+				std::memcpy(&data[0], std::addressof(item), itemsize);
+				int pushcount = 0;
+				for (const auto& v : data) {
+					lua_pushlightuserdata(L, v);
+					pushcount += 1;
+				}
+				return pushcount;
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 2) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				data_t voiddata { {} };
+				for (std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof(void*)) {
+					voiddata[i] = lua_touserdata(L, upvalue_index(index++));
+				}
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues_using_function(lua_State* L, int function_index = -1) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				function_index = lua_absindex(L, function_index);
+				int index = 0;
+				data_t voiddata { {} };
+				for (std::size_t d = 0; d < sizeof(T); d += sizeof(void*)) {
+					// first upvalue is nullptr to respect environment shenanigans
+					// So +2 instead of +1
+					const char* upvalue_name = lua_getupvalue(L, function_index, index + 2);
+					if (upvalue_name == nullptr) {
+						// We should freak out here...
+						break;
+					}
+					voiddata[index] = lua_touserdata(L, -1);
+					++index;
+				}
+				lua_pop(L, index);
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <bool checked, typename Handler, typename Fx, typename... Args>
+			static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, Handler&&, record&, Fx&& fx, Args&&... args) {
+				return std::forward<Fx>(fx)(std::forward<Args>(args)...);
+			}
+
+			template <bool checked, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename Handler, typename Fx, typename... FxArgs>
+			static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L_, int start_index_, Handler&& handler_,
+			     record& tracking_, Fx&& fx_, FxArgs&&... fxargs_) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+				// We can save performance/time by letting errors unwind produced arguments
+				// rather than checking everything once, and then potentially re-doing work
+				if constexpr (checked) {
+					return eval<checked>(types<Args...>(),
+					     std::index_sequence<Is...>(),
+					     L_,
+					     start_index_,
+					     std::forward<Handler>(handler_),
+					     tracking_,
+					     std::forward<Fx>(fx_),
+					     std::forward<FxArgs>(fxargs_)...,
+					     *stack_detail::check_get_arg<Arg>(L_, start_index_ + tracking_.used, handler_, tracking_));
+				}
+				else
+#endif
+				{
+					return eval<checked>(types<Args...>(),
+					     std::index_sequence<Is...>(),
+					     L_,
+					     start_index_,
+					     std::forward<Handler>(handler_),
+					     tracking_,
+					     std::forward<Fx>(fx_),
+					     std::forward<FxArgs>(fxargs_)...,
+					     stack_detail::unchecked_get_arg<Arg>(L_, start_index_ + tracking_.used, tracking_));
+				}
+			}
+
+			template <bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs>
+			inline decltype(auto) call(types<R>, types<Args...> argument_types_, std::index_sequence<I...> argument_indices_, lua_State* L_,
+			     int start_index_, Fx&& fx_, FxArgs&&... args_) {
+				static_assert(meta::all_v<meta::is_not_move_only<Args>...>,
+				     "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take "
+				     "a reference and std::move it manually if this was your intention.");
+				argument_handler<types<R, Args...>> handler {};
+				record tracking {};
+#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+				if constexpr (checkargs) {
+					multi_check<Args...>(L_, start_index_, handler);
+				}
+#endif
+				if constexpr (std::is_void_v<R>) {
+					eval<checkargs>(
+					     argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
+				}
+				else {
+					return eval<checkargs>(
+					     argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
+				}
+			}
+
+			template <typename T>
+			void raw_table_set(lua_State* L, T&& arg, int tableindex = -2) {
+				int push_count = push(L, std::forward<T>(arg));
+				sol_c_assert(push_count == 1);
+				std::size_t unique_index = static_cast<std::size_t>(luaL_len(L, tableindex) + 1u);
+				lua_rawseti(L, tableindex, unique_index);
+			}
+
+		} // namespace stack_detail
+
+		template <typename T>
+		int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
+			int push_count = push(L, std::forward<T>(arg));
+			sol_c_assert(push_count == 1);
+			return luaL_ref(L, tableindex);
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+			using args_indices = std::make_index_sequence<sizeof...(Args)>;
+			if constexpr (std::is_void_v<R>) {
+				stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			using expected_count_t = meta::count_for_pack<lua_size, Args...>;
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Ret0, typename... Ret, typename... Args,
+		     typename Fx, typename... FxArgs>
+		inline int call_into_lua(types<Ret0, Ret...> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			if constexpr (std::is_void_v<Ret0>) {
+				call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				if constexpr (clean_stack) {
+					lua_settop(L, 0);
+				}
+				return 0;
+			}
+			else {
+				(void)tr;
+				decltype(auto) r
+				     = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				using R = meta::unqualified_t<decltype(r)>;
+				using is_stack = meta::any<is_stack_based<R>, std::is_same<R, absolute_index>, std::is_same<R, ref_index>, std::is_same<R, raw_index>>;
+				if constexpr (clean_stack && !is_stack::value) {
+					lua_settop(L, 0);
+				}
+				return push_reference(L, std::forward<decltype(r)>(r));
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Fx, typename... FxArgs>
+		inline int call_lua(lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			using traits_type = lua_bind_traits<meta::unqualified_t<Fx>>;
+			using args_list = typename traits_type::args_list;
+			using returns_list = typename traits_type::returns_list;
+			return call_into_lua<check_args, clean_stack>(returns_list(), args_list(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+		}
+
+		inline call_syntax get_call_syntax(lua_State* L, const string_view& key, int index) {
+			if (lua_gettop(L) < 1) {
+				return call_syntax::dot;
+			}
+			luaL_getmetatable(L, key.data());
+			auto pn = pop_n(L, 1);
+			if (lua_compare(L, -1, index, LUA_OPEQ) != 1) {
+				return call_syntax::dot;
+			}
+			return call_syntax::colon;
+		}
+
+		inline void script(
+		     lua_State* L, lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script(
+		     lua_State* L, const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script_file(lua_State* L, const std::string& filename, load_mode mode = load_mode::any) {
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void luajit_exception_handler(lua_State* L, int (*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
+			if (L == nullptr) {
+				return;
+			}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, (void*)handler);
+			auto pn = pop_n(L, 1);
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
+#else
+			(void)L;
+			(void)handler;
+#endif
+		}
+
+		inline void luajit_exception_off(lua_State* L) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
+			if (L == nullptr) {
+				return;
+			}
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_OFF);
+#else
+			(void)L;
+#endif
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack.hpp
+
+// beginning of sol/object.hpp
+
+// beginning of sol/make_reference.hpp
+
+namespace sol {
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference(lua_State* L, T&& value) {
+		int backpedal = stack::push(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference(lua_State* L, Args&&... args) {
+		int backpedal = stack::push<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference_userdata(lua_State* L, T&& value) {
+		int backpedal = stack::push_userdata(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference_userdata(lua_State* L, Args&&... args) {
+		int backpedal = stack::push_userdata<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+} // namespace sol
+
+// end of sol/make_reference.hpp
+
+// beginning of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	class basic_object_base : public ref_t {
+	private:
+		using base_t = ref_t;
+
+		template <typename T>
+		decltype(auto) as_stack(std::true_type) const {
+			return stack::get<T>(base_t::lua_state(), base_t::stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as_stack(std::false_type) const {
+			base_t::push();
+			return stack::pop<T>(base_t::lua_state());
+		}
+
+		template <typename T>
+		bool is_stack(std::true_type) const {
+			return stack::check<T>(base_t::lua_state(), base_t::stack_index(), &no_panic);
+		}
+
+		template <typename T>
+		bool is_stack(std::false_type) const {
+			int r = base_t::registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(*this);
+			return stack::check<T>(base_t::lua_state(), -1, &no_panic);
+		}
+
+	public:
+		basic_object_base() noexcept = default;
+		basic_object_base(const basic_object_base&) = default;
+		basic_object_base(basic_object_base&&) = default;
+		basic_object_base& operator=(const basic_object_base&) = default;
+		basic_object_base& operator=(basic_object_base&&) = default;
+		template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object_base>>> = meta::enabler>
+		basic_object_base(T&& arg, Args&&... args) : base_t(std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return as_stack<T>(is_stack_based<base_t>());
+		}
+
+		template <typename T>
+		bool is() const {
+			return is_stack<T>(is_stack_based<base_t>());
+		}
+	};
+} // namespace sol
+
+// end of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_object : public basic_object_base<base_type> {
+	private:
+		typedef basic_object_base<base_type> base_t;
+
+		template <bool invert_and_pop = false>
+		basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L_, int index_ = -1) noexcept : base_t(L_, index_) {
+			if (invert_and_pop) {
+				lua_pop(L_, -index_);
+			}
+		}
+
+	protected:
+		basic_object(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L_, int index_) : base_t(L_, index_) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L_, ref_index index_) : base_t(L_, index_) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, lua_State* L_, T&& r) noexcept : base_t(L_, std::forward<T>(r)) {
+		}
+
+	public:
+		basic_object() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(T&& r) : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(lua_State* L_, T&& r) : base_t(L_, std::forward<T>(r)) {
+		}
+		basic_object(lua_State* L_, global_tag_t t) : base_t(L_, t) {
+		}
+		basic_object(lua_nil_t r) : base_t(r) {
+		}
+		basic_object(const basic_object&) = default;
+		basic_object(basic_object&&) = default;
+		basic_object(const stack_reference& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {
+		}
+		basic_object(stack_reference&& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {
+		}
+		template <typename Super>
+		basic_object(const proxy_base<Super>& r) noexcept : basic_object(r.operator basic_object()) {
+		}
+		template <typename Super>
+		basic_object(proxy_base<Super>&& r) noexcept : basic_object(r.operator basic_object()) {
+		}
+		basic_object(lua_State* L_, lua_nil_t r) noexcept : base_t(L_, r) {
+		}
+		basic_object(lua_State* L_, int index_ = -1) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, absolute_index index_) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, raw_index index_) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, ref_index index_) noexcept : base_t(L_, index_) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L_, in_place_type_t<T>, Args&&... args) noexcept
+		: basic_object(std::integral_constant<bool, !is_stack_based<base_t>::value>(), L_, -stack::push<T>(L_, std::forward<Args>(args)...)) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L_, in_place_t, T&& arg, Args&&... args) noexcept
+		: basic_object(L_, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+		basic_object& operator=(const basic_object&) = default;
+		basic_object& operator=(basic_object&&) = default;
+		basic_object& operator=(const base_type& b) {
+			base_t::operator=(b);
+			return *this;
+		}
+		basic_object& operator=(base_type&& b) {
+			base_t::operator=(std::move(b));
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(const proxy_base<Super>& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(proxy_base<Super>&& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+	};
+
+	template <typename T>
+	object make_object(lua_State* L_, T&& value) {
+		return make_reference<object, true>(L_, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object(lua_State* L_, Args&&... args) {
+		return make_reference<T, object, true>(L_, std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	object make_object_userdata(lua_State* L_, T&& value) {
+		return make_reference_userdata<object, true>(L_, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object_userdata(lua_State* L_, Args&&... args) {
+		return make_reference_userdata<T, object, true>(L_, std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/object.hpp
+
+// beginning of sol/function.hpp
+
+// beginning of sol/unsafe_function.hpp
+
+// beginning of sol/function_result.hpp
+
+// beginning of sol/protected_function_result.hpp
+
+// beginning of sol/proxy_base.hpp
+
+namespace sol {
+	struct proxy_base_tag { };
+
+	namespace detail {
+		template <typename T>
+		using proxy_key_t = meta::conditional_t<meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>, T,
+		     std::tuple<meta::conditional_t<std::is_array_v<meta::unqualified_t<T>>, std::remove_reference_t<T>&, meta::unqualified_t<T>>>>;
+	}
+
+	template <typename Super>
+	struct proxy_base : public proxy_base_tag {
+		lua_State* lua_state() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.lua_state();
+		}
+
+		operator std::string() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<std::string>();
+		}
+
+		template <typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, is_proxy_primitive<meta::unqualified_t<T>>> = meta::enabler>
+		operator T() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T>();
+		}
+
+		template <typename T,
+		     meta::enable<meta::neg<meta::is_string_constructible<T>>, meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>> = meta::enabler>
+		operator T&() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T&>();
+		}
+	};
+
+} // namespace sol
+
+// end of sol/proxy_base.hpp
+
+// beginning of sol/stack_iterator.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	template <typename proxy_t, bool is_const>
+	struct stack_iterator {
+		typedef meta::conditional_t<is_const, const proxy_t, proxy_t> reference;
+		typedef meta::conditional_t<is_const, const proxy_t*, proxy_t*> pointer;
+		typedef proxy_t value_type;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::random_access_iterator_tag iterator_category;
+		lua_State* L;
+		int index;
+		int stacktop;
+		proxy_t sp;
+
+		stack_iterator() : L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()), sp() {
+		}
+		stack_iterator(const stack_iterator<proxy_t, true>& r) : L(r.L), index(r.index), stacktop(r.stacktop), sp(r.sp) {
+		}
+		stack_iterator(lua_State* luastate, int idx, int topidx) : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {
+		}
+
+		reference operator*() {
+			return proxy_t(L, index);
+		}
+
+		reference operator*() const {
+			return proxy_t(L, index);
+		}
+
+		pointer operator->() {
+			sp = proxy_t(L, index);
+			return &sp;
+		}
+
+		pointer operator->() const {
+			const_cast<proxy_t&>(sp) = proxy_t(L, index);
+			return &sp;
+		}
+
+		stack_iterator& operator++() {
+			++index;
+			return *this;
+		}
+
+		stack_iterator operator++(int) {
+			auto r = *this;
+			this->operator++();
+			return r;
+		}
+
+		stack_iterator& operator--() {
+			--index;
+			return *this;
+		}
+
+		stack_iterator operator--(int) {
+			auto r = *this;
+			this->operator--();
+			return r;
+		}
+
+		stack_iterator& operator+=(difference_type idx) {
+			index += static_cast<int>(idx);
+			return *this;
+		}
+
+		stack_iterator& operator-=(difference_type idx) {
+			index -= static_cast<int>(idx);
+			return *this;
+		}
+
+		difference_type operator-(const stack_iterator& r) const {
+			return index - r.index;
+		}
+
+		stack_iterator operator+(difference_type idx) const {
+			stack_iterator r = *this;
+			r += idx;
+			return r;
+		}
+
+		reference operator[](difference_type idx) const {
+			return proxy_t(L, index + static_cast<int>(idx));
+		}
+
+		bool operator==(const stack_iterator& r) const {
+			if (stacktop == (std::numeric_limits<int>::max)()) {
+				return r.index == r.stacktop;
+			}
+			else if (r.stacktop == (std::numeric_limits<int>::max)()) {
+				return index == stacktop;
+			}
+			return index == r.index;
+		}
+
+		bool operator!=(const stack_iterator& r) const {
+			return !(this->operator==(r));
+		}
+
+		bool operator<(const stack_iterator& r) const {
+			return index < r.index;
+		}
+
+		bool operator>(const stack_iterator& r) const {
+			return index > r.index;
+		}
+
+		bool operator<=(const stack_iterator& r) const {
+			return index <= r.index;
+		}
+
+		bool operator>=(const stack_iterator& r) const {
+			return index >= r.index;
+		}
+	};
+
+	template <typename proxy_t, bool is_const>
+	inline stack_iterator<proxy_t, is_const> operator+(
+	     typename stack_iterator<proxy_t, is_const>::difference_type n, const stack_iterator<proxy_t, is_const>& r) {
+		return r + n;
+	}
+} // namespace sol
+
+// end of sol/stack_iterator.hpp
+
+// beginning of sol/stack_proxy.hpp
+
+// beginning of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy_base : public proxy_base<stack_proxy_base> {
+	private:
+		lua_State* m_L;
+		int m_index;
+
+	public:
+		stack_proxy_base() : m_L(nullptr), m_index(0) {
+		}
+		stack_proxy_base(lua_State* L_, int index_) : m_L(L_), m_index(index_) {
+		}
+
+		template <typename T>
+		decltype(auto) get() const {
+			return stack::get<T>(m_L, stack_index());
+		}
+
+		template <typename T>
+		bool is() const {
+			return stack::check<T>(m_L, stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return get<T>();
+		}
+
+		type get_type() const noexcept {
+			return type_of(lua_state(), stack_index());
+		}
+
+		int push() const {
+			return push(m_L);
+		}
+
+		int push(lua_State* L_) const {
+			lua_pushvalue(L_, m_index);
+			return 1;
+		}
+
+		lua_State* lua_state() const {
+			return m_L;
+		}
+		int stack_index() const {
+			return m_index;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy_base> {
+			static stack_proxy_base get(lua_State* L_, int index_ = -1) {
+				return stack_proxy_base(L_, index_);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy_base> {
+			static int push(lua_State*, const stack_proxy_base& proxy_reference) {
+				return proxy_reference.push();
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy : public stack_proxy_base {
+	public:
+		stack_proxy() : stack_proxy_base() {
+		}
+		stack_proxy(lua_State* L, int index) : stack_proxy_base(L, index) {
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args);
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy> {
+			static stack_proxy get(lua_State* L, int index, record& tracking) {
+				tracking.use(0);
+				return stack_proxy(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy> {
+			static int push(lua_State*, const stack_proxy& ref) {
+				return ref.push();
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack_proxy.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct protected_function_result : public proxy_base<protected_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		call_status err;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		protected_function_result() noexcept : protected_function_result(nullptr) {}
+		protected_function_result(lua_State* Ls, int idx = -1, int retnum = 0, int popped = 0, call_status pferr = call_status::ok) noexcept
+		: L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		protected_function_result(const protected_function_result&) = delete;
+		protected_function_result& operator=(const protected_function_result&) = delete;
+
+		protected_function_result(protected_function_result&& o) noexcept
+		: L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+		}
+		protected_function_result& operator=(protected_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		protected_function_result(const unsafe_function_result& o) = delete;
+		protected_function_result& operator=(const unsafe_function_result& o) = delete;
+		protected_function_result(unsafe_function_result&& o) noexcept;
+		protected_function_result& operator=(unsafe_function_result&& o) noexcept;
+
+		call_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+		template <typename T>
+		decltype(auto) get(int index_offset = 0) const {
+			using UT = meta::unqualified_t<T>;
+			int target = index + index_offset;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT();
+					}
+					return UT(error(detail::direct_error, stack::get<std::string>(L, target)));
+				}
+				else {
+					if (!valid()) {
+						return UT();
+					}
+					return stack::get<UT>(L, target);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)");
+					}
+#endif // Check Argument Safety
+					return error(detail::direct_error, stack::get<std::string>(L, target));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (!valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is not an error)");
+					}
+#endif // Check Argument Safety
+					return stack::get<T>(L, target);
+				}
+			}
+		}
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#endif
+
+		type get_type(int index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+		int return_count() const noexcept {
+			return returncount;
+		};
+		int pop_count() const noexcept {
+			return popcount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+			popcount = 0;
+			err = call_status::runtime;
+		}
+		~protected_function_result() {
+			if (L == nullptr)
+				return;
+			stack::remove(L, index, popcount);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<protected_function_result> {
+			static int push(lua_State* L, const protected_function_result& pfr) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				int p = 0;
+				for (int i = 0; i < pfr.pop_count(); ++i) {
+					lua_pushvalue(L, i + pfr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/protected_function_result.hpp
+
+// beginning of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct unsafe_function_result : public proxy_base<unsafe_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		unsafe_function_result() noexcept : unsafe_function_result(nullptr) {}
+		unsafe_function_result(lua_State* Ls, int idx = -1, int retnum = 0) noexcept : L(Ls), index(idx), returncount(retnum) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		unsafe_function_result(const unsafe_function_result&) = delete;
+		unsafe_function_result& operator=(const unsafe_function_result&) = delete;
+
+		unsafe_function_result(unsafe_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+		}
+		unsafe_function_result& operator=(unsafe_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		unsafe_function_result(const protected_function_result& o) = delete;
+		unsafe_function_result& operator=(const protected_function_result& o) = delete;
+		unsafe_function_result(protected_function_result&& o) noexcept;
+		unsafe_function_result& operator=(protected_function_result&& o) noexcept;
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		call_status status() const noexcept {
+			return call_status::ok;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int return_count() const {
+			return returncount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+		}
+		~unsafe_function_result() {
+			if (L != nullptr) {
+				lua_pop(L, returncount);
+			}
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<unsafe_function_result> {
+			static int push(lua_State* L, const unsafe_function_result& fr) {
+				int p = 0;
+				for (int i = 0; i < fr.return_count(); ++i) {
+					lua_pushvalue(L, i + fr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+
+	namespace detail {
+		template <>
+		struct is_speshul<unsafe_function_result> : std::true_type { };
+		template <>
+		struct is_speshul<protected_function_result> : std::true_type { };
+
+		template <std::size_t I, typename... Args, typename T>
+		stack_proxy get(types<Args...>, meta::index_value<0>, meta::index_value<I>, const T& fr) {
+			return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+		}
+
+		template <std::size_t I, std::size_t N, typename Arg, typename... Args, typename T, meta::enable<meta::boolean<(N > 0)>> = meta::enabler>
+		stack_proxy get(types<Arg, Args...>, meta::index_value<N>, meta::index_value<I>, const T& fr) {
+			return get(types<Args...>(), meta::index_value<N - 1>(), meta::index_value<I + lua_size<Arg>::value>(), fr);
+		}
+	} // namespace detail
+
+	template <>
+	struct tie_size<unsafe_function_result> : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+	template <>
+	struct tie_size<protected_function_result> : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+	template <std::size_t I>
+	stack_proxy get(const unsafe_function_result& fr) {
+		return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const unsafe_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+
+	template <std::size_t I>
+	stack_proxy get(const protected_function_result& fr) {
+		return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const protected_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+} // namespace sol
+
+// end of sol/function_result.hpp
+
+// beginning of sol/function_types.hpp
+
+// beginning of sol/function_types_core.hpp
+
+// beginning of sol/wrapper.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		using array_return_type = meta::conditional_t<std::is_array<T>::value, std::add_lvalue_reference_t<T>, T>;
+	}
+
+	template <typename F, typename = void>
+	struct wrapper {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <typename... Args>
+		static decltype(auto) call(F& f, Args&&... args) {
+			return f(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_function<std::remove_pointer_t<meta::unqualified_t<F>>>::value>> {
+		typedef lua_bind_traits<std::remove_pointer_t<meta::unqualified_t<F>>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx, typename... Args>
+		static decltype(auto) invoke(Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static decltype(auto) call(F& fx, Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>> {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::object_type object_type;
+		typedef typename traits_type::return_type return_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, return_type> free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx>
+		static auto call(object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <F fx, typename Arg, typename... Args>
+		static decltype(auto) invoke(object_type& mem, Arg&& arg, Args&&...) {
+			return mem.*fx = std::forward<Arg>(arg);
+		}
+
+		template <typename Fx>
+		static auto call(Fx&& fx, object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <typename Fx, typename Arg, typename... Args>
+		static void call(Fx&& fx, object_type& mem, Arg&& arg, Args&&...) {
+			using actual_type = meta::unqualified_t<detail::array_return_type<decltype(mem.*fx)>>;
+			if constexpr (std::is_array_v<actual_type>) {
+				using std::cbegin;
+				using std::cend;
+				auto first = cbegin(arg);
+				auto last = cend(arg);
+				for (std::size_t i = 0; first != last; ++i, ++first) {
+					(mem.*fx)[i] = *first;
+				}
+			}
+			else {
+				(mem.*fx) = std::forward<Arg>(arg);
+			}
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, object_type& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F, typename R, typename O, typename... FArgs>
+	struct member_function_wrapper {
+		typedef O object_type;
+		typedef lua_bind_traits<F> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, FArgs...> free_args_list;
+		typedef meta::tuple_types<R> returns_list;
+
+		template <F fx, typename... Args>
+		static R invoke(O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fx, typename... Args>
+		static R call(Fx&& fx, O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, O& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(O& mem, Args&&... args) const {
+				return invoke<fx>(mem, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)> : public member_function_wrapper<R (O::*)(Args...), R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const> : public member_function_wrapper<R (O::*)(Args...) const, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile> : public member_function_wrapper<R (O::*)(Args...) const volatile, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) &&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) &&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> { };
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+	// noexcept has become a part of a function's type
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) noexcept> : public member_function_wrapper<R (O::*)(Args...) noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const noexcept> : public member_function_wrapper<R (O::*)(Args...) const noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)& noexcept> : public member_function_wrapper<R (O::*)(Args...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)&& noexcept> : public member_function_wrapper<R (O::*)(Args...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> {
+	};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> { };
+
+#endif // noexcept is part of a function's type
+
+} // namespace sol
+
+// end of sol/wrapper.hpp
+
+#include <memory>
+
+namespace sol { namespace function_detail {
+	template <typename Fx, int start = 1, bool is_yielding = false>
+	int call(lua_State* L) {
+		Fx& fx = stack::get<user<Fx>>(L, upvalue_index(start));
+		int nr = fx(L);
+		if (is_yielding) {
+			return lua_yield(L, nr);
+		}
+		else {
+			return nr;
+		}
+	}
+}} // namespace sol::function_detail
+
+// end of sol/function_types_core.hpp
+
+// beginning of sol/function_types_templated.hpp
+
+// beginning of sol/call.hpp
+
+// beginning of sol/property.hpp
+
+#include <type_traits>
+#include <utility>
+
+namespace sol {
+	namespace detail {
+		struct no_prop { };
+	} // namespace detail
+
+	template <typename R, typename W>
+	struct property_wrapper : detail::ebco<R, 0>, detail::ebco<W, 1> {
+	private:
+		using read_base_t = detail::ebco<R, 0>;
+		using write_base_t = detail::ebco<W, 1>;
+
+	public:
+		template <typename Rx, typename Wx>
+		property_wrapper(Rx&& r, Wx&& w) : read_base_t(std::forward<Rx>(r)), write_base_t(std::forward<Wx>(w)) {
+		}
+
+		W& write() {
+			return write_base_t::value();
+		}
+
+		const W& write() const {
+			return write_base_t::value();
+		}
+
+		R& read() {
+			return read_base_t::value();
+		}
+
+		const R& read() const {
+			return read_base_t::value();
+		}
+	};
+
+	template <typename F, typename G>
+	inline decltype(auto) property(F&& f, G&& g) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		typedef lua_bind_traits<meta::unqualified_t<G>> right_traits;
+		if constexpr (left_traits::free_arity < right_traits::free_arity) {
+			return property_wrapper<std::decay_t<F>, std::decay_t<G>>(std::forward<F>(f), std::forward<G>(g));
+		}
+		else {
+			return property_wrapper<std::decay_t<G>, std::decay_t<F>>(std::forward<G>(g), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) property(F&& f) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		if constexpr (left_traits::free_arity < 2) {
+			return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+		}
+		else {
+			return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) readonly_property(F&& f) {
+		return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+	}
+
+	template <typename F>
+	inline decltype(auto) writeonly_property(F&& f) {
+		return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+	}
+
+	template <typename T>
+	struct readonly_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		operator T&() {
+			return base_t::value();
+		}
+		operator const T&() const {
+			return base_t::value();
+		}
+	};
+
+	// Allow someone to make a member variable readonly (const)
+	template <typename R, typename T>
+	inline auto readonly(R T::*v) {
+		return readonly_wrapper<meta::unqualified_t<decltype(v)>>(v);
+	}
+
+	template <typename T>
+	struct var_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename V>
+	inline auto var(V&& v) {
+		typedef std::decay_t<V> T;
+		return var_wrapper<T>(std::forward<V>(v));
+	}
+
+	namespace meta {
+		template <typename T>
+		using is_member_object = std::integral_constant<bool, std::is_member_object_pointer_v<T> || is_specialization_of_v<T, readonly_wrapper>>;
+
+		template <typename T>
+		inline constexpr bool is_member_object_v = is_member_object<T>::value;
+
+		template <typename T>
+		using is_member_object_or_function = std::integral_constant<bool, is_member_object_v<T> || std::is_member_pointer_v<T>>;
+
+		template <typename T>
+		inline constexpr bool is_member_object_or_function_v = is_member_object_or_function<T>::value;
+	} // namespace meta
+
+} // namespace sol
+
+// end of sol/property.hpp
+
+// beginning of sol/protect.hpp
+
+#include <utility>
+
+namespace sol {
+
+	template <typename T>
+	struct protect_t {
+		T value;
+
+		template <typename Arg, typename... Args, meta::disable<std::is_same<protect_t, meta::unqualified_t<Arg>>> = meta::enabler>
+		protect_t(Arg&& arg, Args&&... args) : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		protect_t(const protect_t&) = default;
+		protect_t(protect_t&&) = default;
+		protect_t& operator=(const protect_t&) = default;
+		protect_t& operator=(protect_t&&) = default;
+	};
+
+	template <typename T>
+	auto protect(T&& value) {
+		return protect_t<std::decay_t<T>>(std::forward<T>(value));
+	}
+
+} // namespace sol
+
+// end of sol/protect.hpp
+
+namespace sol {
+	namespace u_detail {
+
+	} // namespace u_detail
+
+	namespace policy_detail {
+		template <int I, int... In>
+		inline void handle_policy(static_stack_dependencies<I, In...>, lua_State* L, int&) {
+			if constexpr (sizeof...(In) == 0) {
+				(void)L;
+				return;
+			}
+			else {
+				absolute_index ai(L, I);
+				if (type_of(L, ai) != type::userdata) {
+					return;
+				}
+				lua_createtable(L, static_cast<int>(sizeof...(In)), 0);
+				stack_reference deps(L, -1);
+				auto per_dep = [&L, &deps](int i) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushvalue(L, i);
+					luaL_ref(L, deps.stack_index());
+				};
+				(void)per_dep;
+				(void)detail::swallow { int(), (per_dep(In), int())... };
+				lua_setuservalue(L, ai);
+			}
+		}
+
+		template <int... In>
+		inline void handle_policy(returns_self_with<In...>, lua_State* L, int& pushed) {
+			pushed = stack::push(L, raw_index(1));
+			handle_policy(static_stack_dependencies<-1, In...>(), L, pushed);
+		}
+
+		inline void handle_policy(const stack_dependencies& sdeps, lua_State* L, int&) {
+			absolute_index ai(L, sdeps.target);
+			if (type_of(L, ai) != type::userdata) {
+				return;
+			}
+			lua_createtable(L, static_cast<int>(sdeps.size()), 0);
+			stack_reference deps(L, -1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, static_cast<int>(sdeps.size()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			for (std::size_t i = 0; i < sdeps.size(); ++i) {
+				lua_pushvalue(L, sdeps.stack_indices[i]);
+				luaL_ref(L, deps.stack_index());
+			}
+			lua_setuservalue(L, ai);
+		}
+
+		template <typename P, meta::disable<std::is_base_of<detail::policy_base_tag, meta::unqualified_t<P>>> = meta::enabler>
+		inline void handle_policy(P&& p, lua_State* L, int& pushed) {
+			pushed = std::forward<P>(p)(L, pushed);
+		}
+	} // namespace policy_detail
+
+	namespace function_detail {
+		inline int no_construction_error(lua_State* L) {
+			return luaL_error(L, "sol: cannot call this constructor (tagged as non-constructible)");
+		}
+	} // namespace function_detail
+
+	namespace call_detail {
+
+		template <typename R, typename W>
+		inline auto& pick(std::true_type, property_wrapper<R, W>& f) {
+			return f.read();
+		}
+
+		template <typename R, typename W>
+		inline auto& pick(std::false_type, property_wrapper<R, W>& f) {
+			return f.write();
+		}
+
+		template <typename T, typename List>
+		struct void_call : void_call<T, meta::function_args_t<List>> { };
+
+		template <typename T, typename... Args>
+		struct void_call<T, types<Args...>> {
+			static void call(Args...) {
+			}
+		};
+
+		template <typename T, bool checked, bool clean_stack>
+		struct constructor_match {
+			T* obj_;
+			reference* obj_lua_ref_;
+			stack::stack_detail::undefined_metatable* p_umf_;
+
+			constructor_match(T* obj_ptr, reference& obj_lua_ref, stack::stack_detail::undefined_metatable& umf)
+			: obj_(obj_ptr), obj_lua_ref_(&obj_lua_ref), p_umf_(&umf) {
+			}
+
+			template <typename Fx, std::size_t I, typename... R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
+				detail::default_construct func {};
+				int result = stack::call_into_lua<checked, clean_stack>(r, a, L, start, func, this->obj_);
+				// construct userdata table
+				// SPECIFICALLY, after we've created it successfully.
+				// If the constructor exits for any reason we have to break things down...
+				if constexpr (clean_stack) {
+					obj_lua_ref_->push();
+					(*this->p_umf_)();
+					obj_lua_ref_->pop();
+				}
+				else {
+					(*this->p_umf_)();
+				}
+				return result;
+			}
+		};
+
+		namespace overload_detail {
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State* L, int, int, Args&&...) {
+				return luaL_error(L, "sol: no matching function call takes this number of arguments and the specified types");
+			}
+
+			template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L,
+			     int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fxs...>(),
+					     std::index_sequence<In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fxs...>(),
+							     std::index_sequence<In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking {};
+					if (!stack::stack_detail::check_types(args_list(), L, start, &no_panic, tracking)) {
+						return overload_match_arity(types<Fxs...>(),
+						     std::index_sequence<In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<>, std::index_sequence<>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				return overload_match_arity(types<>(),
+				     std::index_sequence<>(),
+				     std::index_sequence<M...>(),
+				     std::forward<Match>(matchfx),
+				     L,
+				     fxarity,
+				     start,
+				     std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, std::size_t I, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<Fx>, std::index_sequence<I>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<>(),
+					     std::index_sequence<>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				if constexpr (!traits::runtime_variadics_t::value) {
+					if (traits::free_arity != fxarity) {
+						return overload_match_arity(types<>(),
+						     std::index_sequence<>(),
+						     std::index_sequence<traits::free_arity, M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+				}
+				return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, typename Fx1, typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match,
+			     typename... Args>
+			inline int overload_match_arity_single(types<Fx, Fx1, Fxs...>, std::index_sequence<I, I1, In...>, std::index_sequence<M...>, Match&& matchfx,
+			     lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fx1, Fxs...>(),
+					     std::index_sequence<I1, In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fx1, Fxs...>(),
+							     std::index_sequence<I1, In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking {};
+					if (!stack::stack_detail::check_types(args_list(), L, start, &no_panic, tracking)) {
+						return overload_match_arity(types<Fx1, Fxs...>(),
+						     std::index_sequence<I1, In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+		} // namespace overload_detail
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			return overload_detail::overload_match_arity_single(types<Functions...>(),
+			     std::make_index_sequence<sizeof...(Functions)>(),
+			     std::index_sequence<>(),
+			     std::forward<Match>(matchfx),
+			     L,
+			     fxarity,
+			     start,
+			     std::forward<Args>(args)...);
+		}
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match(Match&& matchfx, lua_State* L, int start, Args&&... args) {
+			int fxarity = lua_gettop(L) - (start - 1);
+			return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename... TypeLists, typename Match, typename... Args>
+		inline int construct_match(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			// use same overload resolution matching as all other parts of the framework
+			return overload_match_arity<decltype(void_call<T, TypeLists>::call)...>(
+			     std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct_trampolined(lua_State* L) {
+			static const auto& meta = usertype_traits<T>::metatable();
+			int argcount = lua_gettop(L);
+			call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+			argcount -= static_cast<int>(syntax);
+
+			T* obj = detail::usertype_allocate<T>(L);
+			reference userdataref(L, -1);
+			stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+
+			// put userdata at the first index
+			lua_insert(L, 1);
+			construct_match<T, TypeLists...>(constructor_match<T, checked, clean_stack>(obj, userdataref, umf), L, argcount, 1 + static_cast<int>(syntax));
+
+			userdataref.push();
+			return 1;
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct(lua_State* L) {
+			return detail::static_trampoline<&construct_trampolined<T, checked, clean_stack, TypeLists...>>(L);
+		}
+
+		template <typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename = void>
+		struct agnostic_lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& f, Args&&... args) {
+				using uFx = meta::unqualified_t<Fx>;
+				static constexpr bool is_ref = is_lua_reference_v<uFx>;
+				if constexpr (is_ref) {
+					if constexpr (is_index) {
+						return stack::push(L, std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+					else {
+						std::forward<Fx>(f) = stack::unqualified_get<F>(L, boost + (is_variable ? 3 : 1));
+						return 0;
+					}
+				}
+				else {
+					using wrap = wrapper<uFx>;
+					using traits_type = typename wrap::traits_type;
+					using fp_t = typename traits_type::function_pointer_type;
+					constexpr bool is_function_pointer_convertible = std::is_class_v<uFx> && std::is_convertible_v<std::decay_t<Fx>, fp_t>;
+					if constexpr (is_function_pointer_convertible) {
+						fp_t fx = f;
+						return agnostic_lua_call_wrapper<fp_t, is_index, is_variable, checked, boost, clean_stack> {}.call(
+						     L, fx, std::forward<Args>(args)...);
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::free_args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + 1, caller(), std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+				}
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<var_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (is_index) {
+					constexpr bool is_stack = is_stack_based_v<meta::unqualified_t<decltype(detail::unwrap(f.value()))>>;
+					if constexpr (clean_stack && !is_stack) {
+						lua_settop(L, 0);
+					}
+					return stack::push_reference(L, detail::unwrap(f.value()));
+				}
+				else {
+					if constexpr (std::is_const_v<meta::unwrapped_t<T>>) {
+						(void)f;
+						return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+					}
+					else {
+						using R = meta::unwrapped_t<T>;
+						if constexpr (std::is_assignable_v<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>) {
+							detail::unwrap(f.value()) = stack::unqualified_get<meta::unwrapped_t<T>>(L, boost + (is_variable ? 3 : 1));
+							if (clean_stack) {
+								lua_settop(L, 0);
+							}
+							return 0;
+						}
+						else {
+							return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+						}
+					}
+				}
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction_ref, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction_ref f) {
+				return f(L);
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction f) {
+				return f(L);
+			}
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::lua_CFunction_noexcept, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, detail::lua_CFunction_noexcept f) {
+				return f(L);
+			}
+		};
+#endif // noexcept function types
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::no_prop, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const detail::no_prop&) {
+				return luaL_error(L, is_index ? "sol: cannot read from a writeonly property" : "sol: cannot write to a readonly property");
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<no_construction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const no_construction&) {
+				return function_detail::no_construction_error(L);
+			}
+		};
+
+		template <typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<bases<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State*, const bases<Args...>&) {
+				// Uh. How did you even call this, lul
+				return 0;
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<std::reference_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, std::reference_wrapper<T> f) {
+				agnostic_lua_call_wrapper<T, is_index, is_variable, checked, boost, clean_stack> alcw {};
+				return alcw.call(L, f.get());
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked = detail::default_safe_function_calls, int boost = 0,
+		     bool clean_stack = true, typename = void>
+		struct lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& fx, Args&&... args) {
+				if constexpr (std::is_member_function_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (sizeof...(Args) < 1) {
+						using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+						static_assert(std::is_base_of_v<object_type, Ta>,
+						     "It seems like you might have accidentally bound a class type with a member function method that does not correspond to the "
+						     "class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one class \"T\" "
+						     "but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							return luaL_error(L,
+							     "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are "
+							     "preceeded by the "
+							     "actual object with '.' syntax)");
+						}
+						object_type* o = static_cast<object_type*>(maybeo.value());
+						return call(L, std::forward<Fx>(fx), *o);
+#else
+						object_type& o = static_cast<object_type&>(*stack::unqualified_get<non_null<Ta*>>(L, 1));
+						return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), std::forward<Args>(args)...);
+					}
+				}
+				else if constexpr (std::is_member_object_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (is_index) {
+						if constexpr (sizeof...(Args) < 1) {
+							using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+							static_assert(std::is_base_of_v<object_type, Ta>,
+							     "It seems like you might have accidentally bound a class type with a member function method that does not correspond "
+							     "to the class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one "
+							     "class \"T\" but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+							auto maybeo = stack::check_get<Ta*>(L, 1);
+							if (!maybeo || maybeo.value() == nullptr) {
+								if (is_variable) {
+									return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+								}
+								return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+							}
+							object_type* o = static_cast<object_type*>(maybeo.value());
+							return call(L, std::forward<Fx>(fx), *o);
+#else
+							object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+							return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+						}
+						else {
+							using returns_list = typename wrap::returns_list;
+							using caller = typename wrap::caller;
+							return stack::call_into_lua<checked, clean_stack>(returns_list(),
+							     types<>(),
+							     L,
+							     boost + (is_variable ? 3 : 2),
+							     caller(),
+							     std::forward<Fx>(fx),
+							     std::forward<Args>(args)...);
+						}
+					}
+					else {
+						using traits_type = lua_bind_traits<F>;
+						using return_type = typename traits_type::return_type;
+						constexpr bool ret_is_const = std::is_const_v<std::remove_reference_t<return_type>>;
+						if constexpr (ret_is_const) {
+							(void)fx;
+							(void)detail::swallow { 0, (static_cast<void>(args), 0)... };
+							return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+						}
+						else {
+							using u_return_type = meta::unqualified_t<return_type>;
+							constexpr bool is_assignable = std::is_copy_assignable_v<u_return_type> || std::is_array_v<u_return_type>;
+							if constexpr (!is_assignable) {
+								(void)fx;
+								(void)detail::swallow { 0, ((void)args, 0)... };
+								return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+							}
+							else {
+								using args_list = typename wrap::args_list;
+								using caller = typename wrap::caller;
+								if constexpr (sizeof...(Args) > 0) {
+									return stack::call_into_lua<checked, clean_stack>(types<void>(),
+									     args_list(),
+									     L,
+									     boost + (is_variable ? 3 : 2),
+									     caller(),
+									     std::forward<Fx>(fx),
+									     std::forward<Args>(args)...);
+								}
+								else {
+									using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+									auto maybeo = stack::check_get<Ta*>(L, 1);
+									if (!maybeo || maybeo.value() == nullptr) {
+										if (is_variable) {
+											return luaL_error(L, "sol: received nil for 'self' argument (bad '.' access?)");
+										}
+										return luaL_error(L, "sol: received nil for 'self' argument (pass 'self' as first argument)");
+									}
+									object_type* po = static_cast<object_type*>(maybeo.value());
+									object_type& o = *po;
+#else
+									object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+
+									return stack::call_into_lua<checked, clean_stack>(
+									     types<void>(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), o);
+								}
+							}
+						}
+					}
+				}
+				else {
+					agnostic_lua_call_wrapper<F, is_index, is_variable, checked, boost, clean_stack> alcw {};
+					return alcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, readonly_wrapper<F>, is_index, is_variable, checked, boost, clean_stack, C> {
+			using traits_type = lua_bind_traits<F>;
+			using wrap = wrapper<F>;
+			using object_type = typename wrap::object_type;
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, std::move(rw.value()));
+				}
+			}
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, std::move(rw));
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value());
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, rw);
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+		};
+
+		template <typename T, typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_list<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_list<Args...> F;
+
+			static int call(lua_State* L, F&) {
+				const auto& meta = usertype_traits<T>::metatable();
+				int argcount = lua_gettop(L);
+				call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+				argcount -= static_cast<int>(syntax);
+
+				T* obj = detail::usertype_allocate<T>(L);
+				reference userdataref(L, -1);
+				stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+
+				// put userdata at the first index
+				lua_insert(L, 1);
+				// Because of the way constructors work,
+				// we have to kill the data, but only if the cosntructor is successfulyl invoked...
+				// if it's not successfully invoked and we panic,
+				// we cannot actually deallcoate/delete the data.
+				construct_match<T, Args...>(
+				     constructor_match<T, checked, clean_stack>(obj, userdataref, umf), L, argcount, boost + 1 + 1 + static_cast<int>(syntax));
+
+				userdataref.push();
+				return 1;
+			}
+		};
+
+		template <typename T, typename... Cxs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_wrapper<Cxs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_wrapper<Cxs...> F;
+
+			struct onmatch {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start, F& f) {
+					const auto& meta = usertype_traits<T>::metatable();
+					T* obj = detail::usertype_allocate<T>(L);
+					reference userdataref(L, -1);
+					stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+					umf();
+
+					auto& func = std::get<I>(f.functions);
+					// put userdata at the first index
+					lua_insert(L, 1);
+					stack::call_into_lua<checked, clean_stack>(r, a, L, boost + 1 + start, func, detail::implicit_wrapper<T>(obj));
+
+					userdataref.push();
+					return 1;
+				}
+			};
+
+			static int call(lua_State* L, F& f) {
+				call_syntax syntax = stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1);
+				int syntaxval = static_cast<int>(syntax);
+				int argcount = lua_gettop(L) - syntaxval;
+				return construct_match<T, meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(), L, argcount, 1 + syntaxval, f);
+			}
+		};
+
+		template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, clean_stack, C> {
+
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (std::is_void_v<Fx>) {
+					return detail::usertype_alloc_destroy<T>(L);
+				}
+				else {
+					using uFx = meta::unqualified_t<Fx>;
+					lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+					return lcw.call(L, std::forward<F>(f).fx);
+				}
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, overload_set<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef overload_set<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost> {}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L), 1, fx);
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, factory_wrapper<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef factory_wrapper<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost, clean_stack> {}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L) - boost, 1 + boost, fx);
+			}
+		};
+
+		template <typename T, typename R, typename W, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, property_wrapper<R, W>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef meta::conditional_t<is_index, R, W> P;
+			typedef meta::unqualified_t<P> U;
+			typedef wrapper<U> wrap;
+			typedef lua_bind_traits<U> traits_type;
+			typedef meta::unqualified_t<typename traits_type::template arg_at<0>> object_type;
+
+			template <typename F, typename... Args>
+			static int call(lua_State* L, F&& f, Args&&... args) {
+				constexpr bool is_specialized = meta::any<std::is_same<U, detail::no_prop>,
+				     meta::is_specialization_of<U, var_wrapper>,
+				     meta::is_specialization_of<U, constructor_wrapper>,
+				     meta::is_specialization_of<U, constructor_list>,
+				     std::is_member_pointer<U>>::value;
+				if constexpr (is_specialized) {
+					if constexpr (is_index) {
+						decltype(auto) p = f.read();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+					else {
+						decltype(auto) p = f.write();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+				}
+				else {
+					constexpr bool non_class_object_type = meta::any<std::is_void<object_type>,
+					     meta::boolean<lua_type_of<meta::unwrap_unqualified_t<object_type>>::value != type::userdata>>::value;
+					if constexpr (non_class_object_type) {
+						// The type being void means we don't have any arguments, so it might be a free functions?
+						using args_list = typename traits_type::free_args_list;
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+					}
+					else {
+						using args_list = meta::pop_front_type_t<typename traits_type::free_args_list>;
+						using Ta = T;
+						using Oa = std::remove_pointer_t<object_type>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							if (is_variable) {
+								return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+							}
+							return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+						}
+						Oa* o = static_cast<Oa*>(maybeo.value());
+#else
+						Oa* o = static_cast<Oa*>(stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+					}
+				}
+			}
+		};
+
+		template <typename T, typename V, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, protect_t<V>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef protect_t<V> F;
+
+			template <typename... Args>
+			static int call(lua_State* L, F& fx, Args&&... args) {
+				return lua_call_wrapper<T, V, is_index, is_variable, true, boost, clean_stack> {}.call(L, fx.value, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T, typename F, typename... Policies, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, policy_wrapper<F, Policies...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef policy_wrapper<F, Policies...> P;
+
+			template <std::size_t... In>
+			static int call(std::index_sequence<In...>, lua_State* L, P& fx) {
+				int pushed = lua_call_wrapper<T, F, is_index, is_variable, checked, boost, false, C> {}.call(L, fx.value);
+				(void)detail::swallow { int(), (policy_detail::handle_policy(std::get<In>(fx.policies), L, pushed), int())... };
+				return pushed;
+			}
+
+			static int call(lua_State* L, P& fx) {
+				typedef typename P::indices indices;
+				return call(indices(), L, fx);
+			}
+		};
+
+		template <typename T, typename Y, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, yielding_t<Y>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				return lua_call_wrapper<T, meta::unqualified_t<Y>, is_index, is_variable, checked, boost, clean_stack> {}.call(L, f.func);
+			}
+		};
+
+		template <typename T, typename Sig, typename P, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, function_arguments<Sig, P>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const function_arguments<Sig, P>& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(f.arguments));
+			}
+
+			static int call(lua_State* L, function_arguments<Sig, P>& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(f.arguments));
+			}
+
+			static int call(lua_State* L, function_arguments<Sig, P>&& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(std::move(f.arguments)));
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, int boost = 0, bool checked = detail::default_safe_function_calls, bool clean_stack = true,
+		     typename Fx, typename... Args>
+		inline int call_wrapped(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				using real_fx = meta::unqualified_t<decltype(std::forward<Fx>(fx).func)>;
+				lua_call_wrapper<T, real_fx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::forward<Fx>(fx).func, std::forward<Args>(args)...);
+			}
+			else {
+				lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, bool is_index, bool is_variable, typename F, int start = 1, bool checked = detail::default_safe_function_calls,
+		     bool clean_stack = true>
+		inline int call_user(lua_State* L) {
+			auto& fx = stack::unqualified_get<user<F>>(L, upvalue_index(start));
+			using uFx = meta::unqualified_t<F>;
+			int nr = call_wrapped<T, is_index, is_variable, 0, checked, clean_stack>(L, fx);
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <typename T, typename = void>
+		struct is_var_bind : std::false_type { };
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<std::is_member_object_pointer<T>::value>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<is_lua_reference_or_proxy<T>::value>> : std::true_type { };
+
+		template <>
+		struct is_var_bind<detail::no_prop> : std::true_type { };
+
+		template <typename R, typename W>
+		struct is_var_bind<property_wrapper<R, W>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<var_wrapper<T>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<readonly_wrapper<T>> : is_var_bind<meta::unqualified_t<T>> { };
+
+		template <typename F, typename... Policies>
+		struct is_var_bind<policy_wrapper<F, Policies...>> : is_var_bind<meta::unqualified_t<F>> { };
+	} // namespace call_detail
+
+	template <typename T>
+	struct is_variable_binding : call_detail::is_var_bind<meta::unqualified_t<T>> { };
+
+	template <typename T>
+	using is_var_wrapper = meta::is_specialization_of<T, var_wrapper>;
+
+	template <typename T>
+	struct is_function_binding : meta::neg<is_variable_binding<T>> { };
+
+} // namespace sol
+
+// end of sol/call.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename F, F fx>
+		inline int call_wrapper_variable(std::false_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<F>> traits_type;
+			typedef typename traits_type::args_list args_list;
+			typedef meta::tuple_types<typename traits_type::return_type> return_type;
+			return stack::call_into_lua(return_type(), args_list(), L, 1, fx);
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
+			return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
+			(mem.*variable) = stack::get<R>(L, 2);
+			return 0;
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_variable(std::false_type, lua_State* L, T&&) {
+			return luaL_error(L, "cannot write to a const variable");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
+			return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
+		}
+
+		template <typename V, V variable>
+		inline int call_wrapper_variable(std::true_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<V>> traits_type;
+			typedef typename traits_type::object_type T;
+			typedef typename traits_type::return_type R;
+			auto& mem = stack::get<T>(L, 1);
+			switch (lua_gettop(L)) {
+			case 1: {
+				decltype(auto) r = (mem.*variable);
+				stack::push_reference(L, std::forward<decltype(r)>(r));
+				return 1;
+			}
+			case 2:
+				return call_set_variable<R, V, variable>(meta::neg<std::is_const<R>>(), L, mem);
+			default:
+				return luaL_error(L, "incorrect number of arguments to member variable function call");
+			}
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::false_type, lua_State* L) {
+			return call_wrapper_variable<F, fx>(std::is_member_object_pointer<F>(), L);
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::true_type, lua_State* L) {
+			return call_detail::call_wrapped<void, false, false>(L, fx);
+		}
+
+		template <typename F, F fx>
+		int call_wrapper_entry(lua_State* L) noexcept(meta::bind_traits<F>::is_noexcept) {
+			return call_wrapper_function<F, fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(), L);
+		}
+
+		template <typename... Fxs>
+		struct c_call_matcher {
+			template <typename Fx, std::size_t I, typename R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R>, types<Args...>, lua_State* L, int, int) const {
+				typedef meta::at_in_pack_t<I, Fxs...> target;
+				return target::call(L);
+			}
+		};
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::true_type, lua_State* L) {
+			return fx(L);
+		}
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::false_type, lua_State* L) {
+#ifdef __clang__
+			return detail::trampoline(L, function_detail::call_wrapper_entry<F, fx>);
+#else
+			return detail::typed_static_trampoline<decltype(&function_detail::call_wrapper_entry<F, fx>), (&function_detail::call_wrapper_entry<F, fx>)>(L);
+#endif // fuck you clang :c
+		}
+
+	} // namespace function_detail
+
+	template <typename F, F fx>
+	inline int c_call(lua_State* L) {
+		typedef meta::unqualified_t<F> Fu;
+		typedef std::integral_constant<bool,
+		     std::is_same<Fu, lua_CFunction>::value
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		          || std::is_same<Fu, detail::lua_CFunction_noexcept>::value
+#endif
+		     >
+		     is_raw;
+		return function_detail::c_call_raw<F, fx>(is_raw(), L);
+	}
+
+	template <typename F, F f>
+	struct wrap {
+		typedef F type;
+
+		static int call(lua_State* L) noexcept(noexcept(c_call<type, f>(L))) {
+			return c_call<type, f>(L);
+		}
+	};
+
+	template <typename... Fxs>
+	inline int c_call(lua_State* L) {
+		if constexpr (sizeof...(Fxs) < 2) {
+			using target = meta::at_in_pack_t<0, Fxs...>;
+			return target::call(L);
+		}
+		else {
+			return call_detail::overload_match_arity<typename Fxs::type...>(function_detail::c_call_matcher<Fxs...>(), L, lua_gettop(L), 1);
+		}
+	}
+
+} // namespace sol
+
+// end of sol/function_types_templated.hpp
+
+// beginning of sol/function_types_stateless.hpp
+
+namespace sol { namespace function_detail {
+	template <typename Function>
+	struct upvalue_free_function {
+		using function_type = std::remove_pointer_t<std::decay_t<Function>>;
+		using traits_type = meta::bind_traits<function_type>;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
+			function_type* fx = udata.first;
+			return call_detail::call_wrapped<void, true, false>(L, fx);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member function pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			auto& item = *static_cast<T*>(stack::get<void*>(L, upvalue_index(3)));
+			return call_detail::call_wrapped<T, true, false, -1>(L, memfx, item);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			case 1:
+				return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_variable<T, readonly_wrapper<Function>> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			return call_detail::call_wrapped<T, false, false>(L, memfx);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+
+		static int real_call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			case 2:
+				return call_detail::call_wrapped<T, false, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_variable<T, readonly_wrapper<Function>> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			return call(L);
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateless.hpp
+
+// beginning of sol/function_types_stateful.hpp
+
+namespace sol { namespace function_detail {
+	template <typename Func, bool is_yielding, bool no_trampoline>
+	struct functor_function {
+		typedef std::decay_t<meta::unwrap_unqualified_t<Func>> function_type;
+		function_type invocation;
+
+		template <typename... Args>
+		functor_function(function_type f, Args&&... args) noexcept(std::is_nothrow_constructible_v<function_type, function_type, Args...>)
+		: invocation(std::move(f), std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, functor_function& self) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, self.invocation))) {
+			int nr = call_detail::call_wrapped<void, true, false>(L, self.invocation);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, invocation))) {
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding, bool no_trampoline>
+	struct member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef meta::function_return_t<function_type> return_type;
+		typedef meta::function_args_t<function_type> args_lists;
+		using traits_type = meta::bind_traits<function_type>;
+		function_type invocation;
+		T member;
+
+		template <typename... Args>
+		member_function(function_type f, Args&&... args) noexcept(
+			std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
+		: invocation(std::move(f)), member(std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, member_function& self)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr = call_detail::call_wrapped<T, true, false, -1>(L, self.invocation, detail::unwrap(detail::deref(self.member)));
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding, bool no_trampoline>
+	struct member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef typename meta::bind_traits<function_type>::return_type return_type;
+		typedef typename meta::bind_traits<function_type>::args_list args_lists;
+		function_type var;
+		T member;
+		typedef std::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>> M;
+
+		template <typename... Args>
+		member_variable(function_type v, Args&&... args) noexcept(
+			std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
+		: var(std::move(v)), member(std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, member_variable& self) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			{
+				M mem = detail::unwrap(detail::deref(self.member));
+				switch (lua_gettop(L)) {
+				case 0:
+					nr = call_detail::call_wrapped<T, true, false, -1>(L, self.var, mem);
+					break;
+				case 1:
+					nr = call_detail::call_wrapped<T, false, false, -1>(L, self.var, mem);
+					break;
+				default:
+					nr = luaL_error(L, "sol: incorrect number of arguments to member variable function");
+					break;
+				}
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateful.hpp
+
+// beginning of sol/function_types_overloaded.hpp
+
+namespace sol { namespace function_detail {
+	template <int start_skew, typename... Functions>
+	struct overloaded_function {
+		typedef std::tuple<Functions...> overload_list;
+		typedef std::make_index_sequence<sizeof...(Functions)> indices;
+		overload_list overloads;
+
+		overloaded_function(overload_list set) : overloads(std::move(set)) {
+		}
+
+		overloaded_function(Functions... fxs) : overloads(fxs...) {
+		}
+
+		template <typename Fx, std::size_t I, typename... R, typename... Args>
+		static int call(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, overload_list& ol) {
+			auto& func = std::get<I>(ol);
+			int nr = call_detail::call_wrapped<void, true, false, start_skew>(L, func);
+			return nr;
+		}
+
+		struct on_success {
+			template <typename... Args>
+			int operator()(Args&&... args) const {
+				return call(std::forward<Args>(args)...);
+			}
+		};
+
+		int operator()(lua_State* L) {
+			on_success call_obj {};
+			return call_detail::overload_match<Functions...>(call_obj, L, 1 + start_skew, overloads);
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_overloaded.hpp
+
+// beginning of sol/resolve.hpp
+
+namespace sol {
+
+#ifndef __clang__
+	// constexpr is fine for not-clang
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline constexpr auto resolve_i(types<R(Args...)>, F&&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline constexpr void resolve_f(std::false_type, F&&) {
+			static_assert(meta::call_operator_deducible_v<F>, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::call_operator_deducible<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::call_operator_deducible<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline constexpr auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline constexpr auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline constexpr Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline constexpr auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline constexpr Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F, meta::disable<std::is_function<meta::unqualified_t<F>>> = meta::enabler>
+	inline constexpr auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+#else
+
+	// Clang has distinct problems with constexpr arguments,
+	// so don't use the constexpr versions inside of clang.
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline auto resolve_i(types<R(Args...)>, F&&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline void resolve_f(std::false_type, F&&) {
+			static_assert(meta::call_operator_deducible_v<F>, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::call_operator_deducible<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::call_operator_deducible<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F>
+	inline auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+
+#endif
+
+} // namespace sol
+
+// end of sol/resolve.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename T>
+		struct class_indicator {
+			using type = T;
+		};
+
+		struct call_indicator { };
+
+		template <bool yielding>
+		int lua_c_wrapper(lua_State* L) {
+			lua_CFunction cf = lua_tocfunction(L, lua_upvalueindex(2));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <bool yielding>
+		int lua_c_noexcept_wrapper(lua_State* L) noexcept {
+			detail::lua_CFunction_noexcept cf = reinterpret_cast<detail::lua_CFunction_noexcept>(lua_tocfunction(L, lua_upvalueindex(2)));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		struct c_function_invocation { };
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args);
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_set_fx(lua_State* L, Args&&... args) {
+			lua_CFunction freefunc = no_trampoline ? function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>
+			                                       : detail::static_trampoline<function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>>;
+
+			int upvalues = 0;
+			upvalues += stack::push(L, nullptr);
+			upvalues += stack::push<user<Fx>>(L, std::forward<Args>(args)...);
+			stack::push(L, c_closure(freefunc, upvalues));
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename R, typename... A, typename Fx, typename... Args>
+		void select_convertible(types<R(A...)>, lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<meta::unwrap_unqualified_t<Fx>>;
+			using fx_ptr_t = R (*)(A...);
+			constexpr bool is_convertible = std::is_convertible_v<dFx, fx_ptr_t>;
+			if constexpr (is_convertible) {
+				fx_ptr_t fxptr = detail::unwrap(std::forward<Fx>(fx));
+				select<is_yielding, no_trampoline>(L, std::move(fxptr), std::forward<Args>(args)...);
+			}
+			else {
+				using F = function_detail::functor_function<dFx, false, true>;
+				select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_convertible(types<>, lua_State* L, Fx&& fx, Args&&... args) {
+			typedef meta::function_signature_t<meta::unwrap_unqualified_t<Fx>> Sig;
+			select_convertible<is_yielding, no_trampoline>(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_member_variable(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (sizeof...(Args) < 2) {
+				using Tu = typename meta::meta_detail::unqualified_non_alias<Args...>::type;
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+					lua_CFunction freefunc
+					     = &function_detail::upvalue_this_member_variable<typename Tu::type, Fx>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else if constexpr (is_reference) {
+					typedef std::decay_t<Fx> dFx;
+					dFx memfxptr(std::forward<Fx>(fx));
+					auto userptr = detail::ptr(std::forward<Args>(args)...);
+					lua_CFunction freefunc = &function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>,
+					     meta::unqualified_t<Fx>>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, memfxptr);
+					upvalues += stack::push(L, static_cast<void const*>(userptr));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+					using F = function_detail::member_variable<Tu, clean_fx, is_yielding, no_trampoline>;
+					select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+			else {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+				using F = function_detail::member_variable<C, clean_fx, is_yielding, no_trampoline>;
+				select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename T, typename... Args>
+		void select_member_function_with(lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+				(void)obj;
+				using C = typename Tu::type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (is_reference) {
+					auto userptr = detail::ptr(std::forward<T>(obj));
+					lua_CFunction freefunc
+					     = &function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>, dFx>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+					upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using F = function_detail::member_function<Tu, dFx, is_yielding, no_trampoline>;
+					select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
+				}
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_member_function(lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx));
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				select_member_function_with<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (is_lua_reference_v<uFx>) {
+				// TODO: hoist into lambda in this case for yielding???
+				stack::push(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (is_lua_c_function_v<uFx>) {
+				if constexpr (no_trampoline) {
+					if (is_yielding) {
+						int upvalues = 0;
+						upvalues += stack::push(L, nullptr);
+						upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+						if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+							detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<true>;
+							lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
+						}
+						else
+#endif
+						{
+							lua_CFunction cf = &function_detail::lua_c_wrapper<true>;
+							lua_pushcclosure(L, cf, upvalues);
+						}
+					}
+					else {
+						lua_pushcclosure(L, std::forward<Fx>(fx), 0);
+					}
+				}
+				else {
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+					if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+						detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<is_yielding>;
+						lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
+					}
+					else {
+						lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+						lua_pushcclosure(L, cf, upvalues);
+					}
+#else
+					lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+					lua_pushcclosure(L, cf, upvalues);
+#endif
+				}
+			}
+			else if constexpr (std::is_function_v<std::remove_pointer_t<uFx>>) {
+				std::decay_t<Fx> target(std::forward<Fx>(fx), std::forward<Args>(args)...);
+				lua_CFunction freefunc = &function_detail::upvalue_free_function<Fx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, target);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (std::is_member_function_pointer_v<uFx>) {
+				select_member_function<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::is_member_object_v<uFx>) {
+				select_member_variable<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else {
+				select_convertible<is_yielding, no_trampoline>(types<>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+	} // namespace function_detail
+
+	namespace stack {
+		template <typename... Sigs>
+		struct unqualified_pusher<function_sig<Sigs...>> {
+			template <bool is_yielding, typename Arg0, typename... Args>
+			static int push_yielding(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, std::function>) {
+					if constexpr (is_yielding) {
+						return stack::push<meta::unqualified_t<Arg0>>(L, detail::yield_tag, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+					else {
+						return stack::push(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+				}
+				else {
+					function_detail::select<is_yielding, false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename Arg0, typename... Args>
+			static int push(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (std::is_same_v<meta::unqualified_t<Arg0>, detail::yield_tag_t>) {
+					push_yielding<true>(L, std::forward<Args>(args)...);
+				}
+				else if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, yielding_t>) {
+					push_yielding<true>(L, std::forward<Arg0>(arg0).func, std::forward<Args>(args)...);
+				}
+				else {
+					push_yielding<false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+				}
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<yielding_t<T>> {
+			template <typename... Args>
+			static int push(lua_State* L, const yielding_t<T>& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, f.func, std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true, false>(L, f.func, std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename... Args>
+			static int push(lua_State* L, yielding_t<T>&& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, std::move(f.func), std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true, false>(L, std::move(f.func), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+		};
+
+		template <typename T, typename... Args>
+		struct unqualified_pusher<function_arguments<T, Args...>> {
+			template <std::size_t... I, typename FP>
+			static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
+				return stack::push<T>(L, std::get<I>(std::forward<FP>(fp).arguments)...);
+			}
+
+			static int push(lua_State* L, const function_arguments<T, Args...>& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, fp);
+			}
+
+			static int push(lua_State* L, function_arguments<T, Args...>&& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, std::move(fp));
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<std::function<Signature>> {
+			using TargetFunctor = function_detail::functor_function<std::function<Signature>, false, true>;
+
+			static int push(lua_State* L, detail::yield_tag_t, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select_set_fx<true, false, TargetFunctor>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, detail::yield_tag_t, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select_set_fx<true, false, TargetFunctor>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select_set_fx<false, false, TargetFunctor>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select_set_fx<false, false, TargetFunctor>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature, std::enable_if_t<meta::is_member_object_or_function_v<Signature>>> {
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				function_detail::select<false, false>(L, std::forward<Args>(args)...);
+				return 1;
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature,
+		     std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		          ,
+		          meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>>
+#endif // noexcept function types
+		          >::value>> {
+			template <typename F>
+			static int push(lua_State* L, F&& f) {
+				function_detail::select<false, true>(L, std::forward<F>(f));
+				return 1;
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<overload_set<Functions...>> {
+			static int push(lua_State* L, overload_set<Functions...>&& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(set.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const overload_set<Functions...>& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, set.functions);
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<protect_t<T>> {
+			static int push(lua_State* L, protect_t<T>&& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, std::move(pw.value));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const protect_t<T>& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, pw.value);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename G>
+		struct unqualified_pusher<property_wrapper<F, G>> {
+			static int push(lua_State* L, property_wrapper<F, G>&& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, std::move(pw.write()));
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, std::move(pw.read()));
+				}
+				else {
+					return stack::push(L, overload(std::move(pw.read()), std::move(pw.write())));
+				}
+			}
+
+			static int push(lua_State* L, const property_wrapper<F, G>& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, pw.write);
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, pw.read);
+				}
+				else {
+					return stack::push(L, overload(pw.read, pw.write));
+				}
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<var_wrapper<T>> {
+			static int push(lua_State* L, var_wrapper<T>&& vw) {
+				return stack::push(L, std::move(vw.value()));
+			}
+			static int push(lua_State* L, const var_wrapper<T>& vw) {
+				return stack::push(L, vw.value());
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<factory_wrapper<Functions...>> {
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<no_construction> {
+			static int push(lua_State* L, no_construction) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
+				return push(L, c);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, no_construction>> {
+			static int push(lua_State* L, detail::tagged<T, no_construction>) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction, function_detail::call_indicator) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename T, typename... Lists>
+		struct unqualified_pusher<detail::tagged<T, constructor_list<Lists...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, constructor_list<Lists...>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename L0, typename... Lists>
+		struct unqualified_pusher<constructor_list<L0, Lists...>> {
+			typedef constructor_list<L0, Lists...> cl_t;
+			static int push(lua_State* L, cl_t cl) {
+				typedef typename meta::bind_traits<L0>::return_type T;
+				return stack::push<detail::tagged<T, cl_t>>(L, cl);
+			}
+		};
+
+		template <typename T, typename... Fxs>
+		struct unqualified_pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_wrapper<Fxs...>>&& c) {
+				return push(L, std::move(c.value()));
+			}
+
+			static int push(lua_State* L, const detail::tagged<T, const constructor_wrapper<Fxs...>>& c) {
+				return push(L, c.value());
+			}
+
+			static int push(lua_State* L, constructor_wrapper<Fxs...>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const constructor_wrapper<Fxs...>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Fxs>
+		struct unqualified_pusher<constructor_wrapper<F, Fxs...>> {
+			static int push(lua_State* L, const constructor_wrapper<F, Fxs...>& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, c);
+			}
+
+			static int push(lua_State* L, constructor_wrapper<F, Fxs...>&& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, std::move(c));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<void>>> {
+			static int push(lua_State* L, destructor_wrapper<void>) {
+				lua_CFunction cf = detail::usertype_alloc_destroy<T>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename T, typename Fx>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename Fx>
+		struct unqualified_pusher<destructor_wrapper<Fx>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Policies>
+		struct unqualified_pusher<policy_wrapper<F, Policies...>> {
+			using P = policy_wrapper<F, Policies...>;
+
+			static int push(lua_State* L, const P& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, P&& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T, typename F, typename... Policies>
+		struct unqualified_pusher<detail::tagged<T, policy_wrapper<F, Policies...>>> {
+			using P = policy_wrapper<F, Policies...>;
+			using Tagged = detail::tagged<T, P>;
+
+			static int push(lua_State* L, const Tagged& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p.value());
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, Tagged&& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p.value()));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<push_invoke_t<T>> {
+			static int push(lua_State* L, push_invoke_t<T>&& pi) {
+				if constexpr (std::is_invocable_v<std::add_rvalue_reference_t<T>, lua_State*>) {
+					return stack::push(L, std::move(pi.value())(L));
+				}
+				else {
+					return stack::push(L, std::move(pi.value())());
+				}
+			}
+
+			static int push(lua_State* L, const push_invoke_t<T>& pi) {
+				if constexpr (std::is_invocable_v<const T, lua_State*>) {
+					return stack::push(L, pi.value()(L));
+				}
+				else {
+					return stack::push(L, pi.value()());
+				}
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				tracking.use(1);
+				bool success = lua_iscfunction(L, index) == 1;
+				if (success) {
+					// there must be at LEAST 2 upvalues; otherwise, we didn't serialize it.
+					const char* upvalue_name = lua_getupvalue(L, index, 2);
+					lua_pop(L, 1);
+					success = upvalue_name != nullptr;
+				}
+				if (!success) {
+					// expected type, actual type
+					handler(
+					     L, index, type::function, type_of(L, index), "type must be a Lua C Function gotten from a function pointer serialized by sol2");
+				}
+				return success;
+#else
+				(void)L;
+				(void)index;
+				(void)handler;
+				(void)tracking;
+				return false;
+#endif
+			}
+
+			template <typename Function>
+			Function* get_function_pointer(lua_State* L, int index, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				tracking.use(1);
+				auto udata = stack::stack_detail::get_as_upvalues_using_function<Function*>(L, index);
+				Function* fx = udata.first;
+				return fx;
+#else
+				(void)L;
+				(void)index;
+				(void)tracking;
+				static_assert(meta::meta_detail::always_true<Function>::value,
+#if SOL_IS_DEFAULT_OFF(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				     "You are attempting to retrieve a function pointer type. "
+				     "This is inherently unsafe in sol2. In order to do this, you must turn on the "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE configuration macro, as detailed in the documentation. "
+				     "Please be careful!"
+#else
+				     "You are attempting to retrieve a function pointer type. "
+				     "You explicitly turned off the ability to do this by defining "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE or similar to be off. "
+				     "Please reconsider this!"
+#endif
+				);
+				return nullptr;
+#endif
+			}
+		} // namespace stack_detail
+	}      // namespace stack
+} // namespace sol
+
+// end of sol/function_types.hpp
+
+// beginning of sol/dump_handler.hpp
+
+#include <cstdint>
+#include <exception>
+
+namespace sol {
+
+	class dump_error : public error {
+	private:
+		int m_ec;
+
+	public:
+		dump_error(int error_code_) : error("dump returned non-zero error of " + std::to_string(error_code_)), m_ec(error_code_) {
+		}
+
+		int error_code() const {
+			return m_ec;
+		}
+	};
+
+	inline int dump_pass_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		return result_code;
+	}
+
+	inline int dump_panic_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		return luaL_error(L_, "a non-zero error code (%d) was returned by the lua_Writer for the dump function", result_code);
+	}
+
+	inline int dump_throw_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		return dump_panic_on_error(L_, result_code, writer_function, userdata_pointer_, strip);
+#else
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		throw dump_error(result_code);
+#endif // no exceptions stuff
+	}
+
+} // namespace sol
+
+// end of sol/dump_handler.hpp
+
+#include <cstdint>
+
+namespace sol {
+	template <typename ref_t, bool aligned = false>
+	class basic_function : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const {
+			lua_call(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount));
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<std::tuple<Ret...>>::value);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret, meta::enable<meta::neg<std::is_void<Ret>>> = meta::enabler>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<Ret>::value);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, 0);
+		}
+
+		unsafe_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) const {
+			int stacksize = lua_gettop(lua_state());
+			int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			return unsafe_function_result(lua_state(), firstreturn, returncount);
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_function() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_function>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_function(const basic_function&) = default;
+		basic_function& operator=(const basic_function&) = default;
+		basic_function(basic_function&&) = default;
+		basic_function& operator=(basic_function&&) = default;
+		basic_function(const stack_reference& r) : basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(stack_reference&& r) : basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(lua_nil_t n) : base_t(n) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_function>(L, index, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata, bool strip = false) const {
+			return dump(writer, userdata, strip, &dump_throw_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_panic_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		unsafe_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if (!aligned) {
+				base_t::push();
+			}
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), static_cast<std::ptrdiff_t>(pushcount));
+		}
+	};
+} // namespace sol
+
+// end of sol/unsafe_function.hpp
+
+// beginning of sol/protected_function.hpp
+
+// beginning of sol/protected_handler.hpp
+
+#include <cstdint>
+
+namespace sol { namespace detail {
+	inline const char (&default_handler_name())[9] {
+		static const char name[9] = "sol.\xF0\x9F\x94\xA9";
+		return name;
+	}
+
+	template <bool ShouldPush, typename Target = reference>
+	struct protected_handler {
+		lua_State* m_L;
+		const Target& target;
+		int stack_index;
+
+		protected_handler(std::false_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
+			if (ShouldPush) {
+				stack_index = lua_gettop(L_) + 1;
+				target.push(L_);
+			}
+		}
+
+		protected_handler(std::true_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
+			if (ShouldPush) {
+				stack_index = target.stack_index();
+			}
+		}
+
+		protected_handler(lua_State* L_, const Target& target_) : protected_handler(meta::boolean<is_stack_based_v<Target>>(), L_, target_) {
+		}
+
+		bool valid() const noexcept {
+			return ShouldPush;
+		}
+
+		~protected_handler() {
+			if constexpr (!is_stack_based_v<Target>) {
+				if (stack_index != 0) {
+					lua_remove(m_L, stack_index);
+				}
+			}
+		}
+	};
+
+	template <typename Base, typename T>
+	inline basic_function<Base> force_cast(T& p) {
+		return p;
+	}
+
+	template <typename Reference, bool IsMainReference = false>
+	inline Reference get_default_handler(lua_State* L_) {
+		if (is_stack_based_v<Reference> || L_ == nullptr)
+			return Reference(L_, lua_nil);
+		L_ = IsMainReference ? main_thread(L_, L_) : L_;
+		lua_getglobal(L_, default_handler_name());
+		auto pp = stack::pop_n(L_, 1);
+		return Reference(L_, -1);
+	}
+
+	template <typename T>
+	inline void set_default_handler(lua_State* L, const T& ref) {
+		if (L == nullptr) {
+			return;
+		}
+		if (!ref.valid()) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushnil(L);
+			lua_setglobal(L, default_handler_name());
+		}
+		else {
+			ref.push(L);
+			lua_setglobal(L, default_handler_name());
+		}
+	}
+}} // namespace sol::detail
+
+// end of sol/protected_handler.hpp
+
+#include <cstdint>
+#include <algorithm>
+
+namespace sol {
+
+	namespace detail {
+		template <bool ShouldPush_, typename Handler_>
+		inline void handle_protected_exception(
+		     lua_State* L_, optional<const std::exception&> maybe_ex, const char* error, detail::protected_handler<ShouldPush_, Handler_>& handler_) {
+			handler_.stack_index = 0;
+			if (ShouldPush_) {
+				handler_.target.push(L_);
+				detail::call_exception_handler(L_, maybe_ex, error);
+				lua_call(L_, 1, 1);
+			}
+			else {
+				detail::call_exception_handler(L_, maybe_ex, error);
+			}
+		}
+	} // namespace detail
+
+	template <typename Reference, bool Aligned = false, typename Handler = reference>
+	class basic_protected_function : public basic_object<Reference> {
+	private:
+		using base_t = basic_object<Reference>;
+		using handler_t = Handler;
+		inline static constexpr bool is_stack_handler_v = is_stack_based_v<handler_t>;
+
+		basic_protected_function(std::true_type, const basic_protected_function& other_) noexcept
+		: base_t(other_), m_error_handler(other_.m_error_handler.copy(lua_state())) {
+		}
+
+		basic_protected_function(std::false_type, const basic_protected_function& other_) noexcept : base_t(other_), m_error_handler(other_.m_error_handler) {
+		}
+
+	public:
+		basic_protected_function() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_protected_function>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(T&& r) noexcept : base_t(std::forward<T>(r)), m_error_handler(get_default_handler(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_protected_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_protected_function(const basic_protected_function& other_) noexcept
+		: basic_protected_function(meta::boolean<is_stateless_lua_reference_v<Handler>>(), other_) {
+		}
+		basic_protected_function& operator=(const basic_protected_function& other_) {
+			base_t::operator=(other_);
+			if constexpr (is_stateless_lua_reference_v<Handler>) {
+				m_error_handler.copy_assign(lua_state(), other_.m_error_handler);
+			}
+			else {
+				m_error_handler = other_.m_error_handler;
+			}
+			return *this;
+		}
+		basic_protected_function(basic_protected_function&&) = default;
+		basic_protected_function& operator=(basic_protected_function&&) = default;
+		basic_protected_function(const basic_function<base_t>& b) : basic_protected_function(b, get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(basic_function<base_t>&& b) : basic_protected_function(std::move(b), get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(const basic_function<base_t>& b, handler_t eh) : base_t(b), m_error_handler(std::move(eh)) {
+		}
+		basic_protected_function(basic_function<base_t>&& b, handler_t eh) : base_t(std::move(b)), m_error_handler(std::move(eh)) {
+		}
+		basic_protected_function(const stack_reference& r) : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(stack_reference&& r) : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(const stack_reference& r, handler_t eh) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_protected_function(stack_reference&& r, handler_t eh) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_protected_function(const proxy_base<Super>& p) : basic_protected_function(p, get_default_handler(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_protected_function(proxy_base<Super>&& p) : basic_protected_function(std::move(p), get_default_handler(p.lua_state())) {
+		}
+		template <typename Proxy, typename HandlerReference,
+		     meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
+		          meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
+		basic_protected_function(Proxy&& p, HandlerReference&& eh)
+		: basic_protected_function(detail::force_cast<base_t>(p), make_reference<handler_t>(p.lua_state(), std::forward<HandlerReference>(eh))) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L_, T&& r) : basic_protected_function(L_, std::forward<T>(r), get_default_handler(L_)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L_, T&& r, handler_t eh) : base_t(L_, std::forward<T>(r)), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		basic_protected_function(lua_nil_t n) : base_t(n), m_error_handler(n) {
+		}
+
+		basic_protected_function(lua_State* L_, int index_ = -1) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, int index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, absolute_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, absolute_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, raw_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, raw_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, ref_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, ref_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		using base_t::lua_state;
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata_pointer_, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata_pointer_, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata_pointer_, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata_pointer_, bool strip = false) const {
+			return dump(writer, userdata_pointer_, strip, &dump_pass_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_throw_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if constexpr (!Aligned) {
+				// we do not expect the function to already be on the stack: push it
+				if (m_error_handler.valid(lua_state())) {
+					detail::protected_handler<true, handler_t> h(lua_state(), m_error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(lua_state(), m_error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+			else {
+				// the function is already on the stack at the right location
+				if (m_error_handler.valid()) {
+					// the handler will be pushed onto the stack manually,
+					// since it's not already on the stack this means we need to push our own
+					// function on the stack too and swap things to be in-place
+					if constexpr (!is_stack_handler_v) {
+						// so, we need to remove the function at the top and then dump the handler out ourselves
+						base_t::push();
+					}
+					detail::protected_handler<true, handler_t> h(lua_state(), m_error_handler);
+					if constexpr (!is_stack_handler_v) {
+						lua_replace(lua_state(), -3);
+						h.stack_index = lua_absindex(lua_state(), -2);
+					}
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(lua_state(), m_error_handler);
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+		}
+
+		~basic_protected_function() {
+			if constexpr (is_stateless_lua_reference_v<handler_t>) {
+				this->m_error_handler.reset(lua_state());
+			}
+		}
+
+		static handler_t get_default_handler(lua_State* L_) {
+			return detail::get_default_handler<handler_t, is_main_threaded_v<base_t>>(L_);
+		}
+
+		template <typename T>
+		static void set_default_handler(const T& ref) {
+			detail::set_default_handler(ref.lua_state(), ref);
+		}
+
+		auto get_error_handler() const noexcept {
+			if constexpr (is_stateless_lua_reference_v<handler_t>) {
+				if constexpr (is_stack_based_v<handler_t>) {
+					return stack_reference(lua_state(), m_error_handler.stack_index());
+				}
+				else {
+					return basic_reference<is_main_threaded_v<base_t>>(lua_state(), ref_index(m_error_handler.registry_index()));
+				}
+			}
+			else {
+				return m_error_handler;
+			}
+		}
+
+		template <typename ErrorHandler_>
+		void set_error_handler(ErrorHandler_&& error_handler_) noexcept {
+			static_assert(!is_stack_based_v<handler_t> || is_stack_based_v<ErrorHandler_>,
+			     "A stack-based error handler can only be set from a parameter that is also stack-based.");
+			if constexpr (std::is_rvalue_reference_v<ErrorHandler_>) {
+				m_error_handler = std::forward<ErrorHandler_>(error_handler_);
+			}
+			else {
+				m_error_handler.copy_assign(lua_state(), std::forward<ErrorHandler_>(error_handler_));
+			}
+		}
+
+		void abandon () noexcept {
+			this->m_error_handler.abandon();
+			base_t::abandon();
+		}
+
+	private:
+		handler_t m_error_handler;
+
+		template <bool b>
+		call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t result_count_, detail::protected_handler<b, handler_t>& h) const {
+			return static_cast<call_status>(lua_pcall(lua_state(), static_cast<int>(argcount), static_cast<int>(result_count_), h.stack_index));
+		}
+
+		template <std::size_t... I, bool b, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, sizeof...(Ret), h);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, bool b, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 1, h);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I, bool b>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 0, h);
+		}
+
+		template <bool b>
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			int stacksize = lua_gettop(lua_state());
+			int poststacksize = stacksize;
+			int firstreturn = 1;
+			int returncount = 0;
+			call_status code = call_status::ok;
+#if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+			try {
+#endif // No Exceptions
+				firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler_v)));
+				code = luacall(n, LUA_MULTRET, h);
+				poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler_v);
+				returncount = poststacksize - (firstreturn - 1);
+#if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+			}
+			// Handle C++ errors thrown from C++ functions bound inside of lua
+			catch (const char* error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::string& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error.c_str(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::exception& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(error), error.what(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), detail::protected_function_error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#endif // Always catch edge case
+#else
+			// do not handle exceptions: they can be propogated into C++ and keep all type information / rich information
+#endif // Exceptions vs. No Exceptions
+			return protected_function_result(lua_state(), firstreturn, returncount, returncount, code);
+		}
+	};
+} // namespace sol
+
+// end of sol/protected_function.hpp
+
+#include <functional>
+
+namespace sol {
+	template <typename... Ret, typename... Args>
+	decltype(auto) stack_proxy::call(Args&&... args) {
+		stack_function sf(this->lua_state(), this->stack_index());
+		return sf.template call<Ret...>(std::forward<Args>(args)...);
+	}
+
+	inline protected_function_result::protected_function_result(unsafe_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()), popcount(o.return_count()), err(o.status()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+
+	inline protected_function_result& protected_function_result::operator=(unsafe_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		popcount = o.return_count();
+		err = o.status();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	inline unsafe_function_result::unsafe_function_result(protected_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+	inline unsafe_function_result& unsafe_function_result::operator=(protected_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	namespace detail {
+		template <typename... R>
+		struct std_shim {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			meta::return_type_t<R...> operator()(Args&&... args) {
+				return lua_func_.call<R...>(std::forward<Args>(args)...);
+			}
+		};
+
+		template <>
+		struct std_shim<void> {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			void operator()(Args&&... args) {
+				lua_func_.call<void>(std::forward<Args>(args)...);
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+		template <typename Signature>
+		struct unqualified_getter<std::function<Signature>> {
+			typedef meta::bind_traits<Signature> fx_t;
+			typedef typename fx_t::args_list args_lists;
+			typedef meta::tuple_types<typename fx_t::return_type> return_types;
+
+			template <typename... R>
+			static std::function<Signature> get_std_func(types<R...>, lua_State* L, int index) {
+				detail::std_shim<R...> fx(unsafe_function(L, index));
+				return fx;
+			}
+
+			static std::function<Signature> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t == type::none || t == type::lua_nil) {
+					return nullptr;
+				}
+				return get_std_func(return_types(), L, index);
+			}
+		};
+
+		template <typename Allocator>
+		struct unqualified_getter<basic_bytecode<Allocator>> {
+			static basic_bytecode<Allocator> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				stack_function sf(L, index);
+				return sf.dump(&dump_panic_on_error);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/function.hpp
+
+// beginning of sol/usertype.hpp
+
+// beginning of sol/usertype_core.hpp
+
+// beginning of sol/deprecate.hpp
+
+#ifndef SOL_DEPRECATED
+#ifdef _MSC_VER
+#define SOL_DEPRECATED __declspec(deprecated)
+#elif __GNUC__
+#define SOL_DEPRECATED __attribute__((deprecated))
+#else
+#define SOL_DEPRECATED [[deprecated]]
+#endif // compilers
+#endif // SOL_DEPRECATED
+
+namespace sol { namespace detail {
+	template <typename T>
+	struct SOL_DEPRECATED deprecate_type {
+		using type = T;
+	};
+}} // namespace sol::detail
+
+// end of sol/deprecate.hpp
+
+// beginning of sol/usertype_container_launch.hpp
+
+// beginning of sol/usertype_container.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_container;
+
+	namespace container_detail {
+
+		template <typename T>
+		struct has_clear_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::clear));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_empty_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::empty));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_after_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(
+			     decltype(std::declval<C>().erase_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T, typename = void>
+		struct has_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_find_test<T, std::enable_if_t<meta::is_lookup<T>::value>> {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::key_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::iterator>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_key_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::key_type>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::find));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_of_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_of));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_insert_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::insert));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::erase));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_at_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::at));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_pairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::pairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_ipairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::ipairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_next_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::next));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_add_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::add));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_size_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::size));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		using has_clear = meta::boolean<has_clear_test<T>::value>;
+
+		template <typename T>
+		using has_empty = meta::boolean<has_empty_test<T>::value>;
+
+		template <typename T>
+		using has_find = meta::boolean<has_find_test<T>::value>;
+
+		template <typename T>
+		using has_erase = meta::boolean<has_erase_test<T>::value>;
+
+		template <typename T>
+		using has_erase_key = meta::boolean<has_erase_key_test<T>::value>;
+
+		template <typename T>
+		using has_erase_after = meta::boolean<has_erase_after_test<T>::value>;
+
+		template <typename T>
+		using has_traits_get = meta::boolean<has_traits_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_at = meta::boolean<has_traits_at_test<T>::value>;
+
+		template <typename T>
+		using has_traits_set = meta::boolean<has_traits_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_get = meta::boolean<has_traits_index_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_set = meta::boolean<has_traits_index_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_pairs = meta::boolean<has_traits_pairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_ipairs = meta::boolean<has_traits_ipairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_next = meta::boolean<has_traits_next_test<T>::value>;
+
+		template <typename T>
+		using has_traits_add = meta::boolean<has_traits_add_test<T>::value>;
+
+		template <typename T>
+		using has_traits_size = meta::boolean<has_traits_size_test<T>::value>;
+
+		template <typename T>
+		using has_traits_clear = has_clear<T>;
+
+		template <typename T>
+		using has_traits_empty = has_empty<T>;
+
+		template <typename T>
+		using has_traits_find = meta::boolean<has_traits_find_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_of = meta::boolean<has_traits_index_of_test<T>::value>;
+
+		template <typename T>
+		using has_traits_insert = meta::boolean<has_traits_insert_test<T>::value>;
+
+		template <typename T>
+		using has_traits_erase = meta::boolean<has_traits_erase_test<T>::value>;
+
+		template <typename T>
+		struct is_forced_container : is_container<T> { };
+
+		template <typename T>
+		struct is_forced_container<as_container_t<T>> : std::true_type { };
+
+		template <typename T>
+		struct container_decay {
+			typedef T type;
+		};
+
+		template <typename T>
+		struct container_decay<as_container_t<T>> {
+			typedef T type;
+		};
+
+		template <typename T>
+		using container_decay_t = typename container_decay<meta::unqualified_t<T>>::type;
+
+		template <typename T>
+		decltype(auto) get_key(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_key(std::true_type, T&& t) {
+			return t.first;
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::true_type, T&& t) {
+			return t.second;
+		}
+
+		template <typename X, typename = void>
+		struct usertype_container_default {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+
+		public:
+			typedef lua_nil_t iterator;
+			typedef lua_nil_t value_type;
+
+			static int at(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'at(index)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int get(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'get(key)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_get(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'container[key]' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int set(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'set(key, value)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_set(lua_State* L_) {
+				return luaL_error(
+				     L_, "sol: cannot call 'container[key] = value' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'add' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'insert' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int find(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'find' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_of(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'index_of' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int size(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int clear(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'clear' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int empty(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'empty' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'erase' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int next(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'next' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int pairs(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call '__pairs/pairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int ipairs(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call '__ipairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static iterator begin(lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call 'being' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+
+			static iterator end(lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X,
+		     std::enable_if_t<meta::all<is_forced_container<meta::unqualified_t<X>>, meta::has_value_type<meta::unqualified_t<container_decay_t<X>>>,
+		          meta::has_iterator<meta::unqualified_t<container_decay_t<X>>>>::value>> {
+		private:
+			using T = std::remove_pointer_t<meta::unwrap_unqualified_t<container_decay_t<X>>>;
+
+		private:
+			using deferred_uc = usertype_container<X>;
+			using is_associative = meta::is_associative<T>;
+			using is_lookup = meta::is_lookup<T>;
+			using is_ordered = meta::is_ordered<T>;
+			using is_matched_lookup = meta::is_matched_lookup<T>;
+			using iterator = typename T::iterator;
+			using value_type = typename T::value_type;
+			typedef meta::conditional_t<is_matched_lookup::value, std::pair<value_type, value_type>,
+			     meta::conditional_t<is_associative::value || is_lookup::value, value_type, std::pair<std::ptrdiff_t, value_type>>>
+			     KV;
+			typedef typename KV::first_type K;
+			typedef typename KV::second_type V;
+			typedef meta::conditional_t<is_matched_lookup::value, std::ptrdiff_t, K> next_K;
+			typedef decltype(*std::declval<iterator&>()) iterator_return;
+			typedef meta::conditional_t<is_associative::value || is_matched_lookup::value, std::add_lvalue_reference_t<V>,
+			     meta::conditional_t<is_lookup::value, V, iterator_return>>
+			     captured_type;
+			typedef typename meta::iterator_tag<iterator>::type iterator_category;
+			typedef std::is_same<iterator_category, std::input_iterator_tag> is_input_iterator;
+			typedef meta::conditional_t<is_input_iterator::value, V, decltype(detail::deref_move_only(std::declval<captured_type>()))> push_type;
+			typedef std::is_copy_assignable<V> is_copyable;
+			typedef meta::neg<meta::any<std::is_const<V>, std::is_const<std::remove_reference_t<iterator_return>>, meta::neg<is_copyable>>> is_writable;
+			typedef meta::unqualified_t<decltype(get_key(is_associative(), std::declval<std::add_lvalue_reference_t<value_type>>()))> key_type;
+			typedef meta::all<std::is_integral<K>, meta::neg<meta::any<is_associative, is_lookup>>> is_linear_integral;
+
+			struct iter {
+				reference keep_alive;
+				T& source;
+				iterator it;
+				std::size_t index;
+
+				iter(lua_State* L_, int stack_index, T& source_, iterator it_) : keep_alive(sol::main_thread(L_, L_), stack_index), source(source_), it(std::move(it_)), index(0) {
+				}
+
+				~iter() {
+				}
+			};
+
+			static auto& get_src(lua_State* L_) {
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+				auto p = stack::unqualified_check_get<T*>(L_, 1);
+				if (!p) {
+					luaL_error(L_,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L_, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+				return *p.value();
+#else
+				return stack::unqualified_get<T>(L_, 1);
+#endif // Safe getting with error
+			}
+
+			static detail::error_result at_category(std::input_iterator_tag, lua_State* L_, T& self, std::ptrdiff_t pos) {
+				pos += deferred_uc::index_adjustment(L_, self);
+				if (pos < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				while (pos > 0) {
+					--pos;
+					++it;
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result at_category(std::random_access_iterator_tag, lua_State* L_, T& self, std::ptrdiff_t pos) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				pos += deferred_uc::index_adjustment(L_, self);
+				if (pos < 0 || pos >= len) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), pos);
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result at_start(lua_State* L_, T& self, std::ptrdiff_t pos) {
+				return at_category(iterator_category(), L_, self, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::true_type, lua_State* L_, Iter& it) {
+				decltype(auto) v = *it;
+				return stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(v.second));
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::false_type, lua_State* L_, Iter& it) {
+				return stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(*it));
+			}
+
+			static detail::error_result get_category(std::input_iterator_tag, lua_State* L_, T& self, K& key) {
+				key = static_cast<K>(key + deferred_uc::index_adjustment(L_, self));
+				if (key < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				while (key > 0) {
+					--key;
+					++it;
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_category(std::random_access_iterator_tag, lua_State* L_, T& self, K& key) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				if (key < 0 || key >= len) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), key);
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_it(std::true_type, lua_State* L_, T& self, K& key) {
+				return get_category(iterator_category(), L_, self, key);
+			}
+
+			static detail::error_result get_comparative(std::true_type, lua_State* L_, T& self, K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_comparative(std::false_type, lua_State*, T&, K&) {
+				return detail::error_result("cannot get this key on '%s': no suitable way to increment iterator and compare to key value '%s'",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			static detail::error_result get_it(std::false_type, lua_State* L_, T& self, K& key) {
+				return get_comparative(meta::supports_op_equal<K, key_type>(), L_, self, key);
+			}
+
+			static detail::error_result set_associative(std::true_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v.second = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_associative(std::false_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_writable(std::true_type, lua_State*, T&, iterator& it, stack_object value) {
+				return set_associative(is_associative(), it, std::move(value));
+			}
+
+			static detail::error_result set_writable(std::false_type, lua_State*, T&, iterator&, stack_object) {
+				return detail::error_result(
+				     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+			}
+
+			static detail::error_result set_category(std::input_iterator_tag, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				auto e = deferred_uc::end(L_, self);
+				auto it = deferred_uc::begin(L_, self);
+				auto backit = it;
+				for (; key > 0 && it != e; --key, ++it) {
+					backit = it;
+				}
+				if (it == e) {
+					if (key == 0) {
+						return add_copyable(is_copyable(), L_, self, std::move(value), meta::has_insert_after<T>::value ? backit : it);
+					}
+					return detail::error_result("out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_category(std::random_access_iterator_tag, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				if (key < 0) {
+					return detail::error_result("sol: out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				if (key == len) {
+					return add_copyable(is_copyable(), L_, self, std::move(value));
+				}
+				else if (key >= len) {
+					return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), key);
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::true_type, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				if (!is_writable::value) {
+					return detail::error_result(
+					     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+				}
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot set this value on '%s': no suitable way to increment iterator or compare to '%s' key",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::true_type, lua_State*, T& self, Iter& it, K& key, stack_object value) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(it, value_type(key, value.as<V>()));
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(value_type(key, value.as<V>()));
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::false_type, lua_State*, T& self, Iter& it, K& key, stack_object) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(it, key);
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(key);
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this non-associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result set_associative_find(std::true_type, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L_, self)) {
+					return set_associative_insert(is_associative(), L_, self, it, key, std::move(value));
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_associative_find(std::false_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_comparative(meta::supports_op_equal<K, key_type>(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_category(iterator_category(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::false_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_associative_find(meta::all<has_find<T>, meta::any<is_associative, is_lookup>>(), L_, self, std::move(key), std::move(value));
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::true_type, lua_State* L_, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L_;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) key = stack::unqualified_get<K>(L_, 2);
+					auto it = self.find(key);
+					if (it == deferred_uc::end(L_, self)) {
+						return stack::push(L_, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L_, self), it);
+						dist -= deferred_uc::index_adjustment(L_, self);
+						return stack::push(L_, dist);
+					}
+					else {
+						return get_associative(is_associative(), L_, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::false_type, lua_State* L_, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L_;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) value = stack::unqualified_get<V>(L_, 2);
+					auto it = self.find(value);
+					if (it == deferred_uc::end(L_, self)) {
+						return stack::push(L_, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L_, self), it);
+						dist -= deferred_uc::index_adjustment(L_, self);
+						return stack::push(L_, dist);
+					}
+					else {
+						return get_associative(is_associative(), L_, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::true_type, lua_State* L_, T& self) {
+				return find_has_associative_lookup<idx_of>(meta::any<is_lookup, is_associative>(), L_, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::true_type, lua_State* L_, T&, Iter& it, std::size_t) {
+				return get_associative(is_associative(), L_, it);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::false_type, lua_State* L_, T& self, Iter&, std::size_t idx) {
+				idx = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(idx) - deferred_uc::index_adjustment(L_, self));
+				return stack::push(L_, idx);
+			}
+
+			template <bool = false>
+			static detail::error_result find_comparative(std::false_type, lua_State*, T&) {
+				return detail::error_result("cannot call 'find' on '%s': there is no 'find' function and the value_type is not equality comparable",
+				     detail::demangle<T>().c_str());
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_comparative(std::true_type, lua_State* L_, T& self) {
+				decltype(auto) value = stack::unqualified_get<V>(L_, 2);
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				std::size_t idx = 0;
+				for (;; ++it, ++idx) {
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+					if (value == get_value(is_associative(), *it)) {
+						break;
+					}
+				}
+				return find_associative_lookup(meta::all<meta::boolean<!idx_of>, meta::any<is_lookup, is_associative>>(), L_, self, it, idx);
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::false_type, lua_State* L_, T& self) {
+				return find_comparative<idx_of>(meta::supports_op_equal<V>(), L_, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::false_type, lua_State* L_, T& self, stack_object value, Iter&) {
+				return add_insert_after(std::false_type(), L_, self, value);
+			}
+
+			static detail::error_result add_insert_after(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on type '%s': no suitable insert/push_back C++ functions", detail::demangle<T>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert_after(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert_after(std::true_type, lua_State* L_, T& self, stack_object value) {
+				auto backit = self.before_begin();
+				{
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); it != e; ++backit, ++it) { }
+				}
+				return add_insert_after(std::true_type(), L_, self, value, backit);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert(std::true_type, lua_State* L_, T& self, stack_object value) {
+				auto pos = deferred_uc::end(L_, self);
+				return add_insert(std::true_type(), L_, self, value, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_insert_after(meta::has_insert_after<T>(), L_, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_insert(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_insert_after(meta::has_insert_after<T>(), L_, self, std::move(value));
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value, Iter&) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_insert(
+				     std::integral_constant < bool, meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (), L_, self, value, pos);
+			}
+
+			static detail::error_result add_push_back(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_insert(
+				     std::integral_constant < bool, meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::true_type, lua_State* L_, T& self, stack_object key, Iter& pos) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(pos, value_type(key.as<K>(), stack::unqualified_get<V>(L_, 3)));
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(value_type(key.as<K>(), stack::unqualified_get<V>(L_, 3)));
+					return {};
+				}
+				else {
+					(void)L_;
+					(void)self;
+					(void)key;
+					(void)pos;
+					return detail::error_result(
+					     "cannot call 'insert' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result add_associative(std::true_type, lua_State* L_, T& self, stack_object key) {
+				auto pos = deferred_uc::end(L_, self);
+				return add_associative(std::true_type(), L_, self, std::move(key), pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_push_back(meta::has_push_back<T>(), L_, self, value, pos);
+			}
+
+			static detail::error_result add_associative(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_push_back(meta::has_push_back<T>(), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::true_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_associative(is_associative(), L_, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_copyable(std::true_type, lua_State* L_, T& self, stack_object value) {
+				return add_associative(is_associative(), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::false_type, lua_State* L_, T& self, stack_object value, Iter&) {
+				return add_copyable(std::false_type(), L_, self, std::move(value));
+			}
+
+			static detail::error_result add_copyable(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_lookup(std::true_type, lua_State* L_, T& self, stack_object, stack_object value) {
+				// TODO: should we warn or error about someone calling insert on an ordered / lookup container with no associativity?
+				return add_copyable(std::true_type(), L_, self, std::move(value));
+			}
+
+			static detail::error_result insert_lookup(std::false_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				auto it = deferred_uc::begin(L_, self);
+				auto key = where.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				std::advance(it, key);
+				self.insert(it, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::true_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				auto key = where.as<K>();
+				auto backit = self.before_begin();
+				{
+					key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.insert_after(backit, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result(
+				     "cannot call 'insert' on '%s': no suitable or similar functionality detected on this container", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_has(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return insert_lookup(meta::any<is_associative, is_lookup>(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result insert_has(std::false_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				return insert_after_has(meta::has_insert_after<T>(), L_, self, where, value);
+			}
+
+			static detail::error_result insert_copyable(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return insert_has(std::integral_constant < bool,
+				     meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (),
+				     L_,
+				     self,
+				     std::move(key),
+				     std::move(value));
+			}
+
+			static detail::error_result insert_copyable(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot call 'insert' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result erase_integral(std::true_type, lua_State* L_, T& self, K& key) {
+				auto it = deferred_uc::begin(L_, self);
+				key = (static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				std::advance(it, key);
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_integral(std::false_type, lua_State* L_, T& self, const K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == r; };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::true_type, lua_State*, T& self, const K& key) {
+				self.erase(key);
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_integral(std::is_integral<K>(), L_, self, key);
+			}
+
+			static detail::error_result erase_after_has(std::true_type, lua_State* L_, T& self, K& key) {
+				auto backit = self.before_begin();
+				{
+					key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds for erase on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.erase_after(backit);
+				return {};
+			}
+
+			static detail::error_result erase_after_has(std::false_type, lua_State*, T&, const K&) {
+				return detail::error_result("sol: cannot call erase on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static detail::error_result erase_key_has(std::true_type, lua_State* L_, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L_, self, key);
+			}
+
+			static detail::error_result erase_key_has(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_after_has(has_erase_after<T>(), L_, self, key);
+			}
+
+			static detail::error_result erase_has(std::true_type, lua_State* L_, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L_, self, key);
+			}
+
+			static detail::error_result erase_has(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_key_has(has_erase_key<T>(), L_, self, key);
+			}
+
+			static auto size_has(std::false_type, lua_State* L_, T& self) {
+				return std::distance(deferred_uc::begin(L_, self), deferred_uc::end(L_, self));
+			}
+
+			static auto size_has(std::true_type, lua_State*, T& self) {
+				return self.size();
+			}
+
+			static void clear_has(std::true_type, lua_State*, T& self) {
+				self.clear();
+			}
+
+			static void clear_has(std::false_type, lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call clear on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static bool empty_has(std::true_type, lua_State*, T& self) {
+				return self.empty();
+			}
+
+			static bool empty_has(std::false_type, lua_State* L_, T& self) {
+				return deferred_uc::begin(L_, self) == deferred_uc::end(L_, self);
+			}
+
+			static detail::error_result get_associative_find(std::true_type, lua_State* L_, T& self, K& key) {
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L_, self)) {
+					stack::push(L_, lua_nil);
+					return {};
+				}
+				return get_associative(std::true_type(), L_, it);
+			}
+
+			static detail::error_result get_associative_find(std::false_type, lua_State* L_, T& self, K& key) {
+				return get_it(is_linear_integral(), L_, self, key);
+			}
+
+			static detail::error_result get_start(lua_State* L_, T& self, K& key) {
+				return get_associative_find(std::integral_constant < bool, is_associative::value&& has_find<T>::value > (), L_, self, key);
+			}
+
+			static detail::error_result set_start(lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_it(is_linear_integral(), L_, self, std::move(key), std::move(value));
+			}
+
+			static std::size_t size_start(lua_State* L_, T& self) {
+				return static_cast<std::size_t>(size_has(meta::has_size<T>(), L_, self));
+			}
+
+			static void clear_start(lua_State* L_, T& self) {
+				clear_has(has_clear<T>(), L_, self);
+			}
+
+			static bool empty_start(lua_State* L_, T& self) {
+				return empty_has(has_empty<T>(), L_, self);
+			}
+
+			static detail::error_result erase_start(lua_State* L_, T& self, K& key) {
+				return erase_has(has_erase<T>(), L_, self, key);
+			}
+
+			template <bool ip>
+			static int next_associative(std::true_type, lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				if (it == deferred_uc::end(L_, source)) {
+					return stack::push(L_, lua_nil);
+				}
+				int p;
+				if constexpr (ip) {
+					++i.index;
+					p = stack::push_reference(L_, i.index);
+				}
+				else {
+					p = stack::push_reference(L_, it->first);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(it->second));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool>
+			static int next_associative(std::false_type, lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				next_K k = stack::unqualified_get<next_K>(L_, 2);
+				if (it == deferred_uc::end(L_, source)) {
+					return stack::push(L_, lua_nil);
+				}
+				int p;
+				if constexpr (std::is_integral_v<next_K>) {
+					p = stack::push_reference(L_, k + 1);
+				}
+				else {
+					p = stack::stack_detail::push_reference(L_, k + 1);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool ip>
+			static int next_iter(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return next_associative<ip>(is_assoc(), L_);
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::true_type, lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter<ip>);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, lua_nil);
+				return 3;
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::false_type, lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter<ip>);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, 0);
+				return 3;
+			}
+
+		public:
+			static int at(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					std::ptrdiff_t pos = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+					er = at_start(L_, self, pos);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int get(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L_);
+					er = get_start(L_, self, key);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int index_get(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int set(lua_State* L_) {
+				stack_object value = stack_object(L_, raw_index(3));
+				if constexpr (is_linear_integral::value) {
+					// for non-associative containers,
+					// erasure only happens if it is the
+					// last index in the container
+					auto key = stack::get<K>(L_, 2);
+					auto self_size = deferred_uc::size(L_);
+					if (key == static_cast<K>(self_size)) {
+						if (type_of(L_, 3) == type::lua_nil) {
+							return erase(L_);
+						}
+					}
+				}
+				else {
+					if (type_of(L_, 3) == type::lua_nil) {
+						return erase(L_);
+					}
+				}
+				auto& self = get_src(L_);
+				detail::error_result er = set_start(L_, self, stack_object(L_, raw_index(2)), std::move(value));
+				return handle_errors(L_, er);
+			}
+
+			static int index_set(lua_State* L_) {
+				return set(L_);
+			}
+
+			static int add(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = add_copyable(is_copyable(), L_, self, stack_object(L_, raw_index(2)));
+				return handle_errors(L_, er);
+			}
+
+			static int insert(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = insert_copyable(is_copyable(), L_, self, stack_object(L_, raw_index(2)), stack_object(L_, raw_index(3)));
+				return handle_errors(L_, er);
+			}
+
+			static int find(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = find_has(has_find<T>(), L_, self);
+				return handle_errors(L_, er);
+			}
+
+			static int index_of(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = find_has<true>(has_find<T>(), L_, self);
+				return handle_errors(L_, er);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.begin();
+				}
+				else {
+					using std::begin;
+					return begin(self);
+				}
+			}
+
+			static iterator end(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.end();
+				}
+				else {
+					using std::end;
+					return end(self);
+				}
+			}
+
+			static int size(lua_State* L_) {
+				auto& self = get_src(L_);
+				std::size_t r = size_start(L_, self);
+				return stack::push(L_, r);
+			}
+
+			static int clear(lua_State* L_) {
+				auto& self = get_src(L_);
+				clear_start(L_, self);
+				return 0;
+			}
+
+			static int erase(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L_, 2);
+					er = erase_start(L_, self, key);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int empty(lua_State* L_) {
+				auto& self = get_src(L_);
+				return stack::push(L_, empty_start(L_, self));
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return static_cast<std::ptrdiff_t>((SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_));
+			}
+
+			static int pairs(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<false>(is_assoc(), L_);
+			}
+
+			static int ipairs(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<true>(is_assoc(), L_);
+			}
+
+			static int next(lua_State* L_) {
+				return stack::push(L_, next_iter<false>);
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X, std::enable_if_t<std::is_array<std::remove_pointer_t<meta::unwrap_unqualified_t<X>>>::value>> {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+			typedef usertype_container<X> deferred_uc;
+
+		public:
+			typedef std::remove_extent_t<T> value_type;
+			typedef value_type* iterator;
+
+		private:
+			struct iter {
+				reference keep_alive;
+				T& source;
+				iterator it;
+
+				iter(lua_State* L_, int stack_index, T& source, iterator it) noexcept
+				: keep_alive(sol::main_thread(L_, L_), stack_index), source(source), it(std::move(it)) {
+				}
+
+				~iter() {
+
+				}
+			};
+
+			static auto& get_src(lua_State* L_) {
+				auto p = stack::unqualified_check_get<T*>(L_, 1);
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+				if (!p) {
+					luaL_error(L_,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L_, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+#endif // Safe getting with error
+				return *p.value();
+			}
+
+			static int find(std::true_type, lua_State* L_) {
+				T& self = get_src(L_);
+				decltype(auto) value = stack::unqualified_get<value_type>(L_, 2);
+				std::size_t N = std::extent<T>::value;
+				for (std::size_t idx = 0; idx < N; ++idx) {
+					using v_t = std::add_const_t<decltype(self[idx])>;
+					v_t v = self[idx];
+					if (v == value) {
+						idx = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(idx) - deferred_uc::index_adjustment(L_, self));
+						return stack::push(L_, idx);
+					}
+				}
+				return stack::push(L_, lua_nil);
+			}
+
+			static int find(std::false_type, lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'find' on '%s': no supported comparison operator for the value type", detail::demangle<T>().c_str());
+			}
+
+			static int next_iter(lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				std::size_t k = stack::unqualified_get<std::size_t>(L_, 2);
+				if (it == deferred_uc::end(L_, source)) {
+					return 0;
+				}
+				int p;
+				p = stack::push(L_, k + 1);
+				p += stack::push_reference(L_, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+		public:
+			static int clear(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'clear' on type '%s': cannot remove all items from a fixed array", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'erase' on type '%s': cannot remove an item from fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'add' on type '%s': cannot add to fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'insert' on type '%s': cannot insert new entries into fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int at(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int get(lua_State* L_) {
+				T& self = get_src(L_);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+				idx += deferred_uc::index_adjustment(L_, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value) || idx < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				return stack::push_reference(L_, detail::deref_move_only(self[idx]));
+			}
+
+			static int index_get(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int set(lua_State* L_) {
+				T& self = get_src(L_);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+				idx += deferred_uc::index_adjustment(L_, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value)) {
+					return luaL_error(L_, "sol: index out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				if (idx < 0) {
+					return luaL_error(L_, "sol: index out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				self[idx] = stack::unqualified_get<value_type>(L_, 3);
+				return 0;
+			}
+
+			static int index_set(lua_State* L_) {
+				return set(L_);
+			}
+
+			static int index_of(lua_State* L_) {
+				return find(L_);
+			}
+
+			static int find(lua_State* L_) {
+				return find(meta::supports_op_equal<value_type, value_type>(), L_);
+			}
+
+			static int size(lua_State* L_) {
+				return stack::push(L_, std::extent<T>::value);
+			}
+
+			static int empty(lua_State* L_) {
+				return stack::push(L_, std::extent<T>::value > 0);
+			}
+
+			static int pairs(lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, 0);
+				return 3;
+			}
+
+			static int ipairs(lua_State* L_) {
+				return pairs(L_);
+			}
+
+			static int next(lua_State* L_) {
+				return stack::push(L_, next_iter);
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return (SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				return std::addressof(self[0]);
+			}
+
+			static iterator end(lua_State*, T& self) {
+				return std::addressof(self[0]) + std::extent<T>::value;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<usertype_container<X>> : usertype_container_default<X> { };
+	} // namespace container_detail
+
+	template <typename T>
+	struct usertype_container : container_detail::usertype_container_default<T> { };
+
+} // namespace sol
+
+// end of sol/usertype_container.hpp
+
+#include <unordered_map>
+
+namespace sol {
+
+	namespace container_detail {
+		template <typename X>
+		struct u_c_launch {
+			using T = std::remove_pointer_t<meta::unqualified_t<X>>;
+			using uc = usertype_container<T>;
+			using default_uc = usertype_container_default<T>;
+
+			static inline int real_index_get_traits(std::true_type, lua_State* L) {
+				return uc::index_get(L);
+			}
+
+			static inline int real_index_get_traits(std::false_type, lua_State* L) {
+				return default_uc::index_get(L);
+			}
+
+			static inline int real_index_call(lua_State* L) {
+				static const std::unordered_map<string_view, lua_CFunction> calls {
+					{ "at", &real_at_call },
+					{ "get", &real_get_call },
+					{ "set", &real_set_call },
+					{ "size", &real_length_call },
+					{ "add", &real_add_call },
+					{ "empty", &real_empty_call },
+					{ "insert", &real_insert_call },
+					{ "clear", &real_clear_call },
+					{ "find", &real_find_call },
+					{ "index_of", &real_index_of_call },
+					{ "erase", &real_erase_call },
+					{ "pairs", &pairs_call },
+					{ "next", &next_call },
+				};
+				auto maybenameview = stack::unqualified_check_get<string_view>(L, 2);
+				if (maybenameview) {
+					const string_view& name = *maybenameview;
+					auto it = calls.find(name);
+					if (it != calls.cend()) {
+						return stack::push(L, it->second);
+					}
+				}
+				return real_index_get_traits(container_detail::has_traits_index_get<uc>(), L);
+			}
+
+			static inline int real_at_traits(std::true_type, lua_State* L) {
+				return uc::at(L);
+			}
+
+			static inline int real_at_traits(std::false_type, lua_State* L) {
+				return default_uc::at(L);
+			}
+
+			static inline int real_at_call(lua_State* L) {
+				return real_at_traits(container_detail::has_traits_at<uc>(), L);
+			}
+
+			static inline int real_get_traits(std::true_type, lua_State* L) {
+				return uc::get(L);
+			}
+
+			static inline int real_get_traits(std::false_type, lua_State* L) {
+				return default_uc::get(L);
+			}
+
+			static inline int real_get_call(lua_State* L) {
+				return real_get_traits(container_detail::has_traits_get<uc>(), L);
+			}
+
+			static inline int real_set_traits(std::true_type, lua_State* L) {
+				return uc::set(L);
+			}
+
+			static inline int real_set_traits(std::false_type, lua_State* L) {
+				return default_uc::set(L);
+			}
+
+			static inline int real_set_call(lua_State* L) {
+				return real_set_traits(container_detail::has_traits_set<uc>(), L);
+			}
+
+			static inline int real_index_set_traits(std::true_type, lua_State* L) {
+				return uc::index_set(L);
+			}
+
+			static inline int real_index_set_traits(std::false_type, lua_State* L) {
+				return default_uc::index_set(L);
+			}
+
+			static inline int real_new_index_call(lua_State* L) {
+				return real_index_set_traits(container_detail::has_traits_index_set<uc>(), L);
+			}
+
+			static inline int real_pairs_traits(std::true_type, lua_State* L) {
+				return uc::pairs(L);
+			}
+
+			static inline int real_pairs_traits(std::false_type, lua_State* L) {
+				return default_uc::pairs(L);
+			}
+
+			static inline int real_pairs_call(lua_State* L) {
+				return real_pairs_traits(container_detail::has_traits_pairs<uc>(), L);
+			}
+
+			static inline int real_ipairs_traits(std::true_type, lua_State* L) {
+				return uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_traits(std::false_type, lua_State* L) {
+				return default_uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_call(lua_State* L) {
+				return real_ipairs_traits(container_detail::has_traits_ipairs<uc>(), L);
+			}
+
+			static inline int real_next_traits(std::true_type, lua_State* L) {
+				return uc::next(L);
+			}
+
+			static inline int real_next_traits(std::false_type, lua_State* L) {
+				return default_uc::next(L);
+			}
+
+			static inline int real_next_call(lua_State* L) {
+				return real_next_traits(container_detail::has_traits_next<uc>(), L);
+			}
+
+			static inline int real_size_traits(std::true_type, lua_State* L) {
+				return uc::size(L);
+			}
+
+			static inline int real_size_traits(std::false_type, lua_State* L) {
+				return default_uc::size(L);
+			}
+
+			static inline int real_length_call(lua_State* L) {
+				return real_size_traits(container_detail::has_traits_size<uc>(), L);
+			}
+
+			static inline int real_add_traits(std::true_type, lua_State* L) {
+				return uc::add(L);
+			}
+
+			static inline int real_add_traits(std::false_type, lua_State* L) {
+				return default_uc::add(L);
+			}
+
+			static inline int real_add_call(lua_State* L) {
+				return real_add_traits(container_detail::has_traits_add<uc>(), L);
+			}
+
+			static inline int real_insert_traits(std::true_type, lua_State* L) {
+				return uc::insert(L);
+			}
+
+			static inline int real_insert_traits(std::false_type, lua_State* L) {
+				return default_uc::insert(L);
+			}
+
+			static inline int real_insert_call(lua_State* L) {
+				return real_insert_traits(container_detail::has_traits_insert<uc>(), L);
+			}
+
+			static inline int real_clear_traits(std::true_type, lua_State* L) {
+				return uc::clear(L);
+			}
+
+			static inline int real_clear_traits(std::false_type, lua_State* L) {
+				return default_uc::clear(L);
+			}
+
+			static inline int real_clear_call(lua_State* L) {
+				return real_clear_traits(container_detail::has_traits_clear<uc>(), L);
+			}
+
+			static inline int real_empty_traits(std::true_type, lua_State* L) {
+				return uc::empty(L);
+			}
+
+			static inline int real_empty_traits(std::false_type, lua_State* L) {
+				return default_uc::empty(L);
+			}
+
+			static inline int real_empty_call(lua_State* L) {
+				return real_empty_traits(container_detail::has_traits_empty<uc>(), L);
+			}
+
+			static inline int real_erase_traits(std::true_type, lua_State* L) {
+				return uc::erase(L);
+			}
+
+			static inline int real_erase_traits(std::false_type, lua_State* L) {
+				return default_uc::erase(L);
+			}
+
+			static inline int real_erase_call(lua_State* L) {
+				return real_erase_traits(container_detail::has_traits_erase<uc>(), L);
+			}
+
+			static inline int real_find_traits(std::true_type, lua_State* L) {
+				return uc::find(L);
+			}
+
+			static inline int real_find_traits(std::false_type, lua_State* L) {
+				return default_uc::find(L);
+			}
+
+			static inline int real_find_call(lua_State* L) {
+				return real_find_traits(container_detail::has_traits_find<uc>(), L);
+			}
+
+			static inline int real_index_of_call(lua_State* L) {
+				if constexpr (container_detail::has_traits_index_of<uc>()) {
+					return uc::index_of(L);
+				}
+				else {
+					return default_uc::index_of(L);
+				}
+			}
+
+			static inline int add_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_add_call), (&real_add_call)>(L);
+			}
+
+			static inline int erase_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_erase_call), (&real_erase_call)>(L);
+			}
+
+			static inline int insert_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_insert_call), (&real_insert_call)>(L);
+			}
+
+			static inline int clear_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_clear_call), (&real_clear_call)>(L);
+			}
+
+			static inline int empty_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_empty_call), (&real_empty_call)>(L);
+			}
+
+			static inline int find_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_find_call), (&real_find_call)>(L);
+			}
+
+			static inline int index_of_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_of_call), (&real_index_of_call)>(L);
+			}
+
+			static inline int length_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_length_call), (&real_length_call)>(L);
+			}
+
+			static inline int pairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_pairs_call), (&real_pairs_call)>(L);
+			}
+
+			static inline int ipairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_ipairs_call), (&real_ipairs_call)>(L);
+			}
+
+			static inline int next_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_next_call), (&real_next_call)>(L);
+			}
+
+			static inline int at_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_at_call), (&real_at_call)>(L);
+			}
+
+			static inline int get_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_get_call), (&real_get_call)>(L);
+			}
+
+			static inline int set_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_set_call), (&real_set_call)>(L);
+			}
+
+			static inline int index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_call), (&real_index_call)>(L);
+			}
+
+			static inline int new_index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_new_index_call), (&real_new_index_call)>(L);
+			}
+		};
+	} // namespace container_detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T, bool is_shim = false>
+			struct metatable_setup {
+				lua_State* L;
+
+				metatable_setup(lua_State* L) : L(L) {
+				}
+
+				void operator()() {
+					using meta_usertype_container
+					     = container_detail::u_c_launch<meta::conditional_t<is_shim, as_container_t<std::remove_pointer_t<T>>, std::remove_pointer_t<T>>>;
+					static const char* metakey
+					     = is_shim ? &usertype_traits<as_container_t<std::remove_pointer_t<T>>>::metatable()[0] : &usertype_traits<T>::metatable()[0];
+					static const std::array<luaL_Reg, 20> reg = { {
+						// clang-format off
+						{ "__pairs", &meta_usertype_container::pairs_call },
+						{ "__ipairs", &meta_usertype_container::ipairs_call },
+						{ "__len", &meta_usertype_container::length_call },
+						{ "__index", &meta_usertype_container::index_call },
+						{ "__newindex", &meta_usertype_container::new_index_call },
+						{ "pairs", &meta_usertype_container::pairs_call },
+						{ "next", &meta_usertype_container::next_call },
+						{ "at", &meta_usertype_container::at_call },
+						{ "get", &meta_usertype_container::get_call },
+						{ "set", &meta_usertype_container::set_call },
+						{ "size", &meta_usertype_container::length_call },
+						{ "empty", &meta_usertype_container::empty_call },
+						{ "clear", &meta_usertype_container::clear_call },
+						{ "insert", &meta_usertype_container::insert_call },
+						{ "add", &meta_usertype_container::add_call },
+						{ "find", &meta_usertype_container::find_call },
+						{ "index_of", &meta_usertype_container::index_of_call },
+						{ "erase", &meta_usertype_container::erase_call },
+						std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destroy<T> },
+						{ nullptr, nullptr }
+						// clang-format on 
+					} };
+
+					if (luaL_newmetatable(L, metakey) == 1) {
+						luaL_setfuncs(L, reg.data(), 0);
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T>> {
+			using C = meta::unqualified_t<T>;
+
+			static int push_lvalue(std::true_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C*, true> fx(L);
+				return stack::push<detail::as_pointer_tag<const C>>(L, detail::with_function_tag(), fx, detail::ptr(cont));
+			}
+
+			static int push_lvalue(std::false_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, cont);
+			}
+
+			static int push_rvalue(std::true_type, lua_State* L, C&& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, std::move(cont));
+			}
+
+			static int push_rvalue(std::false_type, lua_State* L, const C& cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, cont);
+			}
+
+			static int push(lua_State* L, const as_container_t<T>& as_cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, as_cont.value());
+			}
+
+			static int push(lua_State* L, as_container_t<T>&& as_cont) {
+				return push_rvalue(meta::all<std::is_rvalue_reference<T>, meta::neg<std::is_lvalue_reference<T>>>(), L, std::forward<T>(as_cont.value()));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T*>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T, std::enable_if_t<is_container_v<T>>> {
+			using C = T;
+
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_value_tag<T>>(L, detail::with_function_tag(), fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T*, std::enable_if_t<is_container_v<T>>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/usertype_container_launch.hpp
+
+#include <sstream>
+#include <type_traits>
+
+namespace sol {
+	namespace u_detail {
+		constexpr const lua_Integer toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1);
+
+		constexpr const int environment_index = 1;
+		constexpr const int usertype_storage_index = 2;
+		constexpr const int usertype_storage_base_index = 3;
+		constexpr const int exact_function_index = 4;
+		constexpr const int magic_index = 5;
+
+		constexpr const int simple_usertype_storage_index = 2;
+		constexpr const int index_function_index = 3;
+		constexpr const int new_index_function_index = 4;
+
+		constexpr const int base_walking_failed_index = -32467;
+		constexpr const int lookup_failed_index = -42469;
+
+		enum class submetatable_type {
+			// must be sequential
+			value,
+			reference,
+			unique,
+			const_reference,
+			const_value,
+			// must be LAST!
+			named
+		};
+
+		inline auto make_string_view(string_view s) {
+			return s;
+		}
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		inline auto make_string_view(const char8_t* s) {
+			return string_view(reinterpret_cast<const char*>(s));
+		}
+#endif
+
+		inline auto make_string_view(call_construction) {
+			return string_view(to_string(meta_function::call_function));
+		}
+
+		inline auto make_string_view(meta_function mf) {
+			return string_view(to_string(mf));
+		}
+
+		inline auto make_string_view(base_classes_tag) {
+			return string_view(detail::base_class_cast_key());
+		}
+
+		template <typename Arg>
+		inline std::string make_string(Arg&& arg) {
+			string_view s = make_string_view(arg);
+			return std::string(s.data(), s.size());
+		}
+
+		inline int is_indexer(string_view s) {
+			if (s == to_string(meta_function::index)) {
+				return 1;
+			}
+			else if (s == to_string(meta_function::new_index)) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(meta_function mf) {
+			if (mf == meta_function::index) {
+				return 1;
+			}
+			else if (mf == meta_function::new_index) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(call_construction) {
+			return 0;
+		}
+	} // namespace u_detail
+
+	namespace detail {
+
+		template <typename T, typename IFx, typename Fx>
+		inline void insert_default_registrations(IFx&& ifx, Fx&& fx) {
+			(void)ifx;
+			(void)fx;
+			if constexpr (is_automagical<T>::value) {
+				if (fx(meta_function::less_than)) {
+					if constexpr (meta::supports_op_less<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less<>>;
+						ifx(meta_function::less_than, f);
+					}
+				}
+				if (fx(meta_function::less_than_or_equal_to)) {
+					if constexpr (meta::supports_op_less_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less_equal<>>;
+						ifx(meta_function::less_than_or_equal_to, f);
+					}
+				}
+				if (fx(meta_function::equal_to)) {
+					if constexpr (meta::supports_op_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::equal_to<>>;
+						ifx(meta_function::equal_to, f);
+					}
+					else {
+						lua_CFunction f = &comparsion_operator_wrap<T, no_comp>;
+						ifx(meta_function::equal_to, f);
+					}
+				}
+				if (fx(meta_function::pairs)) {
+					ifx(meta_function::pairs, &container_detail::u_c_launch<as_container_t<T>>::pairs_call);
+				}
+				if (fx(meta_function::length)) {
+					if constexpr (meta::has_size<const T>::value || meta::has_size<T>::value) {
+						auto f = &default_size<T>;
+						ifx(meta_function::length, f);
+					}
+				}
+				if (fx(meta_function::to_string)) {
+					if constexpr (is_to_stringable_v<T>) {
+						if constexpr (!meta::is_probably_stateless_lambda_v<T> && !std::is_member_pointer_v<T>) {
+							auto f = &detail::static_trampoline<&default_to_string<T>>;
+							ifx(meta_function::to_string, f);
+						}
+					}
+				}
+				if (fx(meta_function::call_function)) {
+					if constexpr (is_callable_v<T>) {
+						if constexpr (meta::call_operator_deducible_v<T>) {
+							auto f = &c_call<decltype(&T::operator()), &T::operator()>;
+							ifx(meta_function::call_function, f);
+						}
+					}
+				}
+			}
+		}
+	} // namespace detail
+
+	namespace stack { namespace stack_detail {
+		template <typename X>
+		void set_undefined_methods_on(stack_reference t) {
+			using T = std::remove_pointer_t<X>;
+
+			lua_State* L = t.lua_state();
+
+			t.push();
+
+			detail::lua_reg_table l {};
+			int index = 0;
+			detail::indexed_insert insert_fx(l, index);
+			detail::insert_default_registrations<T>(insert_fx, detail::property_always_true);
+			if constexpr (!std::is_pointer_v<X>) {
+				l[index] = luaL_Reg { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+			}
+			luaL_setfuncs(L, l, 0);
+
+			// __type table
+			lua_createtable(L, 0, 2);
+			const std::string& name = detail::demangle<T>();
+			lua_pushlstring(L, name.c_str(), name.size());
+			lua_setfield(L, -2, "name");
+			lua_CFunction is_func = &detail::is_check<T>;
+			lua_pushcclosure(L, is_func, 0);
+			lua_setfield(L, -2, "is");
+			lua_setfield(L, t.stack_index(), to_string(meta_function::type).c_str());
+
+			t.pop();
+		}
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+// end of sol/usertype_core.hpp
+
+// beginning of sol/usertype_storage.hpp
+
+#include <bitset>
+#include <unordered_map>
+#include <memory>
+
+namespace sol { namespace u_detail {
+
+	struct usertype_storage_base;
+	template <typename T>
+	struct usertype_storage;
+
+	optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L_, int index);
+	usertype_storage_base& get_usertype_storage_base(lua_State* L_, const char* gcmetakey);
+	template <typename T>
+	optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L_);
+	template <typename T>
+	usertype_storage<T>& get_usertype_storage(lua_State* L_);
+
+	using index_call_function = int(lua_State*, void*);
+	using change_indexing_mem_func = void (usertype_storage_base::*)(
+		lua_State*, submetatable_type, void*, stateless_stack_reference&, lua_CFunction, lua_CFunction, lua_CFunction, lua_CFunction);
+
+	struct index_call_storage {
+		index_call_function* index;
+		index_call_function* new_index;
+		void* binding_data;
+	};
+
+	struct new_index_call_storage : index_call_storage {
+		void* new_binding_data;
+	};
+
+	struct binding_base {
+		virtual void* data() = 0;
+		virtual ~binding_base() {
+		}
+	};
+
+	template <typename K, typename Fq, typename T = void>
+	struct binding : binding_base {
+		using uF = meta::unqualified_t<Fq>;
+		using F = meta::conditional_t<meta::is_c_str_of_v<uF, char>
+#if SOL_IS_ON(SOL_CHAR8_T)
+			     || meta::is_c_str_of_v<uF, char8_t>
+#endif
+			     || meta::is_c_str_of_v<uF, char16_t> || meta::is_c_str_of_v<uF, char32_t> || meta::is_c_str_of_v<uF, wchar_t>,
+			std::add_pointer_t<std::add_const_t<std::remove_all_extents_t<Fq>>>, std::decay_t<Fq>>;
+		F data_;
+
+		template <typename... Args>
+		binding(Args&&... args) : data_(std::forward<Args>(args)...) {
+		}
+
+		virtual void* data() override {
+			return static_cast<void*>(std::addressof(data_));
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_with_(lua_State* L_, void* target) {
+			constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+			auto& f = *static_cast<F*>(target);
+			return call_detail::call_wrapped<T, is_index, is_variable, boost>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_(lua_State* L_) {
+			void* f = stack::get<void*>(L_, upvalue_index(usertype_storage_index));
+			return call_with_<is_index, is_variable>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call(lua_State* L_) {
+			int r = detail::typed_static_trampoline<decltype(&call_<is_index, is_variable>), (&call_<is_index, is_variable>)>(L_);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L_, r);
+			}
+			else {
+				return r;
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_with_(lua_State* L_, void* target) {
+			if constexpr (!is_variable) {
+				if constexpr (is_lua_c_function_v<std::decay_t<F>>) {
+					auto& f = *static_cast<std::decay_t<F>*>(target);
+					return stack::push(L_, f);
+				}
+				else {
+					// set up upvalues
+					// for a chained call
+					int upvalues = 0;
+					upvalues += stack::push(L_, nullptr);
+					upvalues += stack::push(L_, target);
+					auto cfunc = &call<is_index, is_variable>;
+					return stack::push(L_, c_closure(cfunc, upvalues));
+				}
+			}
+			else {
+				constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+				auto& f = *static_cast<F*>(target);
+				return call_detail::call_wrapped<T, is_index, is_variable, boost>(L_, f);
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_(lua_State* L_) {
+			void* f = stack::get<void*>(L_, upvalue_index(usertype_storage_index));
+			return index_call_with_<is_index, is_variable>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call(lua_State* L_) {
+			int r = detail::typed_static_trampoline<decltype(&index_call_<is_index, is_variable>), (&index_call_<is_index, is_variable>)>(L_);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L_, r);
+			}
+			else {
+				return r;
+			}
+		}
+	};
+
+	inline int index_fail(lua_State* L_) {
+		if (lua_getmetatable(L_, 1) == 1) {
+			int metatarget = lua_gettop(L_);
+			stack::get_field<false, true>(L_, stack_reference(L_, raw_index(2)), metatarget);
+			return 1;
+		}
+		// With runtime extensibility, we can't
+		// hard-error things. They have to
+		// return nil, like regular table types
+		return stack::push(L_, lua_nil);
+	}
+
+	inline int index_target_fail(lua_State* L_, void*) {
+		return index_fail(L_);
+	}
+
+	inline int new_index_fail(lua_State* L_) {
+		return luaL_error(L_, "sol: cannot set (new_index) into this object: no defined new_index operation on usertype");
+	}
+
+	inline int new_index_target_fail(lua_State* L_, void*) {
+		return new_index_fail(L_);
+	}
+
+	struct string_for_each_metatable_func {
+		bool is_destruction = false;
+		bool is_index = false;
+		bool is_new_index = false;
+		bool is_static_index = false;
+		bool is_static_new_index = false;
+		bool poison_indexing = false;
+		bool is_unqualified_lua_CFunction = false;
+		bool is_unqualified_lua_reference = false;
+		std::string* p_key = nullptr;
+		reference* p_binding_ref = nullptr;
+		lua_CFunction call_func = nullptr;
+		index_call_storage* p_ics = nullptr;
+		usertype_storage_base* p_usb = nullptr;
+		void* p_derived_usb = nullptr;
+		lua_CFunction idx_call = nullptr, new_idx_call = nullptr, meta_idx_call = nullptr, meta_new_idx_call = nullptr;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			std::string& key = *p_key;
+			usertype_storage_base& usb = *p_usb;
+			index_call_storage& ics = *p_ics;
+
+			if (smt_ == submetatable_type::named) {
+				// do not override __call or
+				// other specific meta functions on named metatable:
+				// we need that for call construction
+				// and other amenities
+				return;
+			}
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			if (poison_indexing) {
+				(usb.*change_indexing)(L_, smt_, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			}
+			if (is_destruction
+				&& (smt_ == submetatable_type::reference || smt_ == submetatable_type::const_reference || smt_ == submetatable_type::named
+				     || smt_ == submetatable_type::unique)) {
+				// gc does not apply to us here
+				// for reference types (raw T*, std::ref)
+				// for the named metatable itself,
+				// or for unique_usertypes, which do their own custom destroyion
+				t.pop(L_);
+				return;
+			}
+			if (is_index || is_new_index || is_static_index || is_static_new_index) {
+				// do not serialize the new_index and index functions here directly
+				// we control those...
+				t.pop(L_);
+				return;
+			}
+			if (is_unqualified_lua_CFunction) {
+				stack::set_field<false, true>(L_, key, call_func, t.stack_index());
+			}
+			else if (is_unqualified_lua_reference) {
+				reference& binding_ref = *p_binding_ref;
+				stack::set_field<false, true>(L_, key, binding_ref, t.stack_index());
+			}
+			else {
+				stack::set_field<false, true>(L_, key, make_closure(call_func, nullptr, ics.binding_data), t.stack_index());
+			}
+			t.pop(L_);
+		}
+	};
+
+	struct lua_reference_func {
+		reference key;
+		reference value;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			if (smt_ == submetatable_type::named) {
+				return;
+			}
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			stack::set_field<false, true>(L_, key, value, t.stack_index());
+			t.pop(L_);
+		}
+	};
+
+	struct update_bases_func {
+		detail::inheritance_check_function base_class_check_func;
+		detail::inheritance_cast_function base_class_cast_func;
+		lua_CFunction idx_call, new_idx_call, meta_idx_call, meta_new_idx_call;
+		usertype_storage_base* p_usb;
+		void* p_derived_usb;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			stack::set_field(L_, detail::base_class_check_key(), reinterpret_cast<void*>(base_class_check_func), t.stack_index());
+			stack::set_field(L_, detail::base_class_cast_key(), reinterpret_cast<void*>(base_class_cast_func), t.stack_index());
+			// change indexing, forcefully
+			(p_usb->*change_indexing)(L_, smt_, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			t.pop(L_);
+		}
+	};
+
+	struct binding_data_equals {
+		void* binding_data;
+
+		binding_data_equals(void* b) : binding_data(b) {
+		}
+
+		bool operator()(const std::unique_ptr<binding_base>& ptr) const {
+			return binding_data == ptr->data();
+		}
+	};
+
+	struct usertype_storage_base {
+	public:
+		lua_State* m_L;
+		std::vector<std::unique_ptr<binding_base>> storage;
+		std::vector<std::unique_ptr<char[]>> string_keys_storage;
+		std::unordered_map<string_view, index_call_storage> string_keys;
+		std::unordered_map<stateless_reference, stateless_reference, stateless_reference_hash, stateless_reference_equals> auxiliary_keys;
+		stateless_reference value_index_table;
+		stateless_reference reference_index_table;
+		stateless_reference unique_index_table;
+		stateless_reference const_reference_index_table;
+		stateless_reference const_value_index_table;
+		stateless_reference named_index_table;
+		stateless_reference type_table;
+		stateless_reference gc_names_table;
+		stateless_reference named_metatable;
+		new_index_call_storage base_index;
+		new_index_call_storage static_base_index;
+		bool is_using_index;
+		bool is_using_new_index;
+		std::bitset<64> properties;
+
+		usertype_storage_base(lua_State* L_)
+		: m_L(L_)
+		, storage()
+		, string_keys_storage()
+		, string_keys()
+		, auxiliary_keys(0, stateless_reference_hash(L_), stateless_reference_equals(L_))
+		, value_index_table()
+		, reference_index_table()
+		, unique_index_table()
+		, const_reference_index_table()
+		, const_value_index_table()
+		, named_index_table()
+		, type_table(make_reference<stateless_reference>(L_, create))
+		, gc_names_table(make_reference<stateless_reference>(L_, create))
+		, named_metatable(make_reference<stateless_reference>(L_, create))
+		, base_index()
+		, static_base_index()
+		, is_using_index(false)
+		, is_using_new_index(false)
+		, properties() {
+			base_index.binding_data = nullptr;
+			base_index.index = index_target_fail;
+			base_index.new_index = new_index_target_fail;
+			base_index.new_binding_data = nullptr;
+			static_base_index.binding_data = nullptr;
+			static_base_index.index = index_target_fail;
+			static_base_index.new_binding_data = this;
+			static_base_index.new_index = new_index_target_set;
+		}
+
+		template <typename Fx>
+		void for_each_table(lua_State* L_, Fx&& fx) {
+			for (int i = 0; i < 6; ++i) {
+				submetatable_type smt = static_cast<submetatable_type>(i);
+				stateless_reference* p_fast_index_table = nullptr;
+				switch (smt) {
+				case submetatable_type::const_value:
+					p_fast_index_table = &this->const_value_index_table;
+					break;
+				case submetatable_type::reference:
+					p_fast_index_table = &this->reference_index_table;
+					break;
+				case submetatable_type::unique:
+					p_fast_index_table = &this->unique_index_table;
+					break;
+				case submetatable_type::const_reference:
+					p_fast_index_table = &this->const_reference_index_table;
+					break;
+				case submetatable_type::named:
+					p_fast_index_table = &this->named_index_table;
+					break;
+				case submetatable_type::value:
+				default:
+					p_fast_index_table = &this->value_index_table;
+					break;
+				}
+				fx(L_, smt, *p_fast_index_table);
+			}
+		}
+
+		void add_entry(string_view sv, index_call_storage ics) {
+			string_keys_storage.emplace_back(new char[sv.size()]);
+			std::unique_ptr<char[]>& sv_storage = string_keys_storage.back();
+			std::memcpy(sv_storage.get(), sv.data(), sv.size());
+			string_view stored_sv(sv_storage.get(), sv.size());
+			string_keys.insert_or_assign(std::move(stored_sv), std::move(ics));
+		}
+
+		template <typename T, typename... Bases>
+		void update_bases(lua_State* L_, bases<Bases...>) {
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
+			if constexpr (sizeof...(Bases) > 0) {
+				(void)detail::swallow { 0, ((weak_derive<Bases>::value = true), 0)... };
+
+				void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+
+				update_bases_func for_each_fx;
+				for_each_fx.base_class_check_func = &detail::inheritance<T>::template type_check_with<Bases...>;
+				for_each_fx.base_class_cast_func = &detail::inheritance<T>::template type_cast_with<Bases...>;
+				for_each_fx.idx_call = &usertype_storage<T>::template index_call_with_bases<false, Bases...>;
+				for_each_fx.new_idx_call = &usertype_storage<T>::template index_call_with_bases<true, Bases...>;
+				for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<false, Bases...>;
+				for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<true, Bases...>;
+				for_each_fx.p_usb = this;
+				for_each_fx.p_derived_usb = derived_this;
+				for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+				for_each_fx.p_derived_usb = derived_this;
+				this->for_each_table(L_, for_each_fx);
+			}
+			else {
+				(void)L_;
+			}
+		}
+
+		void clear() {
+			if (value_index_table.valid(m_L)) {
+				stack::clear(m_L, value_index_table);
+			}
+			if (reference_index_table.valid(m_L)) {
+				stack::clear(m_L, reference_index_table);
+			}
+			if (unique_index_table.valid(m_L)) {
+				stack::clear(m_L, unique_index_table);
+			}
+			if (const_reference_index_table.valid(m_L)) {
+				stack::clear(m_L, const_reference_index_table);
+			}
+			if (const_value_index_table.valid(m_L)) {
+				stack::clear(m_L, const_value_index_table);
+			}
+			if (named_index_table.valid(m_L)) {
+				stack::clear(m_L, named_index_table);
+			}
+			if (type_table.valid(m_L)) {
+				stack::clear(m_L, type_table);
+			}
+			if (gc_names_table.valid(m_L)) {
+				stack::clear(m_L, gc_names_table);
+			}
+			if (named_metatable.valid(m_L)) {
+				auto pp = stack::push_pop(m_L, named_metatable);
+				int named_metatable_index = pp.index_of(named_metatable);
+				if (lua_getmetatable(m_L, named_metatable_index) == 1) {
+					stack::clear(m_L, absolute_index(m_L, -1));
+				}
+				stack::clear(m_L, named_metatable);
+			}
+
+			value_index_table.reset(m_L);
+			reference_index_table.reset(m_L);
+			unique_index_table.reset(m_L);
+			const_reference_index_table.reset(m_L);
+			const_value_index_table.reset(m_L);
+			named_index_table.reset(m_L);
+			type_table.reset(m_L);
+			gc_names_table.reset(m_L);
+			named_metatable.reset(m_L);
+
+			storage.clear();
+			string_keys.clear();
+			auxiliary_keys.clear();
+			string_keys_storage.clear();
+		}
+
+		template <bool is_new_index, typename Base>
+		static void base_walk_index(lua_State* L_, usertype_storage_base& self, bool& keep_going, int& base_result) {
+			using bases = typename base<Base>::type;
+			if (!keep_going) {
+				return;
+			}
+			(void)L_;
+			(void)self;
+#if SOL_IS_ON(SOL_USE_UNSAFE_BASE_LOOKUP)
+			usertype_storage_base& base_storage = get_usertype_storage<Base>(L_);
+			base_result = self_index_call<is_new_index, true>(bases(), L_, base_storage);
+#else
+			optional<usertype_storage<Base>&> maybe_base_storage = maybe_get_usertype_storage<Base>(L_);
+			if (static_cast<bool>(maybe_base_storage)) {
+				base_result = self_index_call<is_new_index, true>(bases(), L_, *maybe_base_storage);
+				keep_going = base_result == base_walking_failed_index;
+			}
+#endif // Fast versus slow, safe base lookup
+		}
+
+		template <bool is_new_index = false, bool base_walking = false, bool from_named_metatable = false, typename... Bases>
+		static inline int self_index_call(types<Bases...>, lua_State* L, usertype_storage_base& self) {
+			if constexpr (!from_named_metatable || !is_new_index) {
+				type k_type = stack::get<type>(L, 2);
+				if (k_type == type::string) {
+					index_call_storage* target = nullptr;
+					string_view k = stack::get<string_view>(L, 2);
+					{
+						auto it = self.string_keys.find(k);
+						if (it != self.string_keys.cend()) {
+							target = &it->second;
+						}
+					}
+					if (target != nullptr) {
+						// let the target decide what to do, unless it's named...
+						if constexpr (is_new_index) {
+							return (target->new_index)(L, target->binding_data);
+						}
+						else {
+							return (target->index)(L, target->binding_data);
+						}
+					}
+				}
+				else if (k_type != type::lua_nil && k_type != type::none) {
+					stateless_reference* target = nullptr;
+					{
+						stack_reference k = stack::get<stack_reference>(L, 2);
+						auto it = self.auxiliary_keys.find(k);
+						if (it != self.auxiliary_keys.cend()) {
+							target = &it->second;
+						}
+					}
+					if (target != nullptr) {
+						if constexpr (is_new_index) {
+							// set value and return
+							target->reset(L, 3);
+							return 0;
+						}
+						else {
+							// push target to return
+							// what we found
+							return stack::push(L, *target);
+						}
+					}
+				}
+			}
+
+			// retrieve bases and walk through them.
+			bool keep_going = true;
+			int base_result;
+			(void)keep_going;
+			(void)base_result;
+			(void)detail::swallow { 1, (base_walk_index<is_new_index, Bases>(L, self, keep_going, base_result), 1)... };
+			if constexpr (sizeof...(Bases) > 0) {
+				if (!keep_going) {
+					return base_result;
+				}
+			}
+			if constexpr (base_walking) {
+				// if we're JUST base-walking then don't index-fail, just
+				// return the false bits
+				return base_walking_failed_index;
+			}
+			else if constexpr (from_named_metatable) {
+				if constexpr (is_new_index) {
+					return self.static_base_index.new_index(L, self.static_base_index.new_binding_data);
+				}
+				else {
+					return self.static_base_index.index(L, self.static_base_index.binding_data);
+				}
+			}
+			else {
+				if constexpr (is_new_index) {
+					return self.base_index.new_index(L, self.base_index.new_binding_data);
+				}
+				else {
+					return self.base_index.index(L, self.base_index.binding_data);
+				}
+			}
+		}
+
+		void change_indexing(lua_State* L_, submetatable_type submetatable_, void* derived_this_, stateless_stack_reference& t_, lua_CFunction index_,
+			lua_CFunction new_index_, lua_CFunction meta_index_, lua_CFunction meta_new_index_) {
+			usertype_storage_base& this_base = *this;
+			void* base_this = static_cast<void*>(&this_base);
+
+			this->is_using_index |= true;
+			this->is_using_new_index |= true;
+			if (submetatable_ == submetatable_type::named) {
+				stack::set_field(L_, metatable_key, named_index_table, t_.stack_index());
+				stateless_stack_reference stack_metametatable(L_, -named_metatable.push(L_));
+				stack::set_field<false, true>(L_,
+					meta_function::index,
+					make_closure(meta_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(meta_new_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop(L_);
+			}
+			else {
+				stack::set_field<false, true>(
+					L_, meta_function::index, make_closure(index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic), t_.stack_index());
+				stack::set_field<false, true>(
+					L_, meta_function::new_index, make_closure(new_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic), t_.stack_index());
+			}
+		}
+
+		template <typename T = void, typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value);
+
+		static int new_index_target_set(lua_State* L, void* target) {
+			usertype_storage_base& self = *static_cast<usertype_storage_base*>(target);
+			self.set(L, reference(L, raw_index(2)), reference(L, raw_index(3)));
+			return 0;
+		}
+
+		~usertype_storage_base() {
+			value_index_table.reset(m_L);
+			reference_index_table.reset(m_L);
+			unique_index_table.reset(m_L);
+			const_reference_index_table.reset(m_L);
+			const_value_index_table.reset(m_L);
+			named_index_table.reset(m_L);
+			type_table.reset(m_L);
+			gc_names_table.reset(m_L);
+			named_metatable.reset(m_L);
+
+			auto auxiliary_first = auxiliary_keys.cbegin();
+			auto auxiliary_last = auxiliary_keys.cend();
+			while (auxiliary_first != auxiliary_last) {
+				// save a copy to what we're going to destroy
+				auto auxiliary_target = auxiliary_first;
+				// move the iterator up by 1
+				++auxiliary_first;
+				// extract the node and destroy the key
+				auto extracted_node = auxiliary_keys.extract(auxiliary_target);
+				extracted_node.key().reset(m_L);
+				extracted_node.mapped().reset(m_L);
+				// continue if auxiliary_first hasn't been exhausted
+			}
+		}
+	};
+
+	template <typename T>
+	struct usertype_storage : usertype_storage_base {
+
+		using usertype_storage_base::usertype_storage_base;
+
+		template <bool is_new_index, bool from_named_metatable>
+		static inline int index_call_(lua_State* L) {
+			using bases = typename base<T>::type;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index, bool from_named_metatable, typename... Bases>
+		static inline int index_call_with_bases_(lua_State* L) {
+			using bases = types<Bases...>;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index>
+		static inline int index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, false>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, false, Bases...>>(L);
+		}
+
+		template <bool is_new_index>
+		static inline int meta_index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, true>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int meta_index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, true, Bases...>>(L);
+		}
+
+		template <typename Key, typename Value>
+		inline void set(lua_State* L, Key&& key, Value&& value);
+	};
+
+	template <typename T, typename Key, typename Value>
+	void usertype_storage_base::set(lua_State* L, Key&& key, Value&& value) {
+		using ValueU = meta::unwrap_unqualified_t<Value>;
+		using KeyU = meta::unwrap_unqualified_t<Key>;
+		using Binding = binding<KeyU, ValueU, T>;
+		using is_var_bind = is_variable_binding<ValueU>;
+		if constexpr (std::is_same_v<KeyU, call_construction>) {
+			(void)key;
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			this->storage.push_back(std::move(p_binding));
+
+			this->named_index_table.push(L);
+			absolute_index metametatable_index(L, -1);
+			std::string_view call_metamethod_name = to_string(meta_function::call);
+			lua_pushlstring(L, call_metamethod_name.data(), call_metamethod_name.size());
+			stack::push(L, nullptr);
+			stack::push(L, b.data());
+			lua_CFunction target_func = &b.template call<false, false>;
+			lua_pushcclosure(L, target_func, 2);
+			lua_rawset(L, metametatable_index);
+			this->named_index_table.pop(L);
+		}
+		else if constexpr (std::is_same_v<KeyU, base_classes_tag>) {
+			(void)key;
+			this->update_bases<T>(L, std::forward<Value>(value));
+		}
+		else if constexpr ((meta::is_string_like_or_constructible<KeyU>::value || std::is_same_v<KeyU, meta_function>)) {
+			std::string s = u_detail::make_string(std::forward<Key>(key));
+			auto storage_it = this->storage.end();
+			auto string_it = this->string_keys.find(s);
+			if (string_it != this->string_keys.cend()) {
+				const auto& binding_data = string_it->second.binding_data;
+				storage_it = std::find_if(this->storage.begin(), this->storage.end(), binding_data_equals(binding_data));
+				this->string_keys.erase(string_it);
+			}
+
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			if (storage_it != this->storage.cend()) {
+				*storage_it = std::move(p_binding);
+			}
+			else {
+				this->storage.push_back(std::move(p_binding));
+			}
+
+			bool is_index = (s == to_string(meta_function::index));
+			bool is_new_index = (s == to_string(meta_function::new_index));
+			bool is_static_index = (s == to_string(meta_function::static_index));
+			bool is_static_new_index = (s == to_string(meta_function::static_new_index));
+			bool is_destruction = s == to_string(meta_function::garbage_collect);
+			bool poison_indexing = (!is_using_index || !is_using_new_index) && (is_var_bind::value || is_index || is_new_index);
+			void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+			index_call_storage ics;
+			ics.binding_data = b.data();
+			ics.index = is_index || is_static_index ? &Binding::template call_with_<true, is_var_bind::value>
+				                                   : &Binding::template index_call_with_<true, is_var_bind::value>;
+			ics.new_index = is_new_index || is_static_new_index ? &Binding::template call_with_<false, is_var_bind::value>
+				                                               : &Binding::template index_call_with_<false, is_var_bind::value>;
+
+			string_for_each_metatable_func for_each_fx;
+			for_each_fx.is_destruction = is_destruction;
+			for_each_fx.is_index = is_index;
+			for_each_fx.is_new_index = is_new_index;
+			for_each_fx.is_static_index = is_static_index;
+			for_each_fx.is_static_new_index = is_static_new_index;
+			for_each_fx.poison_indexing = poison_indexing;
+			for_each_fx.p_key = &s;
+			for_each_fx.p_ics = &ics;
+			if constexpr (is_lua_c_function_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_CFunction = true;
+				for_each_fx.call_func = *static_cast<lua_CFunction*>(ics.binding_data);
+			}
+			else if constexpr (is_lua_reference_or_proxy_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_reference = true;
+				for_each_fx.p_binding_ref = static_cast<reference*>(ics.binding_data);
+			}
+			else {
+				for_each_fx.call_func = &b.template call<false, is_var_bind::value>;
+			}
+			for_each_fx.p_usb = this;
+			for_each_fx.p_derived_usb = derived_this;
+			for_each_fx.idx_call = &usertype_storage<T>::template index_call<false>;
+			for_each_fx.new_idx_call = &usertype_storage<T>::template index_call<true>;
+			for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call<false>;
+			for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call<true>;
+			for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+			// set base index and base new_index
+			// functions here
+			if (is_index) {
+				this->base_index.index = ics.index;
+				this->base_index.binding_data = ics.binding_data;
+			}
+			if (is_new_index) {
+				this->base_index.new_index = ics.new_index;
+				this->base_index.new_binding_data = ics.binding_data;
+			}
+			if (is_static_index) {
+				this->static_base_index.index = ics.index;
+				this->static_base_index.binding_data = ics.binding_data;
+			}
+			if (is_static_new_index) {
+				this->static_base_index.new_index = ics.new_index;
+				this->static_base_index.new_binding_data = ics.binding_data;
+			}
+			this->for_each_table(L, for_each_fx);
+			this->add_entry(s, std::move(ics));
+		}
+		else {
+			// the reference-based implementation might compare poorly and hash
+			// poorly in some cases...
+			if constexpr (is_lua_reference_v<KeyU> && is_lua_reference_v<ValueU>) {
+				if (key.get_type() == type::string) {
+					stack::push(L, key);
+					std::string string_key = stack::pop<std::string>(L);
+					this->set<T>(L, string_key, std::forward<Value>(value));
+				}
+				else {
+					lua_reference_func ref_additions_fx { key, value };
+
+					this->for_each_table(L, ref_additions_fx);
+					this->auxiliary_keys.insert_or_assign(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+			else {
+				reference ref_key = make_reference(L, std::forward<Key>(key));
+				reference ref_value = make_reference(L, std::forward<Value>(value));
+				lua_reference_func ref_additions_fx { ref_key, ref_value };
+
+				this->for_each_table(L, ref_additions_fx);
+				this->auxiliary_keys.insert_or_assign(std::move(ref_key), std::move(ref_value));
+			}
+		}
+	}
+
+	template <typename T>
+	template <typename Key, typename Value>
+	void usertype_storage<T>::set(lua_State* L, Key&& key, Value&& value) {
+		static_cast<usertype_storage_base&>(*this).set<T>(L, std::forward<Key>(key), std::forward<Value>(value));
+	}
+
+	template <typename T>
+	inline void clear_usertype_registry_names(lua_State* L) {
+		using u_traits = usertype_traits<T>;
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<d::u<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+
+		stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+		registry.push();
+		// eliminate all named entries for this usertype
+		// in the registry (luaL_newmetatable does
+		// [name] = new table
+		// in registry upon creation
+		stack::set_field(L, &u_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_unique_traits::metatable()[0], lua_nil, registry.stack_index());
+		registry.pop();
+	}
+
+	template <typename T>
+	inline int destroy_usertype_storage(lua_State* L) noexcept {
+		clear_usertype_registry_names<T>(L);
+		return detail::user_alloc_destroy<usertype_storage<T>>(L);
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& create_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+
+		// Make sure userdata's memory is properly in lua first,
+		// otherwise all the light userdata we make later will become invalid
+		int usertype_storage_push_count = stack::push<user<usertype_storage<T>>>(L, no_metatable, L);
+		stack_reference usertype_storage_ref(L, -usertype_storage_push_count);
+
+		// create and push onto the stack a table to use as metatable for this GC
+		// we create a metatable to attach to the regular gc_table
+		// so that the destructor is called for the usertype storage
+		int usertype_storage_metatabe_count = stack::push(L, new_table(0, 1));
+		stack_reference usertype_storage_metatable(L, -usertype_storage_metatabe_count);
+		// set the destroyion routine on the metatable
+		stack::set_field(L, meta_function::garbage_collect, &destroy_usertype_storage<T>, usertype_storage_metatable.stack_index());
+		// set the metatable on the usertype storage userdata
+		stack::set_field(L, metatable_key, usertype_storage_metatable, usertype_storage_ref.stack_index());
+		usertype_storage_metatable.pop();
+
+		// set the usertype storage and its metatable
+		// into the global table...
+		stack::set_field<true>(L, gcmetakey, usertype_storage_ref);
+		usertype_storage_ref.pop();
+
+		// then retrieve the lua-stored version so we have a well-pinned
+		// reference that does not die
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	inline optional<usertype_storage_base&> maybe_as_usertype_storage_base(lua_State* L, int index) {
+		if (type_of(L, index) != type::lightuserdata) {
+			return nullopt;
+		}
+		usertype_storage_base& base_storage = *static_cast<usertype_storage_base*>(stack::get<void*>(L, index));
+		return base_storage;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base_inside(lua_State* L, int index) {
+		// okay, maybe we're looking at a table that is nested?
+		if (type_of(L, index) != type::table) {
+			return nullopt;
+		}
+		stack::get_field(L, meta_function::storage, index);
+		auto maybe_storage_base = maybe_as_usertype_storage_base(L, -1);
+		lua_pop(L, 1);
+		return maybe_storage_base;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, int index) {
+		// If we can get the index directly as this type, go for it
+		auto maybe_already_is_usertype_storage_base = maybe_as_usertype_storage_base(L, index);
+		if (maybe_already_is_usertype_storage_base) {
+			return maybe_already_is_usertype_storage_base;
+		}
+		return maybe_get_usertype_storage_base_inside(L, index);
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		auto maybe_storage = maybe_as_usertype_storage_base(L, lua_gettop(L));
+		lua_pop(L, 1);
+		return maybe_storage;
+	}
+
+	inline usertype_storage_base& get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		stack::record tracking;
+		usertype_storage_base& target_umt = stack::stack_detail::unchecked_unqualified_get<user<usertype_storage_base>>(L, -1, tracking);
+		lua_pop(L, 1);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		int target = lua_gettop(L);
+		if (!stack::check<user<usertype_storage<T>>>(L, target)) {
+			return nullopt;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline void clear_usertype_storage(lua_State* L) {
+		using u_traits = usertype_traits<T>;
+
+		const char* gcmetakey = &u_traits::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		if (!stack::check<user<usertype_storage<T>>>(L)) {
+			lua_pop(L, 1);
+			return;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		target_umt.clear();
+
+		clear_usertype_registry_names<T>(L);
+
+		stack::set_field<true>(L, gcmetakey, lua_nil);
+	}
+
+	template <typename T, automagic_flags enrollment_flags>
+	inline int register_usertype(lua_State* L_, automagic_enrollments enrollments_ = {}) {
+		using u_traits = usertype_traits<T>;
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<d::u<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+		using uts = usertype_storage<T>;
+
+		// always have __new_index point to usertype_storage method
+		// have __index always point to regular fast-lookup
+		// meta_method table
+		// if __new_index is invoked, runtime-swap
+		// to slow __index if necessary
+		// (no speed penalty because function calls
+		// are all read-only -- only depend on __index
+		// to retrieve function and then call happens VIA Lua)
+
+		// __type entry:
+		// table contains key -> value lookup,
+		// where key is entry in metatable
+		// and value is type information as a string as
+		// best as we can give it
+
+		// name entry:
+		// string that contains raw class name,
+		// as defined from C++
+
+		// is entry:
+		// checks if argument supplied is of type T
+
+		// __storage entry:
+		// a light userdata pointing to the storage
+		// mostly to enable this new abstraction
+		// to not require the type name `T`
+		// to get at the C++ usertype storage within
+
+		// we then let typical definitions potentially override these intrinsics
+		// it's the user's fault if they override things or screw them up:
+		// these names have been reserved and documented since sol2
+
+		// STEP 0: tell the old usertype (if it exists)
+		// to fuck off
+		clear_usertype_storage<T>(L_);
+
+		// STEP 1: Create backing store for usertype storage
+		// Pretty much the most important step.
+		// STEP 2: Create Lua tables used for fast method indexing.
+		// This is done inside of the storage table's constructor
+		usertype_storage<T>& storage = create_usertype_storage<T>(L_);
+		usertype_storage_base& base_storage = storage;
+		void* light_storage = static_cast<void*>(&storage);
+		void* light_base_storage = static_cast<void*>(&base_storage);
+
+		// STEP 3: set up GC escape hatch table entirely
+		storage.gc_names_table.push(L_);
+		stateless_stack_reference gnt(L_, -1);
+		stack::set_field(L_, submetatable_type::named, &u_traits::gc_table()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::const_value, &u_const_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::const_reference, &u_const_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::reference, &u_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::unique, &u_unique_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::value, &u_traits::metatable()[0], gnt.stack_index());
+		gnt.pop(L_);
+
+		// STEP 4: add some useful information to the type table
+		stateless_stack_reference stacked_type_table(L_, -storage.type_table.push(L_));
+		stack::set_field(L_, "name", detail::demangle<T>(), stacked_type_table.stack_index());
+		stack::set_field(L_, "is", &detail::is_check<T>, stacked_type_table.stack_index());
+		stacked_type_table.pop(L_);
+
+		// STEP 5: create and hook up metatable,
+		// add intrinsics
+		// this one is the actual meta-handling table,
+		// the next one will be the one for
+		int for_each_backing_metatable_calls = 0;
+		auto for_each_backing_metatable = [&](lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			// Pointer types, AKA "references" from C++
+			const char* metakey = nullptr;
+			switch (smt_) {
+			case submetatable_type::const_value:
+				metakey = &u_const_traits::metatable()[0];
+				break;
+			case submetatable_type::reference:
+				metakey = &u_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::unique:
+				metakey = &u_unique_traits::metatable()[0];
+				break;
+			case submetatable_type::const_reference:
+				metakey = &u_const_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::named:
+				metakey = &u_traits::user_metatable()[0];
+				break;
+			case submetatable_type::value:
+			default:
+				metakey = &u_traits::metatable()[0];
+				break;
+			}
+
+			luaL_newmetatable(L_, metakey);
+			if (smt_ == submetatable_type::named) {
+				// the named table itself
+				// gets the associated name value
+				storage.named_metatable.reset(L_, -1);
+				lua_pop(L_, 1);
+				// but the thing we perform the methods on
+				// is still the metatable of the named
+				// table
+				lua_createtable(L_, 0, 6);
+			}
+			stateless_stack_reference t(L_, -1);
+			fast_index_table_.reset(L_, t.stack_index());
+			stack::set_field<false, true>(L_, meta_function::type, storage.type_table, t.stack_index());
+			// destructible? serialize default destructor here
+			// otherwise, not destructible: serialize a "hey you messed up"
+			switch (smt_) {
+			case submetatable_type::const_reference:
+			case submetatable_type::reference:
+			case submetatable_type::named:
+				break;
+			case submetatable_type::unique:
+				if constexpr (std::is_destructible_v<T>) {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::unique_destroy<T>, t.stack_index());
+				}
+				else {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::cannot_destroy<T>, t.stack_index());
+				}
+				break;
+			case submetatable_type::value:
+			case submetatable_type::const_value:
+			default:
+				if constexpr (std::is_destructible_v<T>) {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, detail::make_destructor<T>(), t.stack_index());
+				}
+				else {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::cannot_destroy<T>, t.stack_index());
+				}
+				break;
+			}
+
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			stack::set_field<false, true>(L_, detail::base_class_check_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_check), t.stack_index());
+			stack::set_field<false, true>(L_, detail::base_class_cast_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_cast), t.stack_index());
+
+			auto prop_fx = detail::properties_enrollment_allowed(for_each_backing_metatable_calls, storage.properties, enrollments_);
+			auto insert_fx = [&L_, &t, &storage](meta_function mf, lua_CFunction reg) {
+				stack::set_field<false, true>(L_, mf, reg, t.stack_index());
+				storage.properties[static_cast<std::size_t>(mf)] = true;
+			};
+			detail::insert_default_registrations<T>(insert_fx, prop_fx);
+
+			// There are no variables, so serialize the fast function stuff
+			// be sure to reset the index stuff to the non-fast version
+			// if the user ever adds something later!
+			if (smt_ == submetatable_type::named) {
+				// add escape hatch storage pointer and gc names
+				stack::set_field<false, true>(L_, meta_function::storage, light_base_storage, t.stack_index());
+				stack::set_field<false, true>(L_, meta_function::gc_names, storage.gc_names_table, t.stack_index());
+
+				// fancy new_indexing when using the named table
+				{
+					absolute_index named_metatable_index(L_, -storage.named_metatable.push(L_));
+					stack::set_field<false, true>(L_, metatable_key, t, named_metatable_index);
+					storage.named_metatable.pop(L_);
+				}
+				stack_reference stack_metametatable(L_, -storage.named_index_table.push(L_));
+				stack::set_field<false, true>(L_,
+					meta_function::index,
+					make_closure(uts::template meta_index_call<false>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(uts::template meta_index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop();
+			}
+			else {
+				// otherwise just plain for index,
+				// and elaborated for new_index
+				stack::set_field<false, true>(L_, meta_function::index, t, t.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(uts::template index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					t.stack_index());
+				storage.is_using_new_index = true;
+			}
+
+			++for_each_backing_metatable_calls;
+			fast_index_table_.reset(L_, t.stack_index());
+			t.pop(L_);
+		};
+
+		storage.for_each_table(L_, for_each_backing_metatable);
+
+		// can only use set AFTER we initialize all the metatables
+		if constexpr (std::is_default_constructible_v<T> && has_flag(enrollment_flags, automagic_flags::default_constructor)) {
+			if (enrollments_.default_constructor) {
+				storage.set(L_, meta_function::construct, constructors<T()>());
+			}
+		}
+
+		// return the named metatable we want names linked into
+		storage.named_metatable.push(L_);
+		return 1;
+	}
+}} // namespace sol::u_detail
+
+// end of sol/usertype_storage.hpp
+
+// beginning of sol/usertype_proxy.hpp
+
+namespace sol {
+	template <typename Table, typename Key>
+	struct usertype_proxy : public proxy_base<usertype_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(key)..., std::forward<T>(value));
+			}
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		usertype_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		usertype_proxy& set(T&& item) & {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			tuple_set(idx_seq(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		usertype_proxy&& set(T&& item) && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			std::move(*this).tuple_set(idx_seq(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(T&& other) & {
+			return set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(T&& other) && {
+			return std::move(*this).set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
+			// MSVC is ass sometimes
+			return get<function>().call<Ret...>(std::forward<Args>(args)...);
+#else
+			return get<function>().template call<Ret...>(std::forward<Args>(args)...);
+#endif
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			return get<reference>().push(L);
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+	};
+} // namespace sol
+
+// end of sol/usertype_proxy.hpp
+
+// beginning of sol/metatable.hpp
+
+// beginning of sol/table_core.hpp
+
+// beginning of sol/table_proxy.hpp
+
+namespace sol {
+
+	template <typename Table, typename Key>
+	struct table_proxy : public proxy_base<table_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+		}
+
+		auto setup_table(std::true_type) {
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, tbl.stack_index());
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		bool is_valid(std::false_type) {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		table_proxy& set(T&& item) & {
+			tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		table_proxy&& set(T&& item) && {
+			std::move(*this).tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename... Args>
+		table_proxy& set_function(Args&&... args) & {
+			tbl.set_function(key, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		table_proxy&& set_function(Args&&... args) && {
+			tbl.set_function(std::move(key), std::forward<Args>(args)...);
+			return std::move(*this);
+		}
+
+		template <typename T>
+		table_proxy& operator=(T&& other) & {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu>) {
+				return set_function(std::forward<T>(other));
+			}
+			else {
+				return set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy&& operator=(T&& other) && {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu> && !detail::is_msvc_callable_rigged_v<T>) {
+				return std::move(*this).set_function(std::forward<T>(other));
+			}
+			else {
+				return std::move(*this).set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		table_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		bool is() const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = this->get<optional<U>>();
+			return option.has_value();
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get_or(T&& otherwise) const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = get<optional<U>>();
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename D>
+		decltype(auto) get_or(D&& otherwise) const {
+			optional<T> option = get<optional<T>>();
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T>
+		decltype(auto) get_or_create() {
+			return get_or_create<T>(new_table());
+		}
+
+		template <typename T, typename Otherwise>
+		decltype(auto) get_or_create(Otherwise&& other) {
+			if (!this->valid()) {
+				this->set(std::forward<Otherwise>(other));
+			}
+			return get<T>();
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			lua_State* L = this->lua_state();
+			push(L);
+			int idx = lua_gettop(L);
+			stack_aligned_function func(L, idx);
+			return func.call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			if constexpr (std::is_same_v<meta::unqualified_t<Table>, global_table> || is_stack_table_v<meta::unqualified_t<Table>>) {
+				auto pp = stack::push_pop<true>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int top_index = lua_gettop(L);
+				stack::get_field<true>(lua_state(), key, tableindex);
+				lua_replace(L, top_index + 1);
+				lua_settop(L, top_index + 1);
+			}
+			else {
+				auto pp = stack::push_pop<false>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int aftertableindex = lua_gettop(L);
+				stack::get_field<false>(lua_state(), key, tableindex);
+				lua_replace(L, tableindex);
+				lua_settop(L, aftertableindex + 1);
+			}
+			return 1;
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+
+		table_proxy& force() {
+			if (!this->valid()) {
+				this->set(new_table());
+			}
+			return *this;
+		}
+	};
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return right.valid();
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(proxy_base<Super>&& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(const proxy_base<Super>& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	namespace stack {
+		template <typename Table, typename Key>
+		struct unqualified_pusher<table_proxy<Table, Key>> {
+			static int push(lua_State* L, const table_proxy<Table, Key>& p) {
+				return p.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table_proxy.hpp
+
+// beginning of sol/table_iterator.hpp
+
+#include <iterator>
+
+namespace sol {
+
+	template <typename reference_type>
+	class basic_table_iterator {
+	public:
+		typedef object key_type;
+		typedef object mapped_type;
+		typedef std::pair<object, object> value_type;
+		typedef std::input_iterator_tag iterator_category;
+		typedef std::ptrdiff_t difference_type;
+		typedef value_type* pointer;
+		typedef value_type& reference;
+		typedef const value_type& const_reference;
+
+	private:
+		std::pair<object, object> kvp;
+		reference_type ref;
+		int tableidx = 0;
+		int keyidx = 0;
+		std::ptrdiff_t idx = 0;
+
+	public:
+		basic_table_iterator() noexcept : keyidx(-1), idx(-1) {
+		}
+
+		basic_table_iterator(reference_type x) noexcept : ref(std::move(x)) {
+			ref.push();
+			tableidx = lua_gettop(ref.lua_state());
+			stack::push(ref.lua_state(), lua_nil);
+			this->operator++();
+			if (idx == -1) {
+				return;
+			}
+			--idx;
+		}
+
+		basic_table_iterator& operator++() noexcept {
+			if (idx == -1)
+				return *this;
+
+			if (lua_next(ref.lua_state(), tableidx) == 0) {
+				idx = -1;
+				keyidx = -1;
+				return *this;
+			}
+			++idx;
+			kvp.first = object(ref.lua_state(), -2);
+			kvp.second = object(ref.lua_state(), -1);
+			lua_pop(ref.lua_state(), 1);
+			// leave key on the stack
+			keyidx = lua_gettop(ref.lua_state());
+			return *this;
+		}
+
+		basic_table_iterator operator++(int) noexcept {
+			auto saved = *this;
+			this->operator++();
+			return saved;
+		}
+
+		reference operator*() const noexcept {
+			return const_cast<reference>(kvp);
+		}
+
+		bool operator==(const basic_table_iterator& right) const noexcept {
+			return idx == right.idx;
+		}
+
+		bool operator!=(const basic_table_iterator& right) const noexcept {
+			return idx != right.idx;
+		}
+
+		~basic_table_iterator() {
+			if (keyidx != -1) {
+				stack::remove(ref.lua_state(), keyidx, 1);
+			}
+			if (ref.lua_state() != nullptr && ref.valid()) {
+				stack::remove(ref.lua_state(), tableidx, 1);
+			}
+		}
+	};
+
+} // namespace sol
+
+// end of sol/table_iterator.hpp
+
+// beginning of sol/pairs_iterator.hpp
+
+// beginning of sol/stack/detail/pairs.hpp
+
+#include <optional>
+
+namespace sol { namespace stack { namespace stack_detail {
+
+	inline bool maybe_push_lua_next_function(lua_State* L_) {
+		stack::get_field<true, false>(L_, "next");
+		bool is_next = stack::check<protected_function>(L_);
+		if (is_next) {
+			return true;
+		}
+		stack::get_field<true, false>(L_, "table");
+		stack::record tracking{};
+		if (!stack::loose_table_check(L_, -1, &no_panic, tracking)) {
+			return false;
+		}
+		lua_getfield(L_, -1, "next");
+		bool is_table_next_func = stack::check<protected_function>(L_, -1);
+		if (is_table_next_func) {
+			return true;
+		}
+		lua_pop(L_, 1);
+		return false;
+	}
+
+	inline std::optional<protected_function> find_lua_next_function(lua_State* L_) {
+		if (maybe_push_lua_next_function(L_)) {
+			return stack::pop<protected_function>(L_);
+		}
+		return std::nullopt;
+	}
+
+	inline int c_lua_next(lua_State* L_) noexcept {
+		stack_reference table_stack_ref(L_, raw_index(1));
+		stateless_stack_reference key_stack_ref(L_, raw_index(2));
+		int result = lua_next(table_stack_ref.lua_state(), table_stack_ref.stack_index());
+		if (result == 0) {
+			stack::push(L_, lua_nil);
+			return 1;
+		}
+		return 2;
+	}
+
+	inline int readonly_pairs(lua_State* L_) noexcept {
+		int pushed = 0;
+		if (!maybe_push_lua_next_function(L_)) {
+			// we do not have the "next" function in the global namespace
+			// from the "table" global entiry, use our own
+			pushed += stack::push(L_, &c_lua_next);
+		}
+		else {
+			pushed += 1;
+		}
+		int metatable_exists = lua_getmetatable(L_, 1);
+		sol_c_assert(metatable_exists == 1);
+		const auto& index_key = to_string(sol::meta_function::index);
+		lua_getfield(L_, lua_gettop(L_), index_key.c_str());
+		lua_remove(L_, -2);
+		pushed += 1;
+		pushed += stack::push(L_, lua_nil);
+		return pushed;
+	}
+
+}}} // sol::stack::stack_detail
+
+// end of sol/stack/detail/pairs.hpp
+
+namespace sol {
+
+	struct pairs_sentinel { };
+
+	class pairs_iterator {
+	private:
+		inline static constexpr int empty_key_index = -1;
+
+	public:
+		using key_type = object;
+		using mapped_type = object;
+		using value_type = std::pair<object, object>;
+		using iterator_category = std::input_iterator_tag;
+		using difference_type = std::ptrdiff_t;
+		using pointer = value_type*;
+		using const_pointer = value_type const*;
+		using reference = value_type&;
+		using const_reference = const value_type&;
+
+		pairs_iterator() noexcept
+		: m_L(nullptr)
+		, m_next_function_ref(lua_nil)
+		, m_table_ref(lua_nil)
+		, m_cached_key_value_pair({ lua_nil, lua_nil })
+		, m_key_index(empty_key_index)
+		, m_iteration_index(0) {
+		}
+
+		pairs_iterator(const pairs_iterator&) = delete;
+		pairs_iterator& operator=(const pairs_iterator&) = delete;
+
+		pairs_iterator(pairs_iterator&& right) noexcept
+		: m_L(right.m_L)
+		, m_next_function_ref(std::move(right.m_next_function_ref))
+		, m_table_ref(std::move(right.m_table_ref))
+		, m_cached_key_value_pair(std::move(right.m_cached_key_value_pair))
+		, m_key_index(right.m_key_index)
+		, m_iteration_index(right.m_iteration_index) {
+			right.m_key_index = empty_key_index;
+		}
+
+		pairs_iterator& operator=(pairs_iterator&& right) noexcept {
+			m_L = right.m_L;
+			m_next_function_ref = std::move(right.m_next_function_ref);
+			m_table_ref = std::move(right.m_table_ref);
+			m_cached_key_value_pair = std::move(right.m_cached_key_value_pair);
+			m_key_index = right.m_key_index;
+			m_iteration_index = right.m_iteration_index;
+			right.m_key_index = empty_key_index;
+			return *this;
+		}
+
+		template <typename Source>
+		pairs_iterator(const Source& source_) noexcept : m_L(source_.lua_state()), m_key_index(empty_key_index), m_iteration_index(0) {
+			if (m_L == nullptr || !source_.valid()) {
+				m_key_index = empty_key_index;
+				return;
+			}
+			int source_index = -source_.push(m_L);
+			int abs_source_index = lua_absindex(m_L, source_index);
+			int metatable_exists = lua_getmetatable(m_L, abs_source_index);
+			lua_remove(m_L, abs_source_index);
+			if (metatable_exists == 1) {
+				// just has a metatable, but does it have __pairs ?
+				stack_reference metatable(m_L, raw_index(abs_source_index));
+				stack::get_field<is_global_table_v<Source>, true>(m_L, meta_function::pairs, metatable.stack_index());
+				optional<protected_function> maybe_pairs_function = stack::pop<optional<protected_function>>(m_L);
+				if (maybe_pairs_function.has_value()) {
+					protected_function& pairs_function = *maybe_pairs_function;
+					protected_function_result next_fn_and_table_and_first_key = pairs_function(source_);
+					if (next_fn_and_table_and_first_key.valid()) {
+						m_next_function_ref = next_fn_and_table_and_first_key.get<protected_function>(0);
+						m_table_ref = next_fn_and_table_and_first_key.get<sol::reference>(1);
+						m_key_index = next_fn_and_table_and_first_key.stack_index() - 1;
+						// remove next function and table
+						lua_remove(m_L, m_key_index);
+						lua_remove(m_L, m_key_index);
+						next_fn_and_table_and_first_key.abandon();
+						lua_remove(m_L, abs_source_index);
+						this->operator++();
+						m_iteration_index = 0;
+						return;
+					}
+				}
+			}
+
+			{
+				auto maybe_next = stack::stack_detail::find_lua_next_function(m_L);
+				if (maybe_next.has_value()) {
+					m_next_function_ref = std::move(*maybe_next);
+					m_table_ref = source_;
+
+					stack::push(m_L, lua_nil);
+					m_key_index = lua_gettop(m_L);
+					this->operator++();
+					m_iteration_index = 0;
+					return;
+				}
+			}
+
+			// okay, so none of the above worked and now we need to create
+			// a shim / polyfill instead
+			stack::push(m_L, &stack::stack_detail::c_lua_next);
+			m_next_function_ref = stack::pop<protected_function>(m_L);
+			m_table_ref = source_;
+			stack::push(m_L, lua_nil);
+			m_key_index = lua_gettop(m_L);
+			this->operator++();
+			m_iteration_index = 0;
+		}
+
+		pairs_iterator& operator++() {
+			if (m_key_index == empty_key_index) {
+				return *this;
+			}
+			{
+				sol::protected_function_result next_results = m_next_function_ref(m_table_ref, stack_reference(m_L, m_key_index));
+				if (!next_results.valid()) {
+					// TODO: abort, or throw an error?
+					m_clear();
+					m_key_index = empty_key_index;
+					return *this;
+				}
+				int next_results_count = next_results.return_count();
+				if (next_results_count < 2) {
+					// iteration is over!
+					next_results.abandon();
+					lua_settop(m_L, m_key_index - 1);
+					m_key_index = empty_key_index;
+					++m_iteration_index;
+					return *this;
+				}
+				else {
+					lua_remove(m_L, m_key_index);
+					m_key_index = next_results.stack_index() - 1;
+					m_cached_key_value_pair.first = stack::get<object>(m_L, m_key_index);
+					m_cached_key_value_pair.second = stack::get<object>(m_L, m_key_index + 1);
+					lua_settop(m_L, m_key_index);
+					next_results.abandon();
+				}
+			}
+			++m_iteration_index;
+			return *this;
+		}
+
+		std::ptrdiff_t index() const {
+			return static_cast<std::ptrdiff_t>(m_iteration_index);
+		}
+
+		const_reference operator*() const noexcept {
+			return m_cached_key_value_pair;
+		}
+
+		reference operator*() noexcept {
+			return m_cached_key_value_pair;
+		}
+
+		friend bool operator==(const pairs_iterator& left, const pairs_iterator& right) noexcept {
+			return left.m_table_ref == right.m_table_ref && left.m_iteration_index == right.m_iteration_index;
+		}
+
+		friend bool operator!=(const pairs_iterator& left, const pairs_iterator& right) noexcept {
+			return left.m_table_ref != right.m_table_ref || left.m_iteration_index != right.m_iteration_index;
+		}
+
+		friend bool operator==(const pairs_iterator& left, const pairs_sentinel&) noexcept {
+			return left.m_key_index == empty_key_index;
+		}
+
+		friend bool operator!=(const pairs_iterator& left, const pairs_sentinel&) noexcept {
+			return left.m_key_index != empty_key_index;
+		}
+
+		friend bool operator==(const pairs_sentinel&, const pairs_iterator& left) noexcept {
+			return left.m_key_index == empty_key_index;
+		}
+
+		friend bool operator!=(const pairs_sentinel&, const pairs_iterator& left) noexcept {
+			return left.m_key_index != empty_key_index;
+		}
+
+		~pairs_iterator() {
+			if (m_key_index != empty_key_index) {
+				m_clear();
+			}
+		}
+
+	private:
+		void m_clear() noexcept {
+			lua_remove(m_L, m_key_index);
+		}
+
+		lua_State* m_L;
+		protected_function m_next_function_ref;
+		sol::reference m_table_ref;
+		std::pair<object, object> m_cached_key_value_pair;
+		int m_key_index;
+		int m_iteration_index;
+	};
+
+	template <typename Source>
+	class basic_pairs_range {
+	private:
+		using source_t = std::add_lvalue_reference_t<Source>;
+		source_t m_source;
+
+	public:
+		using iterator = pairs_iterator;
+		using const_iterator = pairs_iterator;
+
+		basic_pairs_range(source_t source_) noexcept : m_source(source_) {
+		}
+
+		iterator begin() noexcept {
+			return iterator(m_source);
+		}
+
+		iterator begin() const noexcept {
+			return iterator(m_source);
+		}
+
+		const_iterator cbegin() const noexcept {
+			return const_iterator(m_source);
+		}
+
+		pairs_sentinel end() noexcept {
+			return {};
+		}
+
+		pairs_sentinel end() const noexcept {
+			return {};
+		}
+
+		pairs_sentinel cend() const noexcept {
+			return {};
+		}
+	};
+} // namespace sol
+
+// end of sol/pairs_iterator.hpp
+
+namespace sol {
+	namespace detail {
+		template <std::size_t n>
+		struct clean {
+			lua_State* L;
+			clean(lua_State* luastate) : L(luastate) {
+			}
+			~clean() {
+				lua_pop(L, static_cast<int>(n));
+			}
+		};
+
+		struct ref_clean {
+			lua_State* L;
+			int& pop_count;
+
+			ref_clean(lua_State* L_, int& pop_count_) noexcept : L(L_), pop_count(pop_count_) {
+			}
+			~ref_clean() {
+				lua_pop(L, static_cast<int>(pop_count));
+			}
+		};
+
+		inline int fail_on_newindex(lua_State* L_) {
+			return luaL_error(L_, "sol: cannot modify the elements of an enumeration table");
+		}
+
+	} // namespace detail
+
+	template <bool top_level, typename ref_t>
+	class basic_table_core : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		friend class state;
+		friend class state_view;
+		template <typename, typename>
+		friend class basic_usertype;
+		template <typename>
+		friend class basic_metatable;
+
+		template <typename T>
+		using is_get_direct_tableless = meta::boolean<stack::stack_detail::is_get_direct_tableless_v<T, top_level, false>>;
+
+		template <typename T>
+		using is_raw_get_direct_tableless = std::false_type;
+
+		template <typename T>
+		using is_set_direct_tableless = meta::boolean<stack::stack_detail::is_set_direct_tableless_v<T, top_level, false>>;
+
+		template <typename T>
+		using is_raw_set_direct_tableless = std::false_type;
+
+		template <bool raw, typename... Ret, typename... Keys>
+		decltype(auto) tuple_get(int table_index, Keys&&... keys) const {
+			if constexpr (sizeof...(Ret) < 2) {
+				return traverse_get_single_maybe_tuple<raw, Ret...>(table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				using multi_ret = decltype(stack::pop<std::tuple<Ret...>>(nullptr));
+				return multi_ret(traverse_get_single_maybe_tuple<raw, Ret>(table_index, std::forward<Keys>(keys))...);
+			}
+		}
+
+		template <bool raw, typename Ret, size_t... I, typename Key>
+		decltype(auto) traverse_get_single_tuple(int table_index, std::index_sequence<I...>, Key&& key) const {
+			return traverse_get_single<raw, Ret>(table_index, std::get<I>(std::forward<Key>(key))...);
+		}
+
+		template <bool raw, typename Ret, typename Key>
+		decltype(auto) traverse_get_single_maybe_tuple(int table_index, Key&& key) const {
+			if constexpr (meta::is_tuple_v<meta::unqualified_t<Key>>) {
+				return traverse_get_single_tuple<raw, Ret>(
+				     table_index, std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<Key>>>(), std::forward<Key>(key));
+			}
+			else {
+				return traverse_get_single<raw, Ret>(table_index, std::forward<Key>(key));
+			}
+		}
+
+		template <bool raw, typename Ret, typename... Keys>
+		decltype(auto) traverse_get_single(int table_index, Keys&&... keys) const {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			if constexpr (meta::is_optional_v<meta::unqualified_t<Ret>>) {
+				int popcount = 0;
+				detail::ref_clean c(base_t::lua_state(), popcount);
+				return traverse_get_deep_optional<global, raw, detail::insert_mode::none, Ret>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				detail::clean<sizeof...(Keys) - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>> c(base_t::lua_state());
+				return traverse_get_deep<global, raw, detail::insert_mode::none, Ret>(table_index, std::forward<Keys>(keys)...);
+			}
+		}
+
+		template <bool raw, typename Pairs, std::size_t... I>
+		void tuple_set(std::index_sequence<I...>, Pairs&& pairs) {
+			constexpr static bool global = (meta::count_even_for_pack_v < is_set_direct_tableless,
+			     meta::unqualified_t<decltype(std::get<I * 2>(std::forward<Pairs>(pairs)))>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)table_index;
+			(void)L;
+			void(detail::swallow { (stack::set_field<(top_level), raw>(
+			                             L, std::get<I * 2>(std::forward<Pairs>(pairs)), std::get<I * 2 + 1>(std::forward<Pairs>(pairs)), table_index),
+			     0)... });
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep(int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				(void)key;
+				return traverse_get_deep<false, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil), T>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+				if constexpr (sizeof...(Keys) > 0) {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if (t == type::lua_nil || t == type::none) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return traverse_get_deep<false, raw, mode, T>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if ((t == type::lua_nil || t == type::none) && (is_table_like_v<T>)) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep_optional(int& popcount, int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, update_if_empty_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, override_value_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				if constexpr (sizeof...(Keys) > 0) {
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+							stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+						}
+						else {
+							return T(nullopt);
+						}
+					}
+					return traverse_get_deep_optional<false, raw, mode, T>(popcount, lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					using R = decltype(stack::get<T>(nullptr));
+					using value_type = typename meta::unqualified_t<R>::value_type;
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw, value_type>(L, key, table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							if (stack::check<value_type>(L, lua_gettop(L), &no_panic)) {
+								return stack::get<T>(L);
+							}
+						}
+						return R(nullopt);
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename Key, typename... Keys>
+		void traverse_set_deep(int table_index, Key&& key, Keys&&... keys) const {
+			using KeyU = meta::unqualified_t<Key>;
+			if constexpr (std::is_same_v<KeyU, update_if_empty_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, create_if_nil_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, override_value_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				if constexpr (sizeof...(Keys) == 1) {
+					if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty) {
+						auto p = stack::probe_get_field<global, raw>(L, key, table_index);
+						lua_pop(L, p.levels);
+						if (!p.success) {
+							stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+						}
+					}
+					else {
+						stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+					}
+				}
+				else {
+					if constexpr (mode != detail::insert_mode::none) {
+						stack::get_field<global, raw>(L, key, table_index);
+						type vt = type_of(L, -1);
+						if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty
+						     || (mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							if (vt == type::lua_nil || vt == type::none) {
+								constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+						else {
+							if (vt != type::table) {
+								constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+					}
+					else {
+						stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					}
+					traverse_set_deep<false, raw, mode>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+			}
+		}
+
+	protected:
+		basic_table_core(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+	public:
+		using iterator = basic_table_iterator<ref_t>;
+		using const_iterator = iterator;
+
+		using base_t::lua_state;
+
+		basic_table_core() noexcept = default;
+		basic_table_core(const basic_table_core&) = default;
+		basic_table_core(basic_table_core&&) = default;
+		basic_table_core& operator=(const basic_table_core&) = default;
+		basic_table_core& operator=(basic_table_core&&) = default;
+
+		basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+
+		basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+
+		basic_table_core(lua_State* L, const new_table& nt) : base_t(L, -stack::push(L, nt)) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+
+		basic_table_core(lua_State* L, int index = -1) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_table_core>(L, index, handler);
+#endif // Safety
+		}
+
+		basic_table_core(lua_State* L, ref_index index) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(T&& r) noexcept : basic_table_core(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				constructor_handler handler {};
+				stack::check<basic_table_core>(lua_state(), table_index, handler);
+			}
+#endif // Safety
+		}
+
+		basic_table_core(lua_nil_t r) noexcept : basic_table_core(detail::no_safety, r) {
+		}
+
+		basic_table_core(lua_State* L, global_tag_t t) noexcept : base_t(L, t) {
+		}
+
+		iterator begin() const {
+			if (this->get_type() == type::table) {
+				return iterator(*this);
+			}
+			return iterator();
+		}
+
+		iterator end() const {
+			return iterator();
+		}
+
+		const_iterator cbegin() const {
+			return begin();
+		}
+
+		const_iterator cend() const {
+			return end();
+		}
+
+		basic_pairs_range<basic_table_core> pairs() noexcept {
+			return basic_pairs_range<basic_table_core>(*this);
+		}
+
+		basic_pairs_range<const basic_table_core> pairs() const noexcept {
+			return basic_pairs_range<const basic_table_core>(*this);
+		}
+
+		void clear() {
+			auto pp = stack::push_pop<false>(*this);
+			int table_index = pp.index_of(*this);
+			stack::clear(lua_state(), table_index);
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = meta::all<meta::boolean<top_level>, is_get_direct_tableless<meta::unqualified_t<Keys>>...>::value;
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<false, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(get<T>("")) U;
+			optional<U> option = get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) > 0, "must pass at least 1 key to get");
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<false, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_set(Keys&&... keys) {
+			static_assert(sizeof...(Keys) > 1, "must pass at least 1 key and 1 value to set");
+			constexpr static bool global
+			     = (meta::count_when_for_to_pack_v < detail::is_not_insert_mode, 1, is_set_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, false, detail::insert_mode::none>(table_index, std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& set(Args&&... args) {
+			if constexpr (sizeof...(Args) == 2) {
+				traverse_set(std::forward<Args>(args)...);
+			}
+			else {
+				tuple_set<false>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			}
+			return *this;
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) raw_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<true, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) raw_get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(raw_get<T>("")) U;
+			optional<U> option = raw_get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) raw_get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = raw_get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_raw_get(Keys&&... keys) const {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<true, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_raw_set(Keys&&... keys) {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_set_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, true, false>(std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& raw_set(Args&&... args) {
+			tuple_set<true>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			return *this;
+		}
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key);
+
+		template <typename Class, typename Key, automagic_flags enrollment_flags>
+		usertype<Class> new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollment);
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key, automagic_enrollments enrollment);
+
+		template <typename Class, typename Key, typename Arg, typename... Args,
+		     typename = std::enable_if_t<!std::is_base_of_v<automagic_enrollments, meta::unqualified_t<Arg>>>>
+		usertype<Class> new_usertype(Key&& key, Arg&& arg, Args&&... args);
+
+		template <bool read_only = true, typename... Args>
+		table new_enum(const string_view& name, Args&&... args) {
+			table target = create_with(std::forward<Args>(args)...);
+			if constexpr (read_only) {
+				// Need to create a special iterator to handle this
+				table x
+				     = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target, meta_function::pairs, stack::stack_detail::readonly_pairs);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename T, bool read_only = true>
+		table new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			table target = create(static_cast<int>(items.size()), static_cast<int>(0));
+			for (const auto& kvp : items) {
+				target.set(kvp.first, kvp.second);
+			}
+			if constexpr (read_only) {
+				table x = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename Key = object, typename Value = object, typename Fx>
+		void for_each(Fx&& fx) const {
+			lua_State* L = base_t::lua_state();
+			if constexpr (std::is_invocable_v<Fx, Key, Value>) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					fx(key, value);
+				}
+			}
+			else {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					std::pair<Key&, Value&> keyvalue(key, value);
+					fx(keyvalue);
+				}
+			}
+		}
+
+		size_t size() const {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			lua_len(L, table_index);
+			return stack::pop<size_t>(L);
+		}
+
+		bool empty() const {
+			return cbegin() == cend();
+		}
+
+		template <typename T>
+		auto operator[](T&& key) & {
+			return table_proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) const& {
+			return table_proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) && {
+			return table_proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key));
+		}
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& add(Args&&... args) {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)detail::swallow { 0, (stack::stack_detail::raw_table_set(L, std::forward<Args>(args), table_index), 0)... };
+			return *this;
+		}
+
+	private:
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		static inline table create(lua_State* L, int narr = 0, int nrec = 0) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename... Args>
+		static inline table create_with(lua_State* L, Args&&... args) {
+			static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
+			constexpr int narr = static_cast<int>(meta::count_odd_for_pack_v<std::is_integral, Args...>);
+			return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
+		}
+
+		table create(int narr = 0, int nrec = 0) {
+			return create(base_t::lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name>
+		table create(Name&& name, int narr = 0, int nrec = 0) {
+			table x = create(base_t::lua_state(), narr, nrec);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename... Args>
+		table create_with(Args&&... args) {
+			return create_with(base_t::lua_state(), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named(Name&& name, Args&&... args) {
+			static const int narr = static_cast<int>(meta::count_even_for_pack_v<std::is_integral, Args...>);
+			return create(std::forward<Name>(name), narr, (sizeof...(Args) / 2) - narr, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/table_core.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_metatable : public basic_table<base_type> {
+		typedef basic_table<base_type> base_t;
+		friend class state;
+		friend class state_view;
+
+	protected:
+		basic_metatable(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_metatable() noexcept = default;
+		basic_metatable(const basic_metatable&) = default;
+		basic_metatable(basic_metatable&&) = default;
+		basic_metatable& operator=(const basic_metatable&) = default;
+		basic_metatable& operator=(basic_metatable&&) = default;
+		basic_metatable(const stack_reference& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		basic_metatable(stack_reference&& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, int index = -1) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_metatable>(L, index, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, ref_index index) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(T&& r) noexcept : basic_metatable(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_metatable>(base_t::lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_metatable(lua_nil_t r) noexcept : basic_metatable(detail::no_safety, r) {
+		}
+
+		template <typename Key, typename Value>
+		basic_metatable<base_type>& set(Key&& key, Value&& value);
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_metatable& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_metatable& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		void unregister() {
+			using ustorage_base = u_detail::usertype_storage_base;
+
+			lua_State* L = this->lua_state();
+
+			auto pp = stack::push_pop(*this);
+			int top = lua_gettop(L);
+
+			stack_reference mt(L, -1);
+			stack::get_field(L, meta_function::gc_names, mt.stack_index());
+			if (type_of(L, -1) != type::table) {
+				lua_settop(L, top);
+				return;
+			}
+			stack_reference gc_names_table(L, -1);
+			stack::get_field(L, meta_function::storage, mt.stack_index());
+			if (type_of(L, -1) != type::lightuserdata) {
+				lua_settop(L, top);
+				return;
+			}
+			ustorage_base& base_storage = *static_cast<ustorage_base*>(stack::get<void*>(L, -1));
+			std::array<string_view, 6> registry_traits;
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				stack::get_field<false, true>(L, smt, gc_names_table.stack_index());
+				registry_traits[i] = stack::get<string_view>(L, -1);
+			}
+
+			// get the registry
+			stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+			registry.push();
+			// eliminate all named entries for this usertype
+			// in the registry (luaL_newmetatable does
+			// [name] = new table
+			// in registry upon creation)
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				const string_view& gcmetakey = registry_traits[i];
+				if (smt == u_detail::submetatable_type::named) {
+					// use .data() to make it treat it like a c string,
+					// which it is...
+					stack::set_field<true>(L, gcmetakey.data(), lua_nil);
+				}
+				else {
+					// do not change the values in the registry: they need to be present
+					// no matter what, for safety's sake
+					// stack::set_field(L, gcmetakey, lua_nil, registry.stack_index());
+				}
+			}
+
+			// destroy all storage and tables
+			base_storage.clear();
+
+			// 6 strings from gc_names table,
+			// + 1 registry,
+			// + 1 gc_names table
+			// + 1 light userdata of storage
+			// + 1 registry
+			// 10 total, 4 left since popping off 6 gc_names tables
+			lua_settop(L, top);
+		}
+	};
+
+} // namespace sol
+
+// end of sol/metatable.hpp
+
+namespace sol {
+
+	template <typename T, typename base_type>
+	class basic_usertype : private basic_metatable<base_type> {
+	private:
+		using base_t = basic_metatable<base_type>;
+		using table_base_t = basic_table<base_type>;
+
+		template <typename>
+		friend class basic_metatable;
+
+		template <bool, typename>
+		friend class basic_table_core;
+
+		template <std::size_t... I, typename... Args>
+		void tuple_set(std::index_sequence<I...>, std::tuple<Args...>&& args) {
+			(void)args;
+			(void)detail::swallow { 0, (this->set(std::get<I * 2>(std::move(args)), std::get<I * 2 + 1>(std::move(args))), 0)... };
+		}
+
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		using base_t::base_t;
+
+		using base_t::get;
+		using base_t::lua_state;
+		using base_t::pop;
+		using base_t::push;
+		using base_t::traverse_get;
+		using base_t::traverse_set;
+		using base_t::unregister;
+
+		template <typename Key, typename Value>
+		basic_usertype& set(Key&& key, Value&& value) {
+			optional<u_detail::usertype_storage<T>&> maybe_uts = u_detail::maybe_get_usertype_storage<T>(this->lua_state());
+			if (maybe_uts) {
+				u_detail::usertype_storage<T>& uts = *maybe_uts;
+				uts.set(this->lua_state(), std::forward<Key>(key), std::forward<Value>(value));
+			}
+			else {
+				using ValueU = meta::unqualified_t<Value>;
+				// cannot get metatable: try regular table set?
+				if constexpr (detail::is_non_factory_constructor_v<ValueU> || detail::is_policy_v<ValueU>) {
+					// tag constructors so we don't get destroyed by lack of info
+					table_base_t::set(std::forward<Key>(key), detail::tagged<T, Value>(std::forward<Value>(value)));
+				}
+				else {
+					table_base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+			return *this;
+		}
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_usertype& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_usertype& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key>
+		usertype_proxy<basic_usertype&, std::decay_t<Key>> operator[](Key&& key) {
+			return usertype_proxy<basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+
+		template <typename Key>
+		usertype_proxy<const basic_usertype&, std::decay_t<Key>> operator[](Key&& key) const {
+			return usertype_proxy<const basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype.hpp
+
+// beginning of sol/table.hpp
+
+// beginning of sol/lua_table.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	struct basic_lua_table : basic_table_core<false, ref_t> {
+	private:
+		using base_t = basic_table_core<false, ref_t>;
+
+		friend class state;
+		friend class state_view;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lua_table() noexcept = default;
+		basic_lua_table(const basic_lua_table&) = default;
+		basic_lua_table(basic_lua_table&&) = default;
+		basic_lua_table& operator=(const basic_lua_table&) = default;
+		basic_lua_table& operator=(basic_lua_table&&) = default;
+		basic_lua_table(const stack_reference& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		basic_lua_table(stack_reference&& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, const new_table& nt) : base_t(L, nt) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+		basic_lua_table(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(L, index, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_lua_table>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(T&& r) noexcept : basic_lua_table(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_lua_table>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_lua_table(lua_nil_t r) noexcept : basic_lua_table(detail::no_safety, r) {
+		}
+	};
+
+} // namespace sol
+
+// end of sol/lua_table.hpp
+
+namespace sol {
+	typedef table_core<false> table;
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key) {
+		constant_automagic_enrollments<> enrollments {};
+		return this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key, automagic_flags enrollment_flags>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollments) {
+		int mt_index = u_detail::register_usertype<Class, enrollment_flags>(this->lua_state(), std::move(enrollments));
+		usertype<Class> mt(this->lua_state(), -mt_index);
+		lua_pop(this->lua_state(), 1);
+		set(std::forward<Key>(key), mt);
+		return mt;
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, automagic_enrollments enrollments) {
+		int mt_index = u_detail::register_usertype<Class, automagic_flags::all>(this->lua_state(), std::move(enrollments));
+		usertype<Class> mt(this->lua_state(), -mt_index);
+		lua_pop(this->lua_state(), 1);
+		set(std::forward<Key>(key), mt);
+		return mt;
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key, typename Arg, typename... Args, typename>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, Arg&& arg, Args&&... args) {
+		constexpr automagic_flags enrollment_flags = meta::any_same_v<no_construction, meta::unqualified_t<Arg>, meta::unqualified_t<Args>...>
+		     ? clear_flags(automagic_flags::all, automagic_flags::default_constructor)
+		     : automagic_flags::all;
+		constant_automagic_enrollments<enrollment_flags> enrollments;
+		enrollments.default_constructor = !detail::any_is_constructor_v<Arg, Args...>;
+		enrollments.destructor = !detail::any_is_destructor_v<Arg, Args...>;
+		usertype<Class> ut = this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+		static_assert(sizeof...(Args) % 2 == static_cast<std::size_t>(!detail::any_is_constructor_v<Arg>),
+		     "you must pass an even number of arguments to new_usertype after first passing a constructor");
+		if constexpr (detail::any_is_constructor_v<Arg>) {
+			ut.set(meta_function::construct, std::forward<Arg>(arg));
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args)) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+		}
+		else {
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args) + 1) / 2>(), std::forward_as_tuple(std::forward<Arg>(arg), std::forward<Args>(args)...));
+		}
+		return ut;
+	}
+
+	template <typename base_type>
+	template <typename Key, typename Value>
+	basic_metatable<base_type>& basic_metatable<base_type>::set(Key&& key, Value&& value) {
+		this->push();
+		lua_State* L = this->lua_state();
+		int target = lua_gettop(L);
+		optional<u_detail::usertype_storage_base&> maybe_uts = nullopt;
+		maybe_uts = u_detail::maybe_get_usertype_storage_base(L, target);
+		if (maybe_uts) {
+			u_detail::usertype_storage_base& uts = *maybe_uts;
+			uts.set(L, std::forward<Key>(key), std::forward<Value>(value));
+			return *this;
+		}
+		else {
+			base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+		}
+		this->pop();
+		return *this;
+	}
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<metatable_key_t> {
+			static metatable get(lua_State* L, int index = -1) {
+				if (lua_getmetatable(L, index) == 0) {
+					return metatable(L, ref_index(LUA_REFNIL));
+				}
+				return metatable(L, -1);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table.hpp
+
+// beginning of sol/state.hpp
+
+// beginning of sol/state_view.hpp
+
+// beginning of sol/environment.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	struct basic_environment : basic_table<base_type> {
+	private:
+		typedef basic_table<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_environment() noexcept = default;
+		basic_environment(const basic_environment&) = default;
+		basic_environment(basic_environment&&) = default;
+		basic_environment& operator=(const basic_environment&) = default;
+		basic_environment& operator=(basic_environment&&) = default;
+		basic_environment(const stack_reference& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+		basic_environment(stack_reference&& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+
+		basic_environment(lua_State* L, new_table nt) : base_t(L, std::move(nt)) {
+		}
+		template <bool b>
+		basic_environment(lua_State* L, new_table t, const basic_reference<b>& fallback) : basic_environment(L, std::move(t)) {
+			stack_table mt(L, new_table(0, 1));
+			mt.set(meta_function::index, fallback);
+			this->set(metatable_key, mt);
+			mt.pop();
+		}
+
+		basic_environment(env_key_t, const stack_reference& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 1);
+		}
+		template <bool b>
+		basic_environment(env_key_t, const basic_reference<b>& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 1);
+		}
+		basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, index, handler);
+#endif // Safety
+		}
+		basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_environment>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_environment(lua_nil_t r) noexcept : base_t(detail::no_safety, r) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(lua_State* L, T&& r) noexcept : base_t(detail::no_safety, L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+
+		template <typename T>
+		bool set_on(const T& target) const {
+			lua_State* L = target.lua_state();
+			auto pp = stack::push_pop(target);
+			int target_index = pp.index_of(target);
+#if SOL_LUA_VERSION_I_ < 502
+			// Use lua_setfenv
+			this->push();
+			int success_result = lua_setfenv(L, target_index);
+			return success_result != 0;
+#else
+			// If this is a C function, the environment is always placed in
+			// the first value, as is expected of sol2 (all upvalues have an empty name, "")
+			if (lua_iscfunction(L, target_index) != 0) {
+				const char* maybe_upvalue_name = lua_getupvalue(L, target_index, 1);
+				if (maybe_upvalue_name == nullptr) {
+					return false;
+				}
+				string_view upvalue_name(maybe_upvalue_name);
+				if (upvalue_name == "") {
+					this->push();
+					const char* success = lua_setupvalue(L, target_index, 1);
+					if (success == nullptr) {
+						// left things alone on the stack, pop them off
+						lua_pop(L, 2);
+						return false;
+					}
+					lua_pop(L, 1);
+					return true;
+				}
+				lua_pop(L, 1);
+				return false;
+			}
+			else {
+				// Must search for the right upvalue target on index
+				for (int upvalue_index = 1;; ++upvalue_index) {
+					const char* maybe_upvalue_name = lua_getupvalue(L, target_index, upvalue_index);
+					if (maybe_upvalue_name == nullptr) {
+						break;
+					}
+					string_view upvalue_name(maybe_upvalue_name);
+					if (upvalue_name == "_ENV") {
+						lua_pop(L, 1);
+						this->push();
+						const char* success = lua_setupvalue(L, target_index, upvalue_index);
+						if (success == nullptr) {
+							// left things alone on the stack, pop them off
+							lua_pop(L, 1);
+							break;
+						}
+						// whether or not we succeeded, we found _ENV
+						// so we need to break
+						return true;
+					}
+					lua_pop(L, 1);
+				}
+				// if we get here,
+				// we did not find an _ENV here...
+				return false;
+			}
+#endif
+		}
+	};
+
+	template <typename T, typename E>
+	bool set_environment(const basic_environment<E>& env, const T& target) {
+		return env.set_on(target);
+	}
+
+	template <typename E = reference, typename T>
+	basic_environment<E> get_environment(const T& target) {
+		lua_State* L = target.lua_state();
+		auto pp = stack::pop_n(L, stack::push_environment_of(target));
+		return basic_environment<E>(L, -1);
+	}
+
+	struct this_environment {
+		optional<environment> env;
+
+		this_environment() : env(nullopt) {
+		}
+		this_environment(environment e) : env(std::move(e)) {
+		}
+		this_environment(const this_environment&) = default;
+		this_environment(this_environment&&) = default;
+		this_environment& operator=(const this_environment&) = default;
+		this_environment& operator=(this_environment&&) = default;
+
+		explicit operator bool() const {
+			return static_cast<bool>(env);
+		}
+
+		operator optional<environment>&() {
+			return env;
+		}
+
+		operator const optional<environment>&() const {
+			return env;
+		}
+
+		operator environment&() {
+			return env.value();
+		}
+
+		operator const environment&() const {
+			return env.value();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<env_key_t> {
+			static environment get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				return get_environment(stack_reference(L, raw_index(index)));
+			}
+		};
+
+		template <>
+		struct unqualified_getter<this_environment> {
+			static this_environment get(lua_State* L, int, record& tracking) {
+				tracking.use(0);
+				lua_Debug info;
+				// Level 0 means current function (this C function, which may or may not be useful for us?)
+				// Level 1 means next call frame up the stack. (Can be nothing if function called directly from C++ with lua_p/call)
+				int pre_stack_size = lua_gettop(L);
+				if (lua_getstack(L, 1, &info) != 1) {
+					if (lua_getstack(L, 0, &info) != 1) {
+						lua_settop(L, pre_stack_size);
+						return this_environment();
+					}
+				}
+				if (lua_getinfo(L, "f", &info) == 0) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+
+				stack_reference f(L, -1);
+				environment env(env_key, f);
+				if (!env.valid()) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+				return this_environment(std::move(env));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/environment.hpp
+
+// beginning of sol/load_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct load_result : public proxy_base<load_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		load_status err;
+
+	public:
+		load_result() noexcept : load_result(nullptr) {}
+		load_result(lua_State* Ls, int stackindex = -1, int retnum = 0, int popnum = 0, load_status lerr = load_status::ok) noexcept
+		: L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		load_result(const load_result&) = delete;
+		load_result& operator=(const load_result&) = delete;
+
+		load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+		}
+		load_result& operator=(load_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+			return *this;
+		}
+
+		load_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == load_status::ok;
+		}
+
+		template <typename T>
+		T get() const {
+			using UT = meta::unqualified_t<T>;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT(nullopt);
+					}
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+					if (!valid()) {
+						return UT(nullopt);
+					}
+					return stack::get<UT>(L, index);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none, "expecting an error type (a string, from Lua)");
+					}
+#endif // Check proxy type's safety
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (!valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none);
+					}
+#endif // Check proxy type's safety
+					return stack::get<T>(L, index);
+				}
+			}
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+
+		~load_result() {
+			if (L != nullptr) {
+				stack::remove(L, index, popcount);
+			}
+		}
+	};
+} // namespace sol
+
+// end of sol/load_result.hpp
+
+// beginning of sol/state_handling.hpp
+
+// beginning of sol/lua_value.hpp
+
+namespace sol {
+	struct lua_value {
+	public:
+		struct arr : detail::ebco<std::initializer_list<lua_value>> {
+		private:
+			using base_t = detail::ebco<std::initializer_list<lua_value>>;
+
+		public:
+			using base_t::base_t;
+		};
+
+	private:
+		template <typename T>
+		using is_reference_or_lua_value_init_list
+		     = meta::any<meta::is_specialization_of<T, std::initializer_list>, std::is_same<T, reference>, std::is_same<T, arr>>;
+
+		template <typename T>
+		using is_lua_value_single_constructible = meta::any<std::is_same<T, lua_value>, is_reference_or_lua_value_init_list<T>>;
+
+		static lua_State*& thread_local_lua_state() {
+#if SOL_IS_ON(SOL_USE_THREAD_LOCAL)
+			static thread_local lua_State* L = nullptr;
+#else
+			static lua_State* L = nullptr;
+#endif
+			return L;
+		}
+
+		reference ref_value;
+
+	public:
+		static void set_lua_state(lua_State* L) {
+			thread_local_lua_state() = L;
+		}
+
+		template <typename T, meta::disable<is_reference_or_lua_value_init_list<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(lua_State* L_, T&& value) : lua_value(((set_lua_state(L_)), std::forward<T>(value))) {
+		}
+
+		template <typename T, meta::disable<is_lua_value_single_constructible<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(T&& value) : ref_value(make_reference(thread_local_lua_state(), std::forward<T>(value))) {
+		}
+
+		lua_value(lua_State* L_, std::initializer_list<std::pair<lua_value, lua_value>> il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(std::initializer_list<std::pair<lua_value, lua_value>> il) : ref_value(make_reference(thread_local_lua_state(), std::move(il))) {
+		}
+
+		lua_value(lua_State* L_, arr il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(arr il) : ref_value(make_reference(thread_local_lua_state(), std::move(il.value()))) {
+		}
+
+		lua_value(lua_State* L_, reference r)
+		: lua_value([&L_, &r]() {
+			set_lua_state(L_);
+			return std::move(r);
+		}()) {
+		}
+
+		lua_value(reference r) : ref_value(std::move(r)) {
+		}
+
+		lua_value(const lua_value&) noexcept = default;
+		lua_value(lua_value&&) = default;
+		lua_value& operator=(const lua_value&) = default;
+		lua_value& operator=(lua_value&&) = default;
+
+		const reference& value() const& {
+			return ref_value;
+		}
+
+		reference& value() & {
+			return ref_value;
+		}
+
+		reference&& value() && {
+			return std::move(ref_value);
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			ref_value.push();
+			return stack::pop<T>(ref_value.lua_state());
+		}
+
+		template <typename T>
+		bool is() const {
+			int r = ref_value.registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(ref_value);
+			return stack::check<T>(ref_value.lua_state(), -1, &no_panic);
+		}
+	};
+
+	using array_value = typename lua_value::arr;
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_value> {
+			static int push(lua_State* L, const lua_value& lv) {
+				return stack::push(L, lv.value());
+			}
+
+			static int push(lua_State* L, lua_value&& lv) {
+				return stack::push(L, std::move(lv).value());
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_value> {
+			static lua_value get(lua_State* L, int index, record& tracking) {
+				return lua_value(L, stack::get<reference>(L, index, tracking));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/lua_value.hpp
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+#include <iostream>
+#endif
+
+namespace sol {
+	inline void register_main_thread(lua_State* L) {
+#if SOL_LUA_VERSION_I_ < 502
+		if (L == nullptr) {
+			lua_pushnil(L);
+			lua_setglobal(L, detail::default_main_thread_name());
+			return;
+		}
+		lua_pushthread(L);
+		lua_setglobal(L, detail::default_main_thread_name());
+#else
+		(void)L;
+#endif
+	}
+
+	inline int default_at_panic(lua_State* L) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		(void)L;
+		return -1;
+#else
+		size_t messagesize;
+		const char* message = lua_tolstring(L, -1, &messagesize);
+		if (message) {
+			std::string err(message, messagesize);
+			lua_settop(L, 0);
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+			std::cerr << "[sol2] An error occurred and panic has been invoked: ";
+			std::cerr << err;
+			std::cerr << std::endl;
+#endif
+			throw error(err);
+		}
+		lua_settop(L, 0);
+		throw error(std::string("An unexpected error occurred and panic has been invoked"));
+#endif // Printing Errors
+	}
+
+	inline int default_traceback_error_handler(lua_State* L) {
+		std::string msg = "An unknown error has triggered the default error handler";
+		optional<string_view> maybetopmsg = stack::unqualified_check_get<string_view>(L, 1, &no_panic);
+		if (maybetopmsg) {
+			const string_view& topmsg = maybetopmsg.value();
+			msg.assign(topmsg.data(), topmsg.size());
+		}
+		luaL_traceback(L, L, msg.c_str(), 1);
+		optional<string_view> maybetraceback = stack::unqualified_check_get<string_view>(L, -1, &no_panic);
+		if (maybetraceback) {
+			const string_view& traceback = maybetraceback.value();
+			msg.assign(traceback.data(), traceback.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+		// std::cerr << "[sol2] An error occurred and was caught in traceback: ";
+		// std::cerr << msg;
+		// std::cerr << std::endl;
+#endif // Printing
+		return stack::push(L, msg);
+	}
+
+	inline void set_default_state(lua_State* L, lua_CFunction panic_function = &default_at_panic,
+	     lua_CFunction traceback_function = c_call<decltype(&default_traceback_error_handler), &default_traceback_error_handler>,
+	     exception_handler_function exf = detail::default_exception_handler) {
+		lua_atpanic(L, panic_function);
+		protected_function::set_default_handler(object(L, in_place, traceback_function));
+		set_default_exception_handler(L, exf);
+		register_main_thread(L);
+		stack::luajit_exception_handler(L);
+		lua_value::set_lua_state(L);
+	}
+
+	inline std::size_t total_memory_used(lua_State* L) {
+		std::size_t kb = static_cast<std::size_t>(lua_gc(L, LUA_GCCOUNT, 0));
+		kb *= 1024;
+		kb += static_cast<std::size_t>(lua_gc(L, LUA_GCCOUNTB, 0));
+		return kb;
+	}
+
+	inline protected_function_result script_pass_on_error(lua_State*, protected_function_result result) {
+		return result;
+	}
+
+	inline protected_function_result script_throw_on_error(lua_State* L, protected_function_result result) {
+		type t = type_of(L, result.stack_index());
+		std::string err = "sol: ";
+		err += to_string(result.status());
+		err += " error";
+#if SOL_IS_ON(SOL_EXCEPTIONS)
+		std::exception_ptr eptr = std::current_exception();
+		if (eptr) {
+			err += " with a ";
+			try {
+				std::rethrow_exception(eptr);
+			}
+			catch (const std::exception& ex) {
+				err += "std::exception -- ";
+				err.append(ex.what());
+			}
+			catch (const std::string& message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (const char* message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (...) {
+				err.append("thrown but unknown type, cannot serialize into error message");
+			}
+		}
+#endif // serialize exception information if possible
+		if (t == type::string) {
+			err += ": ";
+			string_view serr = stack::unqualified_get<string_view>(L, result.stack_index());
+			err.append(serr.data(), serr.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+		std::cerr << "[sol2] An error occurred and has been passed to an error handler: ";
+		std::cerr << err;
+		std::cerr << std::endl;
+#endif
+		// replacing information of stack error into pfr
+		int target = result.stack_index();
+		if (result.pop_count() > 0) {
+			stack::remove(L, target, result.pop_count());
+		}
+		stack::push(L, err);
+		int top = lua_gettop(L);
+		int towards = top - target;
+		if (towards != 0) {
+			lua_rotate(L, top, towards);
+		}
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		return result;
+#else
+		// just throw our error
+		throw error(detail::direct_error, err);
+#endif // If exceptions are allowed
+	}
+
+	inline protected_function_result script_default_on_error(lua_State* L, protected_function_result pfr) {
+#if SOL_IS_ON(SOL_DEFAULT_PASS_ON_ERROR)
+		return script_pass_on_error(L, std::move(pfr));
+#else
+		return script_throw_on_error(L, std::move(pfr));
+#endif
+	}
+
+	namespace stack {
+		inline error get_traceback_or_errors(lua_State* L) {
+			int p = default_traceback_error_handler(L);
+			sol::error err = stack::get<sol::error>(L, -p);
+			lua_pop(L, p);
+			return err;
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/state_handling.hpp
+
+#include <memory>
+#include <cstddef>
+
+namespace sol {
+
+	class state_view {
+	private:
+		lua_State* L;
+		table reg;
+		global_table global;
+
+		optional<object> is_loaded_package(const std::string& key) {
+			auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
+			bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
+			if (is53mod)
+				return loaded;
+#if SOL_LUA_VERSION_I_ <= 501
+			auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
+			bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
+			if (is51mod)
+				return loaded51;
+#endif
+			return nullopt;
+		}
+
+		template <typename T>
+		void ensure_package(const std::string& key, T&& sr) {
+#if SOL_LUA_VERSION_I_ <= 501
+			auto pkg = global["package"];
+			if (!pkg.valid()) {
+				pkg = create_table_with("loaded", create_table_with(key, sr));
+			}
+			else {
+				auto ld = pkg["loaded"];
+				if (!ld.valid()) {
+					ld = create_table_with(key, sr);
+				}
+				else {
+					ld[key] = sr;
+				}
+			}
+#endif
+			auto loaded = reg["_LOADED"];
+			if (!loaded.valid()) {
+				loaded = create_table_with(key, sr);
+			}
+			else {
+				loaded[key] = sr;
+			}
+		}
+
+		template <typename Fx>
+		object require_core(const std::string& key, Fx&& action, bool create_global = true) {
+			optional<object> loaded = is_loaded_package(key);
+			if (loaded && loaded->valid())
+				return std::move(*loaded);
+			int before = lua_gettop(L);
+			action();
+			int after = lua_gettop(L);
+			if (before == after) {
+				// I mean, you were supposed to return
+				// something, ANYTHING, from your requires script. I guess I'll just
+				// but some trash in here, it's on you after that?
+				ensure_package(key, static_cast<void*>(L));
+				return object(L, lua_nil);
+			}
+			stack_reference sr(L, -1);
+			if (create_global)
+				set(key, sr);
+			ensure_package(key, sr);
+			return stack::pop<object>(L);
+		}
+
+	public:
+		using iterator = typename global_table::iterator;
+		using const_iterator = typename global_table::const_iterator;
+
+		state_view(lua_State* Ls) : L(Ls), reg(Ls, LUA_REGISTRYINDEX), global(Ls, global_tag) {
+		}
+
+		state_view(this_state Ls) : state_view(Ls.L) {
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		}
+
+		template <typename... Args>
+		void open_libraries(Args&&... args) {
+			static_assert(meta::all_same<lib, meta::unqualified_t<Args>...>::value, "all types must be libraries");
+			if constexpr (sizeof...(args) == 0) {
+				luaL_openlibs(L);
+				return;
+			}
+			else {
+				lib libraries[1 + sizeof...(args)] = { lib::count, std::forward<Args>(args)... };
+
+				for (auto&& library : libraries) {
+					switch (library) {
+#if SOL_LUA_VERSION_I_ <= 501 && SOL_IS_ON(SOL_USE_LUAJIT)
+					case lib::coroutine:
+#endif // luajit opens coroutine base stuff
+					case lib::base:
+						luaL_requiref(L, "base", luaopen_base, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::package:
+						luaL_requiref(L, "package", luaopen_package, 1);
+						lua_pop(L, 1);
+						break;
+#if SOL_IS_OFF(SOL_USE_LUAJIT)
+					case lib::coroutine:
+#if SOL_LUA_VERSION_I_ > 501
+						luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.2+ only
+						break;
+#endif // Not LuaJIT - comes builtin
+					case lib::string:
+						luaL_requiref(L, "string", luaopen_string, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::table:
+						luaL_requiref(L, "table", luaopen_table, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::math:
+						luaL_requiref(L, "math", luaopen_math, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::bit32:
+#if SOL_IS_ON(SOL_USE_LUAJIT)
+						luaL_requiref(L, "bit32", luaopen_bit, 1);
+						lua_pop(L, 1);
+#elif SOL_IS_ON(SOL_LUA_BIT32_LIB)
+						luaL_requiref(L, "bit32", luaopen_bit32, 1);
+						lua_pop(L, 1);
+#else
+#endif
+						break;
+					case lib::io:
+						luaL_requiref(L, "io", luaopen_io, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::os:
+						luaL_requiref(L, "os", luaopen_os, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::debug:
+						luaL_requiref(L, "debug", luaopen_debug, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::utf8:
+#if SOL_LUA_VERSION_I_ > 502 && SOL_IS_OFF(SOL_USE_LUAJIT)
+						luaL_requiref(L, "utf8", luaopen_utf8, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.3+ only
+						break;
+					case lib::ffi:
+#if SOL_IS_ON(SOL_USE_LUAJIT) && SOL_IS_OFF(SOL_LUAJIT_FFI_DISABLED)
+						luaL_requiref(L, "ffi", luaopen_ffi, 1);
+						lua_pop(L, 1);
+#endif // LuaJIT only
+						break;
+					case lib::jit:
+#if SOL_IS_ON(SOL_USE_LUAJIT)
+						luaL_requiref(L, "jit", luaopen_jit, 0);
+						lua_pop(L, 1);
+#endif // LuaJIT Only
+						break;
+					case lib::count:
+					default:
+						break;
+					}
+				}
+			}
+		}
+
+		object require(const std::string& key, lua_CFunction open_function, bool create_global = true) {
+			luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
+			return stack::pop<object>(L);
+		}
+
+		object require_script(const std::string& key, const string_view& code, bool create_global = true,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			auto action = [this, &code, &chunkname, &mode]() { stack::script(L, code, chunkname, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		object require_file(const std::string& key, const std::string& filename, bool create_global = true, load_mode mode = load_mode::any) {
+			auto action = [this, &filename, &mode]() { stack::script_file(L, filename, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		void clear_package_loaders() {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VERSION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			if (!loaders_proxy.valid()) {
+				// nothing to clear
+				return;
+			}
+			// we need to create the table for loaders
+			// table does not exist, so create and move forward
+			loaders_proxy = new_table(1, 0);
+		}
+
+		template <typename Fx>
+		void add_package_loader(Fx&& fx, bool clear_all_package_loaders = false) {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VERSION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			bool make_new_table = clear_all_package_loaders || !loaders_proxy.valid();
+			if (make_new_table) {
+				// we need to create the table for loaders
+				// table does not exist, so create and move forward
+				loaders_proxy = new_table(1, 0);
+			}
+			optional<table> maybe_loaders = loaders_proxy;
+			if (!maybe_loaders) {
+				// loaders/searches
+				// thing exists in package, but it
+				// ain't a table or a table-alike...!
+				return;
+			}
+			table loaders = loaders_proxy;
+			loaders.add(std::forward<Fx>(fx));
+		}
+
+		template <typename E>
+		protected_function_result do_reader(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_reader(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_string(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_string(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_reader(reader, data, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, env, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result safe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script_file(
+		     const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, env, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+		protected_function_result safe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, script_default_on_error, mode);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, reader, data, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, code, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script_file(L, filename, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, std::forward<Fx>(on_error), mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script_file(const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, std::forward<Fx>(on_error), mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const environment& env, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, const environment& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+		protected_function_result script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, chunkname, mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, mode);
+		}
+#else
+		unsafe_function_result script(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return unsafe_script(code, chunkname, mode);
+		}
+
+		unsafe_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return unsafe_script_file(filename, mode);
+		}
+#endif
+		load_result load(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load_buffer(const char* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(buff, size), chunkname, mode);
+		}
+
+		load_result load_buffer(
+		     const std::byte* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(reinterpret_cast<const char*>(buff), size), chunkname, mode);
+		}
+
+		load_result load_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load(lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		iterator begin() const {
+			return global.begin();
+		}
+
+		iterator end() const {
+			return global.end();
+		}
+
+		const_iterator cbegin() const {
+			return global.cbegin();
+		}
+
+		const_iterator cend() const {
+			return global.cend();
+		}
+
+		global_table globals() const {
+			// if we return a reference
+			// we'll be screwed a bit
+			return global;
+		}
+
+		global_table& globals() {
+			return global;
+		}
+
+		table registry() const {
+			return reg;
+		}
+
+		std::size_t memory_used() const {
+			return total_memory_used(lua_state());
+		}
+
+		int stack_top() const {
+			return stack::top(L);
+		}
+
+		int stack_clear() {
+			int s = stack_top();
+			lua_pop(L, s);
+			return s;
+		}
+
+		bool supports_gc_mode(gc_mode mode) const noexcept {
+#if SOL_LUA_VERSION_I_ >= 504
+			// supports all modes
+			(void)mode;
+			return true;
+#endif
+			return mode == gc_mode::default_value;
+		}
+
+		bool is_gc_on() const {
+#if SOL_LUA_VERSION_I_ >= 502
+			return lua_gc(lua_state(), LUA_GCISRUNNING, 0) == 1;
+#else
+			// You cannot turn it off in Lua 5.1
+			return true;
+#endif
+		}
+
+		void collect_garbage() {
+			lua_gc(lua_state(), LUA_GCCOLLECT, 0);
+		}
+
+		void collect_gc() {
+			collect_garbage();
+		}
+
+		bool step_gc(int step_size_kilobytes) {
+			// THOUGHT: std::chrono-alikes to map "kilobyte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VERSION_I_ >= 504
+			// The manual implies that this function is almost always successful...
+			// is it?? It could depend on the GC mode...
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) != 0;
+#else
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) == 1;
+#endif
+		}
+
+		void restart_gc() {
+			lua_gc(lua_state(), LUA_GCRESTART, 0);
+		}
+
+		void stop_gc() {
+			lua_gc(lua_state(), LUA_GCSTOP, 0);
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_incremental(int pause, int step_multiplier, int step_byte_size) {
+			// "What the fuck does any of this mean??"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.1
+
+			// THOUGHT: std::chrono-alikes to map "byte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VERSION_I_ >= 504
+			int old_mode = lua_gc(lua_state(), LUA_GCINC, pause, step_multiplier, step_byte_size);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#else
+			lua_gc(lua_state(), LUA_GCSETPAUSE, pause);
+			lua_gc(lua_state(), LUA_GCSETSTEPMUL, step_multiplier);
+			(void)step_byte_size; // means nothing in older versions
+#endif
+			return gc_mode::default_value;
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_generational(int minor_multiplier, int major_multiplier) {
+#if SOL_LUA_VERSION_I_ >= 504
+			// "What does this shit mean?"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.2
+			int old_mode = lua_gc(lua_state(), LUA_GCGEN, minor_multiplier, major_multiplier);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#else
+			(void)minor_multiplier;
+			(void)major_multiplier;
+#endif
+			return gc_mode::default_value;
+		}
+
+		operator lua_State*() const {
+			return lua_state();
+		}
+
+		void set_panic(lua_CFunction panic) {
+			lua_atpanic(lua_state(), panic);
+		}
+
+		void set_exception_handler(exception_handler_function handler) {
+			set_default_exception_handler(lua_state(), handler);
+		}
+
+		template <typename... Args, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			return global.get<Args...>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
+		}
+
+		template <typename... Args>
+		state_view& set(Args&&... args) {
+			global.set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			return global.traverse_get<T>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Args>
+		state_view& traverse_set(Args&&... args) {
+			global.traverse_set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Class, typename... Args>
+		usertype<Class> new_usertype(Args&&... args) {
+			return global.new_usertype<Class>(std::forward<Args>(args)...);
+		}
+
+		template <bool read_only = true, typename... Args>
+		state_view& new_enum(const string_view& name, Args&&... args) {
+			global.new_enum<read_only>(name, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, bool read_only = true>
+		state_view& new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			global.new_enum<T, read_only>(name, std::move(items));
+			return *this;
+		}
+
+		template <typename Fx>
+		void for_each(Fx&& fx) {
+			global.for_each(std::forward<Fx>(fx));
+		}
+
+		template <typename T>
+		table_proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename T>
+		table_proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename Sig, typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Name>
+		table create_table(Name&& name, int narr = 0, int nrec = 0) {
+			return global.create(std::forward<Name>(name), narr, nrec);
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create_table(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named_table(Name&& name, Args&&... args) {
+			table x = global.create_with(std::forward<Args>(args)...);
+			global.set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		table create_table(int narr = 0, int nrec = 0) {
+			return create_table(lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create_table(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		table create_table_with(Args&&... args) {
+			return create_table_with(lua_state(), std::forward<Args>(args)...);
+		}
+
+		static inline table create_table(lua_State* L, int narr = 0, int nrec = 0) {
+			return global_table::create(L, narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create_table(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static inline table create_table_with(lua_State* L, Args&&... args) {
+			return global_table::create_with(L, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/state_view.hpp
+
+// beginning of sol/thread.hpp
+
+namespace sol {
+	struct lua_thread_state {
+		lua_State* L;
+
+		lua_thread_state(lua_State* Ls) : L(Ls) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_thread_state> {
+			int push(lua_State*, lua_thread_state lts) {
+				lua_pushthread(lts.L);
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_thread_state> {
+			lua_thread_state get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				lua_thread_state lts(lua_tothread(L, index));
+				return lts;
+			}
+		};
+
+		template <>
+		struct unqualified_check_getter<lua_thread_state> {
+			template <typename Handler>
+			optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+				lua_thread_state lts(lua_tothread(L, index));
+				if (lts.lua_state() == nullptr) {
+					handler(L, index, type::thread, type_of(L, index), "value is not a valid thread type");
+					return nullopt;
+				}
+				tracking.use(1);
+				return lts;
+			}
+		};
+	} // namespace stack
+
+	template <typename ref_t>
+	class basic_thread : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_thread() noexcept = default;
+		basic_thread(const basic_thread&) = default;
+		basic_thread(basic_thread&&) = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_thread>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(T&& r) : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(const stack_reference& r) : basic_thread(r.lua_state(), r.stack_index()) {};
+		basic_thread(stack_reference&& r) : basic_thread(r.lua_state(), r.stack_index()) {};
+		basic_thread& operator=(const basic_thread&) = default;
+		basic_thread& operator=(basic_thread&&) = default;
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_thread>(L, index, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, lua_State* actualthread) : basic_thread(L, lua_thread_state { actualthread }) {
+		}
+		basic_thread(lua_State* L, this_state actualthread) : basic_thread(L, lua_thread_state { actualthread.L }) {
+		}
+		basic_thread(lua_State* L, lua_thread_state actualthread) : base_t(L, -stack::push(L, actualthread)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(lua_state(), 1);
+			}
+		}
+
+		state_view state() const {
+			return state_view(this->thread_state());
+		}
+
+		bool is_main_thread() const {
+			return stack::is_main_thread(this->thread_state());
+		}
+
+		lua_State* thread_state() const {
+			auto pp = stack::push_pop(*this);
+			lua_State* lthread = lua_tothread(lua_state(), -1);
+			return lthread;
+		}
+
+		thread_status status() const {
+			lua_State* lthread = thread_state();
+			auto lstat = static_cast<thread_status>(lua_status(lthread));
+			if (lstat == thread_status::ok) {
+				lua_Debug ar;
+				if (lua_getstack(lthread, 0, &ar) > 0)
+					return thread_status::ok;
+				else if (lua_gettop(lthread) == 0)
+					return thread_status::dead;
+				else
+					return thread_status::yielded;
+			}
+			return lstat;
+		}
+
+		basic_thread create() {
+			return create(lua_state());
+		}
+
+		static basic_thread create(lua_State* L) {
+			lua_newthread(L);
+			basic_thread result(L);
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(L, 1);
+			}
+			return result;
+		}
+	};
+
+	typedef basic_thread<reference> thread;
+	typedef basic_thread<stack_reference> stack_thread;
+} // namespace sol
+
+// end of sol/thread.hpp
+
+namespace sol {
+
+	class state : private std::unique_ptr<lua_State, detail::state_deleter>, public state_view {
+	private:
+		typedef std::unique_ptr<lua_State, detail::state_deleter> unique_base;
+
+	public:
+		state(lua_CFunction panic = default_at_panic) : unique_base(luaL_newstate()), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr)
+		: unique_base(lua_newstate(alfunc, alpointer)), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(const state&) = delete;
+		state(state&&) = default;
+		state& operator=(const state&) = delete;
+		state& operator=(state&& that) {
+			state_view::operator=(std::move(that));
+			unique_base::operator=(std::move(that));
+			return *this;
+		}
+
+		using state_view::get;
+
+		~state() {
+		}
+	};
+} // namespace sol
+
+// end of sol/state.hpp
+
+// beginning of sol/coroutine.hpp
+
+namespace sol {
+	template <typename Reference>
+	class basic_coroutine : public basic_object<Reference> {
+	private:
+		using base_t = basic_object<Reference>;
+		using handler_t = reference;
+
+	private:
+		call_status stats = call_status::yielded;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
+#if SOL_LUA_VERSION_I_ >= 504
+			int nresults;
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount), &nresults));
+#else
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
+#endif
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) {
+			luacall(n, sizeof...(Ret));
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 1);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 0);
+		}
+
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) {
+			int firstreturn = 1;
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(this->lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			if (error()) {
+				if (m_error_handler.valid()) {
+					string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
+					m_error_handler.push();
+					stack::push(this->lua_state(), err);
+					lua_call(lua_state(), 1, 1);
+				}
+				return protected_function_result(this->lua_state(), lua_absindex(this->lua_state(), -1), 1, returncount, status());
+			}
+			return protected_function_result(this->lua_state(), firstreturn, returncount, returncount, status());
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_coroutine() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_coroutine>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(T&& r) noexcept
+		: base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_coroutine>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+
+		basic_coroutine(const basic_coroutine& other) = default;
+		basic_coroutine& operator=(const basic_coroutine&) = default;
+
+		basic_coroutine(basic_coroutine&& other) noexcept : base_t(std::move(other)), m_error_handler(this->lua_state(), std::move(other.m_error_handler)) {
+		}
+
+		basic_coroutine& operator=(basic_coroutine&& other) noexcept {
+			base_t::operator=(std::move(other));
+			// must change the state, since it could change on the coroutine type
+			m_error_handler = handler_t(this->lua_state(), std::move(other.m_error_handler));
+			return *this;
+		}
+
+		basic_coroutine(const basic_function<base_t>& b) noexcept
+		: basic_coroutine(b, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(basic_function<base_t>&& b) noexcept
+		: basic_coroutine(std::move(b), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(const basic_function<base_t>& b, handler_t eh) noexcept : base_t(b), m_error_handler(std::move(eh)) {
+		}
+		basic_coroutine(basic_function<base_t>&& b, handler_t eh) noexcept : base_t(std::move(b)), m_error_handler(std::move(eh)) {
+		}
+		basic_coroutine(const stack_reference& r) noexcept
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(stack_reference&& r) noexcept
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(const stack_reference& r, handler_t eh) noexcept : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_coroutine(stack_reference&& r, handler_t eh) noexcept : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_coroutine(const proxy_base<Super>& p)
+		: basic_coroutine(p, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_coroutine(proxy_base<Super>&& p)
+		: basic_coroutine(std::move(p), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Proxy, typename HandlerReference,
+		     meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
+		          meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
+		basic_coroutine(Proxy&& p, HandlerReference&& eh) : basic_coroutine(detail::force_cast<base_t>(p), std::forward<HandlerReference>(eh)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r) noexcept
+		: basic_coroutine(L, std::forward<T>(r), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		basic_coroutine(lua_nil_t n) : base_t(n), m_error_handler(n) {
+		}
+
+		basic_coroutine(lua_State* L, int index = -1)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, int index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#ifdef SOL_SAFE_REFERENCES
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, absolute_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, raw_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, ref_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		call_status status() const noexcept {
+			return stats;
+		}
+
+		bool error() const noexcept {
+			call_status cs = status();
+			return cs != call_status::ok && cs != call_status::yielded;
+		}
+
+		bool runnable() const noexcept {
+			return base_t::valid() && (status() == call_status::yielded);
+		}
+
+		explicit operator bool() const noexcept {
+			return runnable();
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			// some users screw up coroutine.create
+			// and try to use it with sol::coroutine without ever calling the first resume in Lua
+			// this makes the stack incompatible with other kinds of stacks: protect against this
+			// make sure coroutines don't screw us over
+			base_t::push();
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
+		}
+
+	private:
+		handler_t m_error_handler;
+	};
+} // namespace sol
+
+// end of sol/coroutine.hpp
+
+// beginning of sol/userdata.hpp
+
+namespace sol {
+	template <typename base_type>
+	class basic_userdata : public basic_table<base_type> {
+	private:
+		using base_t = basic_table<base_type>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_userdata() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_userdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::userdata);
+			}
+#endif // Safety
+		}
+		basic_userdata(const basic_userdata&) = default;
+		basic_userdata(basic_userdata&&) = default;
+		basic_userdata& operator=(const basic_userdata&) = default;
+		basic_userdata& operator=(basic_userdata&&) = default;
+		basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+	};
+
+	template <typename base_type>
+	class basic_lightuserdata : public basic_object_base<base_type> {
+		typedef basic_object_base<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lightuserdata() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_lightuserdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::lightuserdata);
+			}
+#endif // Safety
+		}
+		basic_lightuserdata(const basic_lightuserdata&) = default;
+		basic_lightuserdata(basic_lightuserdata&&) = default;
+		basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
+		basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
+		basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(lua_State* L, T&& r) : basic_lightuserdata(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(lua_state(), index, handler);
+#endif // Safety
+		}
+	};
+
+} // namespace sol
+
+// end of sol/userdata.hpp
+
+// beginning of sol/as_args.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_args_t {
+		T src;
+	};
+
+	template <typename Source>
+	auto as_args(Source&& source) {
+		return as_args_t<Source> { std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_args_t<T>> {
+			int push(lua_State* L, const as_args_t<T>& e) {
+				int p = 0;
+				for (const auto& i : e.src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_args.hpp
+
+// beginning of sol/variadic_args.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	struct variadic_args {
+	private:
+		lua_State* L;
+		int index;
+		int stacktop;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		variadic_args() = default;
+		variadic_args(lua_State* luastate, int stackindex = -1) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {
+		}
+		variadic_args(lua_State* luastate, int stackindex, int lastindex) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lastindex) {
+		}
+		variadic_args(const variadic_args&) = default;
+		variadic_args& operator=(const variadic_args&) = default;
+		variadic_args(variadic_args&& o) : L(o.L), index(o.index), stacktop(o.stacktop) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+		}
+		variadic_args& operator=(variadic_args&& o) {
+			L = o.L;
+			index = o.index;
+			stacktop = o.stacktop;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+			return *this;
+		}
+
+		iterator begin() {
+			return iterator(L, index, stacktop + 1);
+		}
+		iterator end() {
+			return iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stacktop + 1);
+		}
+		const_iterator end() const {
+			return const_iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		int push() const {
+			return push(L);
+		}
+
+		int push(lua_State* target) const {
+			int pushcount = 0;
+			for (int i = index; i <= stacktop; ++i) {
+				lua_pushvalue(L, i);
+				pushcount += 1;
+			}
+			if (target != L) {
+				lua_xmove(L, target, pushcount);
+			}
+			return pushcount;
+		}
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int leftover_count() const {
+			return stacktop - (index - 1);
+		}
+		std::size_t size() const {
+			return static_cast<std::size_t>(leftover_count());
+		}
+		int top() const {
+			return stacktop;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<variadic_args> {
+			static variadic_args get(lua_State* L, int index, record& tracking) {
+				tracking.last = 0;
+				return variadic_args(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_args> {
+			static int push(lua_State* L, const variadic_args& ref) {
+				return ref.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/variadic_args.hpp
+
+// beginning of sol/variadic_results.hpp
+
+// beginning of sol/as_returns.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_returns_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+		using base_t::value;
+	};
+
+	template <typename Source>
+	auto as_returns(Source&& source) {
+		return as_returns_t<std::decay_t<Source>> { std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_returns_t<T>> {
+			int push(lua_State* L, const as_returns_t<T>& e) {
+				auto& src = detail::unwrap(e.value());
+				int p = 0;
+				for (const auto& i : src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_returns.hpp
+
+#include <vector>
+
+namespace sol {
+
+	template <typename Al = typename std::allocator<object>>
+	struct basic_variadic_results : public std::vector<object, Al> {
+	private:
+		using base_t = std::vector<object, Al>;
+
+	public:
+		basic_variadic_results() : base_t() {
+		}
+
+		basic_variadic_results(unsafe_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		basic_variadic_results(protected_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		template <typename Arg0, typename... Args,
+		     meta::disable_any<std::is_same<meta::unqualified_t<Arg0>, basic_variadic_results>, std::is_same<meta::unqualified_t<Arg0>, function_result>,
+		          std::is_same<meta::unqualified_t<Arg0>, protected_function_result>> = meta::enabler>
+		basic_variadic_results(Arg0&& arg0, Args&&... args) : base_t(std::forward<Arg0>(arg0), std::forward<Args>(args)...) {
+		}
+
+		basic_variadic_results(const basic_variadic_results&) = default;
+		basic_variadic_results(basic_variadic_results&&) = default;
+	};
+
+	struct variadic_results : public basic_variadic_results<> {
+	private:
+		using base_t = basic_variadic_results<>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename Al>
+	struct is_container<basic_variadic_results<Al>> : std::false_type { };
+
+	template <>
+	struct is_container<variadic_results> : std::false_type { };
+
+	namespace stack {
+		template <typename Al>
+		struct unqualified_pusher<basic_variadic_results<Al>> {
+			int push(lua_State* L, const basic_variadic_results<Al>& e) {
+				int p = 0;
+				for (const auto& i : e) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_results> {
+			int push(lua_State* L, const variadic_results& r) {
+				using base_t = basic_variadic_results<>;
+				return stack::push(L, static_cast<const base_t&>(r));
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/variadic_results.hpp
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#elif SOL_IS_ON(SOL_COMPILER_CLANG)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+#pragma warning(pop)
+#endif // g++
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
+#undef check
+#pragma pop_macro("check")
+#endif // Unreal Engine 4 Bullshit
+
+#endif // SOL_HPP
+// end of sol/sol.hpp
+
+#endif // SOL_SINGLE_INCLUDE_HPP