diff --git a/ElunaIncludes.h b/ElunaIncludes.h
index c5a2c88bd8..3d4a82dbff 100644
--- a/ElunaIncludes.h
+++ b/ElunaIncludes.h
@@ -40,6 +40,7 @@
 #include "ScriptMgr.h"
 #include "Spell.h"
 #include "SpellAuras.h"
+#include "SpellAuraEffects.h"
 #include "SpellMgr.h"
 #include "TemporarySummon.h"
 #include "WorldPacket.h"
diff --git a/ElunaTemplate.cpp b/ElunaTemplate.cpp
index 462ea92d65..8baa2b1425 100644
--- a/ElunaTemplate.cpp
+++ b/ElunaTemplate.cpp
@@ -20,6 +20,13 @@ ElunaConstrainedObjectRef<Aura> GetWeakPtrFor(Aura const* obj)
 #endif
     return { obj->GetWeakPtr(), map };
 }
+
+ElunaConstrainedObjectRef<AuraEffect> GetWeakPtrFor(AuraEffect const* obj)
+{
+    Map* map = obj->GetBase()->GetOwner()->GetMap();
+    return { obj->GetWeakPtr(), map };
+}
+
 ElunaConstrainedObjectRef<BattleGround> GetWeakPtrFor(BattleGround const* obj) { return { obj->GetWeakPtr(), obj->GetBgMap() }; }
 ElunaConstrainedObjectRef<Group> GetWeakPtrFor(Group const* obj) { return { obj->GetWeakPtr(), nullptr }; }
 ElunaConstrainedObjectRef<Guild> GetWeakPtrFor(Guild const* obj) { return { obj->GetWeakPtr(), nullptr }; }
diff --git a/ElunaTemplate.h b/ElunaTemplate.h
index 74d98f3bf2..7fcf780104 100644
--- a/ElunaTemplate.h
+++ b/ElunaTemplate.h
@@ -62,6 +62,7 @@ struct ElunaConstrainedObjectRef
 };
 
 ElunaConstrainedObjectRef<Aura> GetWeakPtrFor(Aura const* obj);
+ElunaConstrainedObjectRef<AuraEffect> GetWeakPtrFor(AuraEffect const* obj);
 ElunaConstrainedObjectRef<BattleGround> GetWeakPtrFor(BattleGround const* obj);
 ElunaConstrainedObjectRef<Group> GetWeakPtrFor(Group const* obj);
 ElunaConstrainedObjectRef<Guild> GetWeakPtrFor(Guild const* obj);
diff --git a/LuaEngine.h b/LuaEngine.h
index b9b2fd94a3..3f08eb0c05 100644
--- a/LuaEngine.h
+++ b/LuaEngine.h
@@ -623,6 +623,12 @@ class ELUNA_GAME_API Eluna
 
     /* Spell */
     void OnSpellCast(Spell* pSpell, bool skipCheck);
+    bool OnAuraApplication(Aura* aura, AuraEffect const* auraEff, Unit* target, uint8 mode, bool apply);
+    void OnAuraDispel(Aura* aura, DispelInfo* dispelInfo);
+    bool OnPerodicTick(Aura* aura, AuraEffect const* auraEff, Unit* target);
+    void OnPerodicUpdate(Aura* aura, AuraEffect const* auraEff);
+    void OnAuraCalcAmount(Aura* aura, AuraEffect const* auraEff, int32& amount, bool& canBeRecalculated);
+    void OnCalcPerodic(Aura* aura, AuraEffect const* auraEff, bool& isPeriodic, int32& amplitude);
 };
 template<> Unit* Eluna::CHECKOBJ<Unit>(int narg, bool error);
 template<> Object* Eluna::CHECKOBJ<Object>(int narg, bool error);
diff --git a/hooks/Hooks.h b/hooks/Hooks.h
index 297278d135..1663346ca5 100644
--- a/hooks/Hooks.h
+++ b/hooks/Hooks.h
@@ -54,16 +54,16 @@ namespace Hooks
     };
 
     // PACKET EVENTS
-    #define PACKET_EVENTS_LIST(X) \
+#define PACKET_EVENTS_LIST(X) \
         X(PACKET_EVENT_ON_PACKET_RECEIVE,         5,  "on_receive")      \
         X(PACKET_EVENT_ON_PACKET_RECEIVE_UNKNOWN, 6,  "on_receive_unk")  \
         X(PACKET_EVENT_ON_PACKET_SEND,            7,  "on_send")
 
     enum PacketEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         PACKET_EVENTS_LIST(X)
