/*
** Lua binding: Framework
** Generated automatically by tolua++-1.0.92 on Fri Feb 21 16:23:06 2014.
*/

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

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

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

#include "required.h"
#include "../../IScriptingProvider.h"
#include <ostream>
#include <istream>
#include <sstream>
#include "framework/AttributeObserver.h"
#include "../../MainLoopController.h"
#include "framework/EntityExporter.h"
#include "framework/EntityImporter.h"
#include "framework/AtlasObjectDecoder.h"

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

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

static int tolua_collect_Atlas__Objects__Root (lua_State* tolua_S)
{
 Atlas::Objects::Root* self = (Atlas::Objects::Root*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

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

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

static int tolua_collect_std__vector_Ember__EntityImporter__ShortInfo_ (lua_State* tolua_S)
{
 std::vector<Ember::EntityImporter::ShortInfo>* self = (std::vector<Ember::EntityImporter::ShortInfo>*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

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

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

static int tolua_collect_std__stringstream (lua_State* tolua_S)
{
 std::stringstream* self = (std::stringstream*) 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,"sigc::signal<void,const Atlas::Objects::Root&>");
 tolua_usertype(tolua_S,"std::iostream");
 tolua_usertype(tolua_S,"Atlas::Objects::Root");
 tolua_usertype(tolua_S,"std::stringstream");
 tolua_usertype(tolua_S,"Atlas::Objects::ObjectsDecoder");
 tolua_usertype(tolua_S,"Ember::EntityImporter::Stats");
 tolua_usertype(tolua_S,"Ember::MainLoopController");
 tolua_usertype(tolua_S,"Ember::AttributeObserver");
 tolua_usertype(tolua_S,"Eris::Account");
 tolua_usertype(tolua_S,"std::istream");
 tolua_usertype(tolua_S,"Ember::EntityExporter");
 tolua_usertype(tolua_S,"sigc::signal<void,bool&>");
 tolua_usertype(tolua_S,"std::vector<Ember::EntityImporter::ShortInfo>");
 tolua_usertype(tolua_S,"Ember::EntityImporter::ShortInfo");
 tolua_usertype(tolua_S,"Ember::EntityImporter");
 tolua_usertype(tolua_S,"Eris::Entity");
 tolua_usertype(tolua_S,"std::ostream");
 tolua_usertype(tolua_S,"Ember::EntityExporter::Stats");
 tolua_usertype(tolua_S,"std::vector<std::string>");
 tolua_usertype(tolua_S,"Ember::AtlasObjectDecoder");
 tolua_usertype(tolua_S,"Ember::ConsoleBackend");
 tolua_usertype(tolua_S,"sigc::signal<void,float>");
 tolua_usertype(tolua_S,"sigc::signal<bool,const std::string&,const std::string&>");
 tolua_usertype(tolua_S,"sigc::signal<void,const Atlas::Message::Element&>");
 tolua_usertype(tolua_S,"sigc::signal<void>");
 tolua_usertype(tolua_S,"Ember::Log");
 tolua_usertype(tolua_S,"Ember::IScriptingProvider");
 tolua_usertype(tolua_S,"Ember::Tokeniser");
}

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

/* method: getSingleton of class  Ember::ConsoleBackend */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_ConsoleBackend_getSingleton00
static int tolua_Framework_Ember_ConsoleBackend_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::ConsoleBackend",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::ConsoleBackend& tolua_ret = (Ember::ConsoleBackend&)  Ember::ConsoleBackend::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::ConsoleBackend");
  }
 }
 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: runCommand of class  Ember::ConsoleBackend */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_ConsoleBackend_runCommand00
static int tolua_Framework_Ember_ConsoleBackend_runCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConsoleBackend",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ConsoleBackend* self = (Ember::ConsoleBackend*)  tolua_tousertype(tolua_S,1,0);
  const std::string command = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  bool addToHistory = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'runCommand'", NULL);
#endif
  {
   self->runCommand(command,addToHistory);
   tolua_pushcppstring(tolua_S,(const char*)command);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'runCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pushMessage of class  Ember::ConsoleBackend */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_ConsoleBackend_pushMessage00
static int tolua_Framework_Ember_ConsoleBackend_pushMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConsoleBackend",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::ConsoleBackend* self = (Ember::ConsoleBackend*)  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 'pushMessage'", NULL);
#endif
  {
   self->pushMessage(message);
   tolua_pushcppstring(tolua_S,(const char*)message);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pushMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pushMessage of class  Ember::ConsoleBackend */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_ConsoleBackend_pushMessage01
static int tolua_Framework_Ember_ConsoleBackend_pushMessage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConsoleBackend",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
 {
  Ember::ConsoleBackend* self = (Ember::ConsoleBackend*)  tolua_tousertype(tolua_S,1,0);
  const std::string message = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string tag = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pushMessage'", NULL);
#endif
  {
   self->pushMessage(message,tag);
   tolua_pushcppstring(tolua_S,(const char*)message);
   tolua_pushcppstring(tolua_S,(const char*)tag);
  }
 }
 return 2;
tolua_lerror:
 return tolua_Framework_Ember_ConsoleBackend_pushMessage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: runCommand of class  Ember::ConsoleBackend */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_ConsoleBackend_runCommand01
static int tolua_Framework_Ember_ConsoleBackend_runCommand01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::ConsoleBackend",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
 {
  Ember::ConsoleBackend* self = (Ember::ConsoleBackend*)  tolua_tousertype(tolua_S,1,0);
  const std::string command = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string args = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'runCommand'", NULL);
#endif
  {
   self->runCommand(command,args);
   tolua_pushcppstring(tolua_S,(const char*)command);
   tolua_pushcppstring(tolua_S,(const char*)args);
  }
 }
 return 2;
tolua_lerror:
 return tolua_Framework_Ember_ConsoleBackend_runCommand00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: new of class  Ember::Tokeniser */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_Tokeniser_new00
static int tolua_Framework_Ember_Tokeniser_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::Tokeniser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::Tokeniser* tolua_ret = (Ember::Tokeniser*)  Mtolua_new((Ember::Tokeniser)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::Tokeniser");
  }
 }
 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::Tokeniser */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_Tokeniser_new00_local
