var Licitracker = {};
Licitracker.GliroConfig = {};

	Licitracker.GliroConfig.getPermissions = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("GliroConfig", "getPermissions", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.GliroConfig.getPlatform = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("GliroConfig", "getPlatform", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.Constants = {};
Licitracker.StaticPermissions = {};

	Licitracker.StaticPermissions.getStaticPermissions = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("StaticPermissions", "getStaticPermissions", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.ClassTraitFromToAssocArray = {};

	Licitracker.ClassTraitFromToAssocArray.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitFromToAssocArray", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.ClassTraitFromToAssocArray.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitFromToAssocArray", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.ClassTraitFromToAssocArray.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitFromToAssocArray", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.ClassTraitFromToAssocArray.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitFromToAssocArray", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ClassTraitFromToAssocArray.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitFromToAssocArray", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.ClassTraitFromToAssocArray.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitFromToAssocArray", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ClassTraitFromToAssocArray.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitFromToAssocArray", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.ClassTraitSerDes = {};

	Licitracker.ClassTraitSerDes.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.ClassTraitSerDes.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.ClassTraitSerDes.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.ClassTraitSerDes.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.ClassTraitSerDes.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.ClassTraitSerDes.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.ClassTraitSerDes.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.ClassTraitSerDes.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ClassTraitSerDes", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.ClientResource = {};
Licitracker.AppInstance = {};

	Licitracker.AppInstance.client_add = async function(cr, fd){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("AppInstance", "client_add", function(decoded) {
				mresolve(decoded.data);
			}, cr, fd);
		});
	}
		

	Licitracker.AppInstance.client_get = async function(fd){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("AppInstance", "client_get", function(decoded) {
				mresolve(decoded.data);
			}, fd);
		});
	}
		

	Licitracker.AppInstance.client_get_fds = async function(user_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("AppInstance", "client_get_fds", function(decoded) {
				mresolve(decoded.data);
			}, user_id);
		});
	}
		

	Licitracker.AppInstance.client_free = async function(fd){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("AppInstance", "client_free", function(decoded) {
				mresolve(decoded.data);
			}, fd);
		});
	}
		

	Licitracker.AppInstance.client_count = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("AppInstance", "client_count", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.Database = {};

	Licitracker.Database.connect = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "connect", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Database.beginTransaction = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "beginTransaction", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Database.commitTransaction = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "commitTransaction", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Database.rollbackTransaction = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "rollbackTransaction", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Database.ping = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "ping", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Database.query_fetchAll = async function(query, params = [], mode = 8, error_info){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "query_fetchAll", function(decoded) {
				mresolve(decoded.data);
			}, query, params, mode, error_info);
		});
	}
		

	Licitracker.Database.query_fetchAllClass = async function(query, params = [], output_class = "stdClass", error_info){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "query_fetchAllClass", function(decoded) {
				mresolve(decoded.data);
			}, query, params, output_class, error_info);
		});
	}
		

	Licitracker.Database.query_execute = async function(query, params = [], error_info, rowcount){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "query_execute", function(decoded) {
				mresolve(decoded.data);
			}, query, params, error_info, rowcount);
		});
	}
		

	Licitracker.Database.query_mexecute = async function(query, all_params = [], error_info){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "query_mexecute", function(decoded) {
				mresolve(decoded.data);
			}, query, all_params, error_info);
		});
	}
		

	Licitracker.Database.query_raw = async function(query){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "query_raw", function(decoded) {
				mresolve(decoded.data);
			}, query);
		});
	}
		

	Licitracker.Database.last_insert_id = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "last_insert_id", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Database.sql_case_from_assoc = async function(what, assoc_array){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Database", "sql_case_from_assoc", function(decoded) {
				mresolve(decoded.data);
			}, what, assoc_array);
		});
	}
		
Licitracker.Sessions = {};

	Licitracker.Sessions.getSessionID = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "getSessionID", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.enableRewrite = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "enableRewrite", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.flushCache = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "flushCache", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.create_session = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "create_session", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.create_cookie = async function(session_id, duration_seconds = 604800){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "create_cookie", function(decoded) {
				mresolve(decoded.data);
			}, session_id, duration_seconds);
		});
	}
		

	Licitracker.Sessions.refresh = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "refresh", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.refresh_session = async function(session_id, data, avoid_set_cookie = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "refresh_session", function(decoded) {
				mresolve(decoded.data);
			}, session_id, data, avoid_set_cookie);
		});
	}
		

	Licitracker.Sessions.clear_session = async function(sess_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "clear_session", function(decoded) {
				mresolve(decoded.data);
			}, sess_id);
		});
	}
		

	Licitracker.Sessions.read_session = async function(sess_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "read_session", function(decoded) {
				mresolve(decoded.data);
			}, sess_id);
		});
	}
		

	Licitracker.Sessions.run_maintenance = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "run_maintenance", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.write_session = async function(sess_id, data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "write_session", function(decoded) {
				mresolve(decoded.data);
			}, sess_id, data);
		});
	}
		

	Licitracker.Sessions.deleteMySession = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "deleteMySession", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.get_data = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "get_data", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.set_data = async function(data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "set_data", function(decoded) {
				mresolve(decoded.data);
			}, data);
		});
	}
		

	Licitracker.Sessions.validate_session_id = async function(sessID){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "validate_session_id", function(decoded) {
				mresolve(decoded.data);
			}, sessID);
		});
	}
		

	Licitracker.Sessions.generate_session_id = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "generate_session_id", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Sessions.cleanup = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Sessions", "cleanup", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.Validators = {};

	Licitracker.Validators.validate_entry_schedule = async function(v, e, val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validate_entry_schedule", function(decoded) {
				mresolve(decoded.data);
			}, v, e, val);
		});
	}
		

	Licitracker.Validators.validate_entry_string = async function(v, e, val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validate_entry_string", function(decoded) {
				mresolve(decoded.data);
			}, v, e, val);
		});
	}
		

	Licitracker.Validators.validate_entry_email = async function(v, e, val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validate_entry_email", function(decoded) {
				mresolve(decoded.data);
			}, v, e, val);
		});
	}
		

	Licitracker.Validators.validate_entry_rut = async function(v, e, val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validate_entry_rut", function(decoded) {
				mresolve(decoded.data);
			}, v, e, val);
		});
	}
		

	Licitracker.Validators.validate_entry_region = async function(v, e, val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validate_entry_region", function(decoded) {
				mresolve(decoded.data);
			}, v, e, val);
		});
	}
		

	Licitracker.Validators.allocate_validation_results = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "allocate_validation_results", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Validators.validation_result_push_message = async function(validation_result, key, invalid_data = []){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validation_result_push_message", function(decoded) {
				mresolve(decoded.data);
			}, validation_result, key, invalid_data);
		});
	}
		

	Licitracker.Validators.validate_array_of = async function(arr, type, full_traverse, invalid_values){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validate_array_of", function(decoded) {
				mresolve(decoded.data);
			}, arr, type, full_traverse, invalid_values);
		});
	}
		

	Licitracker.Validators.filter_array_unique = async function(arr){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_array_unique", function(decoded) {
				mresolve(decoded.data);
			}, arr);
		});
	}
		

	Licitracker.Validators.filter_array_remove_empty_and_deduplicate_entries = async function(arr){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_array_remove_empty_and_deduplicate_entries", function(decoded) {
				mresolve(decoded.data);
			}, arr);
		});
	}
		

	Licitracker.Validators.filter_array_remove_empty_entries = async function(arr){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_array_remove_empty_entries", function(decoded) {
				mresolve(decoded.data);
			}, arr);
		});
	}
		

	Licitracker.Validators.filter_array_trim_remove_empty_and_deduplicate = async function(arr){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_array_trim_remove_empty_and_deduplicate", function(decoded) {
				mresolve(decoded.data);
			}, arr);
		});
	}
		

	Licitracker.Validators.filter_array_of_ruts = async function(arr){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_array_of_ruts", function(decoded) {
				mresolve(decoded.data);
			}, arr);
		});
	}
		

	Licitracker.Validators.validate_uuid = async function(uuid){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validate_uuid", function(decoded) {
				mresolve(decoded.data);
			}, uuid);
		});
	}
		

	Licitracker.Validators.filter_rut = async function(rut){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_rut", function(decoded) {
				mresolve(decoded.data);
			}, rut);
		});
	}
		

	Licitracker.Validators.filter_search_keywords = async function(keywords, bare_array = false, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_search_keywords", function(decoded) {
				mresolve(decoded.data);
			}, keywords, bare_array, tcache);
		});
	}
		

	Licitracker.Validators.filter_reduce_keywords = async function(keywords){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_reduce_keywords", function(decoded) {
				mresolve(decoded.data);
			}, keywords);
		});
	}
		

	Licitracker.Validators.filter_username = async function(username){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_username", function(decoded) {
				mresolve(decoded.data);
			}, username);
		});
	}
		

	Licitracker.Validators.username_hint = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "username_hint", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Validators.email = async function(email){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "email", function(decoded) {
				mresolve(decoded.data);
			}, email);
		});
	}
		

	Licitracker.Validators.email_or_blank = async function(email){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "email_or_blank", function(decoded) {
				mresolve(decoded.data);
			}, email);
		});
	}
		

	Licitracker.Validators.integer_value = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "integer_value", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.Validators.float_value = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "float_value", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.Validators.boolean_value = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "boolean_value", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.Validators.validator_result = async function(value, message_on_failure, message_on_success, validator_function){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "validator_result", function(decoded) {
				mresolve(decoded.data);
			}, value, message_on_failure, message_on_success, validator_function);
		});
	}
		

	Licitracker.Validators.filter_filename = async function(filename){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "filter_filename", function(decoded) {
				mresolve(decoded.data);
			}, filename);
		});
	}
		

	Licitracker.Validators.localizeDate = async function(date){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "localizeDate", function(decoded) {
				mresolve(decoded.data);
			}, date);
		});
	}
		

	Licitracker.Validators.parseLocalizedDate = async function(localized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "parseLocalizedDate", function(decoded) {
				mresolve(decoded.data);
			}, localized);
		});
	}
		

	Licitracker.Validators.mysqlDate = async function(date){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "mysqlDate", function(decoded) {
				mresolve(decoded.data);
			}, date);
		});
	}
		

	Licitracker.Validators.delocalizeNumber = async function(localized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "delocalizeNumber", function(decoded) {
				mresolve(decoded.data);
			}, localized);
		});
	}
		

	Licitracker.Validators.localizeNumber = async function(number){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Validators", "localizeNumber", function(decoded) {
				mresolve(decoded.data);
			}, number);
		});
	}
		
Licitracker.UserRecord = {};

	Licitracker.UserRecord.belongsToGroup = async function(group){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UserRecord", "belongsToGroup", function(decoded) {
				mresolve(decoded.data);
			}, group);
		});
	}
		

	Licitracker.UserRecord.hasPermission = async function(permission_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UserRecord", "hasPermission", function(decoded) {
				mresolve(decoded.data);
			}, permission_name);
		});
	}
		

	Licitracker.UserRecord.getDomainId = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UserRecord", "getDomainId", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.UsersReflectionWrapper = {};

	Licitracker.UsersReflectionWrapper.refreshSession = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "refreshSession", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.UsersReflectionWrapper.getAllUsers = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "getAllUsers", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.UsersReflectionWrapper.registerPublic = async function(email, password){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "registerPublic", function(decoded) {
				mresolve(decoded.data);
			}, email, password);
		});
	}
		

	Licitracker.UsersReflectionWrapper.registerConfirmPublic = async function(email, confirmation_code){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "registerConfirmPublic", function(decoded) {
				mresolve(decoded.data);
			}, email, confirmation_code);
		});
	}
		

	Licitracker.UsersReflectionWrapper.login = async function(username, password){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "login", function(decoded) {
				mresolve(decoded.data);
			}, username, password);
		});
	}
		

	Licitracker.UsersReflectionWrapper.logout = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "logout", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.UsersReflectionWrapper.removeUserByUsername = async function(username){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "removeUserByUsername", function(decoded) {
				mresolve(decoded.data);
			}, username);
		});
	}
		

	Licitracker.UsersReflectionWrapper.getLoadedUser = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "getLoadedUser", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.UsersReflectionWrapper.changeMyPassword = async function(password, password_algo = "PASSWORD_ARGON2I"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "changeMyPassword", function(decoded) {
				mresolve(decoded.data);
			}, password, password_algo);
		});
	}
		

	Licitracker.UsersReflectionWrapper.changeUserPasswordByUsername = async function(username, password, password_algo = "PASSWORD_ARGON2I"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "changeUserPasswordByUsername", function(decoded) {
				mresolve(decoded.data);
			}, username, password, password_algo);
		});
	}
		

	Licitracker.UsersReflectionWrapper.registerLicitrackerUser = async function(unit_id, username){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "registerLicitrackerUser", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, username);
		});
	}
		

	Licitracker.UsersReflectionWrapper.registerUser = async function(username, email, password, group = 2, password_algo = "PASSWORD_ARGON2I", confirmation = 0, domain = "Licitracker"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("UsersReflectionWrapper", "registerUser", function(decoded) {
				mresolve(decoded.data);
			}, username, email, password, group, password_algo, confirmation, domain);
		});
	}
		