-    #undef X
+#undef X
         PACKET_EVENT_COUNT
     };
 
@@ -74,7 +74,7 @@ namespace Hooks
     };
 
     // SERVER EVENTS
-    #define SERVER_EVENTS_LIST(X) \
+#define SERVER_EVENTS_LIST(X) \
         /* Server */ \
         X(SERVER_EVENT_ON_NETWORK_START,          1,  "on_network_start")         \
         X(SERVER_EVENT_ON_NETWORK_STOP,           2,  "on_network_stop")          \
@@ -123,9 +123,9 @@ namespace Hooks
 
     enum ServerEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         SERVER_EVENTS_LIST(X)
-    #undef X
+#undef X
         SERVER_EVENT_COUNT
     };
 
@@ -136,7 +136,7 @@ namespace Hooks
     };
 
     // PLAYER EVENTS
-    #define PLAYER_EVENTS_LIST(X) \
+#define PLAYER_EVENTS_LIST(X) \
         X(PLAYER_EVENT_ON_CHARACTER_CREATE,        1,  "on_character_create")      \
         X(PLAYER_EVENT_ON_CHARACTER_DELETE,        2,  "on_character_delete")      \
         X(PLAYER_EVENT_ON_LOGIN,                   3,  "on_login")                 \
@@ -191,9 +191,9 @@ namespace Hooks
 
     enum PlayerEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         PLAYER_EVENTS_LIST(X)
-    #undef X
+#undef X
         PLAYER_EVENT_COUNT
     };
 
@@ -204,7 +204,7 @@ namespace Hooks
     };
 
     // GUILD EVENTS
-    #define GUILD_EVENTS_LIST(X) \
+#define GUILD_EVENTS_LIST(X) \
         X(GUILD_EVENT_ON_ADD_MEMBER,      1,  "on_add_member")      \
         X(GUILD_EVENT_ON_REMOVE_MEMBER,   2,  "on_remove_member")   \
         X(GUILD_EVENT_ON_MOTD_CHANGE,     3,  "on_motd_change")     \
@@ -219,9 +219,9 @@ namespace Hooks
 
     enum GuildEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         GUILD_EVENTS_LIST(X)
-    #undef X
+#undef X
         GUILD_EVENT_COUNT
     };
 
@@ -232,7 +232,7 @@ namespace Hooks
     };
 
     // GROUP EVENTS
-    #define GROUP_EVENTS_LIST(X) \
+#define GROUP_EVENTS_LIST(X) \
         X(GROUP_EVENT_ON_MEMBER_ADD,     1, "on_add_member")     \
         X(GROUP_EVENT_ON_MEMBER_INVITE,  2, "on_invite_member")  \
         X(GROUP_EVENT_ON_MEMBER_REMOVE,  3, "on_remove_member")  \
@@ -243,9 +243,9 @@ namespace Hooks
 
     enum GroupEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         GROUP_EVENTS_LIST(X)
-    #undef X
+#undef X
         GROUP_EVENT_COUNT
     };
 
@@ -256,7 +256,7 @@ namespace Hooks
     };
 
     // VEHICLE EVENTS
-    #define VEHICLE_EVENTS_LIST(X) \
+#define VEHICLE_EVENTS_LIST(X) \
         X(VEHICLE_EVENT_ON_INSTALL,           1, "on_install")           \
         X(VEHICLE_EVENT_ON_UNINSTALL,         2, "on_uninstall")         \
         /* 3 unused */ \
@@ -266,9 +266,9 @@ namespace Hooks
 
     enum VehicleEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         VEHICLE_EVENTS_LIST(X)
-    #undef X
+#undef X
         VEHICLE_EVENT_COUNT
     };
 
@@ -279,7 +279,7 @@ namespace Hooks
     };
 
     // CREATURE EVENTS
-    #define CREATURE_EVENTS_LIST(X) \
+#define CREATURE_EVENTS_LIST(X) \
         X(CREATURE_EVENT_ON_ENTER_COMBAT,               1,  "on_enter_combat")               \
         X(CREATURE_EVENT_ON_LEAVE_COMBAT,               2,  "on_leave_combat")               \
         X(CREATURE_EVENT_ON_TARGET_DIED,                3,  "on_target_died")                \
@@ -316,9 +316,9 @@ namespace Hooks
 
     enum CreatureEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         CREATURE_EVENTS_LIST(X)
-    #undef X
+#undef X
         CREATURE_EVENT_COUNT
     };
 
