#include "ai_vehiclelist_valuator.hpp"

namespace SQConvert {
	/* Allow AIVehicleList_vLocation to be used as Squirrel parameter */
	template <> AIVehicleList_vLocation *GetParam(ForceType<AIVehicleList_vLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vLocation *)instance; }
	template <> AIVehicleList_vLocation &GetParam(ForceType<AIVehicleList_vLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vLocation *)instance; }
	template <> const AIVehicleList_vLocation *GetParam(ForceType<const AIVehicleList_vLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vLocation *)instance; }
	template <> const AIVehicleList_vLocation &GetParam(ForceType<const AIVehicleList_vLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vLocation *)instance; }
	template <> int Return<AIVehicleList_vLocation *>(HSQUIRRELVM vm, AIVehicleList_vLocation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vLocation", res, NULL, DefSQDestructorCallback<AIVehicleList_vLocation>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vLocation_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vLocation> SQAIVehicleList_vLocation("AIVehicleList_vLocation");
	SQAIVehicleList_vLocation.PreRegister(engine);
	SQAIVehicleList_vLocation.AddConstructor<void (AIVehicleList_vLocation::*)(), 1>(engine, "x");

	SQAIVehicleList_vLocation.DefSQStaticMethod(engine, &AIVehicleList_vLocation::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vLocation.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vEngineType to be used as Squirrel parameter */
	template <> AIVehicleList_vEngineType *GetParam(ForceType<AIVehicleList_vEngineType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vEngineType *)instance; }
	template <> AIVehicleList_vEngineType &GetParam(ForceType<AIVehicleList_vEngineType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vEngineType *)instance; }
	template <> const AIVehicleList_vEngineType *GetParam(ForceType<const AIVehicleList_vEngineType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vEngineType *)instance; }
	template <> const AIVehicleList_vEngineType &GetParam(ForceType<const AIVehicleList_vEngineType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vEngineType *)instance; }
	template <> int Return<AIVehicleList_vEngineType *>(HSQUIRRELVM vm, AIVehicleList_vEngineType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vEngineType", res, NULL, DefSQDestructorCallback<AIVehicleList_vEngineType>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vEngineType_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vEngineType> SQAIVehicleList_vEngineType("AIVehicleList_vEngineType");
	SQAIVehicleList_vEngineType.PreRegister(engine);
	SQAIVehicleList_vEngineType.AddConstructor<void (AIVehicleList_vEngineType::*)(), 1>(engine, "x");

	SQAIVehicleList_vEngineType.DefSQStaticMethod(engine, &AIVehicleList_vEngineType::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vEngineType.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vUnitNumber to be used as Squirrel parameter */
	template <> AIVehicleList_vUnitNumber *GetParam(ForceType<AIVehicleList_vUnitNumber *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vUnitNumber *)instance; }
	template <> AIVehicleList_vUnitNumber &GetParam(ForceType<AIVehicleList_vUnitNumber &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vUnitNumber *)instance; }
	template <> const AIVehicleList_vUnitNumber *GetParam(ForceType<const AIVehicleList_vUnitNumber *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vUnitNumber *)instance; }
	template <> const AIVehicleList_vUnitNumber &GetParam(ForceType<const AIVehicleList_vUnitNumber &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vUnitNumber *)instance; }
	template <> int Return<AIVehicleList_vUnitNumber *>(HSQUIRRELVM vm, AIVehicleList_vUnitNumber *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vUnitNumber", res, NULL, DefSQDestructorCallback<AIVehicleList_vUnitNumber>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vUnitNumber_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vUnitNumber> SQAIVehicleList_vUnitNumber("AIVehicleList_vUnitNumber");
	SQAIVehicleList_vUnitNumber.PreRegister(engine);
	SQAIVehicleList_vUnitNumber.AddConstructor<void (AIVehicleList_vUnitNumber::*)(), 1>(engine, "x");

	SQAIVehicleList_vUnitNumber.DefSQStaticMethod(engine, &AIVehicleList_vUnitNumber::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vUnitNumber.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vAge to be used as Squirrel parameter */
	template <> AIVehicleList_vAge *GetParam(ForceType<AIVehicleList_vAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAge *)instance; }
	template <> AIVehicleList_vAge &GetParam(ForceType<AIVehicleList_vAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAge *)instance; }
	template <> const AIVehicleList_vAge *GetParam(ForceType<const AIVehicleList_vAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAge *)instance; }
	template <> const AIVehicleList_vAge &GetParam(ForceType<const AIVehicleList_vAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAge *)instance; }
	template <> int Return<AIVehicleList_vAge *>(HSQUIRRELVM vm, AIVehicleList_vAge *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vAge", res, NULL, DefSQDestructorCallback<AIVehicleList_vAge>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vAge_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vAge> SQAIVehicleList_vAge("AIVehicleList_vAge");
	SQAIVehicleList_vAge.PreRegister(engine);
	SQAIVehicleList_vAge.AddConstructor<void (AIVehicleList_vAge::*)(), 1>(engine, "x");

	SQAIVehicleList_vAge.DefSQStaticMethod(engine, &AIVehicleList_vAge::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vAge.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vMaxAge to be used as Squirrel parameter */
	template <> AIVehicleList_vMaxAge *GetParam(ForceType<AIVehicleList_vMaxAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vMaxAge *)instance; }
	template <> AIVehicleList_vMaxAge &GetParam(ForceType<AIVehicleList_vMaxAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vMaxAge *)instance; }
	template <> const AIVehicleList_vMaxAge *GetParam(ForceType<const AIVehicleList_vMaxAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vMaxAge *)instance; }
	template <> const AIVehicleList_vMaxAge &GetParam(ForceType<const AIVehicleList_vMaxAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vMaxAge *)instance; }
	template <> int Return<AIVehicleList_vMaxAge *>(HSQUIRRELVM vm, AIVehicleList_vMaxAge *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vMaxAge", res, NULL, DefSQDestructorCallback<AIVehicleList_vMaxAge>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vMaxAge_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vMaxAge> SQAIVehicleList_vMaxAge("AIVehicleList_vMaxAge");
	SQAIVehicleList_vMaxAge.PreRegister(engine);
	SQAIVehicleList_vMaxAge.AddConstructor<void (AIVehicleList_vMaxAge::*)(), 1>(engine, "x");

	SQAIVehicleList_vMaxAge.DefSQStaticMethod(engine, &AIVehicleList_vMaxAge::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vMaxAge.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vAgeLeft to be used as Squirrel parameter */
	template <> AIVehicleList_vAgeLeft *GetParam(ForceType<AIVehicleList_vAgeLeft *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAgeLeft *)instance; }
	template <> AIVehicleList_vAgeLeft &GetParam(ForceType<AIVehicleList_vAgeLeft &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAgeLeft *)instance; }
	template <> const AIVehicleList_vAgeLeft *GetParam(ForceType<const AIVehicleList_vAgeLeft *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAgeLeft *)instance; }
	template <> const AIVehicleList_vAgeLeft &GetParam(ForceType<const AIVehicleList_vAgeLeft &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAgeLeft *)instance; }
	template <> int Return<AIVehicleList_vAgeLeft *>(HSQUIRRELVM vm, AIVehicleList_vAgeLeft *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vAgeLeft", res, NULL, DefSQDestructorCallback<AIVehicleList_vAgeLeft>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vAgeLeft_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vAgeLeft> SQAIVehicleList_vAgeLeft("AIVehicleList_vAgeLeft");
	SQAIVehicleList_vAgeLeft.PreRegister(engine);
	SQAIVehicleList_vAgeLeft.AddConstructor<void (AIVehicleList_vAgeLeft::*)(), 1>(engine, "x");

	SQAIVehicleList_vAgeLeft.DefSQStaticMethod(engine, &AIVehicleList_vAgeLeft::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vAgeLeft.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vProfitThisYear to be used as Squirrel parameter */
	template <> AIVehicleList_vProfitThisYear *GetParam(ForceType<AIVehicleList_vProfitThisYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitThisYear *)instance; }
	template <> AIVehicleList_vProfitThisYear &GetParam(ForceType<AIVehicleList_vProfitThisYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitThisYear *)instance; }
	template <> const AIVehicleList_vProfitThisYear *GetParam(ForceType<const AIVehicleList_vProfitThisYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitThisYear *)instance; }
	template <> const AIVehicleList_vProfitThisYear &GetParam(ForceType<const AIVehicleList_vProfitThisYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitThisYear *)instance; }
	template <> int Return<AIVehicleList_vProfitThisYear *>(HSQUIRRELVM vm, AIVehicleList_vProfitThisYear *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vProfitThisYear", res, NULL, DefSQDestructorCallback<AIVehicleList_vProfitThisYear>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vProfitThisYear_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vProfitThisYear> SQAIVehicleList_vProfitThisYear("AIVehicleList_vProfitThisYear");
	SQAIVehicleList_vProfitThisYear.PreRegister(engine);
	SQAIVehicleList_vProfitThisYear.AddConstructor<void (AIVehicleList_vProfitThisYear::*)(), 1>(engine, "x");

	SQAIVehicleList_vProfitThisYear.DefSQStaticMethod(engine, &AIVehicleList_vProfitThisYear::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vProfitThisYear.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vProfitLastYear to be used as Squirrel parameter */
	template <> AIVehicleList_vProfitLastYear *GetParam(ForceType<AIVehicleList_vProfitLastYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitLastYear *)instance; }
	template <> AIVehicleList_vProfitLastYear &GetParam(ForceType<AIVehicleList_vProfitLastYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitLastYear *)instance; }
	template <> const AIVehicleList_vProfitLastYear *GetParam(ForceType<const AIVehicleList_vProfitLastYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitLastYear *)instance; }
	template <> const AIVehicleList_vProfitLastYear &GetParam(ForceType<const AIVehicleList_vProfitLastYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitLastYear *)instance; }
	template <> int Return<AIVehicleList_vProfitLastYear *>(HSQUIRRELVM vm, AIVehicleList_vProfitLastYear *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vProfitLastYear", res, NULL, DefSQDestructorCallback<AIVehicleList_vProfitLastYear>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vProfitLastYear_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vProfitLastYear> SQAIVehicleList_vProfitLastYear("AIVehicleList_vProfitLastYear");
	SQAIVehicleList_vProfitLastYear.PreRegister(engine);
	SQAIVehicleList_vProfitLastYear.AddConstructor<void (AIVehicleList_vProfitLastYear::*)(), 1>(engine, "x");

	SQAIVehicleList_vProfitLastYear.DefSQStaticMethod(engine, &AIVehicleList_vProfitLastYear::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vProfitLastYear.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AIVehicleList_vVehicleType to be used as Squirrel parameter */
	template <> AIVehicleList_vVehicleType *GetParam(ForceType<AIVehicleList_vVehicleType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vVehicleType *)instance; }
	template <> AIVehicleList_vVehicleType &GetParam(ForceType<AIVehicleList_vVehicleType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vVehicleType *)instance; }
	template <> const AIVehicleList_vVehicleType *GetParam(ForceType<const AIVehicleList_vVehicleType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vVehicleType *)instance; }
	template <> const AIVehicleList_vVehicleType &GetParam(ForceType<const AIVehicleList_vVehicleType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vVehicleType *)instance; }
	template <> int Return<AIVehicleList_vVehicleType *>(HSQUIRRELVM vm, AIVehicleList_vVehicleType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vVehicleType", res, NULL, DefSQDestructorCallback<AIVehicleList_vVehicleType>); return 1; }
}; // namespace SQConvert

void SQAIVehicleList_vVehicleType_Register(Squirrel *engine) {
	DefSQClass <AIVehicleList_vVehicleType> SQAIVehicleList_vVehicleType("AIVehicleList_vVehicleType");
	SQAIVehicleList_vVehicleType.PreRegister(engine);
	SQAIVehicleList_vVehicleType.AddConstructor<void (AIVehicleList_vVehicleType::*)(), 1>(engine, "x");

	SQAIVehicleList_vVehicleType.DefSQStaticMethod(engine, &AIVehicleList_vVehicleType::GetClassName, "GetClassName", 1, "x");

	SQAIVehicleList_vVehicleType.PostRegister(engine);
}