Licitracker.Users = {};

	Licitracker.Users.getAllUsers = async function(domain = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "getAllUsers", function(decoded) {
				mresolve(decoded.data);
			}, domain);
		});
	}
		

	Licitracker.Users.generateRandomHex = async function(nbytes = 4){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "generateRandomHex", function(decoded) {
				mresolve(decoded.data);
			}, nbytes);
		});
	}
		

	Licitracker.Users.generateRandomNumber = async function(min, max){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "generateRandomNumber", function(decoded) {
				mresolve(decoded.data);
			}, min, max);
		});
	}
		

	Licitracker.Users.generatePassword = async function(password, salt, hashed_password, password_algo = "PASSWORD_ARGON2I"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "generatePassword", function(decoded) {
				mresolve(decoded.data);
			}, password, salt, hashed_password, password_algo);
		});
	}
		

	Licitracker.Users.changeUserPassword = async function(user_id, new_password, password_algo = "PASSWORD_ARGON2I"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "changeUserPassword", function(decoded) {
				mresolve(decoded.data);
			}, user_id, new_password, password_algo);
		});
	}
		

	Licitracker.Users.changeUserName = async function(user_id, new_username, new_email = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "changeUserName", function(decoded) {
				mresolve(decoded.data);
			}, user_id, new_username, new_email);
		});
	}
		

	Licitracker.Users.setConfirmation = async function(user_id, new_confirmation){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "setConfirmation", function(decoded) {
				mresolve(decoded.data);
			}, user_id, new_confirmation);
		});
	}
		

	Licitracker.Users.changeUserPasswordByUsername = async function(username, password, password_algo = "PASSWORD_ARGON2I"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "changeUserPasswordByUsername", function(decoded) {
				mresolve(decoded.data);
			}, username, password, password_algo);
		});
	}
		

	Licitracker.Users.userExists = async function(db, username, email){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "userExists", function(decoded) {
				mresolve(decoded.data);
			}, db, username, email);
		});
	}
		

	Licitracker.Users.removeUserByUsername = async function(username){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "removeUserByUsername", function(decoded) {
				mresolve(decoded.data);
			}, username);
		});
	}
		

	Licitracker.Users.registerUser = async function(username, email, password, groups = [], password_algo = "PASSWORD_ARGON2I", confirmation = 0, domain_id = 0){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "registerUser", function(decoded) {
				mresolve(decoded.data);
			}, username, email, password, groups, password_algo, confirmation, domain_id);
		});
	}
		

	Licitracker.Users.changeUserGroups = async function(user_id, new_groups){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "changeUserGroups", function(decoded) {
				mresolve(decoded.data);
			}, user_id, new_groups);
		});
	}
		

	Licitracker.Users.getPermissions = async function(group_ids){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "getPermissions", function(decoded) {
				mresolve(decoded.data);
			}, group_ids);
		});
	}
		

	Licitracker.Users.getLicitrackerUnits = async function(user_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "getLicitrackerUnits", function(decoded) {
				mresolve(decoded.data);
			}, user_id);
		});
	}
		

	Licitracker.Users.getUser = async function(db = false, user_id = false, domain_id = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Users", "getUser", function(decoded) {
				mresolve(decoded.data);
			}, db, user_id, domain_id);
		});
	}
		
Licitracker.CSVDB = {};

	Licitracker.CSVDB.isolated_search = async function(parameters){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "isolated_search", function(decoded) {
				mresolve(decoded.data);
			}, parameters);
		});
	}
		

	Licitracker.CSVDB.rut_filter = async function(rut){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "rut_filter", function(decoded) {
				mresolve(decoded.data);
			}, rut);
		});
	}
		

	Licitracker.CSVDB.monetary_value = async function(val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "monetary_value", function(decoded) {
				mresolve(decoded.data);
			}, val);
		});
	}
		

	Licitracker.CSVDB.number_monetary = async function(val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "number_monetary", function(decoded) {
				mresolve(decoded.data);
			}, val);
		});
	}
		

	Licitracker.CSVDB.number_filter = async function(val, decimal_places){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "number_filter", function(decoded) {
				mresolve(decoded.data);
			}, val, decimal_places);
		});
	}
		

	Licitracker.CSVDB.word_filter = async function(line){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "word_filter", function(decoded) {
				mresolve(decoded.data);
			}, line);
		});
	}
		

	Licitracker.CSVDB.word_filter2 = async function(line){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "word_filter2", function(decoded) {
				mresolve(decoded.data);
			}, line);
		});
	}
		

	Licitracker.CSVDB.word_filter2_post = async function(line){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "word_filter2_post", function(decoded) {
				mresolve(decoded.data);
			}, line);
		});
	}
		

	Licitracker.CSVDB.word_filter3 = async function(line){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "word_filter3", function(decoded) {
				mresolve(decoded.data);
			}, line);
		});
	}
		

	Licitracker.CSVDB.word_filter4 = async function(line){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "word_filter4", function(decoded) {
				mresolve(decoded.data);
			}, line);
		});
	}
		

	Licitracker.CSVDB.add_to_index = async function(iarray, idx, value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "add_to_index", function(decoded) {
				mresolve(decoded.data);
			}, iarray, idx, value);
		});
	}
		

	Licitracker.CSVDB.getDTName = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getDTName", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.connect = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "connect", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.disconnect = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "disconnect", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.encodeRequest = async function(func, args){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "encodeRequest", function(decoded) {
				mresolve(decoded.data);
			}, func, args);
		});
	}
		

	Licitracker.CSVDB.isRemoteOffloadingToDisk = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "isRemoteOffloadingToDisk", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getLoadableFilesAsKeys = async function(years = [], months = []){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getLoadableFilesAsKeys", function(decoded) {
				mresolve(decoded.data);
			}, years, months);
		});
	}
		

	Licitracker.CSVDB.getAvailableYearsLocal = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAvailableYearsLocal", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getAvailableYears = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAvailableYears", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getAvailableMonths = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAvailableMonths", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getAvailableYearMonths = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAvailableYearMonths", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.parseHTMLDate = async function(date){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "parseHTMLDate", function(decoded) {
				mresolve(decoded.data);
			}, date);
		});
	}
		

	Licitracker.CSVDB.generateDatesFromRange = async function(start, end){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "generateDatesFromRange", function(decoded) {
				mresolve(decoded.data);
			}, start, end);
		});
	}
		

	Licitracker.CSVDB.getStaticData = async function(filename, index, subindex){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getStaticData", function(decoded) {
				mresolve(decoded.data);
			}, filename, index, subindex);
		});
	}
		

	Licitracker.CSVDB.getAllStaticData = async function(index, subindex, dates = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAllStaticData", function(decoded) {
				mresolve(decoded.data);
			}, index, subindex, dates);
		});
	}
		

	Licitracker.CSVDB.isIndexOffloaded = async function(index){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "isIndexOffloaded", function(decoded) {
				mresolve(decoded.data);
			}, index);
		});
	}
		

	Licitracker.CSVDB.isIndexNative = async function(index){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "isIndexNative", function(decoded) {
				mresolve(decoded.data);
			}, index);
		});
	}
		

	Licitracker.CSVDB.convertResultIfOffloaded = async function(result, index){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "convertResultIfOffloaded", function(decoded) {
				mresolve(decoded.data);
			}, result, index);
		});
	}
		

	Licitracker.CSVDB.readIndexStaticTable = async function(fname, index, offset, limit = 0){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "readIndexStaticTable", function(decoded) {
				mresolve(decoded.data);
			}, fname, index, offset, limit);
		});
	}
		

	Licitracker.CSVDB.getRandomKey = async function(index){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getRandomKey", function(decoded) {
				mresolve(decoded.data);
			}, index);
		});
	}
		

	Licitracker.CSVDB.getAllStaticDataSingle = async function(index, subindex, first_only){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAllStaticDataSingle", function(decoded) {
				mresolve(decoded.data);
			}, index, subindex, first_only);
		});
	}
		

	Licitracker.CSVDB.getAllStaticDataSingleEntries = async function(index, subindex, first_only){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAllStaticDataSingleEntries", function(decoded) {
				mresolve(decoded.data);
			}, index, subindex, first_only);
		});
	}
		

	Licitracker.CSVDB.setWorkingFile = async function(filename){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "setWorkingFile", function(decoded) {
				mresolve(decoded.data);
			}, filename);
		});
	}
		

	Licitracker.CSVDB.getAllHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAllHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.debugConvertToEntries = async function(data, dt = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "debugConvertToEntries", function(decoded) {
				mresolve(decoded.data);
			}, data, dt);
		});
	}
		

	Licitracker.CSVDB.debugConvertToEntriesRaw = async function(data, dt = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "debugConvertToEntriesRaw", function(decoded) {
				mresolve(decoded.data);
			}, data, dt);
		});
	}
		

	Licitracker.CSVDB.transliterate_with_cache = async function(t, word, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "transliterate_with_cache", function(decoded) {
				mresolve(decoded.data);
			}, t, word, tcache);
		});
	}
		

	Licitracker.CSVDB.create_header_transliterator = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "create_header_transliterator", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getCleanHeaders = async function(line){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getCleanHeaders", function(decoded) {
				mresolve(decoded.data);
			}, line);
		});
	}
		

	Licitracker.CSVDB.convertToEntries = async function(data, progressfn = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "convertToEntries", function(decoded) {
				mresolve(decoded.data);
			}, data, progressfn);
		});
	}
		

	Licitracker.CSVDB.convertToEntriesRaw = async function(data, progressfn = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "convertToEntriesRaw", function(decoded) {
				mresolve(decoded.data);
			}, data, progressfn);
		});
	}
		

	Licitracker.CSVDB.standardizeOCHeader = async function(header, header_changed){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "standardizeOCHeader", function(decoded) {
				mresolve(decoded.data);
			}, header, header_changed);
		});
	}
		

	Licitracker.CSVDB.standardizeOCDec = async function(header_changed, dec){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "standardizeOCDec", function(decoded) {
				mresolve(decoded.data);
			}, header_changed, dec);
		});
	}
		

	Licitracker.CSVDB.convertToEntries2 = async function(data, callback = false, without_header = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "convertToEntries2", function(decoded) {
				mresolve(decoded.data);
			}, data, callback, without_header);
		});
	}
		

	Licitracker.CSVDB.getAllPreviewHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAllPreviewHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getAllAnalysisSchemas = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAllAnalysisSchemas", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.loadAnalysisSchemas = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "loadAnalysisSchemas", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.debugConvertToEntriesWSchema = async function(data, dt = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "debugConvertToEntriesWSchema", function(decoded) {
				mresolve(decoded.data);
			}, data, dt);
		});
	}
		

	Licitracker.CSVDB.convertToEntriesWithSchema = async function(data, callback = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "convertToEntriesWithSchema", function(decoded) {
				mresolve(decoded.data);
			}, data, callback);
		});
	}
		

	Licitracker.CSVDB.lic_filename = async function(year, month){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "lic_filename", function(decoded) {
				mresolve(decoded.data);
			}, year, month);
		});
	}
		

	Licitracker.CSVDB.oc_filename = async function(year, month){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "oc_filename", function(decoded) {
				mresolve(decoded.data);
			}, year, month);
		});
	}
		

	Licitracker.CSVDB.getFilenames = async function(year, month){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getFilenames", function(decoded) {
				mresolve(decoded.data);
			}, year, month);
		});
	}
		

	Licitracker.CSVDB.getIndexFullPath = async function(index, fname){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getIndexFullPath", function(decoded) {
				mresolve(decoded.data);
			}, index, fname);
		});
	}
		

	Licitracker.CSVDB.loadIndicesIntoMemory = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "loadIndicesIntoMemory", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getValidFiles = async function(dates = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getValidFiles", function(decoded) {
				mresolve(decoded.data);
			}, dates);
		});
	}
		

	Licitracker.CSVDB.getValidZipFiles = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getValidZipFiles", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getDataDir = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getDataDir", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getIndices = async function(dt = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getIndices", function(decoded) {
				mresolve(decoded.data);
			}, dt);
		});
	}
		

	Licitracker.CSVDB.getFetchFilenames = async function(years = [], months = []){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getFetchFilenames", function(decoded) {
				mresolve(decoded.data);
			}, years, months);
		});
	}
		

	Licitracker.CSVDB.convertIndexToNativeHashtable = async function(loaded_index){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "convertIndexToNativeHashtable", function(decoded) {
				mresolve(decoded.data);
			}, loaded_index);
		});
	}
		

	Licitracker.CSVDB.__destruct = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "__destruct", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.printNamedDec = async function(header, dec){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "printNamedDec", function(decoded) {
				mresolve(decoded.data);
			}, header, dec);
		});
	}
		

	Licitracker.CSVDB.checkConvenioMarco = async function(dec, dec_headers_assoc){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "checkConvenioMarco", function(decoded) {
				mresolve(decoded.data);
			}, dec, dec_headers_assoc);
		});
	}
		

	Licitracker.CSVDB.checkCompraAgil = async function(dec, dec_headers_assoc){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "checkCompraAgil", function(decoded) {
				mresolve(decoded.data);
			}, dec, dec_headers_assoc);
		});
	}
		

	Licitracker.CSVDB.checkLicitacion = async function(dec, dec_headers_assoc){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "checkLicitacion", function(decoded) {
				mresolve(decoded.data);
			}, dec, dec_headers_assoc);
		});
	}
		

	Licitracker.CSVDB.caAnalysisHeaders_default_preview_headers = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "caAnalysisHeaders_default_preview_headers", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.caAnalysisHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "caAnalysisHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.ocAnalysisHeaders_default_preview_headers = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "ocAnalysisHeaders_default_preview_headers", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.ocAnalysisHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "ocAnalysisHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.licAnalysisHeaders_default_preview_headers = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "licAnalysisHeaders_default_preview_headers", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.licAnalysisHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "licAnalysisHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.analysisHeaders = async function(data_type = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "analysisHeaders", function(decoded) {
				mresolve(decoded.data);
			}, data_type);
		});
	}
		

	Licitracker.CSVDB.headersIndexAssoc = async function(headers){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "headersIndexAssoc", function(decoded) {
				mresolve(decoded.data);
			}, headers);
		});
	}
		

	Licitracker.CSVDB.headersIndexAssocNoRename = async function(headers){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "headersIndexAssocNoRename", function(decoded) {
				mresolve(decoded.data);
			}, headers);
		});
	}
		

	Licitracker.CSVDB.getEntriesAssocHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getEntriesAssocHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getReversedAnalysisHeaders_static = async function(dt){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getReversedAnalysisHeaders_static", function(decoded) {
				mresolve(decoded.data);
			}, dt);
		});
	}
		

	Licitracker.CSVDB.getReversedAnalysisHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getReversedAnalysisHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.getAnalysisHeaders = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "getAnalysisHeaders", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.CSVDB.asNumber = async function(val){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "asNumber", function(decoded) {
				mresolve(decoded.data);
			}, val);
		});
	}
		

	Licitracker.CSVDB.mergeSchemas = async function(write_files = true){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "mergeSchemas", function(decoded) {
				mresolve(decoded.data);
			}, write_files);
		});
	}
		

	Licitracker.CSVDB.genSchema = async function(csv_filename, encoding = "ISO-8859-1"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "genSchema", function(decoded) {
				mresolve(decoded.data);
			}, csv_filename, encoding);
		});
	}
		

	Licitracker.CSVDB.deepAnalysis = async function(csv_filenames, entry_cb){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "deepAnalysis", function(decoded) {
				mresolve(decoded.data);
			}, csv_filenames, entry_cb);
		});
	}
		

	Licitracker.CSVDB.convertIndex = async function(csv_filename){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "convertIndex", function(decoded) {
				mresolve(decoded.data);
			}, csv_filename);
		});
	}
		

	Licitracker.CSVDB.indexFile = async function(csv_filename){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "indexFile", function(decoded) {
				mresolve(decoded.data);
			}, csv_filename);
		});
	}
		

	Licitracker.CSVDB.generateStaticIndices = async function(dt = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("CSVDB", "generateStaticIndices", function(decoded) {
				mresolve(decoded.data);
			}, dt);
		});
	}
		