@@ -329,7 +329,7 @@ namespace Hooks
     };
 
     // GAMEOBJECT EVENTS
-    #define GAMEOBJECT_EVENTS_LIST(X) \
+#define GAMEOBJECT_EVENTS_LIST(X) \
         X(GAMEOBJECT_EVENT_ON_AIUPDATE,          1,  "on_ai_update")         \
         X(GAMEOBJECT_EVENT_ON_SPAWN,             2,  "on_spawn")             \
         X(GAMEOBJECT_EVENT_ON_DUMMY_EFFECT,      3,  "on_dummy_effect")      \
@@ -347,9 +347,9 @@ namespace Hooks
 
     enum GameObjectEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         GAMEOBJECT_EVENTS_LIST(X)
-    #undef X
+#undef X
         GAMEOBJECT_EVENT_COUNT
     };
 
@@ -360,14 +360,20 @@ namespace Hooks
     };
 
     // SPELL EVENTS
-    #define SPELL_EVENTS_LIST(X) \
+#define SPELL_EVENTS_LIST(X) \
         X(SPELL_EVENT_ON_CAST, 1, "on_cast")
+        X(SPELL_EVENT_ON_AURA_APPLICATION, 2, "on_aura_application")
+        X(SPELL_EVENT_ON_DISPEL, 3, "on_dispel")
+        X(SPELL_EVENT_ON_PERODIC_TICK, 4, "on_periodic_tick")
+        X(SPELL_EVENT_ON_PERODIC_UPDATE, 5, "on_periodic_update")
+        X(SPELL_EVENT_ON_AURA_CALC_AMOUNT, 6, "on_aura_calc_amount")
+        X(SPELL_EVENT_ON_CALC_PERODIC, 7, "on_calc_periodic")
 
     enum SpellEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         SPELL_EVENTS_LIST(X)
-    #undef X
+#undef X
         SPELL_EVENT_COUNT
     };
 
@@ -378,7 +384,7 @@ namespace Hooks
     };
 
     // ITEM EVENTS
-    #define ITEM_EVENTS_LIST(X) \
+#define ITEM_EVENTS_LIST(X) \
         X(ITEM_EVENT_ON_DUMMY_EFFECT, 1, "on_dummy_effect") \
         X(ITEM_EVENT_ON_USE,          2, "on_use")          \
         X(ITEM_EVENT_ON_QUEST_ACCEPT, 3, "on_quest_accept") \
@@ -391,9 +397,9 @@ namespace Hooks
 
     enum ItemEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         ITEM_EVENTS_LIST(X)
-    #undef X
+#undef X
         ITEM_EVENT_COUNT
     };
 
@@ -404,15 +410,15 @@ namespace Hooks
     };
 
     // GOSSIP EVENTS
-    #define GOSSIP_EVENTS_LIST(X) \
+#define GOSSIP_EVENTS_LIST(X) \
         X(GOSSIP_EVENT_ON_HELLO,  1, "on_hello") \
         X(GOSSIP_EVENT_ON_SELECT, 2, "on_select")
 
     enum GossipEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         GOSSIP_EVENTS_LIST(X)
-    #undef X
+#undef X
         GOSSIP_EVENT_COUNT
     };
 
@@ -423,7 +429,7 @@ namespace Hooks
     };
 
     // BG EVENTS
-    #define BG_EVENTS_LIST(X) \
+#define BG_EVENTS_LIST(X) \
         X(BG_EVENT_ON_START,      1, "on_start")      \
         X(BG_EVENT_ON_END,        2, "on_end")        \
         X(BG_EVENT_ON_CREATE,     3, "on_create")     \
@@ -431,9 +437,9 @@ namespace Hooks
 
     enum BGEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         BG_EVENTS_LIST(X)
-    #undef X
+#undef X
         BG_EVENT_COUNT
     };
 
@@ -444,7 +450,7 @@ namespace Hooks
     };
 
     // INSTANCE EVENTS
-    #define INSTANCE_EVENTS_LIST(X) \
+#define INSTANCE_EVENTS_LIST(X) \
         X(INSTANCE_EVENT_ON_INITIALIZE,                  1, "on_initialize")                 \
         X(INSTANCE_EVENT_ON_LOAD,                        2, "on_load")                       \
         X(INSTANCE_EVENT_ON_UPDATE,                      3, "on_update")                     \