static int tolua_Framework_Ember_Tokeniser_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::Tokeniser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::Tokeniser* tolua_ret = (Ember::Tokeniser*)  Mtolua_new((Ember::Tokeniser)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::Tokeniser");
    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::Tokeniser */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_Tokeniser_delete00
static int tolua_Framework_Ember_Tokeniser_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Tokeniser",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Tokeniser* self = (Ember::Tokeniser*)  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: initTokens of class  Ember::Tokeniser */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_Tokeniser_initTokens00
static int tolua_Framework_Ember_Tokeniser_initTokens00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::Tokeniser",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::Tokeniser* self = (Ember::Tokeniser*)  tolua_tousertype(tolua_S,1,0);
  const std::string tokens = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'initTokens'", NULL);
#endif
  {
   self->initTokens(tokens);
   tolua_pushcppstring(tolua_S,(const char*)tokens);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initTokens'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: log of class  Ember::Log */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_Log_log00
static int tolua_Framework_Ember_Log_log00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::Log",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* message = ((const char*)  tolua_tostring(tolua_S,2,0));
  {
   Ember::Log::log(message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'log'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: log of class  Ember::Log */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_Log_log01
static int tolua_Framework_Ember_Log_log01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::Log",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Ember::Log::MessageImportance importance = ((const Ember::Log::MessageImportance) (int)  tolua_tonumber(tolua_S,2,0));
  const char* message = ((const char*)  tolua_tostring(tolua_S,3,0));
  {
   Ember::Log::log(importance,message);
  }
 }
 return 0;
tolua_lerror:
 return tolua_Framework_Ember_Log_log00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* function: S_LOG_VERBOSE */
#ifndef TOLUA_DISABLE_tolua_Framework_S_LOG_VERBOSE00
static int tolua_Framework_S_LOG_VERBOSE00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* message = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   S_LOG_VERBOSE(message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'S_LOG_VERBOSE'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: S_LOG_INFO */
#ifndef TOLUA_DISABLE_tolua_Framework_S_LOG_INFO00
static int tolua_Framework_S_LOG_INFO00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* message = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   S_LOG_INFO(message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'S_LOG_INFO'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: S_LOG_WARNING */
#ifndef TOLUA_DISABLE_tolua_Framework_S_LOG_WARNING00
static int tolua_Framework_S_LOG_WARNING00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* message = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   S_LOG_WARNING(message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'S_LOG_WARNING'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: S_LOG_FAILURE */
#ifndef TOLUA_DISABLE_tolua_Framework_S_LOG_FAILURE00
static int tolua_Framework_S_LOG_FAILURE00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* message = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   S_LOG_FAILURE(message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'S_LOG_FAILURE'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: S_LOG_CRITICAL */
#ifndef TOLUA_DISABLE_tolua_Framework_S_LOG_CRITICAL00
static int tolua_Framework_S_LOG_CRITICAL00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const char* message = ((const char*)  tolua_tostring(tolua_S,1,0));
  {
   S_LOG_CRITICAL(message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'S_LOG_CRITICAL'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: new of class  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_Framework_std_stringstream_new00
static int tolua_Framework_std_stringstream_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::stringstream",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::stringstream* tolua_ret = (std::stringstream*)  Mtolua_new((std::stringstream)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::stringstream");
  }
 }
 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  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_Framework_std_stringstream_new00_local
static int tolua_Framework_std_stringstream_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::stringstream",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   std::stringstream* tolua_ret = (std::stringstream*)  Mtolua_new((std::stringstream)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::stringstream");
    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: new of class  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_Framework_std_stringstream_new01
static int tolua_Framework_std_stringstream_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::stringstream",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string str = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   std::stringstream* tolua_ret = (std::stringstream*)  Mtolua_new((std::stringstream)(str));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::stringstream");
   tolua_pushcppstring(tolua_S,(const char*)str);
  }
 }
 return 2;
tolua_lerror:
 return tolua_Framework_std_stringstream_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_Framework_std_stringstream_new01_local
static int tolua_Framework_std_stringstream_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"std::stringstream",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const std::string str = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   std::stringstream* tolua_ret = (std::stringstream*)  Mtolua_new((std::stringstream)(str));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"std::stringstream");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)str);
  }
 }
 return 2;
tolua_lerror:
 return tolua_Framework_std_stringstream_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_Framework_std_stringstream_delete00