Licitracker.FetchProgress = {};

	Licitracker.FetchProgress.initialize = async function(mime_type = "application/octet-stream"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FetchProgress", "initialize", function(decoded) {
				mresolve(decoded.data);
			}, mime_type);
		});
	}
		

	Licitracker.FetchProgress.encode_message = async function(data, message_type = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FetchProgress", "encode_message", function(decoded) {
				mresolve(decoded.data);
			}, data, message_type);
		});
	}
		

	Licitracker.FetchProgress.try_decode_encoded_message = async function(accumulator, debug = false, message_type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FetchProgress", "try_decode_encoded_message", function(decoded) {
				mresolve(decoded.data);
			}, accumulator, debug, message_type);
		});
	}
		

	Licitracker.FetchProgress.try_decode_encoded_message2 = async function(accumulator, debug = false, message_type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FetchProgress", "try_decode_encoded_message2", function(decoded) {
				mresolve(decoded.data);
			}, accumulator, debug, message_type);
		});
	}
		

	Licitracker.FetchProgress.write_encoded_message = async function(data, message_type = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FetchProgress", "write_encoded_message", function(decoded) {
				mresolve(decoded.data);
			}, data, message_type);
		});
	}
		

	Licitracker.FetchProgress.write_raw_message = async function(data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FetchProgress", "write_raw_message", function(decoded) {
				mresolve(decoded.data);
			}, data);
		});
	}
		
Licitracker.KeywordUtil = {};

	Licitracker.KeywordUtil.transliterate = async function(str){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "transliterate", function(decoded) {
				mresolve(decoded.data);
			}, str);
		});
	}
		

	Licitracker.KeywordUtil.transliterate_keywords = async function(keywords){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "transliterate_keywords", function(decoded) {
				mresolve(decoded.data);
			}, keywords);
		});
	}
		

	Licitracker.KeywordUtil.clean_keyword = async function(keyword){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "clean_keyword", function(decoded) {
				mresolve(decoded.data);
			}, keyword);
		});
	}
		

	Licitracker.KeywordUtil.keyword_remove_whitespace = async function(keyword){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "keyword_remove_whitespace", function(decoded) {
				mresolve(decoded.data);
			}, keyword);
		});
	}
		

	Licitracker.KeywordUtil.clean_keywords = async function(keywords){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "clean_keywords", function(decoded) {
				mresolve(decoded.data);
			}, keywords);
		});
	}
		

	Licitracker.KeywordUtil.sort_by_counts = async function(arr){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "sort_by_counts", function(decoded) {
				mresolve(decoded.data);
			}, arr);
		});
	}
		

	Licitracker.KeywordUtil.split_into_words = async function(sentence){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "split_into_words", function(decoded) {
				mresolve(decoded.data);
			}, sentence);
		});
	}
		

	Licitracker.KeywordUtil.grouped_keywords_counts = async function(grouped_kw, total){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "grouped_keywords_counts", function(decoded) {
				mresolve(decoded.data);
			}, grouped_kw, total);
		});
	}
		

	Licitracker.KeywordUtil.keywords_to_grouped_keywords_from_list = async function(keywords, grouping_list){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "keywords_to_grouped_keywords_from_list", function(decoded) {
				mresolve(decoded.data);
			}, keywords, grouping_list);
		});
	}
		

	Licitracker.KeywordUtil.keywords_to_grouped_keywords = async function(keywords, reduce = true, banned_keywords_assoc = []){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "keywords_to_grouped_keywords", function(decoded) {
				mresolve(decoded.data);
			}, keywords, reduce, banned_keywords_assoc);
		});
	}
		

	Licitracker.KeywordUtil.keywords_merge_and_dedupe = async function(kws_arrays){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("KeywordUtil", "keywords_merge_and_dedupe", function(decoded) {
				mresolve(decoded.data);
			}, kws_arrays);
		});
	}
		
Licitracker.RemoteRecord = {};

	Licitracker.RemoteRecord.remoteGetDefs = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("RemoteRecord", "remoteGetDefs", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.RemoteRecord.additionalWhereClauses = async function(op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("RemoteRecord", "additionalWhereClauses", function(decoded) {
				mresolve(decoded.data);
			}, op);
		});
	}
		

	Licitracker.RemoteRecord.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("RemoteRecord", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		

	Licitracker.RemoteRecord.remoteCountRows = async function(search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("RemoteRecord", "remoteCountRows", function(decoded) {
				mresolve(decoded.data);
			}, search_value);
		});
	}
		

	Licitracker.RemoteRecord.remoteGetRange = async function(begin = 0, end = 1, order_by = false, order = false, search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("RemoteRecord", "remoteGetRange", function(decoded) {
				mresolve(decoded.data);
			}, begin, end, order_by, order, search_value);
		});
	}
		
Licitracker.TestRecord = {};

	Licitracker.TestRecord.remoteGetDefs = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestRecord", "remoteGetDefs", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.TestRecord.additionalWhereClauses = async function(op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestRecord", "additionalWhereClauses", function(decoded) {
				mresolve(decoded.data);
			}, op);
		});
	}
		

	Licitracker.TestRecord.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestRecord", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		

	Licitracker.TestRecord.remoteCountRows = async function(search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestRecord", "remoteCountRows", function(decoded) {
				mresolve(decoded.data);
			}, search_value);
		});
	}
		

	Licitracker.TestRecord.remoteGetRange = async function(begin = 0, end = 1, order_by = false, order = false, search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestRecord", "remoteGetRange", function(decoded) {
				mresolve(decoded.data);
			}, begin, end, order_by, order, search_value);
		});
	}
		
