/*
** Lua binding: EmberServices
** Generated automatically by tolua++-1.0.92 on Fri Feb 21 16:22:41 2014.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "components/lua/tolua++.h"

/* Exported function */
TOLUA_API int  tolua_EmberServices_open (lua_State* tolua_S);

#include "required.h"
#include "services/EmberServices.h"
#include "services/logging/LoggingService.h"
#include "services/server/ServerService.h"
#include "services/config/ConfigService.h"
#include "services/metaserver/MetaserverService.h"
#include "services/scripting/ScriptingService.h"
#include "services/input/Input.h"
#include "services/input/InputService.h"
#include "services/input/IInputAdapter.h"
#include "services/serversettings/ServerSettings.h"
#include "services/serversettings/ServerSettingsCredentials.h"
#include "services/server/LocalServerAdminCreator.h"
#include "services/server/AvatarTransferInfo.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_varconf__Variable (lua_State* tolua_S)
{
 varconf::Variable* self = (varconf::Variable*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ember__Services__ServerSettingsCredentials (lua_State* tolua_S)
{
 Ember::Services::ServerSettingsCredentials* self = (Ember::Services::ServerSettingsCredentials*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ember__LocalServerAdminCreator (lua_State* tolua_S)
{
 Ember::LocalServerAdminCreator* self = (Ember::LocalServerAdminCreator*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Ember__IInputAdapter (lua_State* tolua_S)
{
 Ember::IInputAdapter* self = (Ember::IInputAdapter*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_std__vector_std__string_ (lua_State* tolua_S)
{
 std::vector<std::string>* self = (std::vector<std::string>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"WFMath::Point<3>");
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::BaseConnection::Status>");
 tolua_usertype(tolua_S,"WFMath::Vector<3>");
 tolua_usertype(tolua_S,"Ember::Services::ServerSettingsCredentials");
 tolua_usertype(tolua_S,"Atlas::Objects::Root");
 tolua_usertype(tolua_S,"std::vector<const Eris::Entity*>");
 tolua_usertype(tolua_S,"Eris::TransferInfo");
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Avatar*>");
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::View*>");
 tolua_usertype(tolua_S,"SDLKey");
 tolua_usertype(tolua_S,"Eris::Account");
 tolua_usertype(tolua_S,"sigc::signal<void,const Atlas::Objects::Entity::RootEntity&>");
 tolua_usertype(tolua_S,"Ember::EmberServices");
 tolua_usertype(tolua_S,"sigc::signal<void,Ember::Input::InputMode>");
 tolua_usertype(tolua_S,"Ember::ConfigService");
 tolua_usertype(tolua_S,"std::map<std::string,varconf::Variable>");
 tolua_usertype(tolua_S,"sigc::signal<void,const Ember::MouseMotion&,Ember::Input::InputMode>");
 tolua_usertype(tolua_S,"WFMath::Quaternion");
 tolua_usertype(tolua_S,"WFMath::TimeStamp");
 tolua_usertype(tolua_S,"Service");
 tolua_usertype(tolua_S,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>");
 tolua_usertype(tolua_S,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>");
 tolua_usertype(tolua_S,"Ember::AvatarTransferInfo");
 tolua_usertype(tolua_S,"Ember::LocalServerAdminCreator");
 tolua_usertype(tolua_S,"Ember::Services::ServerSettings");
 tolua_usertype(tolua_S,"Eris::Meta");
 tolua_usertype(tolua_S,"Ember::MouseMotion");
 tolua_usertype(tolua_S,"Ember::ServerService");
 tolua_usertype(tolua_S,"Ember::IInputAdapter");
 tolua_usertype(tolua_S,"Ember::InputService");
 tolua_usertype(tolua_S,"std::vector<std::string>");
 tolua_usertype(tolua_S,"varconf::Variable");
 tolua_usertype(tolua_S,"Ember::Input");
 tolua_usertype(tolua_S,"Eris::Entity");
 tolua_usertype(tolua_S,"Ember::IScriptingProvider");
 tolua_usertype(tolua_S,"Ember::ScriptingService");
 tolua_usertype(tolua_S,"sigc::signal<void,const std::string&>");
 tolua_usertype(tolua_S,"Ember::MetaserverService");
 tolua_usertype(tolua_S,"sigc::signal<void,const Atlas::Objects::Root&>");
 tolua_usertype(tolua_S,"sigc::signal<void,const std::string&,const std::string&>");
 tolua_usertype(tolua_S,"sigc::signal<void>");
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Account*,const std::string&>");
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Account*>");
 tolua_usertype(tolua_S,"Ember::LoggingService");
 tolua_usertype(tolua_S,"Atlas::Message::MapType");
 tolua_usertype(tolua_S,"sigc::signal<void,Eris::Connection*>");
}

/* get function: xPosition of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_xPosition
static int tolua_get_Ember__MouseMotion_xPosition(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xPosition'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->xPosition);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: xPosition of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_xPosition
static int tolua_set_Ember__MouseMotion_xPosition(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xPosition'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->xPosition = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: yPosition of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_yPosition
static int tolua_get_Ember__MouseMotion_yPosition(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yPosition'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->yPosition);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: yPosition of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_yPosition
static int tolua_set_Ember__MouseMotion_yPosition(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yPosition'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->yPosition = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: xRelativeMovement of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_xRelativeMovement
static int tolua_get_Ember__MouseMotion_xRelativeMovement(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovement'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->xRelativeMovement);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: xRelativeMovement of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_xRelativeMovement
static int tolua_set_Ember__MouseMotion_xRelativeMovement(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovement'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->xRelativeMovement = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: yRelativeMovement of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_yRelativeMovement
static int tolua_get_Ember__MouseMotion_yRelativeMovement(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovement'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->yRelativeMovement);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: yRelativeMovement of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_yRelativeMovement
static int tolua_set_Ember__MouseMotion_yRelativeMovement(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovement'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->yRelativeMovement = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: xRelativeMovementInPixels of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_xRelativeMovementInPixels
static int tolua_get_Ember__MouseMotion_xRelativeMovementInPixels(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovementInPixels'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->xRelativeMovementInPixels);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: xRelativeMovementInPixels of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_xRelativeMovementInPixels
static int tolua_set_Ember__MouseMotion_xRelativeMovementInPixels(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'xRelativeMovementInPixels'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->xRelativeMovementInPixels = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: yRelativeMovementInPixels of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_yRelativeMovementInPixels
static int tolua_get_Ember__MouseMotion_yRelativeMovementInPixels(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovementInPixels'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->yRelativeMovementInPixels);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: yRelativeMovementInPixels of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_yRelativeMovementInPixels
static int tolua_set_Ember__MouseMotion_yRelativeMovementInPixels(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'yRelativeMovementInPixels'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->yRelativeMovementInPixels = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: timeSinceLastMovement of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_get_Ember__MouseMotion_timeSinceLastMovement
static int tolua_get_Ember__MouseMotion_timeSinceLastMovement(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'timeSinceLastMovement'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->timeSinceLastMovement);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: timeSinceLastMovement of class  Ember::MouseMotion */
#ifndef TOLUA_DISABLE_tolua_set_Ember__MouseMotion_timeSinceLastMovement
static int tolua_set_Ember__MouseMotion_timeSinceLastMovement(lua_State* tolua_S)
{
  Ember::MouseMotion* self = (Ember::MouseMotion*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'timeSinceLastMovement'",NULL);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->timeSinceLastMovement = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_getSingleton00
static int tolua_EmberServices_Ember_Input_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::Input",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::Input& tolua_ret = (Ember::Input&)  Ember::Input::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::Input");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventKeyPressed of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventKeyPressed
static int tolua_get_Ember__Input_EventKeyPressed(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventKeyPressed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventKeyPressed,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventKeyReleased of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventKeyReleased
static int tolua_get_Ember__Input_EventKeyReleased(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventKeyReleased'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventKeyReleased,"sigc::signal<void,const SDL_keysym&,Ember::Input::InputMode>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMouseMoved of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventMouseMoved
static int tolua_get_Ember__Input_EventMouseMoved(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseMoved'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMouseMoved,"sigc::signal<void,const Ember::MouseMotion&,Ember::Input::InputMode>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMouseButtonPressed of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventMouseButtonPressed
static int tolua_get_Ember__Input_EventMouseButtonPressed(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseButtonPressed'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMouseButtonPressed,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMouseButtonPressed of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventMouseButtonPressed
static int tolua_set_Ember__Input_EventMouseButtonPressed(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseButtonPressed'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMouseButtonPressed = *((sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventMouseButtonReleased of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventMouseButtonReleased
static int tolua_get_Ember__Input_EventMouseButtonReleased(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseButtonReleased'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventMouseButtonReleased,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventMouseButtonReleased of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventMouseButtonReleased
static int tolua_set_Ember__Input_EventMouseButtonReleased(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventMouseButtonReleased'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventMouseButtonReleased = *((sigc::signal<void,Ember::Input::MouseButton,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventChangedInputMode of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_get_Ember__Input_EventChangedInputMode
static int tolua_get_Ember__Input_EventChangedInputMode(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventChangedInputMode'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventChangedInputMode,"sigc::signal<void,Ember::Input::InputMode>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventChangedInputMode of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_set_Ember__Input_EventChangedInputMode
static int tolua_set_Ember__Input_EventChangedInputMode(lua_State* tolua_S)
{
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventChangedInputMode'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Ember::Input::InputMode>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventChangedInputMode = *((sigc::signal<void,Ember::Input::InputMode>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: isKeyDown of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_isKeyDown00
static int tolua_EmberServices_Ember_Input_isKeyDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::Input",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const SDLKey",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::Input* self = (const Ember::Input*)  tolua_tousertype(tolua_S,1,0);
  const SDLKey* tolua_var_1 = ((const SDLKey*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isKeyDown'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isKeyDown(*tolua_var_1);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isKeyDown'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setInputMode of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_setInputMode00
static int tolua_EmberServices_Ember_Input_setInputMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
  Ember::Input::InputMode mode = ((Ember::Input::InputMode) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setInputMode'", NULL);
#endif
  {
   self->setInputMode(mode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setInputMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInputMode of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_getInputMode00
static int tolua_EmberServices_Ember_Input_getInputMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::Input",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::Input* self = (const Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInputMode'", NULL);
#endif
  {
   Ember::Input::InputMode tolua_ret = (Ember::Input::InputMode)  self->getInputMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInputMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toggleInputMode of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_toggleInputMode00
static int tolua_EmberServices_Ember_Input_toggleInputMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toggleInputMode'", NULL);
#endif
  {
   Ember::Input::InputMode tolua_ret = (Ember::Input::InputMode)  self->toggleInputMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toggleInputMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addAdapter of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_addAdapter00
static int tolua_EmberServices_Ember_Input_addAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Ember::IInputAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
  Ember::IInputAdapter* adapter = ((Ember::IInputAdapter*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addAdapter'", NULL);
#endif
  {
   self->addAdapter(adapter);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeAdapter of class  Ember::Input */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Input_removeAdapter00
static int tolua_EmberServices_Ember_Input_removeAdapter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Input",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Ember::IInputAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Input* self = (Ember::Input*)  tolua_tousertype(tolua_S,1,0);
  Ember::IInputAdapter* adapter = ((Ember::IInputAdapter*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'removeAdapter'", NULL);
#endif
  {
   self->removeAdapter(adapter);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeAdapter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SETVALUE of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ConfigService_SETVALUE
static int tolua_get_Ember__ConfigService_SETVALUE(lua_State* tolua_S)
{
  tolua_pushcppstring(tolua_S,(const char*)Ember::ConfigService::SETVALUE);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GETVALUE of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ConfigService_GETVALUE
static int tolua_get_Ember__ConfigService_GETVALUE(lua_State* tolua_S)
{
  tolua_pushcppstring(tolua_S,(const char*)Ember::ConfigService::GETVALUE);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getValue of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getValue00
static int tolua_EmberServices_Ember_ConfigService_getValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getValue'", NULL);
#endif
  {
   varconf::Variable tolua_ret = (varconf::Variable)  self->getValue(section,key);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((varconf::Variable)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(varconf::Variable));
     tolua_pushusertype(tolua_S,tolua_obj,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)section);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setValue of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_setValue00
static int tolua_EmberServices_Ember_ConfigService_setValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const varconf::Variable",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const varconf::Variable* value = ((const varconf::Variable*)  tolua_tousertype(tolua_S,4,0));
  int scope = ((int)  tolua_tonumber(tolua_S,5,varconf::INSTANCE));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setValue'", NULL);
#endif
  {
   self->setValue(section,key,*value,scope);
   tolua_pushcppstring(tolua_S,(const char*)section);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isItemSet of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_isItemSet00
static int tolua_EmberServices_Ember_ConfigService_isItemSet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string value = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isItemSet'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isItemSet(section,key,value);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)section);
   tolua_pushcppstring(tolua_S,(const char*)key);
   tolua_pushcppstring(tolua_S,(const char*)value);
  }
 }
 return 4;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isItemSet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: itemExists of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_itemExists00
static int tolua_EmberServices_Ember_ConfigService_itemExists00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'itemExists'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->itemExists(section,key);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)section);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'itemExists'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: deleteItem of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_deleteItem00
static int tolua_EmberServices_Ember_ConfigService_deleteItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string section = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'deleteItem'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->deleteItem(section,key);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)section);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'deleteItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadSavedConfig of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_loadSavedConfig00
static int tolua_EmberServices_Ember_ConfigService_loadSavedConfig00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string filename = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadSavedConfig'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->loadSavedConfig(filename);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)filename);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadSavedConfig'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveConfig of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_saveConfig00
static int tolua_EmberServices_Ember_ConfigService_saveConfig00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string filename = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveConfig'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->saveConfig(filename);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)filename);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'saveConfig'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: saveConfig of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_saveConfig01
static int tolua_EmberServices_Ember_ConfigService_saveConfig01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConfigService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
  const std::string filename = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  int scopeMask = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'saveConfig'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->saveConfig(filename,scopeMask);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)filename);
  }
 }
 return 2;
tolua_lerror:
 return tolua_EmberServices_Ember_ConfigService_saveConfig00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: getHomeDirectory of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getHomeDirectory00
static int tolua_EmberServices_Ember_ConfigService_getHomeDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getHomeDirectory'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getHomeDirectory();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getHomeDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSharedDataDirectory of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getSharedDataDirectory00
static int tolua_EmberServices_Ember_ConfigService_getSharedDataDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSharedDataDirectory'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getSharedDataDirectory();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSharedDataDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEmberDataDirectory of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getEmberDataDirectory00
static int tolua_EmberServices_Ember_ConfigService_getEmberDataDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEmberDataDirectory'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getEmberDataDirectory();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEmberDataDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEmberMediaDirectory of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getEmberMediaDirectory00
static int tolua_EmberServices_Ember_ConfigService_getEmberMediaDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEmberMediaDirectory'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getEmberMediaDirectory();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEmberMediaDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getUserMediaDirectory of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getUserMediaDirectory00
static int tolua_EmberServices_Ember_ConfigService_getUserMediaDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getUserMediaDirectory'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getUserMediaDirectory();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getUserMediaDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSharedMediaDirectory of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getSharedMediaDirectory00
static int tolua_EmberServices_Ember_ConfigService_getSharedMediaDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSharedMediaDirectory'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getSharedMediaDirectory();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSharedMediaDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSharedConfigDirectory of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getSharedConfigDirectory00
static int tolua_EmberServices_Ember_ConfigService_getSharedConfigDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getSharedConfigDirectory'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getSharedConfigDirectory();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSharedConfigDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventChangedConfigItem of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ConfigService_EventChangedConfigItem
static int tolua_get_Ember__ConfigService_EventChangedConfigItem(lua_State* tolua_S)
{
  Ember::ConfigService* self = (Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventChangedConfigItem'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventChangedConfigItem,"sigc::signal<void,const std::string&,const std::string&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: getPrefix of class  Ember::ConfigService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ConfigService_getPrefix00
static int tolua_EmberServices_Ember_ConfigService_getPrefix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ConfigService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ConfigService* self = (const Ember::ConfigService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getPrefix'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getPrefix();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getPrefix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMetaServer of class  Ember::MetaserverService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_MetaserverService_getMetaServer00
static int tolua_EmberServices_Ember_MetaserverService_getMetaServer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::MetaserverService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::MetaserverService* self = (const Ember::MetaserverService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMetaServer'", NULL);
#endif
  {
   Eris::Meta& tolua_ret = (Eris::Meta&)  self->getMetaServer();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Eris::Meta");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMetaServer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: compareVersions of class  Ember::MetaserverService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_MetaserverService_compareVersions00
static int tolua_EmberServices_Ember_MetaserverService_compareVersions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::MetaserverService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string firstVersion = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string secondVersion = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   int tolua_ret = (int)  Ember::MetaserverService::compareVersions(firstVersion,secondVersion);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)firstVersion);
   tolua_pushcppstring(tolua_S,(const char*)secondVersion);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'compareVersions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAccount of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_getAccount00
static int tolua_EmberServices_Ember_ServerService_getAccount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ServerService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ServerService* self = (const Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAccount'", NULL);
#endif
  {
   Eris::Account* tolua_ret = (Eris::Account*)  self->getAccount();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Eris::Account");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAccount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: connect of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_connect00
static int tolua_EmberServices_Ember_ServerService_connect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string host = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  short port = ((short)  tolua_tonumber(tolua_S,3,6767));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'connect'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->connect(host,port);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)host);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'connect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: connectLocal of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_connectLocal00
static int tolua_EmberServices_Ember_ServerService_connectLocal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string socketPath = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'connectLocal'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->connectLocal(socketPath);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)socketPath);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'connectLocal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: hasLocalSocket of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_hasLocalSocket00
static int tolua_EmberServices_Ember_ServerService_hasLocalSocket00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string socketPath = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'hasLocalSocket'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->hasLocalSocket(socketPath);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)socketPath);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'hasLocalSocket'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: disconnect of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_disconnect00
static int tolua_EmberServices_Ember_ServerService_disconnect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'disconnect'", NULL);
#endif
  {
   self->disconnect();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'disconnect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: takeTransferredCharacter of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_takeTransferredCharacter00
static int tolua_EmberServices_Ember_ServerService_takeTransferredCharacter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Eris::TransferInfo",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const Eris::TransferInfo* transferInfo = ((const Eris::TransferInfo*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'takeTransferredCharacter'", NULL);
#endif
  {
   self->takeTransferredCharacter(*transferInfo);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'takeTransferredCharacter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: takeCharacter of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_takeCharacter00
static int tolua_EmberServices_Ember_ServerService_takeCharacter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string id = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'takeCharacter'", NULL);
#endif
  {
   self->takeCharacter(id);
   tolua_pushcppstring(tolua_S,(const char*)id);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'takeCharacter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createCharacter of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_createCharacter00
static int tolua_EmberServices_Ember_ServerService_createCharacter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const Atlas::Message::MapType",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string name = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string sex = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string type = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  const std::string description = ((const std::string)  tolua_tocppstring(tolua_S,5,0));
  const std::string spawnName = ((const std::string)  tolua_tocppstring(tolua_S,6,0));
  const Atlas::Message::MapType* extraProperties = ((const Atlas::Message::MapType*)  tolua_tousertype(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createCharacter'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->createCharacter(name,sex,type,description,spawnName,*extraProperties);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)name);
   tolua_pushcppstring(tolua_S,(const char*)sex);
   tolua_pushcppstring(tolua_S,(const char*)type);
   tolua_pushcppstring(tolua_S,(const char*)description);
   tolua_pushcppstring(tolua_S,(const char*)spawnName);
  }
 }
 return 6;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createCharacter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveToPoint of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_moveToPoint00
static int tolua_EmberServices_Ember_ServerService_moveToPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Point<3>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const WFMath::Point<3>* dest = ((const WFMath::Point<3>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveToPoint'", NULL);
#endif
  {
   self->moveToPoint(*dest);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveToPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveInDirection of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_moveInDirection00
static int tolua_EmberServices_Ember_ServerService_moveInDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Vector<3>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const WFMath::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const WFMath::Vector<3>* velocity = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,2,0));
  const WFMath::Quaternion* orientation = ((const WFMath::Quaternion*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveInDirection'", NULL);
#endif
  {
   self->moveInDirection(*velocity,*orientation);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'moveInDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: moveInDirection of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_moveInDirection01
static int tolua_EmberServices_Ember_ServerService_moveInDirection01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const WFMath::Vector<3>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const WFMath::Vector<3>* velocity = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'moveInDirection'", NULL);
#endif
  {
   self->moveInDirection(*velocity);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberServices_Ember_ServerService_moveInDirection00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: say of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_say00
static int tolua_EmberServices_Ember_ServerService_say00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'say'", NULL);
#endif
  {
   self->say(message);
   tolua_pushcppstring(tolua_S,(const char*)message);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'say'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sayTo of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_sayTo00
static int tolua_EmberServices_Ember_ServerService_sayTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const std::vector<const Eris::Entity*>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::vector<const Eris::Entity*>* entities = ((const std::vector<const Eris::Entity*>*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sayTo'", NULL);
#endif
  {
   self->sayTo(message,*entities);
   tolua_pushcppstring(tolua_S,(const char*)message);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'sayTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: sayTo of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_sayTo01
static int tolua_EmberServices_Ember_ServerService_sayTo01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Eris::Entity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const Eris::Entity* entity = ((const Eris::Entity*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'sayTo'", NULL);
#endif
  {
   self->sayTo(message,*entity);
   tolua_pushcppstring(tolua_S,(const char*)message);
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberServices_Ember_ServerService_sayTo00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: touch of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_touch00
static int tolua_EmberServices_Ember_ServerService_touch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'touch'", NULL);
#endif
  {
   self->touch(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'touch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: emote of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_emote00
static int tolua_EmberServices_Ember_ServerService_emote00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const std::string emote = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'emote'", NULL);
#endif
  {
   self->emote(emote);
   tolua_pushcppstring(tolua_S,(const char*)emote);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'emote'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: drop of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_drop00
static int tolua_EmberServices_Ember_ServerService_drop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'drop'", NULL);
#endif
  {
   self->drop(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'drop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: drop of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_drop01
static int tolua_EmberServices_Ember_ServerService_drop01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const WFMath::Vector<3>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const WFMath::Vector<3>* offset = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'drop'", NULL);
#endif
  {
   self->drop(entity,*offset);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberServices_Ember_ServerService_drop00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: drop of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_drop02
static int tolua_EmberServices_Ember_ServerService_drop02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const WFMath::Vector<3>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const WFMath::Quaternion",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const WFMath::Vector<3>* offset = ((const WFMath::Vector<3>*)  tolua_tousertype(tolua_S,3,0));
  const WFMath::Quaternion* orientation = ((const WFMath::Quaternion*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'drop'", NULL);
#endif
  {
   self->drop(entity,*offset,*orientation);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberServices_Ember_ServerService_drop01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: place of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_place00
static int tolua_EmberServices_Ember_ServerService_place00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  Eris::Entity* target = ((Eris::Entity*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'place'", NULL);
#endif
  {
   self->place(entity,target);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'place'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: wield of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_wield00
static int tolua_EmberServices_Ember_ServerService_wield00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'wield'", NULL);
#endif
  {
   self->wield(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'wield'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: wield of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_wield01
static int tolua_EmberServices_Ember_ServerService_wield01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::string outfitSlot = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'wield'", NULL);
#endif
  {
   self->wield(entity,outfitSlot);
   tolua_pushcppstring(tolua_S,(const char*)outfitSlot);
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberServices_Ember_ServerService_wield00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: take of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_take00
static int tolua_EmberServices_Ember_ServerService_take00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'take'", NULL);
#endif
  {
   self->take(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'take'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: use of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_use00
static int tolua_EmberServices_Ember_ServerService_use00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'use'", NULL);
#endif
  {
   self->use(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'use'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: use of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_use01
static int tolua_EmberServices_Ember_ServerService_use01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"WFMath::Point<3>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  WFMath::Point<3> pos = *((WFMath::Point<3>*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'use'", NULL);
#endif
  {
   self->use(entity,pos);
  }
 }
 return 0;
tolua_lerror:
 return tolua_EmberServices_Ember_ServerService_use00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: use of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_use02
static int tolua_EmberServices_Ember_ServerService_use02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"WFMath::Point<3>",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  WFMath::Point<3> pos = *((WFMath::Point<3>*)  tolua_tousertype(tolua_S,3,0));
  const std::string operation = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'use'", NULL);
#endif
  {
   self->use(entity,pos,operation);
   tolua_pushcppstring(tolua_S,(const char*)operation);
  }
 }
 return 1;
tolua_lerror:
 return tolua_EmberServices_Ember_ServerService_use01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: useStop of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_useStop00
static int tolua_EmberServices_Ember_ServerService_useStop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'useStop'", NULL);
#endif
  {
   self->useStop();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'useStop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: actuate of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_actuate00
static int tolua_EmberServices_Ember_ServerService_actuate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::string action = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'actuate'", NULL);
#endif
  {
   self->actuate(entity,action);
   tolua_pushcppstring(tolua_S,(const char*)action);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'actuate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: attack of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_attack00
static int tolua_EmberServices_Ember_ServerService_attack00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'attack'", NULL);
#endif
  {
   self->attack(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'attack'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: eat of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_eat00
static int tolua_EmberServices_Ember_ServerService_eat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eat'", NULL);
#endif
  {
   self->eat(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'eat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: deleteEntity of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_deleteEntity00
static int tolua_EmberServices_Ember_ServerService_deleteEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'deleteEntity'", NULL);
#endif
  {
   self->deleteEntity(entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'deleteEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAttributes of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_setAttributes00
static int tolua_EmberServices_Ember_ServerService_setAttributes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Eris::Entity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Atlas::Message::MapType",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  Atlas::Message::MapType* attributes = ((Atlas::Message::MapType*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAttributes'", NULL);
#endif
  {
   self->setAttributes(entity,*attributes);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAttributes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: createTypeInfo of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_createTypeInfo00
static int tolua_EmberServices_Ember_ServerService_createTypeInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Objects::Root",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const Atlas::Objects::Root* typeInfo = ((const Atlas::Objects::Root*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'createTypeInfo'", NULL);
#endif
  {
   self->createTypeInfo(*typeInfo);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'createTypeInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setTypeInfo of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ServerService_setTypeInfo00
static int tolua_EmberServices_Ember_ServerService_setTypeInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ServerService",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Atlas::Objects::Root",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
  const Atlas::Objects::Root* typeInfo = ((const Atlas::Objects::Root*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setTypeInfo'", NULL);
#endif
  {
   self->setTypeInfo(*typeInfo);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setTypeInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GotAvatar of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotAvatar
static int tolua_get_Ember__ServerService_GotAvatar(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAvatar'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->GotAvatar,"sigc::signal<void,Eris::Avatar*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: GotAvatar of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotAvatar
static int tolua_set_Ember__ServerService_GotAvatar(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAvatar'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Avatar*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->GotAvatar = *((sigc::signal<void,Eris::Avatar*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GotView of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotView
static int tolua_get_Ember__ServerService_GotView(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotView'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->GotView,"sigc::signal<void,Eris::View*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: GotView of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotView
static int tolua_set_Ember__ServerService_GotView(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotView'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::View*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->GotView = *((sigc::signal<void,Eris::View*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GotConnection of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotConnection
static int tolua_get_Ember__ServerService_GotConnection(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotConnection'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->GotConnection,"sigc::signal<void,Eris::Connection*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: GotConnection of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotConnection
static int tolua_set_Ember__ServerService_GotConnection(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotConnection'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Connection*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->GotConnection = *((sigc::signal<void,Eris::Connection*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GotAccount of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotAccount
static int tolua_get_Ember__ServerService_GotAccount(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAccount'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->GotAccount,"sigc::signal<void,Eris::Account*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: GotAccount of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotAccount
static int tolua_set_Ember__ServerService_GotAccount(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAccount'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Account*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->GotAccount = *((sigc::signal<void,Eris::Account*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: LoginSuccess of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_LoginSuccess
static int tolua_get_Ember__ServerService_LoginSuccess(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'LoginSuccess'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->LoginSuccess,"sigc::signal<void,Eris::Account*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: LoginSuccess of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_LoginSuccess
static int tolua_set_Ember__ServerService_LoginSuccess(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'LoginSuccess'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Account*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->LoginSuccess = *((sigc::signal<void,Eris::Account*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: LoginFailure of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_LoginFailure
static int tolua_get_Ember__ServerService_LoginFailure(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'LoginFailure'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->LoginFailure,"sigc::signal<void,Eris::Account*,const std::string&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GotCharacterInfo of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotCharacterInfo
static int tolua_get_Ember__ServerService_GotCharacterInfo(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotCharacterInfo'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->GotCharacterInfo,"sigc::signal<void,const Atlas::Objects::Entity::RootEntity&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GotAllCharacters of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_GotAllCharacters
static int tolua_get_Ember__ServerService_GotAllCharacters(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAllCharacters'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->GotAllCharacters,"sigc::signal<void,Eris::Account*>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: GotAllCharacters of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_GotAllCharacters
static int tolua_set_Ember__ServerService_GotAllCharacters(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'GotAllCharacters'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::Account*>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->GotAllCharacters = *((sigc::signal<void,Eris::Account*>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DestroyedAccount of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_DestroyedAccount
static int tolua_get_Ember__ServerService_DestroyedAccount(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DestroyedAccount'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->DestroyedAccount,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DestroyedAccount of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_DestroyedAccount
static int tolua_set_Ember__ServerService_DestroyedAccount(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DestroyedAccount'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DestroyedAccount = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DestroyedAvatar of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_DestroyedAvatar
static int tolua_get_Ember__ServerService_DestroyedAvatar(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DestroyedAvatar'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->DestroyedAvatar,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DestroyedAvatar of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_DestroyedAvatar
static int tolua_set_Ember__ServerService_DestroyedAvatar(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DestroyedAvatar'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DestroyedAvatar = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DestroyedView of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_DestroyedView
static int tolua_get_Ember__ServerService_DestroyedView(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DestroyedView'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->DestroyedView,"sigc::signal<void>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DestroyedView of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_DestroyedView
static int tolua_set_Ember__ServerService_DestroyedView(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DestroyedView'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DestroyedView = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventSendingObject of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_EventSendingObject
static int tolua_get_Ember__ServerService_EventSendingObject(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventSendingObject'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventSendingObject,"sigc::signal<void,const Atlas::Objects::Root&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventReceivedObject of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_EventReceivedObject
static int tolua_get_Ember__ServerService_EventReceivedObject(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventReceivedObject'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventReceivedObject,"sigc::signal<void,const Atlas::Objects::Root&>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EventStatusChanged of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_get_Ember__ServerService_EventStatusChanged
static int tolua_get_Ember__ServerService_EventStatusChanged(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventStatusChanged'",NULL);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->EventStatusChanged,"sigc::signal<void,Eris::BaseConnection::Status>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EventStatusChanged of class  Ember::ServerService */
#ifndef TOLUA_DISABLE_tolua_set_Ember__ServerService_EventStatusChanged
static int tolua_set_Ember__ServerService_EventStatusChanged(lua_State* tolua_S)
{
  Ember::ServerService* self = (Ember::ServerService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventStatusChanged'",NULL);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"sigc::signal<void,Eris::BaseConnection::Status>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->EventStatusChanged = *((sigc::signal<void,Eris::BaseConnection::Status>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: registerScriptingProvider of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_registerScriptingProvider00
static int tolua_EmberServices_Ember_ScriptingService_registerScriptingProvider00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Ember::IScriptingProvider",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
  Ember::IScriptingProvider* provider = ((Ember::IScriptingProvider*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'registerScriptingProvider'", NULL);
#endif
  {
   self->registerScriptingProvider(provider);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'registerScriptingProvider'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: loadScript of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_loadScript00
static int tolua_EmberServices_Ember_ScriptingService_loadScript00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
  const std::string script = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'loadScript'", NULL);
#endif
  {
   self->loadScript(script);
   tolua_pushcppstring(tolua_S,(const char*)script);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'loadScript'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: executeCode of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_executeCode00
static int tolua_EmberServices_Ember_ScriptingService_executeCode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
  const std::string scriptCode = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string scriptType = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'executeCode'", NULL);
#endif
  {
   self->executeCode(scriptCode,scriptType);
   tolua_pushcppstring(tolua_S,(const char*)scriptCode);
   tolua_pushcppstring(tolua_S,(const char*)scriptType);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'executeCode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getEventScriptError of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getEventScriptError00
static int tolua_EmberServices_Ember_ScriptingService_getEventScriptError00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getEventScriptError'", NULL);
#endif
  {
   sigc::signal<void,const std::string&>& tolua_ret = (sigc::signal<void,const std::string&>&)  self->getEventScriptError();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"sigc::signal<void,const std::string&>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getEventScriptError'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getProviderFor of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getProviderFor00
static int tolua_EmberServices_Ember_ScriptingService_getProviderFor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
  const std::string providerName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProviderFor'", NULL);
#endif
  {
   Ember::IScriptingProvider* tolua_ret = (Ember::IScriptingProvider*)  self->getProviderFor(providerName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::IScriptingProvider");
   tolua_pushcppstring(tolua_S,(const char*)providerName);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getProviderFor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getProviderNames of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getProviderNames00
static int tolua_EmberServices_Ember_ScriptingService_getProviderNames00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getProviderNames'", NULL);
#endif
  {
   std::vector<std::string> tolua_ret = (std::vector<std::string>)  self->getProviderNames();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<std::string>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<std::string>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<std::string>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getProviderNames'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAlwaysLookup of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_getAlwaysLookup00
static int tolua_EmberServices_Ember_ScriptingService_getAlwaysLookup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::ScriptingService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::ScriptingService* self = (const Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAlwaysLookup'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->getAlwaysLookup();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAlwaysLookup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setAlwaysLookup of class  Ember::ScriptingService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_ScriptingService_setAlwaysLookup00
static int tolua_EmberServices_Ember_ScriptingService_setAlwaysLookup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ScriptingService",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ScriptingService* self = (Ember::ScriptingService*)  tolua_tousertype(tolua_S,1,0);
  bool alwaysLookup = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setAlwaysLookup'", NULL);
#endif
  {
   self->setAlwaysLookup(alwaysLookup);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setAlwaysLookup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getInput of class  Ember::InputService */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_InputService_getInput00
static int tolua_EmberServices_Ember_InputService_getInput00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::InputService",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::InputService* self = (Ember::InputService*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getInput'", NULL);
#endif
  {
   Ember::Input& tolua_ret = (Ember::Input&)  self->getInput();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::Input");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInput'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  Ember::IInputAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_delete00
static int tolua_EmberServices_Ember_IInputAdapter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseMove of class  Ember::IInputAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectMouseMove00
static int tolua_EmberServices_Ember_IInputAdapter_injectMouseMove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ember::MouseMotion",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
  const Ember::MouseMotion* motion = ((const Ember::MouseMotion*)  tolua_tousertype(tolua_S,2,0));
  bool freezeMouse = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseMove'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->injectMouseMove(*motion,freezeMouse);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushboolean(tolua_S,(bool)freezeMouse);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseMove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseButtonUp of class  Ember::IInputAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonUp00
static int tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
  const Ember::Input::MouseButton button = ((const Ember::Input::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonUp'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->injectMouseButtonUp(button);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushnumber(tolua_S,(lua_Number)button);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonUp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectMouseButtonDown of class  Ember::IInputAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonDown00
static int tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
  const Ember::Input::MouseButton button = ((const Ember::Input::MouseButton) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectMouseButtonDown'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->injectMouseButtonDown(button);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushnumber(tolua_S,(lua_Number)button);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectMouseButtonDown'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectChar of class  Ember::IInputAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectChar00
static int tolua_EmberServices_Ember_IInputAdapter_injectChar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
  char character = ((char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectChar'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->injectChar(character);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectChar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectKeyDown of class  Ember::IInputAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectKeyDown00
static int tolua_EmberServices_Ember_IInputAdapter_injectKeyDown00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const SDLKey",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
  const SDLKey* key = ((const SDLKey*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectKeyDown'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->injectKeyDown(*key);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectKeyDown'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: injectKeyUp of class  Ember::IInputAdapter */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_IInputAdapter_injectKeyUp00
static int tolua_EmberServices_Ember_IInputAdapter_injectKeyUp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::IInputAdapter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const SDLKey",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::IInputAdapter* self = (Ember::IInputAdapter*)  tolua_tousertype(tolua_S,1,0);
  const SDLKey* key = ((const SDLKey*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'injectKeyUp'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->injectKeyUp(*key);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'injectKeyUp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: findItem of class  Ember::Services::ServerSettings */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettings_findItem00
static int tolua_EmberServices_Ember_Services_ServerSettings_findItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::Services::ServerSettings",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ember::Services::ServerSettingsCredentials",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::Services::ServerSettings* self = (const Ember::Services::ServerSettings*)  tolua_tousertype(tolua_S,1,0);
  const Ember::Services::ServerSettingsCredentials* credentials = ((const Ember::Services::ServerSettingsCredentials*)  tolua_tousertype(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'findItem'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->findItem(*credentials,key);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'findItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getItem of class  Ember::Services::ServerSettings */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettings_getItem00
static int tolua_EmberServices_Ember_Services_ServerSettings_getItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::Services::ServerSettings",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ember::Services::ServerSettingsCredentials",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::Services::ServerSettings* self = (const Ember::Services::ServerSettings*)  tolua_tousertype(tolua_S,1,0);
  const Ember::Services::ServerSettingsCredentials* credentials = ((const Ember::Services::ServerSettingsCredentials*)  tolua_tousertype(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getItem'", NULL);
#endif
  {
   varconf::Variable tolua_ret = (varconf::Variable)  self->getItem(*credentials,key);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((varconf::Variable)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(varconf::Variable));
     tolua_pushusertype(tolua_S,tolua_obj,"varconf::Variable");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItem of class  Ember::Services::ServerSettings */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettings_setItem00
static int tolua_EmberServices_Ember_Services_ServerSettings_setItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Services::ServerSettings",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ember::Services::ServerSettingsCredentials",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const varconf::Variable",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Services::ServerSettings* self = (Ember::Services::ServerSettings*)  tolua_tousertype(tolua_S,1,0);
  const Ember::Services::ServerSettingsCredentials* credentials = ((const Ember::Services::ServerSettingsCredentials*)  tolua_tousertype(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const varconf::Variable* item = ((const varconf::Variable*)  tolua_tousertype(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItem'", NULL);
#endif
  {
   self->setItem(*credentials,key,*item);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: eraseItem of class  Ember::Services::ServerSettings */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettings_eraseItem00
static int tolua_EmberServices_Ember_Services_ServerSettings_eraseItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Services::ServerSettings",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ember::Services::ServerSettingsCredentials",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Services::ServerSettings* self = (Ember::Services::ServerSettings*)  tolua_tousertype(tolua_S,1,0);
  const Ember::Services::ServerSettingsCredentials* credentials = ((const Ember::Services::ServerSettingsCredentials*)  tolua_tousertype(tolua_S,2,0));
  const std::string key = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'eraseItem'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->eraseItem(*credentials,key);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
   tolua_pushcppstring(tolua_S,(const char*)key);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'eraseItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getServerSettings of class  Ember::Services::ServerSettings */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettings_getServerSettings00
static int tolua_EmberServices_Ember_Services_ServerSettings_getServerSettings00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Services::ServerSettings",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Ember::Services::ServerSettingsCredentials",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Services::ServerSettings* self = (Ember::Services::ServerSettings*)  tolua_tousertype(tolua_S,1,0);
  const Ember::Services::ServerSettingsCredentials* credentials = ((const Ember::Services::ServerSettingsCredentials*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getServerSettings'", NULL);
#endif
  {
   const std::map<std::string,varconf::Variable>& tolua_ret = (const std::map<std::string,varconf::Variable>&)  self->getServerSettings(*credentials);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const std::map<std::string,varconf::Variable>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getServerSettings'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: writeToDisk of class  Ember::Services::ServerSettings */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettings_writeToDisk00
static int tolua_EmberServices_Ember_Services_ServerSettings_writeToDisk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Services::ServerSettings",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Services::ServerSettings* self = (Ember::Services::ServerSettings*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'writeToDisk'", NULL);
#endif
  {
   self->writeToDisk();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'writeToDisk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Ember::Services::ServerSettingsCredentials */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettingsCredentials_new00
static int tolua_EmberServices_Ember_Services_ServerSettingsCredentials_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::Services::ServerSettingsCredentials",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string hostName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string serverName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   Ember::Services::ServerSettingsCredentials* tolua_ret = (Ember::Services::ServerSettingsCredentials*)  Mtolua_new((Ember::Services::ServerSettingsCredentials)(hostName,serverName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::Services::ServerSettingsCredentials");
   tolua_pushcppstring(tolua_S,(const char*)hostName);
   tolua_pushcppstring(tolua_S,(const char*)serverName);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Ember::Services::ServerSettingsCredentials */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_Services_ServerSettingsCredentials_new00_local
static int tolua_EmberServices_Ember_Services_ServerSettingsCredentials_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::Services::ServerSettingsCredentials",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string hostName = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string serverName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   Ember::Services::ServerSettingsCredentials* tolua_ret = (Ember::Services::ServerSettingsCredentials*)  Mtolua_new((Ember::Services::ServerSettingsCredentials)(hostName,serverName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::Services::ServerSettingsCredentials");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)hostName);
   tolua_pushcppstring(tolua_S,(const char*)serverName);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Ember::LocalServerAdminCreator */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_LocalServerAdminCreator_new00
static int tolua_EmberServices_Ember_LocalServerAdminCreator_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::LocalServerAdminCreator",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ember::ServerService",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* serverService = ((Ember::ServerService*)  tolua_tousertype(tolua_S,2,0));
  {
   Ember::LocalServerAdminCreator* tolua_ret = (Ember::LocalServerAdminCreator*)  Mtolua_new((Ember::LocalServerAdminCreator)(*serverService));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::LocalServerAdminCreator");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Ember::LocalServerAdminCreator */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_LocalServerAdminCreator_new00_local
static int tolua_EmberServices_Ember_LocalServerAdminCreator_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::LocalServerAdminCreator",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Ember::ServerService",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ServerService* serverService = ((Ember::ServerService*)  tolua_tousertype(tolua_S,2,0));
  {
   Ember::LocalServerAdminCreator* tolua_ret = (Ember::LocalServerAdminCreator*)  Mtolua_new((Ember::LocalServerAdminCreator)(*serverService));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::LocalServerAdminCreator");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  Ember::LocalServerAdminCreator */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_LocalServerAdminCreator_delete00
static int tolua_EmberServices_Ember_LocalServerAdminCreator_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::LocalServerAdminCreator",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::LocalServerAdminCreator* self = (Ember::LocalServerAdminCreator*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getAvatarName of class  Ember::AvatarTransferInfo */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_AvatarTransferInfo_getAvatarName00
static int tolua_EmberServices_Ember_AvatarTransferInfo_getAvatarName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::AvatarTransferInfo",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::AvatarTransferInfo* self = (const Ember::AvatarTransferInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getAvatarName'", NULL);
#endif
  {
   const std::string tolua_ret = (const std::string)  self->getAvatarName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getAvatarName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTimestamp of class  Ember::AvatarTransferInfo */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_AvatarTransferInfo_getTimestamp00
static int tolua_EmberServices_Ember_AvatarTransferInfo_getTimestamp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::AvatarTransferInfo",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::AvatarTransferInfo* self = (const Ember::AvatarTransferInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTimestamp'", NULL);
#endif
  {
   const WFMath::TimeStamp& tolua_ret = (const WFMath::TimeStamp&)  self->getTimestamp();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const WFMath::TimeStamp");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTimestamp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getTransferInfo of class  Ember::AvatarTransferInfo */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_AvatarTransferInfo_getTransferInfo00
static int tolua_EmberServices_Ember_AvatarTransferInfo_getTransferInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Ember::AvatarTransferInfo",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Ember::AvatarTransferInfo* self = (const Ember::AvatarTransferInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getTransferInfo'", NULL);
#endif
  {
   const Eris::TransferInfo& tolua_ret = (const Eris::TransferInfo&)  self->getTransferInfo();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Eris::TransferInfo");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getTransferInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getSingleton of class  Ember::EmberServices */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getSingleton00
static int tolua_EmberServices_Ember_EmberServices_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::EmberServices& tolua_ret = (Ember::EmberServices&)  Ember::EmberServices::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::EmberServices");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getSingleton'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getLoggingService of class  Ember::EmberServices */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getLoggingService00
static int tolua_EmberServices_Ember_EmberServices_getLoggingService00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLoggingService'", NULL);
#endif
  {
   Ember::LoggingService& tolua_ret = (Ember::LoggingService&)  self->getLoggingService();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::LoggingService");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLoggingService'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getConfigService of class  Ember::EmberServices */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getConfigService00
static int tolua_EmberServices_Ember_EmberServices_getConfigService00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getConfigService'", NULL);
#endif
  {
   Ember::ConfigService& tolua_ret = (Ember::ConfigService&)  self->getConfigService();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::ConfigService");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getConfigService'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getMetaserverService of class  Ember::EmberServices */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getMetaserverService00
static int tolua_EmberServices_Ember_EmberServices_getMetaserverService00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getMetaserverService'", NULL);
#endif
  {
   Ember::MetaserverService& tolua_ret = (Ember::MetaserverService&)  self->getMetaserverService();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::MetaserverService");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getMetaserverService'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getServerService of class  Ember::EmberServices */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getServerService00
static int tolua_EmberServices_Ember_EmberServices_getServerService00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getServerService'", NULL);
#endif
  {
   Ember::ServerService& tolua_ret = (Ember::ServerService&)  self->getServerService();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::ServerService");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getServerService'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getScriptingService of class  Ember::EmberServices */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getScriptingService00
static int tolua_EmberServices_Ember_EmberServices_getScriptingService00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getScriptingService'", NULL);
#endif
  {
   Ember::ScriptingService& tolua_ret = (Ember::ScriptingService&)  self->getScriptingService();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::ScriptingService");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getScriptingService'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: getServerSettingsService of class  Ember::EmberServices */
#ifndef TOLUA_DISABLE_tolua_EmberServices_Ember_EmberServices_getServerSettingsService00
static int tolua_EmberServices_Ember_EmberServices_getServerSettingsService00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EmberServices",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EmberServices* self = (Ember::EmberServices*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getServerSettingsService'", NULL);
#endif
  {
   Ember::Services::ServerSettings& tolua_ret = (Ember::Services::ServerSettings&)  self->getServerSettingsService();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::Services::ServerSettings");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getServerSettingsService'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_EmberServices_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"MouseMotion","Ember::MouseMotion","",NULL);
   tolua_beginmodule(tolua_S,"MouseMotion");
    tolua_variable(tolua_S,"xPosition",tolua_get_Ember__MouseMotion_xPosition,tolua_set_Ember__MouseMotion_xPosition);
    tolua_variable(tolua_S,"yPosition",tolua_get_Ember__MouseMotion_yPosition,tolua_set_Ember__MouseMotion_yPosition);
    tolua_variable(tolua_S,"xRelativeMovement",tolua_get_Ember__MouseMotion_xRelativeMovement,tolua_set_Ember__MouseMotion_xRelativeMovement);
    tolua_variable(tolua_S,"yRelativeMovement",tolua_get_Ember__MouseMotion_yRelativeMovement,tolua_set_Ember__MouseMotion_yRelativeMovement);
    tolua_variable(tolua_S,"xRelativeMovementInPixels",tolua_get_Ember__MouseMotion_xRelativeMovementInPixels,tolua_set_Ember__MouseMotion_xRelativeMovementInPixels);
    tolua_variable(tolua_S,"yRelativeMovementInPixels",tolua_get_Ember__MouseMotion_yRelativeMovementInPixels,tolua_set_Ember__MouseMotion_yRelativeMovementInPixels);
    tolua_variable(tolua_S,"timeSinceLastMovement",tolua_get_Ember__MouseMotion_timeSinceLastMovement,tolua_set_Ember__MouseMotion_timeSinceLastMovement);
   tolua_endmodule(tolua_S);
   tolua_cclass(tolua_S,"Input","Ember::Input","",NULL);
   tolua_beginmodule(tolua_S,"Input");
    tolua_function(tolua_S,"getSingleton",tolua_EmberServices_Ember_Input_getSingleton00);
    tolua_constant(tolua_S,"MouseButtonLeft",Ember::Input::MouseButtonLeft);
    tolua_constant(tolua_S,"MouseButtonRight",Ember::Input::MouseButtonRight);
    tolua_constant(tolua_S,"MouseButtonMiddle",Ember::Input::MouseButtonMiddle);
    tolua_constant(tolua_S,"IM_GUI",Ember::Input::IM_GUI);
    tolua_constant(tolua_S,"IM_MOVEMENT",Ember::Input::IM_MOVEMENT);
    tolua_variable(tolua_S,"EventKeyPressed",tolua_get_Ember__Input_EventKeyPressed,NULL);
    tolua_variable(tolua_S,"EventKeyReleased",tolua_get_Ember__Input_EventKeyReleased,NULL);
    tolua_variable(tolua_S,"EventMouseMoved",tolua_get_Ember__Input_EventMouseMoved,NULL);
    tolua_variable(tolua_S,"EventMouseButtonPressed",tolua_get_Ember__Input_EventMouseButtonPressed,tolua_set_Ember__Input_EventMouseButtonPressed);
    tolua_variable(tolua_S,"EventMouseButtonReleased",tolua_get_Ember__Input_EventMouseButtonReleased,tolua_set_Ember__Input_EventMouseButtonReleased);
    tolua_variable(tolua_S,"EventChangedInputMode",tolua_get_Ember__Input_EventChangedInputMode,tolua_set_Ember__Input_EventChangedInputMode);
    tolua_function(tolua_S,"isKeyDown",tolua_EmberServices_Ember_Input_isKeyDown00);
    tolua_function(tolua_S,"setInputMode",tolua_EmberServices_Ember_Input_setInputMode00);
    tolua_function(tolua_S,"getInputMode",tolua_EmberServices_Ember_Input_getInputMode00);
    tolua_function(tolua_S,"toggleInputMode",tolua_EmberServices_Ember_Input_toggleInputMode00);
    tolua_function(tolua_S,"addAdapter",tolua_EmberServices_Ember_Input_addAdapter00);
    tolua_function(tolua_S,"removeAdapter",tolua_EmberServices_Ember_Input_removeAdapter00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"LoggingService","Ember::LoggingService","",NULL);
   tolua_beginmodule(tolua_S,"LoggingService");
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"ConfigService","Ember::ConfigService","",NULL);
   tolua_beginmodule(tolua_S,"ConfigService");
    tolua_variable(tolua_S,"SETVALUE",tolua_get_Ember__ConfigService_SETVALUE,NULL);
    tolua_variable(tolua_S,"GETVALUE",tolua_get_Ember__ConfigService_GETVALUE,NULL);
    tolua_function(tolua_S,"getValue",tolua_EmberServices_Ember_ConfigService_getValue00);
    tolua_function(tolua_S,"setValue",tolua_EmberServices_Ember_ConfigService_setValue00);
    tolua_function(tolua_S,"isItemSet",tolua_EmberServices_Ember_ConfigService_isItemSet00);
    tolua_function(tolua_S,"itemExists",tolua_EmberServices_Ember_ConfigService_itemExists00);
    tolua_function(tolua_S,"deleteItem",tolua_EmberServices_Ember_ConfigService_deleteItem00);
    tolua_function(tolua_S,"loadSavedConfig",tolua_EmberServices_Ember_ConfigService_loadSavedConfig00);
    tolua_function(tolua_S,"saveConfig",tolua_EmberServices_Ember_ConfigService_saveConfig00);
    tolua_function(tolua_S,"saveConfig",tolua_EmberServices_Ember_ConfigService_saveConfig01);
    tolua_function(tolua_S,"getHomeDirectory",tolua_EmberServices_Ember_ConfigService_getHomeDirectory00);
    tolua_function(tolua_S,"getSharedDataDirectory",tolua_EmberServices_Ember_ConfigService_getSharedDataDirectory00);
    tolua_function(tolua_S,"getEmberDataDirectory",tolua_EmberServices_Ember_ConfigService_getEmberDataDirectory00);
    tolua_function(tolua_S,"getEmberMediaDirectory",tolua_EmberServices_Ember_ConfigService_getEmberMediaDirectory00);
    tolua_function(tolua_S,"getUserMediaDirectory",tolua_EmberServices_Ember_ConfigService_getUserMediaDirectory00);
    tolua_function(tolua_S,"getSharedMediaDirectory",tolua_EmberServices_Ember_ConfigService_getSharedMediaDirectory00);
    tolua_function(tolua_S,"getSharedConfigDirectory",tolua_EmberServices_Ember_ConfigService_getSharedConfigDirectory00);
    tolua_variable(tolua_S,"EventChangedConfigItem",tolua_get_Ember__ConfigService_EventChangedConfigItem,NULL);
    tolua_function(tolua_S,"getPrefix",tolua_EmberServices_Ember_ConfigService_getPrefix00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"MetaserverService","Ember::MetaserverService","",NULL);
   tolua_beginmodule(tolua_S,"MetaserverService");
    tolua_function(tolua_S,"getMetaServer",tolua_EmberServices_Ember_MetaserverService_getMetaServer00);
    tolua_function(tolua_S,"compareVersions",tolua_EmberServices_Ember_MetaserverService_compareVersions00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"ServerService","Ember::ServerService","",NULL);
   tolua_beginmodule(tolua_S,"ServerService");
    tolua_function(tolua_S,"getAccount",tolua_EmberServices_Ember_ServerService_getAccount00);
    tolua_function(tolua_S,"connect",tolua_EmberServices_Ember_ServerService_connect00);
    tolua_function(tolua_S,"connectLocal",tolua_EmberServices_Ember_ServerService_connectLocal00);
    tolua_function(tolua_S,"hasLocalSocket",tolua_EmberServices_Ember_ServerService_hasLocalSocket00);
    tolua_function(tolua_S,"disconnect",tolua_EmberServices_Ember_ServerService_disconnect00);
    tolua_function(tolua_S,"takeTransferredCharacter",tolua_EmberServices_Ember_ServerService_takeTransferredCharacter00);
    tolua_function(tolua_S,"takeCharacter",tolua_EmberServices_Ember_ServerService_takeCharacter00);
    tolua_function(tolua_S,"createCharacter",tolua_EmberServices_Ember_ServerService_createCharacter00);
    tolua_function(tolua_S,"moveToPoint",tolua_EmberServices_Ember_ServerService_moveToPoint00);
    tolua_function(tolua_S,"moveInDirection",tolua_EmberServices_Ember_ServerService_moveInDirection00);
    tolua_function(tolua_S,"moveInDirection",tolua_EmberServices_Ember_ServerService_moveInDirection01);
    tolua_function(tolua_S,"say",tolua_EmberServices_Ember_ServerService_say00);
    tolua_function(tolua_S,"sayTo",tolua_EmberServices_Ember_ServerService_sayTo00);
    tolua_function(tolua_S,"sayTo",tolua_EmberServices_Ember_ServerService_sayTo01);
    tolua_function(tolua_S,"touch",tolua_EmberServices_Ember_ServerService_touch00);
    tolua_function(tolua_S,"emote",tolua_EmberServices_Ember_ServerService_emote00);
    tolua_function(tolua_S,"drop",tolua_EmberServices_Ember_ServerService_drop00);
    tolua_function(tolua_S,"drop",tolua_EmberServices_Ember_ServerService_drop01);
    tolua_function(tolua_S,"drop",tolua_EmberServices_Ember_ServerService_drop02);
    tolua_function(tolua_S,"place",tolua_EmberServices_Ember_ServerService_place00);
    tolua_function(tolua_S,"wield",tolua_EmberServices_Ember_ServerService_wield00);
    tolua_function(tolua_S,"wield",tolua_EmberServices_Ember_ServerService_wield01);
    tolua_function(tolua_S,"take",tolua_EmberServices_Ember_ServerService_take00);
    tolua_function(tolua_S,"use",tolua_EmberServices_Ember_ServerService_use00);
    tolua_function(tolua_S,"use",tolua_EmberServices_Ember_ServerService_use01);
    tolua_function(tolua_S,"use",tolua_EmberServices_Ember_ServerService_use02);
    tolua_function(tolua_S,"useStop",tolua_EmberServices_Ember_ServerService_useStop00);
    tolua_function(tolua_S,"actuate",tolua_EmberServices_Ember_ServerService_actuate00);
    tolua_function(tolua_S,"attack",tolua_EmberServices_Ember_ServerService_attack00);
    tolua_function(tolua_S,"eat",tolua_EmberServices_Ember_ServerService_eat00);
    tolua_function(tolua_S,"deleteEntity",tolua_EmberServices_Ember_ServerService_deleteEntity00);
    tolua_function(tolua_S,"setAttributes",tolua_EmberServices_Ember_ServerService_setAttributes00);
    tolua_function(tolua_S,"createTypeInfo",tolua_EmberServices_Ember_ServerService_createTypeInfo00);
    tolua_function(tolua_S,"setTypeInfo",tolua_EmberServices_Ember_ServerService_setTypeInfo00);
    tolua_variable(tolua_S,"GotAvatar",tolua_get_Ember__ServerService_GotAvatar,tolua_set_Ember__ServerService_GotAvatar);
    tolua_variable(tolua_S,"GotView",tolua_get_Ember__ServerService_GotView,tolua_set_Ember__ServerService_GotView);
    tolua_variable(tolua_S,"GotConnection",tolua_get_Ember__ServerService_GotConnection,tolua_set_Ember__ServerService_GotConnection);
    tolua_variable(tolua_S,"GotAccount",tolua_get_Ember__ServerService_GotAccount,tolua_set_Ember__ServerService_GotAccount);
    tolua_variable(tolua_S,"LoginSuccess",tolua_get_Ember__ServerService_LoginSuccess,tolua_set_Ember__ServerService_LoginSuccess);
    tolua_variable(tolua_S,"LoginFailure",tolua_get_Ember__ServerService_LoginFailure,NULL);
    tolua_variable(tolua_S,"GotCharacterInfo",tolua_get_Ember__ServerService_GotCharacterInfo,NULL);
    tolua_variable(tolua_S,"GotAllCharacters",tolua_get_Ember__ServerService_GotAllCharacters,tolua_set_Ember__ServerService_GotAllCharacters);
    tolua_variable(tolua_S,"DestroyedAccount",tolua_get_Ember__ServerService_DestroyedAccount,tolua_set_Ember__ServerService_DestroyedAccount);
    tolua_variable(tolua_S,"DestroyedAvatar",tolua_get_Ember__ServerService_DestroyedAvatar,tolua_set_Ember__ServerService_DestroyedAvatar);
    tolua_variable(tolua_S,"DestroyedView",tolua_get_Ember__ServerService_DestroyedView,tolua_set_Ember__ServerService_DestroyedView);
    tolua_variable(tolua_S,"EventSendingObject",tolua_get_Ember__ServerService_EventSendingObject,NULL);
    tolua_variable(tolua_S,"EventReceivedObject",tolua_get_Ember__ServerService_EventReceivedObject,NULL);
    tolua_variable(tolua_S,"EventStatusChanged",tolua_get_Ember__ServerService_EventStatusChanged,tolua_set_Ember__ServerService_EventStatusChanged);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"ScriptingService","Ember::ScriptingService","",NULL);
   tolua_beginmodule(tolua_S,"ScriptingService");
    tolua_function(tolua_S,"registerScriptingProvider",tolua_EmberServices_Ember_ScriptingService_registerScriptingProvider00);
    tolua_function(tolua_S,"loadScript",tolua_EmberServices_Ember_ScriptingService_loadScript00);
    tolua_function(tolua_S,"executeCode",tolua_EmberServices_Ember_ScriptingService_executeCode00);
    tolua_function(tolua_S,"getEventScriptError",tolua_EmberServices_Ember_ScriptingService_getEventScriptError00);
    tolua_function(tolua_S,"getProviderFor",tolua_EmberServices_Ember_ScriptingService_getProviderFor00);
    tolua_function(tolua_S,"getProviderNames",tolua_EmberServices_Ember_ScriptingService_getProviderNames00);
    tolua_function(tolua_S,"getAlwaysLookup",tolua_EmberServices_Ember_ScriptingService_getAlwaysLookup00);
    tolua_function(tolua_S,"setAlwaysLookup",tolua_EmberServices_Ember_ScriptingService_setAlwaysLookup00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"InputService","Ember::InputService","",NULL);
   tolua_beginmodule(tolua_S,"InputService");
    tolua_function(tolua_S,"getInput",tolua_EmberServices_Ember_InputService_getInput00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"IInputAdapter","Ember::IInputAdapter","",tolua_collect_Ember__IInputAdapter);
   #else
   tolua_cclass(tolua_S,"IInputAdapter","Ember::IInputAdapter","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"IInputAdapter");
    tolua_function(tolua_S,"delete",tolua_EmberServices_Ember_IInputAdapter_delete00);
    tolua_function(tolua_S,"injectMouseMove",tolua_EmberServices_Ember_IInputAdapter_injectMouseMove00);
    tolua_function(tolua_S,"injectMouseButtonUp",tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonUp00);
    tolua_function(tolua_S,"injectMouseButtonDown",tolua_EmberServices_Ember_IInputAdapter_injectMouseButtonDown00);
    tolua_function(tolua_S,"injectChar",tolua_EmberServices_Ember_IInputAdapter_injectChar00);
    tolua_function(tolua_S,"injectKeyDown",tolua_EmberServices_Ember_IInputAdapter_injectKeyDown00);
    tolua_function(tolua_S,"injectKeyUp",tolua_EmberServices_Ember_IInputAdapter_injectKeyUp00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_module(tolua_S,"Services",0);
   tolua_beginmodule(tolua_S,"Services");
    tolua_cclass(tolua_S,"ServerSettings","Ember::Services::ServerSettings","Service",NULL);
    tolua_beginmodule(tolua_S,"ServerSettings");
     tolua_function(tolua_S,"findItem",tolua_EmberServices_Ember_Services_ServerSettings_findItem00);
     tolua_function(tolua_S,"getItem",tolua_EmberServices_Ember_Services_ServerSettings_getItem00);
     tolua_function(tolua_S,"setItem",tolua_EmberServices_Ember_Services_ServerSettings_setItem00);
     tolua_function(tolua_S,"eraseItem",tolua_EmberServices_Ember_Services_ServerSettings_eraseItem00);
     tolua_function(tolua_S,"getServerSettings",tolua_EmberServices_Ember_Services_ServerSettings_getServerSettings00);
     tolua_function(tolua_S,"writeToDisk",tolua_EmberServices_Ember_Services_ServerSettings_writeToDisk00);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_module(tolua_S,"Services",0);
   tolua_beginmodule(tolua_S,"Services");
    #ifdef __cplusplus
    tolua_cclass(tolua_S,"ServerSettingsCredentials","Ember::Services::ServerSettingsCredentials","",tolua_collect_Ember__Services__ServerSettingsCredentials);
    #else
    tolua_cclass(tolua_S,"ServerSettingsCredentials","Ember::Services::ServerSettingsCredentials","",NULL);
    #endif
    tolua_beginmodule(tolua_S,"ServerSettingsCredentials");
     tolua_function(tolua_S,"new",tolua_EmberServices_Ember_Services_ServerSettingsCredentials_new00);
     tolua_function(tolua_S,"new_local",tolua_EmberServices_Ember_Services_ServerSettingsCredentials_new00_local);
     tolua_function(tolua_S,".call",tolua_EmberServices_Ember_Services_ServerSettingsCredentials_new00_local);
    tolua_endmodule(tolua_S);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"LocalServerAdminCreator","Ember::LocalServerAdminCreator","",tolua_collect_Ember__LocalServerAdminCreator);
   #else
   tolua_cclass(tolua_S,"LocalServerAdminCreator","Ember::LocalServerAdminCreator","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"LocalServerAdminCreator");
    tolua_function(tolua_S,"new",tolua_EmberServices_Ember_LocalServerAdminCreator_new00);
    tolua_function(tolua_S,"new_local",tolua_EmberServices_Ember_LocalServerAdminCreator_new00_local);
    tolua_function(tolua_S,".call",tolua_EmberServices_Ember_LocalServerAdminCreator_new00_local);
    tolua_function(tolua_S,"delete",tolua_EmberServices_Ember_LocalServerAdminCreator_delete00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"AvatarTransferInfo","Ember::AvatarTransferInfo","",NULL);
   tolua_beginmodule(tolua_S,"AvatarTransferInfo");
    tolua_function(tolua_S,"getAvatarName",tolua_EmberServices_Ember_AvatarTransferInfo_getAvatarName00);
    tolua_function(tolua_S,"getTimestamp",tolua_EmberServices_Ember_AvatarTransferInfo_getTimestamp00);
    tolua_function(tolua_S,"getTransferInfo",tolua_EmberServices_Ember_AvatarTransferInfo_getTransferInfo00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"EmberServices","Ember::EmberServices","",NULL);
   tolua_beginmodule(tolua_S,"EmberServices");
    tolua_function(tolua_S,"getSingleton",tolua_EmberServices_Ember_EmberServices_getSingleton00);
    tolua_function(tolua_S,"getLoggingService",tolua_EmberServices_Ember_EmberServices_getLoggingService00);
    tolua_function(tolua_S,"getConfigService",tolua_EmberServices_Ember_EmberServices_getConfigService00);
    tolua_function(tolua_S,"getMetaserverService",tolua_EmberServices_Ember_EmberServices_getMetaserverService00);
    tolua_function(tolua_S,"getServerService",tolua_EmberServices_Ember_EmberServices_getServerService00);
    tolua_function(tolua_S,"getScriptingService",tolua_EmberServices_Ember_EmberServices_getScriptingService00);
    tolua_function(tolua_S,"getServerSettingsService",tolua_EmberServices_Ember_EmberServices_getServerSettingsService00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_EmberServices (lua_State* tolua_S) {
 return tolua_EmberServices_open(tolua_S);
};
#endif