static int tolua_Framework_std_stringstream_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"std::stringstream",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  std::stringstream* self = (std::stringstream*)  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: str of class  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_Framework_std_stringstream_str00
static int tolua_Framework_std_stringstream_str00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const std::stringstream",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::stringstream* self = (const std::stringstream*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'str'", NULL);
#endif
  {
   std::string tolua_ret = (std::string)  self->str();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'str'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: __std of class  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_get_std__stringstream___std__istream__
static int tolua_get_std__stringstream___std__istream__(lua_State* tolua_S)
{
  std::stringstream* self = (std::stringstream*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable '__std'",NULL);
#endif
#ifdef __cplusplus
   tolua_pushusertype(tolua_S,(void*)static_cast<std::istream*>(self), "std::istream");
#else
   tolua_pushusertype(tolua_S,(void*)((std::istream*)self), "std::istream");
#endif
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: __std of class  std::stringstream */
#ifndef TOLUA_DISABLE_tolua_get_std__stringstream___std__ostream__
static int tolua_get_std__stringstream___std__ostream__(lua_State* tolua_S)
{
  std::stringstream* self = (std::stringstream*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable '__std'",NULL);
#endif
#ifdef __cplusplus
   tolua_pushusertype(tolua_S,(void*)static_cast<std::ostream*>(self), "std::ostream");
#else
   tolua_pushusertype(tolua_S,(void*)((std::ostream*)self), "std::ostream");
#endif
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Ember::AttributeObserver */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AttributeObserver_new00
static int tolua_Framework_Ember_AttributeObserver_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AttributeObserver",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&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
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::string attributeName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   Ember::AttributeObserver* tolua_ret = (Ember::AttributeObserver*)  Mtolua_new((Ember::AttributeObserver)(*entity,attributeName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AttributeObserver");
   tolua_pushcppstring(tolua_S,(const char*)attributeName);
  }
 }
 return 2;
#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::AttributeObserver */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AttributeObserver_new00_local
static int tolua_Framework_Ember_AttributeObserver_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AttributeObserver",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&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
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::string attributeName = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  {
   Ember::AttributeObserver* tolua_ret = (Ember::AttributeObserver*)  Mtolua_new((Ember::AttributeObserver)(*entity,attributeName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AttributeObserver");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)attributeName);
  }
 }
 return 2;
#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::AttributeObserver */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AttributeObserver_new01
static int tolua_Framework_Ember_AttributeObserver_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AttributeObserver",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&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 std::vector<std::string>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::vector<std::string>* attributePath = ((const std::vector<std::string>*)  tolua_tousertype(tolua_S,3,0));
  {
   Ember::AttributeObserver* tolua_ret = (Ember::AttributeObserver*)  Mtolua_new((Ember::AttributeObserver)(*entity,*attributePath));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AttributeObserver");
  }
 }
 return 1;
tolua_lerror:
 return tolua_Framework_Ember_AttributeObserver_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Ember::AttributeObserver */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AttributeObserver_new01_local
static int tolua_Framework_Ember_AttributeObserver_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AttributeObserver",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&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 std::vector<std::string>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::vector<std::string>* attributePath = ((const std::vector<std::string>*)  tolua_tousertype(tolua_S,3,0));
  {
   Ember::AttributeObserver* tolua_ret = (Ember::AttributeObserver*)  Mtolua_new((Ember::AttributeObserver)(*entity,*attributePath));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AttributeObserver");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_Framework_Ember_AttributeObserver_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Ember::AttributeObserver */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AttributeObserver_new02
static int tolua_Framework_Ember_AttributeObserver_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AttributeObserver",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::Entity",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
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::string attributePath = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string delimitor = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  {
   Ember::AttributeObserver* tolua_ret = (Ember::AttributeObserver*)  Mtolua_new((Ember::AttributeObserver)(*entity,attributePath,delimitor));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AttributeObserver");
   tolua_pushcppstring(tolua_S,(const char*)attributePath);
   tolua_pushcppstring(tolua_S,(const char*)delimitor);
  }
 }
 return 3;
tolua_lerror:
 return tolua_Framework_Ember_AttributeObserver_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Ember::AttributeObserver */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AttributeObserver_new02_local
static int tolua_Framework_Ember_AttributeObserver_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AttributeObserver",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::Entity",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
 {
  Eris::Entity* entity = ((Eris::Entity*)  tolua_tousertype(tolua_S,2,0));
  const std::string attributePath = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
  const std::string delimitor = ((const std::string)  tolua_tocppstring(tolua_S,4,0));
  {
   Ember::AttributeObserver* tolua_ret = (Ember::AttributeObserver*)  Mtolua_new((Ember::AttributeObserver)(*entity,attributePath,delimitor));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AttributeObserver");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
   tolua_pushcppstring(tolua_S,(const char*)attributePath);
   tolua_pushcppstring(tolua_S,(const char*)delimitor);
  }
 }
 return 3;
tolua_lerror:
 return tolua_Framework_Ember_AttributeObserver_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  Ember::AttributeObserver */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AttributeObserver_delete00
static int tolua_Framework_Ember_AttributeObserver_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::AttributeObserver",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::AttributeObserver* self = (Ember::AttributeObserver*)  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

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

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

/* method: getSingleton of class  Ember::MainLoopController */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_MainLoopController_getSingleton00
static int tolua_Framework_Ember_MainLoopController_getSingleton00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::MainLoopController",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::MainLoopController& tolua_ret = (Ember::MainLoopController&)  Ember::MainLoopController::getSingleton();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"Ember::MainLoopController");
  }
 }
 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: shouldQuit of class  Ember::MainLoopController */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_MainLoopController_shouldQuit00
static int tolua_Framework_Ember_MainLoopController_shouldQuit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::MainLoopController",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::MainLoopController* self = (Ember::MainLoopController*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'shouldQuit'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->shouldQuit();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'shouldQuit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* method: new of class  Ember::EntityExporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityExporter_new00
static int tolua_Framework_Ember_EntityExporter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::EntityExporter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::Account",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::Account* account = ((Eris::Account*)  tolua_tousertype(tolua_S,2,0));
  {
   Ember::EntityExporter* tolua_ret = (Ember::EntityExporter*)  Mtolua_new((Ember::EntityExporter)(*account));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::EntityExporter");
  }
 }
 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::EntityExporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityExporter_new00_local
static int tolua_Framework_Ember_EntityExporter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::EntityExporter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::Account",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::Account* account = ((Eris::Account*)  tolua_tousertype(tolua_S,2,0));
  {
   Ember::EntityExporter* tolua_ret = (Ember::EntityExporter*)  Mtolua_new((Ember::EntityExporter)(*account));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::EntityExporter");
    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::EntityExporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityExporter_delete00
static int tolua_Framework_Ember_EntityExporter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EntityExporter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EntityExporter* self = (Ember::EntityExporter*)  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: start of class  Ember::EntityExporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityExporter_start00
static int tolua_Framework_Ember_EntityExporter_start00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EntityExporter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EntityExporter* self = (Ember::EntityExporter*)  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 'start'", NULL);
#endif
  {
   self->start(filename);
   tolua_pushcppstring(tolua_S,(const char*)filename);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'start'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: start of class  Ember::EntityExporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityExporter_start01
static int tolua_Framework_Ember_EntityExporter_start01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EntityExporter",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
 {
  Ember::EntityExporter* self = (Ember::EntityExporter*)  tolua_tousertype(tolua_S,1,0);
  const std::string filename = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  const std::string entityId = ((const std::string)  tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'start'", NULL);
#endif
  {
   self->start(filename,entityId);
   tolua_pushcppstring(tolua_S,(const char*)filename);
   tolua_pushcppstring(tolua_S,(const char*)entityId);
  }
 }
 return 2;
tolua_lerror:
 return tolua_Framework_Ember_EntityExporter_start00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

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

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

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

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

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

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

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

/* set function: EventCompleted of class  Ember::EntityExporter */
#ifndef TOLUA_DISABLE_tolua_set_Ember__EntityExporter_EventCompleted
static int tolua_set_Ember__EntityExporter_EventCompleted(lua_State* tolua_S)
{
  Ember::EntityExporter* self = (Ember::EntityExporter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCompleted'",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->EventCompleted = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

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

/* set function: EventProgress of class  Ember::EntityExporter */
#ifndef TOLUA_DISABLE_tolua_set_Ember__EntityExporter_EventProgress
static int tolua_set_Ember__EntityExporter_EventProgress(lua_State* tolua_S)
{
  Ember::EntityExporter* self = (Ember::EntityExporter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventProgress'",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->EventProgress = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: filename of class  ShortInfo */
#ifndef TOLUA_DISABLE_tolua_get_Ember__EntityImporter__ShortInfo_filename
static int tolua_get_Ember__EntityImporter__ShortInfo_filename(lua_State* tolua_S)
{
  Ember::EntityImporter::ShortInfo* self = (Ember::EntityImporter::ShortInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'filename'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->filename);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: filename of class  ShortInfo */
#ifndef TOLUA_DISABLE_tolua_set_Ember__EntityImporter__ShortInfo_filename
static int tolua_set_Ember__EntityImporter__ShortInfo_filename(lua_State* tolua_S)
{
  Ember::EntityImporter::ShortInfo* self = (Ember::EntityImporter::ShortInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'filename'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->filename = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: name of class  ShortInfo */
#ifndef TOLUA_DISABLE_tolua_get_Ember__EntityImporter__ShortInfo_name
static int tolua_get_Ember__EntityImporter__ShortInfo_name(lua_State* tolua_S)
{
  Ember::EntityImporter::ShortInfo* self = (Ember::EntityImporter::ShortInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: name of class  ShortInfo */
#ifndef TOLUA_DISABLE_tolua_set_Ember__EntityImporter__ShortInfo_name
static int tolua_set_Ember__EntityImporter__ShortInfo_name(lua_State* tolua_S)
{
  Ember::EntityImporter::ShortInfo* self = (Ember::EntityImporter::ShortInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->name = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: description of class  ShortInfo */
#ifndef TOLUA_DISABLE_tolua_get_Ember__EntityImporter__ShortInfo_description
static int tolua_get_Ember__EntityImporter__ShortInfo_description(lua_State* tolua_S)
{
  Ember::EntityImporter::ShortInfo* self = (Ember::EntityImporter::ShortInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'description'",NULL);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->description);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: description of class  ShortInfo */
#ifndef TOLUA_DISABLE_tolua_set_Ember__EntityImporter__ShortInfo_description
static int tolua_set_Ember__EntityImporter__ShortInfo_description(lua_State* tolua_S)
{
  Ember::EntityImporter::ShortInfo* self = (Ember::EntityImporter::ShortInfo*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'description'",NULL);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->description = ((std::string)  tolua_tocppstring(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* method: new of class  Ember::EntityImporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityImporter_new00
static int tolua_Framework_Ember_EntityImporter_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::EntityImporter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::Account",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::Account* account = ((Eris::Account*)  tolua_tousertype(tolua_S,2,0));
  {
   Ember::EntityImporter* tolua_ret = (Ember::EntityImporter*)  Mtolua_new((Ember::EntityImporter)(*account));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::EntityImporter");
  }
 }
 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::EntityImporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityImporter_new00_local
static int tolua_Framework_Ember_EntityImporter_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::EntityImporter",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Eris::Account",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Eris::Account* account = ((Eris::Account*)  tolua_tousertype(tolua_S,2,0));
  {
   Ember::EntityImporter* tolua_ret = (Ember::EntityImporter*)  Mtolua_new((Ember::EntityImporter)(*account));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::EntityImporter");
    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::EntityImporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityImporter_delete00
static int tolua_Framework_Ember_EntityImporter_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EntityImporter",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EntityImporter* self = (Ember::EntityImporter*)  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: getInfoFromDirectory of class  Ember::EntityImporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityImporter_getInfoFromDirectory00
static int tolua_Framework_Ember_EntityImporter_getInfoFromDirectory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::EntityImporter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const std::string directoryPath = ((const std::string)  tolua_tocppstring(tolua_S,2,0));
  {
   std::vector<Ember::EntityImporter::ShortInfo> tolua_ret = (std::vector<Ember::EntityImporter::ShortInfo>)  Ember::EntityImporter::getInfoFromDirectory(directoryPath);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((std::vector<Ember::EntityImporter::ShortInfo>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<Ember::EntityImporter::ShortInfo>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(std::vector<Ember::EntityImporter::ShortInfo>));
     tolua_pushusertype(tolua_S,tolua_obj,"std::vector<Ember::EntityImporter::ShortInfo>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
   tolua_pushcppstring(tolua_S,(const char*)directoryPath);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getInfoFromDirectory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: start of class  Ember::EntityImporter */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_EntityImporter_start00
static int tolua_Framework_Ember_EntityImporter_start00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::EntityImporter",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::EntityImporter* self = (Ember::EntityImporter*)  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 'start'", NULL);
#endif
  {
   self->start(filename);
   tolua_pushcppstring(tolua_S,(const char*)filename);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'start'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* set function: EventCompleted of class  Ember::EntityImporter */
#ifndef TOLUA_DISABLE_tolua_set_Ember__EntityImporter_EventCompleted
static int tolua_set_Ember__EntityImporter_EventCompleted(lua_State* tolua_S)
{
  Ember::EntityImporter* self = (Ember::EntityImporter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventCompleted'",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->EventCompleted = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

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

/* set function: EventProgress of class  Ember::EntityImporter */
#ifndef TOLUA_DISABLE_tolua_set_Ember__EntityImporter_EventProgress
static int tolua_set_Ember__EntityImporter_EventProgress(lua_State* tolua_S)
{
  Ember::EntityImporter* self = (Ember::EntityImporter*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'EventProgress'",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->EventProgress = *((sigc::signal<void>*)  tolua_tousertype(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Ember::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AtlasObjectDecoder_new00
static int tolua_Framework_Ember_AtlasObjectDecoder_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::AtlasObjectDecoder* tolua_ret = (Ember::AtlasObjectDecoder*)  Mtolua_new((Ember::AtlasObjectDecoder)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AtlasObjectDecoder");
  }
 }
 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::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AtlasObjectDecoder_new00_local
static int tolua_Framework_Ember_AtlasObjectDecoder_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Ember::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Ember::AtlasObjectDecoder* tolua_ret = (Ember::AtlasObjectDecoder*)  Mtolua_new((Ember::AtlasObjectDecoder)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Ember::AtlasObjectDecoder");
    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::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AtlasObjectDecoder_delete00
static int tolua_Framework_Ember_AtlasObjectDecoder_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::AtlasObjectDecoder* self = (Ember::AtlasObjectDecoder*)  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: getLastObject of class  Ember::AtlasObjectDecoder */
#ifndef TOLUA_DISABLE_tolua_Framework_Ember_AtlasObjectDecoder_getLastObject00
static int tolua_Framework_Ember_AtlasObjectDecoder_getLastObject00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Ember::AtlasObjectDecoder",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Ember::AtlasObjectDecoder* self = (Ember::AtlasObjectDecoder*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'getLastObject'", NULL);
#endif
  {
   Atlas::Objects::Root tolua_ret = (Atlas::Objects::Root)  self->getLastObject();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Atlas::Objects::Root)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Objects::Root");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Atlas::Objects::Root));
     tolua_pushusertype(tolua_S,tolua_obj,"Atlas::Objects::Root");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'getLastObject'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* Open function */
TOLUA_API int tolua_Framework_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,"ConsoleBackend","Ember::ConsoleBackend","",NULL);
   tolua_beginmodule(tolua_S,"ConsoleBackend");
    tolua_function(tolua_S,"getSingletonPtr",tolua_Framework_Ember_ConsoleBackend_getSingletonPtr00);
    tolua_function(tolua_S,"getSingleton",tolua_Framework_Ember_ConsoleBackend_getSingleton00);
    tolua_function(tolua_S,"runCommand",tolua_Framework_Ember_ConsoleBackend_runCommand00);
    tolua_function(tolua_S,"pushMessage",tolua_Framework_Ember_ConsoleBackend_pushMessage00);
    tolua_function(tolua_S,"pushMessage",tolua_Framework_Ember_ConsoleBackend_pushMessage01);
    tolua_function(tolua_S,"runCommand",tolua_Framework_Ember_ConsoleBackend_runCommand01);
    tolua_variable(tolua_S,"GotMessage",tolua_get_Ember__ConsoleBackend_GotMessage,NULL);
   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,"Tokeniser","Ember::Tokeniser","",tolua_collect_Ember__Tokeniser);
   #else
   tolua_cclass(tolua_S,"Tokeniser","Ember::Tokeniser","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"Tokeniser");
    tolua_function(tolua_S,"new",tolua_Framework_Ember_Tokeniser_new00);
    tolua_function(tolua_S,"new_local",tolua_Framework_Ember_Tokeniser_new00_local);
    tolua_function(tolua_S,".call",tolua_Framework_Ember_Tokeniser_new00_local);
    tolua_function(tolua_S,"delete",tolua_Framework_Ember_Tokeniser_delete00);
    tolua_function(tolua_S,"initTokens",tolua_Framework_Ember_Tokeniser_initTokens00);
    tolua_function(tolua_S,"nextToken",tolua_Framework_Ember_Tokeniser_nextToken00);
    tolua_function(tolua_S,"remainingTokens",tolua_Framework_Ember_Tokeniser_remainingTokens00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"Log","Ember::Log","",NULL);
   tolua_beginmodule(tolua_S,"Log");
    tolua_constant(tolua_S,"VERBOSE",Ember::Log::VERBOSE);
    tolua_constant(tolua_S,"INFO",Ember::Log::INFO);
    tolua_constant(tolua_S,"WARNING",Ember::Log::WARNING);
    tolua_constant(tolua_S,"FAILURE",Ember::Log::FAILURE);
    tolua_constant(tolua_S,"CRITICAL",Ember::Log::CRITICAL);
    tolua_constant(tolua_S,"END_MESSAGE",Ember::Log::END_MESSAGE);
    tolua_function(tolua_S,"log",tolua_Framework_Ember_Log_log00);
    tolua_function(tolua_S,"log",tolua_Framework_Ember_Log_log01);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_function(tolua_S,"S_LOG_VERBOSE",tolua_Framework_S_LOG_VERBOSE00);
  tolua_function(tolua_S,"S_LOG_INFO",tolua_Framework_S_LOG_INFO00);
  tolua_function(tolua_S,"S_LOG_WARNING",tolua_Framework_S_LOG_WARNING00);
  tolua_function(tolua_S,"S_LOG_FAILURE",tolua_Framework_S_LOG_FAILURE00);
  tolua_function(tolua_S,"S_LOG_CRITICAL",tolua_Framework_S_LOG_CRITICAL00);

  { /* begin embedded lua code */
   int top = lua_gettop(tolua_S);
   static const unsigned char B[] = {
    10,108,111,103, 32, 61, 10,123, 10,118,101,114, 98,111,115,
    101, 32, 61, 32, 83, 95, 76, 79, 71, 95, 86, 69, 82, 66, 79,
     83, 69, 59, 10,105,110,102,111, 32, 61, 32, 83, 95, 76, 79,
     71, 95, 73, 78, 70, 79, 59, 10,119, 97,114,110,105,110,103,
     32, 61, 32, 83, 95, 76, 79, 71, 95, 87, 65, 82, 78, 73, 78,
     71, 59, 10,102, 97,105,108,117,114,101, 32, 61, 32, 83, 95,
     76, 79, 71, 95, 70, 65, 73, 76, 85, 82, 69, 59, 10, 99,114,
    105,116,105, 99, 97,108, 32, 61, 32, 83, 95, 76, 79, 71, 95,
     67, 82, 73, 84, 73, 67, 65, 76, 10,125, 45, 45, 45, 45, 45,
     45, 45, 45, 45, 45, 45, 45, 45, 45,32
   };
   tolua_dobuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code 1");
   lua_settop(tolua_S, top);
  } /* end of embedded lua code */

  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"IScriptingProvider","Ember::IScriptingProvider","",NULL);
   tolua_beginmodule(tolua_S,"IScriptingProvider");
    tolua_function(tolua_S,"getName",tolua_Framework_Ember_IScriptingProvider_getName00);
    tolua_function(tolua_S,"forceGC",tolua_Framework_Ember_IScriptingProvider_forceGC00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"std",0);
  tolua_beginmodule(tolua_S,"std");
   #ifdef __cplusplus
   tolua_cclass(tolua_S,"stringstream","std::stringstream","std::iostream",tolua_collect_std__stringstream);
   #else
   tolua_cclass(tolua_S,"stringstream","std::stringstream","std::iostream",NULL);
   #endif
   tolua_beginmodule(tolua_S,"stringstream");
    tolua_function(tolua_S,"new",tolua_Framework_std_stringstream_new00);
    tolua_function(tolua_S,"new_local",tolua_Framework_std_stringstream_new00_local);
    tolua_function(tolua_S,".call",tolua_Framework_std_stringstream_new00_local);
    tolua_function(tolua_S,"new",tolua_Framework_std_stringstream_new01);
    tolua_function(tolua_S,"new_local",tolua_Framework_std_stringstream_new01_local);
    tolua_function(tolua_S,".call",tolua_Framework_std_stringstream_new01_local);
    tolua_function(tolua_S,"delete",tolua_Framework_std_stringstream_delete00);
    tolua_function(tolua_S,"str",tolua_Framework_std_stringstream_str00);
    tolua_variable(tolua_S,"__std__istream__",tolua_get_std__stringstream___std__istream__,NULL);
    tolua_variable(tolua_S,"__std__ostream__",tolua_get_std__stringstream___std__ostream__,NULL);
   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,"AttributeObserver","Ember::AttributeObserver","",tolua_collect_Ember__AttributeObserver);
   #else
   tolua_cclass(tolua_S,"AttributeObserver","Ember::AttributeObserver","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"AttributeObserver");
    tolua_function(tolua_S,"new",tolua_Framework_Ember_AttributeObserver_new00);
    tolua_function(tolua_S,"new_local",tolua_Framework_Ember_AttributeObserver_new00_local);
    tolua_function(tolua_S,".call",tolua_Framework_Ember_AttributeObserver_new00_local);
    tolua_function(tolua_S,"new",tolua_Framework_Ember_AttributeObserver_new01);
    tolua_function(tolua_S,"new_local",tolua_Framework_Ember_AttributeObserver_new01_local);
    tolua_function(tolua_S,".call",tolua_Framework_Ember_AttributeObserver_new01_local);
    tolua_function(tolua_S,"new",tolua_Framework_Ember_AttributeObserver_new02);
    tolua_function(tolua_S,"new_local",tolua_Framework_Ember_AttributeObserver_new02_local);
    tolua_function(tolua_S,".call",tolua_Framework_Ember_AttributeObserver_new02_local);
    tolua_function(tolua_S,"delete",tolua_Framework_Ember_AttributeObserver_delete00);
    tolua_variable(tolua_S,"EventChanged",tolua_get_Ember__AttributeObserver_EventChanged,NULL);
    tolua_function(tolua_S,"forceEvaluation",tolua_Framework_Ember_AttributeObserver_forceEvaluation00);
   tolua_endmodule(tolua_S);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"Ember",0);
  tolua_beginmodule(tolua_S,"Ember");
   tolua_cclass(tolua_S,"MainLoopController","Ember::MainLoopController","",NULL);
   tolua_beginmodule(tolua_S,"MainLoopController");
    tolua_function(tolua_S,"getSingleton",tolua_Framework_Ember_MainLoopController_getSingleton00);
    tolua_function(tolua_S,"shouldQuit",tolua_Framework_Ember_MainLoopController_shouldQuit00);
    tolua_function(tolua_S,"quit",tolua_Framework_Ember_MainLoopController_quit00);
    tolua_function(tolua_S,"requestQuit",tolua_Framework_Ember_MainLoopController_requestQuit00);
    tolua_function(tolua_S,"setErisPolling",tolua_Framework_Ember_MainLoopController_setErisPolling00);
    tolua_function(tolua_S,"getErisPolling",tolua_Framework_Ember_MainLoopController_getErisPolling00);
    tolua_variable(tolua_S,"EventBeforeInputProcessing",tolua_get_Ember__MainLoopController_EventBeforeInputProcessing,tolua_set_Ember__MainLoopController_EventBeforeInputProcessing);
    tolua_variable(tolua_S,"EventAfterInputProcessing",tolua_get_Ember__MainLoopController_EventAfterInputProcessing,tolua_set_Ember__MainLoopController_EventAfterInputProcessing);
    tolua_variable(tolua_S,"EventRequestQuit",tolua_get_Ember__MainLoopController_EventRequestQuit,tolua_set_Ember__MainLoopController_EventRequestQuit);
   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,"EntityExporter","Ember::EntityExporter","",tolua_collect_Ember__EntityExporter);
   #else
   tolua_cclass(tolua_S,"EntityExporter","Ember::EntityExporter","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"EntityExporter");
    tolua_cclass(tolua_S,"Stats","Ember::EntityExporter::Stats","",NULL);
    tolua_beginmodule(tolua_S,"Stats");
     tolua_variable(tolua_S,"entitiesQueried",tolua_get_Ember__EntityExporter__Stats_unsigned_entitiesQueried,tolua_set_Ember__EntityExporter__Stats_unsigned_entitiesQueried);
     tolua_variable(tolua_S,"entitiesReceived",tolua_get_Ember__EntityExporter__Stats_unsigned_entitiesReceived,tolua_set_Ember__EntityExporter__Stats_unsigned_entitiesReceived);
     tolua_variable(tolua_S,"entitiesError",tolua_get_Ember__EntityExporter__Stats_unsigned_entitiesError,tolua_set_Ember__EntityExporter__Stats_unsigned_entitiesError);
     tolua_variable(tolua_S,"mindsQueried",tolua_get_Ember__EntityExporter__Stats_unsigned_mindsQueried,tolua_set_Ember__EntityExporter__Stats_unsigned_mindsQueried);
     tolua_variable(tolua_S,"mindsReceived",tolua_get_Ember__EntityExporter__Stats_unsigned_mindsReceived,tolua_set_Ember__EntityExporter__Stats_unsigned_mindsReceived);
     tolua_variable(tolua_S,"mindsError",tolua_get_Ember__EntityExporter__Stats_unsigned_mindsError,tolua_set_Ember__EntityExporter__Stats_unsigned_mindsError);
     tolua_variable(tolua_S,"rulesQueried",tolua_get_Ember__EntityExporter__Stats_unsigned_rulesQueried,tolua_set_Ember__EntityExporter__Stats_unsigned_rulesQueried);
     tolua_variable(tolua_S,"rulesReceived",tolua_get_Ember__EntityExporter__Stats_unsigned_rulesReceived,tolua_set_Ember__EntityExporter__Stats_unsigned_rulesReceived);
     tolua_variable(tolua_S,"rulesError",tolua_get_Ember__EntityExporter__Stats_unsigned_rulesError,tolua_set_Ember__EntityExporter__Stats_unsigned_rulesError);
    tolua_endmodule(tolua_S);
    tolua_function(tolua_S,"new",tolua_Framework_Ember_EntityExporter_new00);
    tolua_function(tolua_S,"new_local",tolua_Framework_Ember_EntityExporter_new00_local);
    tolua_function(tolua_S,".call",tolua_Framework_Ember_EntityExporter_new00_local);
    tolua_function(tolua_S,"delete",tolua_Framework_Ember_EntityExporter_delete00);
    tolua_function(tolua_S,"start",tolua_Framework_Ember_EntityExporter_start00);
    tolua_function(tolua_S,"start",tolua_Framework_Ember_EntityExporter_start01);
    tolua_function(tolua_S,"cancel",tolua_Framework_Ember_EntityExporter_cancel00);
    tolua_function(tolua_S,"setDescription",tolua_Framework_Ember_EntityExporter_setDescription00);
    tolua_function(tolua_S,"setName",tolua_Framework_Ember_EntityExporter_setName00);
    tolua_function(tolua_S,"setExportTransient",tolua_Framework_Ember_EntityExporter_setExportTransient00);
    tolua_function(tolua_S,"getExportTransient",tolua_Framework_Ember_EntityExporter_getExportTransient00);
    tolua_function(tolua_S,"setPreserveIds",tolua_Framework_Ember_EntityExporter_setPreserveIds00);
    tolua_function(tolua_S,"getPreserveIds",tolua_Framework_Ember_EntityExporter_getPreserveIds00);
    tolua_function(tolua_S,"setExportRules",tolua_Framework_Ember_EntityExporter_setExportRules00);
    tolua_function(tolua_S,"getExportRules",tolua_Framework_Ember_EntityExporter_getExportRules00);
    tolua_function(tolua_S,"getStats",tolua_Framework_Ember_EntityExporter_getStats00);
    tolua_variable(tolua_S,"EventCompleted",tolua_get_Ember__EntityExporter_EventCompleted,tolua_set_Ember__EntityExporter_EventCompleted);
    tolua_variable(tolua_S,"EventProgress",tolua_get_Ember__EntityExporter_EventProgress,tolua_set_Ember__EntityExporter_EventProgress);
   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,"EntityImporter","Ember::EntityImporter","",tolua_collect_Ember__EntityImporter);
   #else
   tolua_cclass(tolua_S,"EntityImporter","Ember::EntityImporter","",NULL);
   #endif
   tolua_beginmodule(tolua_S,"EntityImporter");
    tolua_cclass(tolua_S,"ShortInfo","Ember::EntityImporter::ShortInfo","",NULL);
    tolua_beginmodule(tolua_S,"ShortInfo");
     tolua_variable(tolua_S,"filename",tolua_get_Ember__EntityImporter__ShortInfo_filename,tolua_set_Ember__EntityImporter__ShortInfo_filename);
     tolua_variable(tolua_S,"name",tolua_get_Ember__EntityImporter__ShortInfo_name,tolua_set_Ember__EntityImporter__ShortInfo_name);
     tolua_variable(tolua_S,"description",tolua_get_Ember__EntityImporter__ShortInfo_description,tolua_set_Ember__EntityImporter__ShortInfo_description);
     tolua_variable(tolua_S,"entityCount",tolua_get_Ember__EntityImporter__ShortInfo_entityCount,tolua_set_Ember__EntityImporter__ShortInfo_entityCount);
     tolua_variable(tolua_S,"rulesCount",tolua_get_Ember__EntityImporter__ShortInfo_rulesCount,tolua_set_Ember__EntityImporter__ShortInfo_rulesCount);
     tolua_variable(tolua_S,"mindsCount",tolua_get_Ember__EntityImporter__ShortInfo_mindsCount,tolua_set_Ember__EntityImporter__ShortInfo_mindsCount);
    tolua_endmodule(tolua_S);
    tolua_cclass(tolua_S,"Stats","Ember::EntityImporter::Stats","",NULL);
    tolua_beginmodule(tolua_S,"Stats");
     tolua_variable(tolua_S,"entitiesCount",tolua_get_Ember__EntityImporter__Stats_unsigned_entitiesCount,tolua_set_Ember__EntityImporter__Stats_unsigned_entitiesCount);
     tolua_variable(tolua_S,"entitiesProcessedCount",tolua_get_Ember__EntityImporter__Stats_unsigned_entitiesProcessedCount,tolua_set_Ember__EntityImporter__Stats_unsigned_entitiesProcessedCount);
     tolua_variable(tolua_S,"entitiesUpdateCount",tolua_get_Ember__EntityImporter__Stats_unsigned_entitiesUpdateCount,tolua_set_Ember__EntityImporter__Stats_unsigned_entitiesUpdateCount);
     tolua_variable(tolua_S,"entitiesCreateCount",tolua_get_Ember__EntityImporter__Stats_unsigned_entitiesCreateCount,tolua_set_Ember__EntityImporter__Stats_unsigned_entitiesCreateCount);
     tolua_variable(tolua_S,"entitiesCreateErrorCount",tolua_get_Ember__EntityImporter__Stats_unsigned_entitiesCreateErrorCount,tolua_set_Ember__EntityImporter__Stats_unsigned_entitiesCreateErrorCount);
     tolua_variable(tolua_S,"mindsCount",tolua_get_Ember__EntityImporter__Stats_unsigned_mindsCount,tolua_set_Ember__EntityImporter__Stats_unsigned_mindsCount);
     tolua_variable(tolua_S,"mindsProcessedCount",tolua_get_Ember__EntityImporter__Stats_unsigned_mindsProcessedCount,tolua_set_Ember__EntityImporter__Stats_unsigned_mindsProcessedCount);
     tolua_variable(tolua_S,"rulesCount",tolua_get_Ember__EntityImporter__Stats_unsigned_rulesCount,tolua_set_Ember__EntityImporter__Stats_unsigned_rulesCount);
     tolua_variable(tolua_S,"rulesProcessedCount",tolua_get_Ember__EntityImporter__Stats_unsigned_rulesProcessedCount,tolua_set_Ember__EntityImporter__Stats_unsigned_rulesProcessedCount);
     tolua_variable(tolua_S,"rulesUpdateCount",tolua_get_Ember__EntityImporter__Stats_unsigned_rulesUpdateCount,tolua_set_Ember__EntityImporter__Stats_unsigned_rulesUpdateCount);
     tolua_variable(tolua_S,"rulesCreateCount",tolua_get_Ember__EntityImporter__Stats_unsigned_rulesCreateCount,tolua_set_Ember__EntityImporter__Stats_unsigned_rulesCreateCount);
     tolua_variable(tolua_S,"rulesCreateErrorCount",tolua_get_Ember__EntityImporter__Stats_unsigned_rulesCreateErrorCount,tolua_set_Ember__EntityImporter__Stats_unsigned_rulesCreateErrorCount);
    tolua_endmodule(tolua_S);
    tolua_function(tolua_S,"new",tolua_Framework_Ember_EntityImporter_new00);
    tolua_function(tolua_S,"new_local",tolua_Framework_Ember_EntityImporter_new00_local);
    tolua_function(tolua_S,".call",tolua_Framework_Ember_EntityImporter_new00_local);
    tolua_function(tolua_S,"delete",tolua_Framework_Ember_EntityImporter_delete00);
    tolua_function(tolua_S,"getInfoFromDirectory",tolua_Framework_Ember_EntityImporter_getInfoFromDirectory00);
    tolua_function(tolua_S,"start",tolua_Framework_Ember_EntityImporter_start00);
    tolua_function(tolua_S,"cancel",tolua_Framework_Ember_EntityImporter_cancel00);
    tolua_function(tolua_S,"getStats",tolua_Framework_Ember_EntityImporter_getStats00);
    tolua_variable(tolua_S,"EventCompleted",tolua_get_Ember__EntityImporter_EventCompleted,tolua_set_Ember__EntityImporter_EventCompleted);
    tolua_variable(tolua_S,"EventProgress",tolua_get_Ember__EntityImporter_EventProgress,tolua_set_Ember__EntityImporter_EventProgress);
   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,"AtlasObjectDecoder","Ember::AtlasObjectDecoder","Atlas::Objects::ObjectsDecoder",tolua_collect_Ember__AtlasObjectDecoder);
   #else
   tolua_cclass(tolua_S,"AtlasObjectDecoder","Ember::AtlasObjectDecoder","Atlas::Objects::ObjectsDecoder",NULL);
   #endif
   tolua_beginmodule(tolua_S,"AtlasObjectDecoder");
    tolua_function(tolua_S,"new",tolua_Framework_Ember_AtlasObjectDecoder_new00);
    tolua_function(tolua_S,"new_local",tolua_Framework_Ember_AtlasObjectDecoder_new00_local);
    tolua_function(tolua_S,".call",tolua_Framework_Ember_AtlasObjectDecoder_new00_local);
    tolua_function(tolua_S,"delete",tolua_Framework_Ember_AtlasObjectDecoder_delete00);
    tolua_function(tolua_S,"getLastObject",tolua_Framework_Ember_AtlasObjectDecoder_getLastObject00);
    tolua_variable(tolua_S,"EventObjectArrived",tolua_get_Ember__AtlasObjectDecoder_EventObjectArrived,NULL);
   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_Framework (lua_State* tolua_S) {
 return tolua_Framework_open(tolua_S);
};
#endif