Licitracker.TestClassRecurse = {};

	Licitracker.TestClassRecurse.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.TestClassRecurse.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.TestClassRecurse.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.TestClassRecurse.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.TestClassRecurse.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.TestClassRecurse.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.TestClassRecurse.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.TestClassRecurse.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClassRecurse", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.TestClass = {};

	Licitracker.TestClass.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.TestClass.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.TestClass.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.TestClass.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.TestClass.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.TestClass.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.TestClass.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.TestClass.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TestClass", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.Licitracker = {};

	Licitracker.Licitracker.getRegiones = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "getRegiones", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Licitracker.legacy_regiones = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "legacy_regiones", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Licitracker.check_lic_region = async function(dec, region){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "check_lic_region", function(decoded) {
				mresolve(decoded.data);
			}, dec, region);
		});
	}
		

	Licitracker.Licitracker.check_ca_region = async function(dec, region){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "check_ca_region", function(decoded) {
				mresolve(decoded.data);
			}, dec, region);
		});
	}
		

	Licitracker.Licitracker.check_coverage = async function(keyed_array, values){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "check_coverage", function(decoded) {
				mresolve(decoded.data);
			}, keyed_array, values);
		});
	}
		

	Licitracker.Licitracker.dropdown_test = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "dropdown_test", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Licitracker.kw_to_recombinant_kw = async function(input, quote_kw = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "kw_to_recombinant_kw", function(decoded) {
				mresolve(decoded.data);
			}, input, quote_kw);
		});
	}
		

	Licitracker.Licitracker.keywords_split_and_deduplicate = async function(keywords){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "keywords_split_and_deduplicate", function(decoded) {
				mresolve(decoded.data);
			}, keywords);
		});
	}
		

	Licitracker.Licitracker.transliterate_array = async function(arr, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "transliterate_array", function(decoded) {
				mresolve(decoded.data);
			}, arr, tcache);
		});
	}
		

	Licitracker.Licitracker.transliterate_array_keys = async function(arr, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "transliterate_array_keys", function(decoded) {
				mresolve(decoded.data);
			}, arr, tcache);
		});
	}
		

	Licitracker.Licitracker.transliterate = async function(word, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "transliterate", function(decoded) {
				mresolve(decoded.data);
			}, word, tcache);
		});
	}
		

	Licitracker.Licitracker.transliterated_match = async function(haystack, needle, underline = false, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "transliterated_match", function(decoded) {
				mresolve(decoded.data);
			}, haystack, needle, underline, tcache);
		});
	}
		

	Licitracker.Licitracker.magic = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "magic", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Licitracker.legacy_query_to_unnumbered_keywords = async function(query){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "legacy_query_to_unnumbered_keywords", function(decoded) {
				mresolve(decoded.data);
			}, query);
		});
	}
		

	Licitracker.Licitracker.legacy_keywords_to_query = async function(unnumbered_keywords){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "legacy_keywords_to_query", function(decoded) {
				mresolve(decoded.data);
			}, unnumbered_keywords);
		});
	}
		

	Licitracker.Licitracker.keywords_to_grouped_keywords = async function(keywords, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "keywords_to_grouped_keywords", function(decoded) {
				mresolve(decoded.data);
			}, keywords, tcache);
		});
	}
		

	Licitracker.Licitracker.human_filesize = async function(bytes, dec = 2){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "human_filesize", function(decoded) {
				mresolve(decoded.data);
			}, bytes, dec);
		});
	}
		

	Licitracker.Licitracker.dir_size = async function(directory, recursive = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "dir_size", function(decoded) {
				mresolve(decoded.data);
			}, directory, recursive);
		});
	}
		

	Licitracker.Licitracker.dir_stats = async function(directory, recursive = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "dir_stats", function(decoded) {
				mresolve(decoded.data);
			}, directory, recursive);
		});
	}
		

	Licitracker.Licitracker.dir_stats_text = async function(directory, recursive = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "dir_stats_text", function(decoded) {
				mresolve(decoded.data);
			}, directory, recursive);
		});
	}
		

	Licitracker.Licitracker.get_service_status = async function(no_html = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker", "get_service_status", function(decoded) {
				mresolve(decoded.data);
			}, no_html);
		});
	}
		
Licitracker.Process = {};

	Licitracker.Process.DefaultEncodedOutputHandler = async function(stdout_data, stderr_data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Process", "DefaultEncodedOutputHandler", function(decoded) {
				mresolve(decoded.data);
			}, stdout_data, stderr_data);
		});
	}
		

	Licitracker.Process.InstanceAsProcess = async function(stdin_params, dir, file, stdin_parameters = false, output_handler = "Gliro\Valorito\App\Process::DefaultEncodedOutputHandler"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Process", "InstanceAsProcess", function(decoded) {
				mresolve(decoded.data);
			}, stdin_params, dir, file, stdin_parameters, output_handler);
		});
	}
		

	Licitracker.Process.getInvocationInfo = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Process", "getInvocationInfo", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Process.write = async function(text, output_type = 0){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Process", "write", function(decoded) {
				mresolve(decoded.data);
			}, text, output_type);
		});
	}
		

	Licitracker.Process.spawn2 = async function(command, cwd, env, retcode, pipefunction = false, stdin_data = false, raw = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Process", "spawn2", function(decoded) {
				mresolve(decoded.data);
			}, command, cwd, env, retcode, pipefunction, stdin_data, raw);
		});
	}
		

	Licitracker.Process.spawn = async function(command, cwd, env, retcode, serdata = false, pipefunction = false, stdin_data = false, on_shutdown = false, ignore_abort = true){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Process", "spawn", function(decoded) {
				mresolve(decoded.data);
			}, command, cwd, env, retcode, serdata, pipefunction, stdin_data, on_shutdown, ignore_abort);
		});
	}
		
Licitracker.LicitrackerUnitConfigType = {};

	Licitracker.LicitrackerUnitConfigType.cases = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigType", "cases", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitConfigType.from = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigType", "from", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.LicitrackerUnitConfigType.tryFrom = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigType", "tryFrom", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		
Licitracker.LicitrackerUnitTrackedEntry = {};

	Licitracker.LicitrackerUnitTrackedEntry.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitTrackedEntry", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerUnitTrackedEntry.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitTrackedEntry", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerUnitTrackedEntry.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitTrackedEntry", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerUnitTrackedEntry.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitTrackedEntry", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitTrackedEntry.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitTrackedEntry", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.LicitrackerUnitTrackedEntry.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitTrackedEntry", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitTrackedEntry.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitTrackedEntry", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerUnitReflectionWrapper = {};

	Licitracker.LicitrackerUnitReflectionWrapper.load_unit_config_v2 = async function(unit_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitReflectionWrapper", "load_unit_config_v2", function(decoded) {
				mresolve(decoded.data);
			}, unit_name);
		});
	}
		

	Licitracker.LicitrackerUnitReflectionWrapper.load_unit_config_by_id_v2 = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitReflectionWrapper", "load_unit_config_by_id_v2", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.LicitrackerUnitReflectionWrapper.dropdown_units = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitReflectionWrapper", "dropdown_units", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitReflectionWrapper.validate_unit_config_v2 = async function(unit_id, config){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitReflectionWrapper", "validate_unit_config_v2", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, config);
		});
	}
		

	Licitracker.LicitrackerUnitReflectionWrapper.upsert_licitracker_user = async function(user_id, username = false, password = false, confirmation = 0){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitReflectionWrapper", "upsert_licitracker_user", function(decoded) {
				mresolve(decoded.data);
			}, user_id, username, password, confirmation);
		});
	}
		

	Licitracker.LicitrackerUnitReflectionWrapper.save_unit_config_v2 = async function(unit_id, config){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitReflectionWrapper", "save_unit_config_v2", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, config);
		});
	}
		
Licitracker.LicitrackerUnitStruct = {};

	Licitracker.LicitrackerUnitStruct.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitStruct", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerUnitStruct.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitStruct", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerUnitStruct.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitStruct", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerUnitStruct.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitStruct", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitStruct.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitStruct", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.LicitrackerUnitStruct.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitStruct", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitStruct.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitStruct", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerUnitDisplayTable = {};

	Licitracker.LicitrackerUnitDisplayTable.remoteGetDefs = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitDisplayTable", "remoteGetDefs", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitDisplayTable.additionalWhereClauses = async function(op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitDisplayTable", "additionalWhereClauses", function(decoded) {
				mresolve(decoded.data);
			}, op);
		});
	}
		

	Licitracker.LicitrackerUnitDisplayTable.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitDisplayTable", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		

	Licitracker.LicitrackerUnitDisplayTable.remoteCountRows = async function(search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitDisplayTable", "remoteCountRows", function(decoded) {
				mresolve(decoded.data);
			}, search_value);
		});
	}
		

	Licitracker.LicitrackerUnitDisplayTable.remoteGetRange = async function(begin = 0, end = 1, order_by = false, order = false, search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitDisplayTable", "remoteGetRange", function(decoded) {
				mresolve(decoded.data);
			}, begin, end, order_by, order, search_value);
		});
	}
		
Licitracker.LicitrackerUnit = {};

	Licitracker.LicitrackerUnit.getUnitById = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getUnitById", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.LicitrackerUnit.getUnitByAuthToken = async function(auth_token){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getUnitByAuthToken", function(decoded) {
				mresolve(decoded.data);
			}, auth_token);
		});
	}
		

	Licitracker.LicitrackerUnit.getUnitByUserId = async function(user_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getUnitByUserId", function(decoded) {
				mresolve(decoded.data);
			}, user_id);
		});
	}
		

	Licitracker.LicitrackerUnit.deleteUnit = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "deleteUnit", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.LicitrackerUnit.createNewUnit = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "createNewUnit", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.listAllUnits = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "listAllUnits", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.getAllUnits = async function(enabled_only = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getAllUnits", function(decoded) {
				mresolve(decoded.data);
			}, enabled_only);
		});
	}
		

	Licitracker.LicitrackerUnit.setPlatformConfigClass = async function(unit_id, pc){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setPlatformConfigClass", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, pc);
		});
	}
		

	Licitracker.LicitrackerUnit.getPlatformConfigClass = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getPlatformConfigClass", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.LicitrackerUnit.setPlatformConfig = async function(unit_id, platform_config){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setPlatformConfig", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, platform_config);
		});
	}
		

	Licitracker.LicitrackerUnit.getPlatformConfig = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getPlatformConfig", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.LicitrackerUnit.getAllEnabledUnits = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getAllEnabledUnits", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.getAllEnabledConfigs = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getAllEnabledConfigs", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.getPrecacheConfigKeywords = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getPrecacheConfigKeywords", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.getAllEnabledSchedules = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getAllEnabledSchedules", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.loadUnit = async function(unit_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "loadUnit", function(decoded) {
				mresolve(decoded.data);
			}, unit_name);
		});
	}
		

	Licitracker.LicitrackerUnit.loadUnitByID = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "loadUnitByID", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.LicitrackerUnit.saveUnit = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "saveUnit", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.createUnit = async function(unit_name, rut = ""){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "createUnit", function(decoded) {
				mresolve(decoded.data);
			}, unit_name, rut);
		});
	}
		

	Licitracker.LicitrackerUnit.getUnitConfig = async function(unit_id, config_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getUnitConfig", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, config_name);
		});
	}
		

	Licitracker.LicitrackerUnit.setUnitConfig = async function(unit_id, config_name, config){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setUnitConfig", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, config_name, config);
		});
	}
		

	Licitracker.LicitrackerUnit.getConfig = async function(config_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getConfig", function(decoded) {
				mresolve(decoded.data);
			}, config_name);
		});
	}
		

	Licitracker.LicitrackerUnit.setConfig = async function(config_name, config){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setConfig", function(decoded) {
				mresolve(decoded.data);
			}, config_name, config);
		});
	}
		

	Licitracker.LicitrackerUnit.setEnabled = async function(enabled){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setEnabled", function(decoded) {
				mresolve(decoded.data);
			}, enabled);
		});
	}
		

	Licitracker.LicitrackerUnit.getEnabled = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getEnabled", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.setSchedule = async function(sched_type, new_schedule){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setSchedule", function(decoded) {
				mresolve(decoded.data);
			}, sched_type, new_schedule);
		});
	}
		

	Licitracker.LicitrackerUnit.getSchedule = async function(sched_type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getSchedule", function(decoded) {
				mresolve(decoded.data);
			}, sched_type);
		});
	}
		

	Licitracker.LicitrackerUnit.setServiceEnabled = async function(ct, enabled){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setServiceEnabled", function(decoded) {
				mresolve(decoded.data);
			}, ct, enabled);
		});
	}
		

	Licitracker.LicitrackerUnit.getServiceEnabled = async function(ct){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getServiceEnabled", function(decoded) {
				mresolve(decoded.data);
			}, ct);
		});
	}
		

	Licitracker.LicitrackerUnit.getServiceEnabledName = async function(sched_type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getServiceEnabledName", function(decoded) {
				mresolve(decoded.data);
			}, sched_type);
		});
	}
		

	Licitracker.LicitrackerUnit.getSchedConfigName = async function(sched_type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getSchedConfigName", function(decoded) {
				mresolve(decoded.data);
			}, sched_type);
		});
	}
		

	Licitracker.LicitrackerUnit.getSchedConfigLastRunName = async function(sched_type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getSchedConfigLastRunName", function(decoded) {
				mresolve(decoded.data);
			}, sched_type);
		});
	}
		

	Licitracker.LicitrackerUnit.getAllSchedules = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getAllSchedules", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.isset_get_default = async function(ar, idx, _def){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "isset_get_default", function(decoded) {
				mresolve(decoded.data);
			}, ar, idx, _def);
		});
	}
		

	Licitracker.LicitrackerUnit.getAllScheduledToRun = async function(schedules){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getAllScheduledToRun", function(decoded) {
				mresolve(decoded.data);
			}, schedules);
		});
	}
		

	Licitracker.LicitrackerUnit.migrateLegacyParamsToConfig = async function(legacy_parameters){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "migrateLegacyParamsToConfig", function(decoded) {
				mresolve(decoded.data);
			}, legacy_parameters);
		});
	}
		

	Licitracker.LicitrackerUnit.setFullConfig = async function(full_config){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "setFullConfig", function(decoded) {
				mresolve(decoded.data);
			}, full_config);
		});
	}
		

	Licitracker.LicitrackerUnit.getFullConfig = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "getFullConfig", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnit.stringTimeToWeight = async function(stime){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "stringTimeToWeight", function(decoded) {
				mresolve(decoded.data);
			}, stime);
		});
	}
		

	Licitracker.LicitrackerUnit.timeToWeight = async function(hour, minute){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "timeToWeight", function(decoded) {
				mresolve(decoded.data);
			}, hour, minute);
		});
	}
		

	Licitracker.LicitrackerUnit.schedEntryToWeight = async function(day, hour, minute){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "schedEntryToWeight", function(decoded) {
				mresolve(decoded.data);
			}, day, hour, minute);
		});
	}
		

	Licitracker.LicitrackerUnit.appendEncodedSched = async function(ar, day, time){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "appendEncodedSched", function(decoded) {
				mresolve(decoded.data);
			}, ar, day, time);
		});
	}
		

	Licitracker.LicitrackerUnit.encodeFullSchedule = async function(schedule){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "encodeFullSchedule", function(decoded) {
				mresolve(decoded.data);
			}, schedule);
		});
	}
		

	Licitracker.LicitrackerUnit.decodeFullSchedule = async function(enc){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "decodeFullSchedule", function(decoded) {
				mresolve(decoded.data);
			}, enc);
		});
	}
		

	Licitracker.LicitrackerUnit.scheduleGetNext = async function(t, schedule, last_run = false, return_dow = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "scheduleGetNext", function(decoded) {
				mresolve(decoded.data);
			}, t, schedule, last_run, return_dow);
		});
	}
		

	Licitracker.LicitrackerUnit.scheduleSpread = async function(sched){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "scheduleSpread", function(decoded) {
				mresolve(decoded.data);
			}, sched);
		});
	}
		

	Licitracker.LicitrackerUnit.schedulePeekForward = async function(t, sched, amount){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "schedulePeekForward", function(decoded) {
				mresolve(decoded.data);
			}, t, sched, amount);
		});
	}
		

	Licitracker.LicitrackerUnit.schedulePeekBackwards = async function(t, sched, amount){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "schedulePeekBackwards", function(decoded) {
				mresolve(decoded.data);
			}, t, sched, amount);
		});
	}
		

	Licitracker.LicitrackerUnit.test = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnit", "test", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerUnitConfigSectionv2 = {};

	Licitracker.LicitrackerUnitConfigSectionv2.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.LicitrackerUnitConfigSectionv2.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.LicitrackerUnitConfigSectionv2.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerUnitConfigSectionv2.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.LicitrackerUnitConfigSectionv2.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.LicitrackerUnitConfigSectionv2.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.LicitrackerUnitConfigSectionv2.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.LicitrackerUnitConfigSectionv2.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSectionv2", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.LicitrackerUnitConfigv2 = {};