@@ -455,9 +461,9 @@ namespace Hooks
 
     enum InstanceEvents
     {
-    #define X(ID, VALUE, NAME) ID = VALUE,
+#define X(ID, VALUE, NAME) ID = VALUE,
         INSTANCE_EVENTS_LIST(X)
-    #undef X
+#undef X
         INSTANCE_EVENT_COUNT
     };
 
diff --git a/hooks/SpellHooks.cpp b/hooks/SpellHooks.cpp
index a5ef8a30a6..e3e76ec986 100644
--- a/hooks/SpellHooks.cpp
+++ b/hooks/SpellHooks.cpp
@@ -15,13 +15,13 @@ using namespace Hooks;
 
 #define START_HOOK(EVENT, SPELL) \
     auto binding = GetBinding<EntryKey<SpellEvents>>(REGTYPE_SPELL);\
-    auto key = EntryKey<SpellEvents>(EVENT, SPELL->m_spellInfo->Id);\
+    auto key = EntryKey<SpellEvents>(EVENT, SPELL->GetSpellInfo()->Id);\
     if (!binding->HasBindingsFor(key))\
         return;
 
 #define START_HOOK_WITH_RETVAL(EVENT, SPELL, RETVAL) \
     auto binding = GetBinding<EntryKey<SpellEvents>>(REGTYPE_SPELL);\
-    auto key = EntryKey<SpellEvents>(EVENT, SPELL->m_spellInfo->Id);\
+    auto key = EntryKey<SpellEvents>(EVENT, SPELL->GetSpellInfo()->Id);\
     if (!binding->HasBindingsFor(key))\
         return RETVAL;
 
@@ -32,3 +32,112 @@ void Eluna::OnSpellCast(Spell* pSpell, bool skipCheck)
     HookPush(skipCheck);
     CallAllFunctions(binding, key);
 }
+
+bool Eluna::OnAuraApplication(Aura* aura, AuraEffect const* auraEff, Unit* target, uint8 mode, bool apply)
+{
+    START_HOOK_WITH_RETVAL(SPELL_EVENT_ON_AURA_APPLICATION, aura, false);
+    HookPush(aura);
+    HookPush(auraEff);
+    HookPush(target);
+    HookPush(mode);
+    HookPush(apply);
+    return CallAllFunctionsBool(binding, key, false);
+}
+
+void Eluna::OnAuraDispel(Aura* aura, DispelInfo* dispelInfo)
+{
+    START_HOOK(SPELL_EVENT_ON_DISPEL, aura);
+    HookPush(aura);
+    HookPush(dispelInfo->GetDispeller());
+    HookPush(dispelInfo->GetDispellerSpellId());
+    HookPush(dispelInfo->GetRemovedCharges());
+    CallAllFunctions(binding, key);
+}
+
+bool Eluna::OnPerodicTick(Aura* aura, AuraEffect const* auraEff, Unit* target)
+{
+    START_HOOK_WITH_RETVAL(SPELL_EVENT_ON_PERODIC_TICK, aura, false);
+    HookPush(aura);
+    HookPush(auraEff);
+    HookPush(target);
+    return CallAllFunctionsBool(binding, key, false);
+}
+
+void Eluna::OnPerodicUpdate(Aura* aura, AuraEffect const* auraEff)
+{
+    START_HOOK(SPELL_EVENT_ON_PERODIC_UPDATE, aura);
+    HookPush(aura);
+    HookPush(auraEff);
+    CallAllFunctions(binding, key);
+}
+
+void Eluna::OnAuraCalcAmount(Aura* aura, AuraEffect const* auraEff, int32& amount, bool& canBeRecalculated)
+{
+    START_HOOK(SPELL_EVENT_ON_AURA_CALC_AMOUNT, aura);
+    HookPush(aura);
+    HookPush(auraEff);
+    HookPush(amount);
+    int amountIndex = lua_gettop(L);
+    HookPush(canBeRecalculated);
+    int canBeRecalculatedIndex = lua_gettop(L);
+    int n = SetupStack(binding, key, 4);
+
+    while (n > 0)
+    {
+        int r = CallOneFunction(n--, 4, 2);
+
+        if (lua_isnumber(L, r + 0))
+        {
+            amount = CHECKVAL<uint32>(r + 0);
+            // Update the stack for subsequent calls.
+            ReplaceArgument(amount, amountIndex);
+        }
+
+
+        if (lua_isboolean(L, r + 1))
+        {
+            canBeRecalculated = lua_toboolean(L, r + 1);
+            // Update the stack for subsequent calls.
+            ReplaceArgument(amount, canBeRecalculatedIndex);
+        }
+
+        lua_pop(L, 2);
+    }
+
+    CleanUpStack(2);
+}
+
+void Eluna::OnCalcPerodic(Aura* aura, AuraEffect const* auraEff, bool& isPeriodic, int32& amplitude)
+{
+    START_HOOK(SPELL_EVENT_ON_AURA_CALC_AMOUNT, aura);
+    HookPush(aura);
+    HookPush(auraEff);
+    HookPush(isPeriodic);
+    int isPeriodicIndex = lua_gettop(L);
+    HookPush(amplitude);
+    int amplitudeIndex = lua_gettop(L);
+    int n = SetupStack(binding, key, 4);
+
+    while (n > 0)
+    {
+        int r = CallOneFunction(n--, 4, 2);
+
+        if (lua_isboolean(L, r + 0))
+        {
+            isPeriodic = lua_toboolean(L, r + 0);
+            // Update the stack for subsequent calls.
+            ReplaceArgument(isPeriodic, isPeriodicIndex);
+        }
+
+        if (lua_isnumber(L, r + 1))
+        {
+            amplitude = CHECKVAL<int32>(r + 1);
+            // Update the stack for subsequent calls.
+            ReplaceArgument(amplitude, amplitudeIndex);
+        }
+
+        lua_pop(L, 2);
+    }
+
+    CleanUpStack(2);
+}
diff --git a/methods/Methods.cpp b/methods/Methods.cpp
index ae2bf4d229..0f53ef36c9 100644
--- a/methods/Methods.cpp
+++ b/methods/Methods.cpp
@@ -23,6 +23,7 @@
 #include "GameObjectMethods.h"
 #include "ElunaQueryMethods.h"
 #include "AuraMethods.h"