Licitracker.LicitrackerUnitConfigv2.schema = {
    "fields": {
        "id": {
            "desc": "ID Config",
            "hint": "ID de la configuracion",
            "hidden": true,
            "type": "int",
            "name": "id",
            "default": 0
        },
        "user_id": {
            "type": "int",
            "name": "user_id",
            "desc": "user_id",
            "default": 0
        },
        "name": {
            "desc": "Nombre unidad",
            "hint": "Nombre de la unidad",
            "type": "string",
            "name": "name",
            "default": ""
        },
        "rut": {
            "desc": "Rut unidad",
            "hint": "RUT de la unidad",
            "type": "string",
            "name": "rut",
            "default": ""
        },
        "magic": {
            "type": "bool",
            "name": "magic",
            "desc": "magic",
            "default": true
        },
        "enabled": {
            "type": "bool",
            "name": "enabled",
            "desc": "enabled",
            "default": false
        }
    },
    "display_name": "Configuracion de unidad"
};

	Licitracker.LicitrackerUnitConfigv2.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.LicitrackerUnitConfigv2.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.LicitrackerUnitConfigv2.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerUnitConfigv2.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.LicitrackerUnitConfigv2.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.LicitrackerUnitConfigv2.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.LicitrackerUnitConfigv2.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.LicitrackerUnitConfigv2.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigv2", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.LicitrackerUnitPlatformConfig = {};

	Licitracker.LicitrackerUnitPlatformConfig.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitPlatformConfig", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerUnitPlatformConfig.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitPlatformConfig", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerUnitPlatformConfig.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitPlatformConfig", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerUnitPlatformConfig.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitPlatformConfig", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitPlatformConfig.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitPlatformConfig", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.LicitrackerUnitPlatformConfig.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitPlatformConfig", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitPlatformConfig.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitPlatformConfig", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerUnitConfigSection = {};

	Licitracker.LicitrackerUnitConfigSection.getDefaults = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSection", "getDefaults", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitConfigSection.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSection", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitConfigSection.from_object_vars = async function(object_vars, validation_result){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfigSection", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars, validation_result);
		});
	}
		
Licitracker.LicitrackerUnitConfig = {};

	Licitracker.LicitrackerUnitConfig.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfig", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerUnitConfig.from_object_vars = async function(object_vars, validation_results){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerUnitConfig", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars, validation_results);
		});
	}
		
Licitracker.LicitrackerUnitLegacyConfig = {};
Licitracker.LicitrackerQueueReflectionWrapper = {};

	Licitracker.LicitrackerQueueReflectionWrapper.getQueueSlice = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueReflectionWrapper", "getQueueSlice", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerTaskLogger = {};

	Licitracker.LicitrackerTaskLogger.log = async function(data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerTaskLogger", "log", function(decoded) {
				mresolve(decoded.data);
			}, data);
		});
	}
		

	Licitracker.LicitrackerTaskLogger.close = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerTaskLogger", "close", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerQueueTask = {};

	Licitracker.LicitrackerQueueTask.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTask", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueTask.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTask", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueTask.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTask", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerQueueTask.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTask", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTask.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTask", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.LicitrackerQueueTask.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTask", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTask.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTask", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerQueueTaskInfo = {};

	Licitracker.LicitrackerQueueTaskInfo.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskInfo", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueTaskInfo.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskInfo", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueTaskInfo.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskInfo", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerQueueTaskInfo.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskInfo", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTaskInfo.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskInfo", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.LicitrackerQueueTaskInfo.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskInfo", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTaskInfo.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskInfo", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerQueueSearchTaskTemplateParameters = {};

	Licitracker.LicitrackerQueueSearchTaskTemplateParameters.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskTemplateParameters", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskTemplateParameters.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskTemplateParameters", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskTemplateParameters.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskTemplateParameters", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskTemplateParameters.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskTemplateParameters", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskTemplateParameters.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskTemplateParameters", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskTemplateParameters.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskTemplateParameters", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskTemplateParameters.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskTemplateParameters", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerQueueSearchTaskOutput = {};

	Licitracker.LicitrackerQueueSearchTaskOutput.get_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskOutput", "get_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskOutput.get_remote_defs = async function(called_class = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskOutput", "get_remote_defs", function(decoded) {
				mresolve(decoded.data);
			}, called_class);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskOutput.get_schema = async function(called_class = false, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskOutput", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskOutput.to_object_vars = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskOutput", "to_object_vars", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskOutput.from_object_vars = async function(object_vars){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskOutput", "from_object_vars", function(decoded) {
				mresolve(decoded.data);
			}, object_vars);
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskOutput.serialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskOutput", "serialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueSearchTaskOutput.deserialize = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueSearchTaskOutput", "deserialize", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.LicitrackerQueueTaskDefinition = {};

	Licitracker.LicitrackerQueueTaskDefinition.__constructor = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskDefinition", "__constructor", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTaskDefinition.getAllUserDefinedTasks = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskDefinition", "getAllUserDefinedTasks", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTaskDefinition.getAllDefinedTasks = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskDefinition", "getAllDefinedTasks", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTaskDefinition.getAllDefinedTasksSqlCase = async function(what){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTaskDefinition", "getAllDefinedTasksSqlCase", function(decoded) {
				mresolve(decoded.data);
			}, what);
		});
	}
		
Licitracker.LicitrackerQueue = {};

	Licitracker.LicitrackerQueue.nuke = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "nuke", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueue.createDirIfNotExists = async function(directory){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "createDirIfNotExists", function(decoded) {
				mresolve(decoded.data);
			}, directory);
		});
	}
		

	Licitracker.LicitrackerQueue.getUnitTasksDir = async function(unit_id, create = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getUnitTasksDir", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, create);
		});
	}
		

	Licitracker.LicitrackerQueue.getUnitIdByName = async function(unit_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getUnitIdByName", function(decoded) {
				mresolve(decoded.data);
			}, unit_name);
		});
	}
		

	Licitracker.LicitrackerQueue.getUnitOutput = async function(unit_id, task_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getUnitOutput", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, task_id);
		});
	}
		

	Licitracker.LicitrackerQueue.renderSearchTaskOutputTemplate = async function(task_output, error_output){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "renderSearchTaskOutputTemplate", function(decoded) {
				mresolve(decoded.data);
			}, task_output, error_output);
		});
	}
		

	Licitracker.LicitrackerQueue.saveParametersByHash = async function(unit_id, parameters, hash){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "saveParametersByHash", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, parameters, hash);
		});
	}
		

	Licitracker.LicitrackerQueue.loadParametersByHash = async function(unit_id, hash){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "loadParametersByHash", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, hash);
		});
	}
		

	Licitracker.LicitrackerQueue.getUnitTasksSlice = async function(unit_id, _begin = 0, _end = 10){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getUnitTasksSlice", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, _begin, _end);
		});
	}
		

	Licitracker.LicitrackerQueue.enqueueTask = async function(unit_id, internal_task_id, max_failures = 1, parameters = false, params_hash){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "enqueueTask", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, internal_task_id, max_failures, parameters, params_hash);
		});
	}
		

	Licitracker.LicitrackerQueue.getUnitDataDir = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getUnitDataDir", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.LicitrackerQueue.getUnitLogFile = async function(unit_id, task_id, debug = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getUnitLogFile", function(decoded) {
				mresolve(decoded.data);
			}, unit_id, task_id, debug);
		});
	}
		

	Licitracker.LicitrackerQueue.getFinishedTaskData = async function(task_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getFinishedTaskData", function(decoded) {
				mresolve(decoded.data);
			}, task_id);
		});
	}
		

	Licitracker.LicitrackerQueue.getFinishedTaskDataWithOuput = async function(task_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getFinishedTaskDataWithOuput", function(decoded) {
				mresolve(decoded.data);
			}, task_id);
		});
	}
		

	Licitracker.LicitrackerQueue.getQueueTask = async function(task_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getQueueTask", function(decoded) {
				mresolve(decoded.data);
			}, task_id);
		});
	}
		

	Licitracker.LicitrackerQueue.getQueueCount = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getQueueCount", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueue.getQueueSlice = async function(_from = 0, _to = 10){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getQueueSlice", function(decoded) {
				mresolve(decoded.data);
			}, _from, _to);
		});
	}
		

	Licitracker.LicitrackerQueue.getNextInQueue = async function(limit = 1, set_as_started = false, reverse_order = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "getNextInQueue", function(decoded) {
				mresolve(decoded.data);
			}, limit, set_as_started, reverse_order);
		});
	}
		

	Licitracker.LicitrackerQueue.changeTaskState = async function(task_id, new_state, failures = 0){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "changeTaskState", function(decoded) {
				mresolve(decoded.data);
			}, task_id, new_state, failures);
		});
	}
		

	Licitracker.LicitrackerQueue.runTask = async function(task, task_outputs, override_parameters = false, write_logs = false, quiet = false, proxy_id = "localhost", extra_params = []){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueue", "runTask", function(decoded) {
				mresolve(decoded.data);
			}, task, task_outputs, override_parameters, write_logs, quiet, proxy_id, extra_params);
		});
	}
		
Licitracker.LicitrackerQueueTableView = {};

	Licitracker.LicitrackerQueueTableView.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTableView", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		

	Licitracker.LicitrackerQueueTableView.remoteCountRows = async function(search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTableView", "remoteCountRows", function(decoded) {
				mresolve(decoded.data);
			}, search_value);
		});
	}
		

	Licitracker.LicitrackerQueueTableView.remoteGetRange = async function(begin = 0, end = 1, order_by = false, order = false, search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTableView", "remoteGetRange", function(decoded) {
				mresolve(decoded.data);
			}, begin, end, order_by, order, search_value);
		});
	}
		

	Licitracker.LicitrackerQueueTableView.remoteGetTaskData = async function(task_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTableView", "remoteGetTaskData", function(decoded) {
				mresolve(decoded.data);
			}, task_id);
		});
	}
		

	Licitracker.LicitrackerQueueTableView.remoteGetDefs = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTableView", "remoteGetDefs", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitrackerQueueTableView.additionalWhereClauses = async function(op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("LicitrackerQueueTableView", "additionalWhereClauses", function(decoded) {
				mresolve(decoded.data);
			}, op);
		});
	}
		
Licitracker.ReflectionUtil = {};

	Licitracker.ReflectionUtil.getN8nWebhooks = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "getN8nWebhooks", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ReflectionUtil.toLiteral = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "toLiteral", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.ReflectionUtil.toPythonLiteral = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "toPythonLiteral", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.ReflectionUtil.generatePythonMethodSignature = async function(super_name, object_name, method_name, method_def, class_prefix = ""){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "generatePythonMethodSignature", function(decoded) {
				mresolve(decoded.data);
			}, super_name, object_name, method_name, method_def, class_prefix);
		});
	}
		

	Licitracker.ReflectionUtil.generateJSMethodSignature = async function(super_name, object_name, method_name, method_def, class_prefix = ""){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "generateJSMethodSignature", function(decoded) {
				mresolve(decoded.data);
			}, super_name, object_name, method_name, method_def, class_prefix);
		});
	}
		

	Licitracker.ReflectionUtil.generateJSHeader = async function(super_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "generateJSHeader", function(decoded) {
				mresolve(decoded.data);
			}, super_name);
		});
	}
		

	Licitracker.ReflectionUtil.generatePythonHeader = async function(super_name){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "generatePythonHeader", function(decoded) {
				mresolve(decoded.data);
			}, super_name);
		});
	}
		

	Licitracker.ReflectionUtil.generatePythonWrappers = async function(super_name, class_def, class_prefix = ""){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "generatePythonWrappers", function(decoded) {
				mresolve(decoded.data);
			}, super_name, class_def, class_prefix);
		});
	}
		

	Licitracker.ReflectionUtil.generateJSWrappers = async function(super_name, class_def, class_prefix = ""){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "generateJSWrappers", function(decoded) {
				mresolve(decoded.data);
			}, super_name, class_def, class_prefix);
		});
	}
		

	Licitracker.ReflectionUtil.getClassDefinition = async function(class_name, working_namespace = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "getClassDefinition", function(decoded) {
				mresolve(decoded.data);
			}, class_name, working_namespace);
		});
	}
		

	Licitracker.ReflectionUtil.getLoadedClasses = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "getLoadedClasses", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ReflectionUtil.getLoadedNamespaceClasses = async function(namespace){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionUtil", "getLoadedNamespaceClasses", function(decoded) {
				mresolve(decoded.data);
			}, namespace);
		});
	}
		
Licitracker.WebDecoder = {};

	Licitracker.WebDecoder.chrome_headers = async function(cookiestring){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "chrome_headers", function(decoded) {
				mresolve(decoded.data);
			}, cookiestring);
		});
	}
		

	Licitracker.WebDecoder.setCurlProxy = async function(curl){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "setCurlProxy", function(decoded) {
				mresolve(decoded.data);
			}, curl);
		});
	}
		

	Licitracker.WebDecoder.genericPost = async function(url, cookie, post_data, headers = false, onerror = false, cookiefile = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "genericPost", function(decoded) {
				mresolve(decoded.data);
			}, url, cookie, post_data, headers, onerror, cookiefile);
		});
	}
		

	Licitracker.WebDecoder.static_genericPost = async function(curl, url, cookie, post_data, headers = false, onerror = false, cookiefile = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "static_genericPost", function(decoded) {
				mresolve(decoded.data);
			}, curl, url, cookie, post_data, headers, onerror, cookiefile);
		});
	}
		

	Licitracker.WebDecoder.static_navigate = async function(curl, url, cookiestring, headers = false, retcode = 0, response = "", retheaders = true, cookiefile = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "static_navigate", function(decoded) {
				mresolve(decoded.data);
			}, curl, url, cookiestring, headers, retcode, response, retheaders, cookiefile);
		});
	}
		

	Licitracker.WebDecoder.navigate = async function(url, cookiestring, headers = false, retcode = 0, response = "", retheaders = true, cookiefile = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "navigate", function(decoded) {
				mresolve(decoded.data);
			}, url, cookiestring, headers, retcode, response, retheaders, cookiefile);
		});
	}
		

	Licitracker.WebDecoder.curl_start = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "curl_start", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.WebDecoder.curl_end = async function(curl){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "curl_end", function(decoded) {
				mresolve(decoded.data);
			}, curl);
		});
	}
		

	Licitracker.WebDecoder.getCookie = async function(curl, url){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "getCookie", function(decoded) {
				mresolve(decoded.data);
			}, curl, url);
		});
	}
		

	Licitracker.WebDecoder.HTMLQuery = async function(raw_html, query, sub = false, prependxml = true){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "HTMLQuery", function(decoded) {
				mresolve(decoded.data);
			}, raw_html, query, sub, prependxml);
		});
	}
		

	Licitracker.WebDecoder.genericTableDecoder = async function(raw_html, table_xpath, table_header, table_rows){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "genericTableDecoder", function(decoded) {
				mresolve(decoded.data);
			}, raw_html, table_xpath, table_header, table_rows);
		});
	}
		

	Licitracker.WebDecoder.getChild = async function(node, child_node_name, index){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "getChild", function(decoded) {
				mresolve(decoded.data);
			}, node, child_node_name, index);
		});
	}
		

	Licitracker.WebDecoder.between = async function(value, min, max){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "between", function(decoded) {
				mresolve(decoded.data);
			}, value, min, max);
		});
	}
		

	Licitracker.WebDecoder.contains = async function(value, array){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "contains", function(decoded) {
				mresolve(decoded.data);
			}, value, array);
		});
	}
		

	Licitracker.WebDecoder.function_allowed_char = async function(char){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "function_allowed_char", function(decoded) {
				mresolve(decoded.data);
			}, char);
		});
	}
		

	Licitracker.WebDecoder.unwrap_js_function = async function(jsfunc){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("WebDecoder", "unwrap_js_function", function(decoded) {
				mresolve(decoded.data);
			}, jsfunc);
		});
	}
		
Licitracker.ProxiedMCurl = {};

	Licitracker.ProxiedMCurl.time_ms = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "time_ms", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMCurl.clear = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "clear", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMCurl.__destruct = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "__destruct", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMCurl.reset = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "reset", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMCurl.queueEntry = async function(user_data, event_handler){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "queueEntry", function(decoded) {
				mresolve(decoded.data);
			}, user_data, event_handler);
		});
	}
		

	Licitracker.ProxiedMCurl.getNextQueueEntry = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "getNextQueueEntry", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMCurl.setQueue = async function(queue){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "setQueue", function(decoded) {
				mresolve(decoded.data);
			}, queue);
		});
	}
		

	Licitracker.ProxiedMCurl.set_curl_proxy = async function(curl, proxyurl = "socks://127.0.0.1:11111"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "set_curl_proxy", function(decoded) {
				mresolve(decoded.data);
			}, curl, proxyurl);
		});
	}
		

	Licitracker.ProxiedMCurl.static_http_request_pre_exec = async function(curl, is_post, url, headers, post_data = false, cookie_file = false, retheaders = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "static_http_request_pre_exec", function(decoded) {
				mresolve(decoded.data);
			}, curl, is_post, url, headers, post_data, cookie_file, retheaders);
		});
	}
		

	Licitracker.ProxiedMCurl.static_http_request_post_exec = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "static_http_request_post_exec", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMCurl.exec = async function(reset = true, cancel_threshhold = 1){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "exec", function(decoded) {
				mresolve(decoded.data);
			}, reset, cancel_threshhold);
		});
	}
		

	Licitracker.ProxiedMCurl.test = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "test", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMCurl.genericParallelTask = async function(input, output, task_params = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMCurl", "genericParallelTask", function(decoded) {
				mresolve(decoded.data);
			}, input, output, task_params);
		});
	}
		