+#include "AuraEffectMethods.h"
 #include "ItemMethods.h"
 #include "WorldPacketMethods.h"
 #include "SpellMethods.h"
@@ -90,6 +91,9 @@ void RegisterMethods(Eluna* E)
     ElunaTemplate<Aura>::Register(E, "Aura");
     ElunaTemplate<Aura>::SetMethods(E, LuaAura::AuraMethods);
 
+    ElunaTemplate<AuraEffect>::Register(E, "AuraEffect");
+    ElunaTemplate<AuraEffect>::SetMethods(E, LuaAuraEffects::AuraEffectMethods);
+
     ElunaTemplate<Spell>::Register(E, "Spell");
     ElunaTemplate<Spell>::SetMethods(E, LuaSpell::SpellMethods);
 
diff --git a/methods/TrinityCore/AuraEffectMethods.h b/methods/TrinityCore/AuraEffectMethods.h
new file mode 100644
index 0000000000..1fd750258a
--- /dev/null
+++ b/methods/TrinityCore/AuraEffectMethods.h
@@ -0,0 +1,200 @@
+/*
+* Copyright (C) 2010 - 2024 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 AURAEFFECTMETHODS_H
+#define AURAEFFECTMETHODS_H
+
+
+namespace LuaAuraEffects
+{
+    int GetBase(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetBase());
+        return 1;
+    }
+
+    int GetBaseAmount(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetBaseAmount());
+        return 1;
+    }
+
+    int GetAmplitude(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetAmplitude());
+        return 1;
+    }
+
+    int GetAmount(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetAmount());
+        return 1;
+    }
+
+    int SetAmount(Eluna* E, AuraEffect* aurEff)
+    {
+        int32 amount = E->CHECKVAL<int32>(2);
+        aurEff->SetAmount(amount);
+        return 0;
+    }
+
+    int GetPeriodicTimer(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetPeriodicTimer());
+        return 1;
+    }
+
+    int SetPeriodicTimer(Eluna* E, AuraEffect* aurEff)
+    {
+        int32 timer = E->CHECKVAL<int32>(2);
+        aurEff->SetPeriodicTimer(timer);
+        return 0;
+    }
+
+    int CalculateAmount(Eluna* E, AuraEffect* aurEff)
+    {
+        Unit* caster = E->CHECKOBJ<Unit>(2);
+        E->Push(aurEff->CalculateAmount(caster));
+        return 1;
+    }
+
+    int CalculatePeriodic(Eluna* E, AuraEffect* aurEff)
+    {
+        Unit* caster = E->CHECKOBJ<Unit>(2);
+        bool resetPeriodicTimer = E->CHECKVAL<bool>(3, false);
+        bool load = E->CHECKVAL<bool>(4, false);
+        aurEff->CalculatePeriodic(caster, resetPeriodicTimer, load);
+        return 0;
+    }
+
+    int ChangeAmount(Eluna* E, AuraEffect* aurEff)
+    {
+        int32 newAmount = E->CHECKVAL<int32>(2);
+        bool mark = E->CHECKVAL<bool>(3, true);
+        bool onStackOrReapply = E->CHECKVAL<bool>(4, false);
+        aurEff->ChangeAmount(newAmount, mark, onStackOrReapply);
+        return 0;
+    }
+
+    int RecalculateAmount(Eluna* /*E*/, AuraEffect* aurEff)
+    {
+        aurEff->RecalculateAmount();
+        return 0;
+    }
+
+    int CanBeRecalculated(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->CanBeRecalculated());
+        return 1;
+    }
+
+    int SetCanBeRecalculated(Eluna* E, AuraEffect* aurEff)
+    {
+        bool val = E->CHECKVAL<bool>(2, true);
+        aurEff->SetCanBeRecalculated(val);
+        return 0;
+    }
+
+    int GetTickNumber(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetTickNumber());
+        return 1;
+    }
+
+    int GetRemainingTicks(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetRemainingTicks());
+        return 1;
+    }
+
+    int GetTotalTicks(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetTotalTicks());
+        return 1;
+    }
+
+    int GetTargetList(Eluna* E, AuraEffect* aurEff)
+    {
+        std::list<Unit*> list;
+        aurEff->GetTargetList(list);
+        lua_createtable(E->L, list.size(), 0);
+        int tbl = lua_gettop(E->L);
+        uint32 i = 0;
+
+        for (std::list<Unit*>::const_iterator it = list.begin(); it != list.end(); ++it)
+        {
+            E->Push(*it);
+            lua_rawseti(E->L, tbl, ++i);
+        }
+
+        lua_settop(E->L, tbl);
+        return 1;
+    }
+
+    int GetId(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetId());
+        return 1;
+    }
+
+    int GetEffIndex(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(uint8(aurEff->GetEffIndex()));
+        return 1;
+    }
+
+    int GetEffIndex(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(uint8(aurEff->GetEffIndex()));
+        return 1;
+    }
+
+    int GetAuraType(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(uint16(aurEff->GetAuraType()));
+        return 1;
+    }
+
+    int GetCaster(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetCaster());
+        return 1;
+    }
+
+    int GetCasterGUID(Eluna* E, AuraEffect* aurEff)
+    {
+        E->Push(aurEff->GetCasterGUID());
+        return 1;
+    }
+
+    ElunaRegister<AuraEffect> AuraEffectMethods[] =
+    {
+        {"GetBase", &LuaAuraEffects::GetBase},
+        {"GetBaseAmount", &LuaAuraEffects::GetBaseAmount},
+        {"GetAmplitude", &LuaAuraEffects::GetAmplitude},
+        {"GetAmount", &LuaAuraEffects::GetAmount},
+        {"SetAmount", &LuaAuraEffects::SetAmount},
+        {"GetPeriodicTimer", &LuaAuraEffects::GetPeriodicTimer},
+        {"SetPeriodicTimer", &LuaAuraEffects::SetPeriodicTimer},
+        {"CalculateAmount", &LuaAuraEffects::CalculateAmount},
+        {"CalculatePeriodic", &LuaAuraEffects::CalculatePeriodic},
+        {"ChangeAmount", &LuaAuraEffects::ChangeAmount},
+        {"RecalculateAmount", &LuaAuraEffects::RecalculateAmount},
+        {"CanBeRecalculated", &LuaAuraEffects::CanBeRecalculated},
+        {"SetCanBeRecalculated", &LuaAuraEffects::SetCanBeRecalculated},
+        {"GetTickNumber", &LuaAuraEffects::GetTickNumber},
+        {"GetRemainingTicks", &LuaAuraEffects::GetRemainingTicks},
+        {"GetTotalTicks", &LuaAuraEffects::GetTotalTicks},
+        {"GetTargetList", &LuaAuraEffects::GetTargetList},
+        {"GetId", &LuaAuraEffects::GetId},
+        {"GetEffIndex", &LuaAuraEffects::GetEffIndex},
+        {"GetAuraType", &LuaAuraEffects::GetAuraType},
+        {"GetCaster", &LuaAuraEffects::GetCaster},
+        {"GetCasterGUID", &LuaAuraEffects::GetCasterGUID}
+    };
+};
+#endif
+