Licitracker.ProxiedMCurlGenericTaskParams = {};
Licitracker.ProxiedMLicMagic = {};

	Licitracker.ProxiedMLicMagic.getExtension = async function(filename){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getExtension", function(decoded) {
				mresolve(decoded.data);
			}, filename);
		});
	}
		

	Licitracker.ProxiedMLicMagic.defaultCADetailsCallback = async function(event, data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "defaultCADetailsCallback", function(decoded) {
				mresolve(decoded.data);
			}, event, data);
		});
	}
		

	Licitracker.ProxiedMLicMagic.defaultCASearchCallback = async function(event, data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "defaultCASearchCallback", function(decoded) {
				mresolve(decoded.data);
			}, event, data);
		});
	}
		

	Licitracker.ProxiedMLicMagic.defaultLicDetailsCallback = async function(event, queue_entry, http_code, data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "defaultLicDetailsCallback", function(decoded) {
				mresolve(decoded.data);
			}, event, queue_entry, http_code, data);
		});
	}
		

	Licitracker.ProxiedMLicMagic.defaultLicSearchCallback = async function(event, data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "defaultLicSearchCallback", function(decoded) {
				mresolve(decoded.data);
			}, event, data);
		});
	}
		

	Licitracker.ProxiedMLicMagic.getViewState = async function(response, viewstate){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getViewState", function(decoded) {
				mresolve(decoded.data);
			}, response, viewstate);
		});
	}
		

	Licitracker.ProxiedMLicMagic.getCuadroOfertasHref = async function(response, ret){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getCuadroOfertasHref", function(decoded) {
				mresolve(decoded.data);
			}, response, ret);
		});
	}
		

	Licitracker.ProxiedMLicMagic.stringCapture = async function(subject, begin_str = false, end_str = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "stringCapture", function(decoded) {
				mresolve(decoded.data);
			}, subject, begin_str, end_str);
		});
	}
		

	Licitracker.ProxiedMLicMagic.getAdjuntosDetalleHref = async function(response, ret){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getAdjuntosDetalleHref", function(decoded) {
				mresolve(decoded.data);
			}, response, ret);
		});
	}
		

	Licitracker.ProxiedMLicMagic.getCuadroOfertasDetalleHref = async function(response, ret){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getCuadroOfertasDetalleHref", function(decoded) {
				mresolve(decoded.data);
			}, response, ret);
		});
	}
		

	Licitracker.ProxiedMLicMagic.getAnexoDetalle = async function(response, ret){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getAnexoDetalle", function(decoded) {
				mresolve(decoded.data);
			}, response, ret);
		});
	}
		

	Licitracker.ProxiedMLicMagic.getAdjuntosDetalle = async function(response, ret){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getAdjuntosDetalle", function(decoded) {
				mresolve(decoded.data);
			}, response, ret);
		});
	}
		

	Licitracker.ProxiedMLicMagic.getCuadroOfertasDetalle = async function(response, ret){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "getCuadroOfertasDetalle", function(decoded) {
				mresolve(decoded.data);
			}, response, ret);
		});
	}
		

	Licitracker.ProxiedMLicMagic.validate_ca_id = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "validate_ca_id", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.lic_search_count_pages = async function(response, npages){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "lic_search_count_pages", function(decoded) {
				mresolve(decoded.data);
			}, response, npages);
		});
	}
		

	Licitracker.ProxiedMLicMagic.lic_search_decode_page = async function(response, decoded_page){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "lic_search_decode_page", function(decoded) {
				mresolve(decoded.data);
			}, response, decoded_page);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mCADetailsCotizacion = async function(search_queue_ids, outputs_by_id, use_cache = true, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mCADetailsCotizacion", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_ids, outputs_by_id, use_cache, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mCADetails = async function(search_queue_ids_assoc, search_results, onevent = false, use_cache = true, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mCADetails", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_ids_assoc, search_results, onevent, use_cache, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.defaultOnEvent = async function(event, key, event_data, location){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "defaultOnEvent", function(decoded) {
				mresolve(decoded.data);
			}, event, key, event_data, location);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicAnexoFormulario1 = async function(anexos_data, output, use_cache = true, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicAnexoFormulario1", function(decoded) {
				mresolve(decoded.data);
			}, anexos_data, output, use_cache, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicAdjuntos = async function(search_queue_ids, outputs_by_id, use_cache = true, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicAdjuntos", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_ids, outputs_by_id, use_cache, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicCuadroComparativo = async function(search_queue_ids, output, use_cache = true, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicCuadroComparativo", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_ids, output, use_cache, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicDetails = async function(search_queue_ids, search_results, onevent = false, use_cache = true, npreq = 1, proxy_id = "localhost", force_fallback = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicDetails", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_ids, search_results, onevent, use_cache, npreq, proxy_id, force_fallback);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mCASearchParametersFromWords = async function(search_queue_words, override_params = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mCASearchParametersFromWords", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_words, override_params);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mCASearchP = async function(search_queue_parameters, search_results, onevent = false, use_cache = true, nmaxpages = 1, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mCASearchP", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_parameters, search_results, onevent, use_cache, nmaxpages, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mCASearch = async function(search_queue_words, search_results, onevent = false, use_cache = true, nmaxpages = 1, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mCASearch", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_words, search_results, onevent, use_cache, nmaxpages, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mSearchResultsToIds = async function(search_results){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mSearchResultsToIds", function(decoded) {
				mresolve(decoded.data);
			}, search_results);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mSearchResultsByIdToIds = async function(results_by_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mSearchResultsByIdToIds", function(decoded) {
				mresolve(decoded.data);
			}, results_by_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mCASearchResultsByIdToIds = async function(results_by_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mCASearchResultsByIdToIds", function(decoded) {
				mresolve(decoded.data);
			}, results_by_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mSearchResultsById = async function(search_results){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mSearchResultsById", function(decoded) {
				mresolve(decoded.data);
			}, search_results);
		});
	}
		

	Licitracker.ProxiedMLicMagic.arrayKeepOnlyContaining = async function(arr_fields, arr_target, include_only_keywords, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "arrayKeepOnlyContaining", function(decoded) {
				mresolve(decoded.data);
			}, arr_fields, arr_target, include_only_keywords, tcache);
		});
	}
		

	Licitracker.ProxiedMLicMagic.arrayRemoveEntriesWithEmptyField = async function(field, arr_target){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "arrayRemoveEntriesWithEmptyField", function(decoded) {
				mresolve(decoded.data);
			}, field, arr_target);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mSearchResultKeepOnlyContaining = async function(find_in_fields, search_results_by_id, include_only_keywords, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mSearchResultKeepOnlyContaining", function(decoded) {
				mresolve(decoded.data);
			}, find_in_fields, search_results_by_id, include_only_keywords, tcache);
		});
	}
		

	Licitracker.ProxiedMLicMagic.underlineMatch = async function(haystack, needle, underline = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "underlineMatch", function(decoded) {
				mresolve(decoded.data);
			}, haystack, needle, underline);
		});
	}
		

	Licitracker.ProxiedMLicMagic.arrayMatchAndFilterFields = async function(find_in_fields, array_of_entries, to_match, underline, tcache, filter_fn = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "arrayMatchAndFilterFields", function(decoded) {
				mresolve(decoded.data);
			}, find_in_fields, array_of_entries, to_match, underline, tcache, filter_fn);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mSearchResultRemoveContaining = async function(find_in_fields, search_results_by_id, exclude_keywords, tcache){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mSearchResultRemoveContaining", function(decoded) {
				mresolve(decoded.data);
			}, find_in_fields, search_results_by_id, exclude_keywords, tcache);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mSearchCalculateComplexity = async function(ndetails_to_download, nsearches, pages){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mSearchCalculateComplexity", function(decoded) {
				mresolve(decoded.data);
			}, ndetails_to_download, nsearches, pages);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicSearchResultsToIds = async function(search_results){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicSearchResultsToIds", function(decoded) {
				mresolve(decoded.data);
			}, search_results);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mCASearchResultsToIds = async function(search_results){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mCASearchResultsToIds", function(decoded) {
				mresolve(decoded.data);
			}, search_results);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicSearchParametersFromWords = async function(search_queue_words, other_params = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicSearchParametersFromWords", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_words, other_params);
		});
	}
		

	Licitracker.ProxiedMLicMagic.convertToIdentifier = async function(data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "convertToIdentifier", function(decoded) {
				mresolve(decoded.data);
			}, data);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicSearchP = async function(search_queue_parameters, search_results, onevent = false, use_cache = true, nmaxpages = 1, npreq = 1, proxy_id = "localhost"){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicSearchP", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_parameters, search_results, onevent, use_cache, nmaxpages, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.mLicSearch = async function(search_queue_words, search_results, onevent, use_cache, nmaxpages, npreq, proxy_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "mLicSearch", function(decoded) {
				mresolve(decoded.data);
			}, search_queue_words, search_results, onevent, use_cache, nmaxpages, npreq, proxy_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.CAUrl = async function(ca_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "CAUrl", function(decoded) {
				mresolve(decoded.data);
			}, ca_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.LICUrl = async function(lic_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "LICUrl", function(decoded) {
				mresolve(decoded.data);
			}, lic_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.LICMonto = async function(lic_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "LICMonto", function(decoded) {
				mresolve(decoded.data);
			}, lic_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.licUnitPlural = async function(name, count){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "licUnitPlural", function(decoded) {
				mresolve(decoded.data);
			}, name, count);
		});
	}
		

	Licitracker.ProxiedMLicMagic.currencyDecimalsInverse = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "currencyDecimalsInverse", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.ProxiedMLicMagic.currencyDecimals = async function(value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "currencyDecimals", function(decoded) {
				mresolve(decoded.data);
			}, value);
		});
	}
		

	Licitracker.ProxiedMLicMagic.licFallbackAPIBase = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "licFallbackAPIBase", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ProxiedMLicMagic.convertHtmlDateToIso = async function(node_value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "convertHtmlDateToIso", function(decoded) {
				mresolve(decoded.data);
			}, node_value);
		});
	}
		

	Licitracker.ProxiedMLicMagic.recursiveFillJSONAPIBaseWithSelectors = async function(context, api_base_assoc, xpath, body){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "recursiveFillJSONAPIBaseWithSelectors", function(decoded) {
				mresolve(decoded.data);
			}, context, api_base_assoc, xpath, body);
		});
	}
		

	Licitracker.ProxiedMLicMagic.licPopulateDetailsWithSearchData = async function(search_details_by_id, search_results_by_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "licPopulateDetailsWithSearchData", function(decoded) {
				mresolve(decoded.data);
			}, search_details_by_id, search_results_by_id);
		});
	}
		

	Licitracker.ProxiedMLicMagic.licDetailsFallbackPopulatePreviewAwardAct = async function(award_act_html, api_base_assoc){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "licDetailsFallbackPopulatePreviewAwardAct", function(decoded) {
				mresolve(decoded.data);
			}, award_act_html, api_base_assoc);
		});
	}
		

	Licitracker.ProxiedMLicMagic.licDetailsFallbackPopulateDetailsAcquisitions = async function(details_html, qs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ProxiedMLicMagic", "licDetailsFallbackPopulateDetailsAcquisitions", function(decoded) {
				mresolve(decoded.data);
			}, details_html, qs);
		});
	}
		
Licitracker.FileCache = {};

	Licitracker.FileCache.read_data = async function(identifier, max_age = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileCache", "read_data", function(decoded) {
				mresolve(decoded.data);
			}, identifier, max_age);
		});
	}
		

	Licitracker.FileCache.write_data = async function(identifier, value){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileCache", "write_data", function(decoded) {
				mresolve(decoded.data);
			}, identifier, value);
		});
	}
		
Licitracker.FileManagerFileData = {};
Licitracker.FileManager = {};

	Licitracker.FileManager.getFullDirectory = async function(domain_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getFullDirectory", function(decoded) {
				mresolve(decoded.data);
			}, domain_id);
		});
	}
		

	Licitracker.FileManager.getFileFullPath = async function(fname){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getFileFullPath", function(decoded) {
				mresolve(decoded.data);
			}, fname);
		});
	}
		

	Licitracker.FileManager.getFSText = async function(fsize){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getFSText", function(decoded) {
				mresolve(decoded.data);
			}, fsize);
		});
	}
		

	Licitracker.FileManager.getFileInfo = async function(fname){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getFileInfo", function(decoded) {
				mresolve(decoded.data);
			}, fname);
		});
	}
		

	Licitracker.FileManager.getDomainUsage = async function(domain_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getDomainUsage", function(decoded) {
				mresolve(decoded.data);
			}, domain_id);
		});
	}
		

	Licitracker.FileManager.getUsage = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getUsage", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.FileManager.filePutContents = async function(fname, contents){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "filePutContents", function(decoded) {
				mresolve(decoded.data);
			}, fname, contents);
		});
	}
		

	Licitracker.FileManager.removeFile = async function(fname){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "removeFile", function(decoded) {
				mresolve(decoded.data);
			}, fname);
		});
	}
		

	Licitracker.FileManager.getFullFilename = async function(domain_id, fname){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getFullFilename", function(decoded) {
				mresolve(decoded.data);
			}, domain_id, fname);
		});
	}
		

	Licitracker.FileManager.updateDBFile = async function(file_id, domain_id, fname = false, owner_id = false, group_id = false, permissions = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "updateDBFile", function(decoded) {
				mresolve(decoded.data);
			}, file_id, domain_id, fname, owner_id, group_id, permissions);
		});
	}
		

	Licitracker.FileManager.createDBFile = async function(domain_id, fname = "", owner_id = 0, group_id = 0, permissions = 0){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "createDBFile", function(decoded) {
				mresolve(decoded.data);
			}, domain_id, fname, owner_id, group_id, permissions);
		});
	}
		

	Licitracker.FileManager.getDBFile = async function(file_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getDBFile", function(decoded) {
				mresolve(decoded.data);
			}, file_id);
		});
	}
		

	Licitracker.FileManager.writeDBFile = async function(contents, file_id, fname = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "writeDBFile", function(decoded) {
				mresolve(decoded.data);
			}, contents, file_id, fname);
		});
	}
		

	Licitracker.FileManager.readDBFile = async function(file_id = 0, domain_id = 0){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "readDBFile", function(decoded) {
				mresolve(decoded.data);
			}, file_id, domain_id);
		});
	}
		

	Licitracker.FileManager.deleteDBFile = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "deleteDBFile", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Licitracker.FileManager.getAllAccessibleFiles = async function(user_id, group_id, domain_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "getAllAccessibleFiles", function(decoded) {
				mresolve(decoded.data);
			}, user_id, group_id, domain_id);
		});
	}
		

	Licitracker.FileManager.test2 = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "test2", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.FileManager.test4 = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "test4", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.FileManager.test = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("FileManager", "test", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Licitracker.TaskFollower = {};

	Licitracker.TaskFollower.subscribe = async function(action, task_id, internal_task_id, identifier, auth_token, info = ""){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TaskFollower", "subscribe", function(decoded) {
				mresolve(decoded.data);
			}, action, task_id, internal_task_id, identifier, auth_token, info);
		});
	}
		

	Licitracker.TaskFollower.getSubStatus = async function(auth_token, id_list){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("TaskFollower", "getSubStatus", function(decoded) {
				mresolve(decoded.data);
			}, auth_token, id_list);
		});
	}
		
Licitracker.Tools = {};

	Licitracker.Tools.time_ms = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "time_ms", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Tools.n8n_call = async function(parameters){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "n8n_call", function(decoded) {
				mresolve(decoded.data);
			}, parameters);
		});
	}
		

	Licitracker.Tools.n8n_read_cache = async function(identifier, max_age = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "n8n_read_cache", function(decoded) {
				mresolve(decoded.data);
			}, identifier, max_age);
		});
	}
		

	Licitracker.Tools.n8n_write_cache = async function(identifier, data){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "n8n_write_cache", function(decoded) {
				mresolve(decoded.data);
			}, identifier, data);
		});
	}
		

	Licitracker.Tools.infoEmpresa = async function(rut){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "infoEmpresa", function(decoded) {
				mresolve(decoded.data);
			}, rut);
		});
	}
		

	Licitracker.Tools.LicAnexos = async function(lic_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "LicAnexos", function(decoded) {
				mresolve(decoded.data);
			}, lic_id);
		});
	}
		

	Licitracker.Tools.LicFetch = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "LicFetch", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Licitracker.Tools.LICSearch = async function(params){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "LICSearch", function(decoded) {
				mresolve(decoded.data);
			}, params);
		});
	}
		

	Licitracker.Tools.CASearch = async function(params){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "CASearch", function(decoded) {
				mresolve(decoded.data);
			}, params);
		});
	}
		

	Licitracker.Tools.CAFetch = async function(id, use_cache = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "CAFetch", function(decoded) {
				mresolve(decoded.data);
			}, id, use_cache);
		});
	}
		

	Licitracker.Tools.CACotFetch = async function(cotizacion_id, use_cache = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "CACotFetch", function(decoded) {
				mresolve(decoded.data);
			}, cotizacion_id, use_cache);
		});
	}
		

	Licitracker.Tools.n8n_generic_curl_post = async function(endpoint, parameters){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Tools", "n8n_generic_curl_post", function(decoded) {
				mresolve(decoded.data);
			}, endpoint, parameters);
		});
	}
		
Licitracker.ReflectionRequest = {};

	Licitracker.ReflectionRequest.default_response = async function(message, status){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionRequest", "default_response", function(decoded) {
				mresolve(decoded.data);
			}, message, status);
		});
	}
		

	Licitracker.ReflectionRequest.typeName = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionRequest", "typeName", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.ReflectionRequest.mapFirstArgToAvailableType = async function(source, method){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionRequest", "mapFirstArgToAvailableType", function(decoded) {
				mresolve(decoded.data);
			}, source, method);
		});
	}
		

	Licitracker.ReflectionRequest.isFirstArgClientResource = async function(method){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionRequest", "isFirstArgClientResource", function(decoded) {
				mresolve(decoded.data);
			}, method);
		});
	}
		

	Licitracker.ReflectionRequest.try_request = async function(request_body = false, using_ws = false, user = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("ReflectionRequest", "try_request", function(decoded) {
				mresolve(decoded.data);
			}, request_body, using_ws, user);
		});
	}
		
Licitracker.Following = {};

	Licitracker.Following.getUnitRows = async function(unit_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "getUnitRows", function(decoded) {
				mresolve(decoded.data);
			}, unit_id);
		});
	}
		

	Licitracker.Following.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.Following.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.Following.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.Following.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.Following.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.Following.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.Following.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.Following.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Following", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.FollowingTableView = {};

	Licitracker.FollowingTableView.additionalWhereClauses = async function(op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\FollowingTableView", "additionalWhereClauses", function(decoded) {
				mresolve(decoded.data);
			}, op);
		});
	}
		

	Licitracker.FollowingTableView.remoteCountRows = async function(search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\FollowingTableView", "remoteCountRows", function(decoded) {
				mresolve(decoded.data);
			}, search_value);
		});
	}
		

	Licitracker.FollowingTableView.remoteGetDefs = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\FollowingTableView", "remoteGetDefs", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.FollowingTableView.remoteGetRange = async function(begin = 0, end = 1, order_by = false, order = false, search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\FollowingTableView", "remoteGetRange", function(decoded) {
				mresolve(decoded.data);
			}, begin, end, order_by, order, search_value);
		});
	}
		

	Licitracker.FollowingTableView.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\FollowingTableView", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		
Licitracker.Clientes = {};
Licitracker.Clientes.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno asociado con el cliente",
            "type": "int",
            "name": "id",
            "default": 0
        },
        "priority": {
            "hidden": false,
            "ro": false,
            "desc": "Prioridad",
            "hint": "Prioridad, numeros mayores tienen preferencia sobre numeros menores",
            "type": "int",
            "name": "priority",
            "default": 0
        },
        "name": {
            "hidden": false,
            "ro": false,
            "desc": "Nombre",
            "hint": "Nombre del cliente",
            "type": "string",
            "name": "name",
            "default": ""
        },
        "rut": {
            "hidden": false,
            "ro": false,
            "desc": "RUT",
            "hint": "RUT del cliente",
            "type": "string",
            "name": "rut",
            "default": ""
        },
        "auth_token": {
            "hidden": false,
            "ro": false,
            "desc": "Token",
            "hint": "Token de autorizaci\u00f3n",
            "type": "string",
            "name": "auth_token",
            "default": ""
        },
        "enabled": {
            "hidden": false,
            "ro": false,
            "desc": "Activar",
            "hint": "Activa y desactiva la cuenta. Esto incluye el login y todas las busquedas",
            "type": "bool",
            "name": "enabled",
            "default": false
        },
        "tasks": {
            "hidden": false,
            "ro": false,
            "type": "string",
            "desc": "Tareas",
            "hint": "Lista de tareas programadas del cliente.",
            "name": "tasks",
            "default": []
        }
    },
    "display_name": "Informaci\u00f3n Cliente"
};

	Licitracker.Clientes.getClientes = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "getClientes", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Clientes.load = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "load", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Licitracker.Clientes.validate = async function(serialized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "validate", function(decoded) {
				mresolve(decoded.data);
			}, serialized);
		});
	}
		

	Licitracker.Clientes.save = async function(serialized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "save", function(decoded) {
				mresolve(decoded.data);
			}, serialized);
		});
	}
		

	Licitracker.Clientes.create = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "create", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.Clientes.delete = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "delete", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Licitracker.Clientes.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.Clientes.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.Clientes.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.Clientes.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.Clientes.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.Clientes.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.Clientes.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.Clientes.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\Clientes", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.ClientesTableView = {};

	Licitracker.ClientesTableView.additionalWhereClauses = async function(op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTableView", "additionalWhereClauses", function(decoded) {
				mresolve(decoded.data);
			}, op);
		});
	}
		

	Licitracker.ClientesTableView.remoteCountRows = async function(search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTableView", "remoteCountRows", function(decoded) {
				mresolve(decoded.data);
			}, search_value);
		});
	}
		

	Licitracker.ClientesTableView.remoteGetRange = async function(begin = 0, end = 1, order_by = false, order = false, search_value = false){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTableView", "remoteGetRange", function(decoded) {
				mresolve(decoded.data);
			}, begin, end, order_by, order, search_value);
		});
	}
		

	Licitracker.ClientesTableView.remoteGetDefs = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTableView", "remoteGetDefs", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.ClientesTableView.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTableView", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		
Licitracker.ClientesTaskScheduleEntry = {};
Licitracker.ClientesKeywordSearchTaskParameters = {};

	Licitracker.ClientesKeywordSearchTaskParameters.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.ClientesKeywordSearchTaskParameters.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.ClientesKeywordSearchTaskParameters.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.ClientesKeywordSearchTaskParameters.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.ClientesKeywordSearchTaskParameters.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.ClientesKeywordSearchTaskParameters.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.ClientesKeywordSearchTaskParameters.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.ClientesKeywordSearchTaskParameters.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesKeywordSearchTaskParameters", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.ClientesTask = {};

	Licitracker.ClientesTask.migrateFromLegacyFullConfig = async function(full_config){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "migrateFromLegacyFullConfig", function(decoded) {
				mresolve(decoded.data);
			}, full_config);
		});
	}
		

	Licitracker.ClientesTask.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.ClientesTask.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.ClientesTask.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.ClientesTask.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.ClientesTask.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.ClientesTask.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.ClientesTask.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.ClientesTask.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\ClientesTask", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Licitracker.LicitacionTaskSearchParameters = {};
Licitracker.LicitacionTaskSearchParameters.schema = {
    "fields": {
        "enabled": {
            "hidden": false,
            "desc": "Activado",
            "hint": "Activado: se realizara esta busqueda\nDesactivado: no se realizara esta busqueda",
            "type": "bool",
            "name": "enabled",
            "default": false
        },
        "demo_mode": {
            "hidden": false,
            "desc": "Modo Demo",
            "hint": "Activado: Se omitira el subrayado de las keywords con match\nDesactivado: Se subrayaran las keywords con match.",
            "type": "bool",
            "name": "demo_mode",
            "default": false
        },
        "send_email": {
            "hidden": false,
            "desc": "Enviar Correos",
            "hint": "Activado: Se enviaran los correos a los destinatarios\nDesactivado: Se generara el reporte pero no se enviara correo",
            "type": "bool",
            "name": "send_email",
            "default": false
        },
        "testing_mode": {
            "hidden": false,
            "desc": "Modo Test",
            "hint": "No envia correo ni escribe historial",
            "type": "bool",
            "name": "testing_mode",
            "default": false
        },
        "reduce_keywords": {
            "hidden": false,
            "desc": "Reduccion de keywords",
            "hint": "Reduce la cantidad de keywords\n(Recomendado para busquedas de Compra \u00c1gil)",
            "type": "bool",
            "name": "reduce_keywords",
            "default": false
        },
        "schedule": {
            "hidden": false,
            "desc": "Horas de envio",
            "hint": "Itinerario de generacion del reporte",
            "type": "string",
            "name": "schedule",
            "default": ""
        },
        "include_regiones": {
            "hidden": false,
            "desc": "Regiones a incluir",
            "hint": "No envia correo ni escribe historial",
            "type": "string",
            "name": "include_regiones",
            "default": ""
        },
        "email_recipients": {
            "hidden": false,
            "desc": "Destinatarios",
            "hint": "Destinatarios de correo, un E-Mail en cada linea",
            "type": "string",
            "name": "email_recipients",
            "default": ""
        },
        "search_keywords": {
            "hidden": false,
            "desc": "Keywords",
            "hint": "Keywords de busqueda, cada linea es un keyword y puede contener espacios.",
            "type": "string",
            "name": "search_keywords",
            "default": ""
        },
        "include_keywords": {
            "hidden": false,
            "desc": "Keywords de inclusion",
            "hint": "Keywords que si los resultados de la\nbusqueda NO CONTIENEN, se excluiran del reporte.",
            "type": "string",
            "name": "include_keywords",
            "default": ""
        },
        "exclude_keywords": {
            "hidden": false,
            "desc": "Keywords de exclusion",
            "hint": "Keywords que si los resultados de la\nbusqueda CONTIENEN, se excluiran del reporte",
            "type": "string",
            "name": "exclude_keywords",
            "default": ""
        }
    },
    "display_name": "Parametros de Busqueda"
};

	Licitracker.LicitacionTaskSearchParameters.getClientes = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "getClientes", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.load = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "load", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.validate = async function(serialized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "validate", function(decoded) {
				mresolve(decoded.data);
			}, serialized);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.save = async function(serialized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "save", function(decoded) {
				mresolve(decoded.data);
			}, serialized);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.create = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "create", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.delete = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "delete", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.is_builtin = async function(type){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "is_builtin", function(decoded) {
				mresolve(decoded.data);
			}, type);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.isset_get = async function(arr, sub){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "isset_get", function(decoded) {
				mresolve(decoded.data);
			}, arr, sub);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.get_class_schema_static = async function(called_class, r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "get_class_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, called_class, r);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.get_schema_static = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "get_schema_static", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.serialize_class = async function(instance, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "serialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, r, prop_descs);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.serialize = async function(r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "serialize", function(decoded) {
				mresolve(decoded.data);
			}, r, prop_descs);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		

	Licitracker.LicitacionTaskSearchParameters.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Licitracker\\LicitacionTaskSearchParameters", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}