var Certife = {};
Certife.Archivos = {};
Certife.Archivos.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno",
            "type": "int",
            "name": "id"
        },
        "nombre": {
            "desc": "Nombre",
            "hint": "Nombre del archivo.",
            "required": false,
            "type": "string",
            "name": "nombre",
            "default": ""
        },
        "usuario": {
            "desc": "Usuario",
            "ro": true,
            "type": "string",
            "name": "usuario",
            "default": ""
        },
        "size": {
            "desc": "Datos",
            "type": "string",
            "name": "size",
            "default": ""
        }
    },
    "display_name": "Informaci\u00f3n del archivo"
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Certife.Constants.getAllConstants = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Constants", "getAllConstants", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Certife.Clientes = {};
Certife.Clientes.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno asociado con el cliente",
            "type": "int",
            "name": "id",
            "default": 0
        },
        "nombre": {
            "hidden": false,
            "ro": false,
            "desc": "Nombre",
            "hint": "Nombre del cliente",
            "type": "string",
            "name": "nombre",
            "default": ""
        },
        "rut": {
            "hidden": false,
            "ro": false,
            "desc": "RUT",
            "hint": "RUT del cliente",
            "type": "string",
            "name": "rut",
            "default": ""
        },
        "direccion": {
            "hidden": false,
            "ro": false,
            "desc": "Direccion",
            "hint": "Direccion del cliente",
            "type": "string",
            "name": "direccion",
            "default": ""
        },
        "comuna": {
            "hidden": false,
            "ro": false,
            "desc": "Comuna",
            "hint": "Comuna del cliente",
            "options": [
                "Arica",
                "Camarones",
                "Putre",
                "General Lagos",
                "Iquique",
                "Cami\u00f1a",
                "Colchane",
                "Huara",
                "Pica",
                "Pozo Almonte",
                "Alto Hospicio",
                "Antofagasta",
                "Mejillones",
                "Sierra Gorda",
                "Taltal",
                "Calama",
                "Ollag\u00fce",
                "San Pedro de Atacama",
                "Tocopilla",
                "Mar\u00eda Elena",
                "Copiap\u00f3",
                "Caldera",
                "Tierra Amarilla",
                "Cha\u00f1aral",
                "Diego de Almagro",
                "Vallenar",
                "Alto del Carmen",
                "Freirina",
                "Huasco",
                "La Serena",
                "Coquimbo",
                "Andacollo",
                "La Higuera",
                "Paiguano",
                "Vicu\u00f1a",
                "Illapel",
                "Canela",
                "Los Vilos",
                "Salamanca",
                "Ovalle",
                "Combarbal\u00e1",
                "Monte Patria",
                "Punitaqui",
                "R\u00edo Hurtado",
                "Valpara\u00edso",
                "Casablanca",
                "Conc\u00f3n",
                "Juan Fern\u00e1ndez",
                "Puchuncav\u00ed",
                "Quilpu\u00e9",
                "Quintero",
                "Villa Alemana",
                "Vi\u00f1a del Mar",
                "Isla de Pascua",
                "Los Andes",
                "Calle Larga",
                "Rinconada",
                "San Esteban",
                "La Ligua",
                "Cabildo",
                "Papudo",
                "Petorca",
                "Zapallar",
                "Quillota",
                "Calera",
                "Hijuelas",
                "La Cruz",
                "Limache",
                "Nogales",
                "Olmu\u00e9",
                "San Antonio",
                "Algarrobo",
                "Cartagena",
                "El Quisco",
                "El Tabo",
                "Santo Domingo",
                "San Felipe",
                "Catemu",
                "Llaillay",
                "Panquehue",
                "Putaendo",
                "Santa Mar\u00eda",
                "Rancagua",
                "Codegua",
                "Coinco",
                "Coltauco",
                "Do\u00f1ihue",
                "Graneros",
                "Las Cabras",
                "Machal\u00ed",
                "Malloa",
                "Mostazal",
                "Olivar",
                "Peumo",
                "Pichidegua",
                "Quinta de Tilcoco",
                "Rengo",
                "Requ\u00ednoa",
                "San Vicente",
                "Pichilemu",
                "La Estrella",
                "Litueche",
                "Marchihue",
                "Navidad",
                "Paredones",
                "San Fernando",
                "Ch\u00e9pica",
                "Chimbarongo",
                "Lolol",
                "Nancagua",
                "Palmilla",
                "Peralillo",
                "Placilla",
                "Pumanque",
                "Santa Cruz",
                "Talca",
                "Constituci\u00f3n",
                "Curepto",
                "Empedrado",
                "Maule",
                "Pelarco",
                "Pencahue",
                "R\u00edo Claro",
                "San Clemente",
                "San Rafael",
                "Cauquenes",
                "Chanco",
                "Pelluhue",
                "Curic\u00f3",
                "Huala\u00f1\u00e9",
                "Licant\u00e9n",
                "Molina",
                "Rauco",
                "Romeral",
                "Sagrada Familia",
                "Teno",
                "Vichuqu\u00e9n",
                "Linares",
                "Colb\u00fan",
                "Longav\u00ed",
                "Parral",
                "Retiro",
                "San Javier",
                "Villa Alegre",
                "Yerbas Buenas",
                "Concepci\u00f3n",
                "Coronel",
                "Chiguayante",
                "Florida",
                "Hualqui",
                "Lota",
                "Penco",
                "San Pedro de la Paz",
                "Santa Juana",
                "Talcahuano",
                "Tom\u00e9",
                "Hualp\u00e9n",
                "Lebu",
                "Arauco",
                "Ca\u00f1ete",
                "Contulmo",
                "Curanilahue",
                "Tir\u00faa",
                "Los \u00c1ngeles",
                "Antuco",
                "Cabrero",
                "Laja",
                "Mulch\u00e9n",
                "Nacimiento",
                "Negrete",
                "Quilaco",
                "Quilleco",
                "San Rosendo",
                "Santa B\u00e1rbara",
                "Tucapel",
                "Yumbel",
                "Alto Biob\u00edo",
                "Los \u00c1lamos",
                "Chill\u00e1n",
                "Bulnes",
                "Cobquecura",
                "Coelemu",
                "Coihueco",
                "Chill\u00e1n Viejo",
                "El Carmen",
                "Ninhue",
                "\u00d1iqu\u00e9n",
                "Pemuco",
                "Pinto",
                "Portezuelo",
                "Quill\u00f3n",
                "Quirihue",
                "R\u00e1nquil",
                "San Carlos",
                "San Fabi\u00e1n",
                "San Ignacio",
                "San Nicol\u00e1s",
                "Treguaco",
                "Yungay",
                "Temuco",
                "Carahue",
                "Cunco",
                "Curarrehue",
                "Freire",
                "Galvarino",
                "Gorbea",
                "Lautaro",
                "Loncoche",
                "Melipeuco",
                "Nueva Imperial",
                "Padre Las Casas",
                "Perquenco",
                "Pitrufqu\u00e9n",
                "Puc\u00f3n",
                "Saavedra",
                "Teodoro Schmidt",
                "Tolt\u00e9n",
                "Vilc\u00fan",
                "Villarrica",
                "Cholchol",
                "Angol",
                "Collipulli",
                "Curacaut\u00edn",
                "Ercilla",
                "Lonquimay",
                "Los Sauces",
                "Lumaco",
                "Pur\u00e9n",
                "Renaico",
                "Traigu\u00e9n",
                "Victoria",
                "Valdivia",
                "Corral",
                "Futrono",
                "La Uni\u00f3n",
                "Lago Ranco",
                "Lanco",
                "Los Lagos",
                "M\u00e1fil",
                "Mariquina",
                "Paillaco",
                "Panguipulli",
                "R\u00edo Bueno",
                "Puerto Montt",
                "Calbuco",
                "Cocham\u00f3",
                "Fresia",
                "Frutillar",
                "Los Muermos",
                "Llanquihue",
                "Maull\u00edn",
                "Puerto Varas",
                "Castro",
                "Ancud",
                "Chonchi",
                "Curaco de V\u00e9lez",
                "Dalcahue",
                "Puqueld\u00f3n",
                "Queil\u00e9n",
                "Quell\u00f3n",
                "Quemchi",
                "Quinchao",
                "Osorno",
                "Puerto Octay",
                "Purranque",
                "Puyehue",
                "R\u00edo Negro",
                "San Juan de la Costa",
                "San Pablo",
                "Chait\u00e9n",
                "Futaleuf\u00fa",
                "Hualaihu\u00e9",
                "Palena",
                "Coihaique",
                "Lago Verde",
                "Ais\u00e9n",
                "Cisnes",
                "Guaitecas",
                "Cochrane",
                "O'Higgins",
                "Tortel",
                "Chile Chico",
                "R\u00edo Ib\u00e1\u00f1ez",
                "Punta Arenas",
                "Laguna Blanca",
                "R\u00edo Verde",
                "San Gregorio",
                "Cabo de Hornos",
                "Ant\u00e1rtica",
                "Porvenir",
                "Primavera",
                "Timaukel",
                "Natales",
                "Torres del Paine",
                "Santiago",
                "Cerrillos",
                "Cerro Navia",
                "Conchal\u00ed",
                "El Bosque",
                "Estaci\u00f3n Central",
                "Huechuraba",
                "Independencia",
                "La Cisterna",
                "La Florida",
                "La Granja",
                "La Pintana",
                "La Reina",
                "Las Condes",
                "Lo Barnechea",
                "Lo Espejo",
                "Lo Prado",
                "Macul",
                "Maip\u00fa",
                "\u00d1u\u00f1oa",
                "Pedro Aguirre Cerda",
                "Pe\u00f1alol\u00e9n",
                "Providencia",
                "Pudahuel",
                "Quilicura",
                "Quinta Normal",
                "Recoleta",
                "Renca",
                "San Joaqu\u00edn",
                "San Miguel",
                "San Ram\u00f3n",
                "Vitacura",
                "Puente Alto",
                "Pirque",
                "San Jos\u00e9 de Maipo",
                "Colina",
                "Lampa",
                "Tiltil",
                "San Bernardo",
                "Buin",
                "Calera de Tango",
                "Paine",
                "Melipilla",
                "Alhu\u00e9",
                "Curacav\u00ed",
                "Mar\u00eda Pinto",
                "San Pedro",
                "Talagante",
                "El Monte",
                "Isla de Maipo",
                "Padre Hurtado",
                "Pe\u00f1aflor",
                ""
            ],
            "type": "string",
            "name": "comuna",
            "default": ""
        },
        "region": {
            "hidden": false,
            "ro": true,
            "desc": "Region",
            "hint": "Region del cliente",
            "type": "string",
            "name": "region",
            "default": ""
        }
    },
    "display_name": "Informaci\u00f3n Cliente"
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Certife.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("Certife\\ClientesTableView", "remoteGetRange", function(decoded) {
				mresolve(decoded.data);
			}, begin, end, order_by, order, search_value);
		});
	}
		
Certife.Admin = {};
Certife.CotizacionesDetalle = {};

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

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

	Certife.CotizacionesDetalle.saveCotizacionDetalles = async function(detalles, cot_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\CotizacionesDetalle", "saveCotizacionDetalles", function(decoded) {
				mresolve(decoded.data);
			}, detalles, cot_id);
		});
	}
		

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

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

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

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

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

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

	Certife.CotizacionesDetalle.deserialize_class = async function(instance, serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\CotizacionesDetalle", "deserialize_class", function(decoded) {
				mresolve(decoded.data);
			}, instance, serialized, r, prop_descs);
		});
	}
		
Certife.Cotizaciones = {};
Certife.Cotizaciones.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno",
            "type": "int",
            "name": "id",
            "default": 0
        },
        "pagado": {
            "hidden": false,
            "ro": false,
            "desc": "Pagado",
            "type": "bool",
            "name": "pagado",
            "default": false
        },
        "fecha": {
            "hidden": false,
            "ro": true,
            "desc": "Fecha",
            "hint": "Fecha de creacion",
            "type": "string",
            "name": "fecha",
            "default": ""
        },
        "cliente_id": {
            "desc": "ID Cliente",
            "ro": true,
            "hint": "ID del cliente",
            "required": false,
            "type": "int",
            "name": "cliente_id",
            "default": 0
        },
        "contacto_persona_id": {
            "desc": "ID Contacto",
            "ro": true,
            "hint": "ID de la persona.",
            "required": false,
            "type": "int",
            "name": "contacto_persona_id",
            "default": 0
        },
        "estado_id": {
            "type": "select",
            "desc": "Estado",
            "options": {
                "1": "Proceso",
                "2": "Aprobada",
                "3": "Rechazada",
                "4": "Nula",
                "5": "Borrador"
            },
            "name": "estado_id",
            "default": 5
        },
        "factura": {
            "hidden": false,
            "ro": false,
            "desc": "Factura",
            "type": "string",
            "name": "factura",
            "default": ""
        },
        "uf": {
            "desc": "Valor UF",
            "hint": "Valor UF",
            "type": "float",
            "name": "uf",
            "default": 0
        },
        "precio_exento": {
            "ro": true,
            "desc": "Precio exento $",
            "hint": "",
            "type": "int",
            "name": "precio_exento",
            "default": 0
        },
        "descuento": {
            "desc": "Descuento $",
            "hint": "Numero positivo",
            "type": "int",
            "name": "descuento",
            "default": 0
        },
        "iva": {
            "ro": true,
            "desc": "I.V.A. $",
            "type": "int",
            "name": "iva",
            "default": 0
        },
        "precio_total": {
            "ro": true,
            "desc": "Total Neto $",
            "hint": "",
            "type": "int",
            "name": "precio_total",
            "default": 0
        },
        "forma_de_pago_id": {
            "type": "select",
            "desc": "Forma de Pago",
            "options": {
                "1": "Contado",
                "2": "30 d\u00edas",
                "3": "60 d\u00edas",
                "4": "90 d\u00edas"
            },
            "name": "forma_de_pago_id",
            "default": 0
        },
        "norma_inspeccion_id": {
            "desc": "Norma Inspecci\u00f3n",
            "hint": "Norma de inspecci\u00f3n.",
            "type": "select",
            "name": "norma_inspeccion_id",
            "default": 0
        },
        "norma_evaluacion_id": {
            "desc": "Norma Evaluaci\u00f3n",
            "hint": "Norma de evaluaci\u00f3n.",
            "type": "select",
            "name": "norma_evaluacion_id",
            "default": 0
        },
        "descripcion": {
            "type": "string",
            "desc": "Descripci\u00f3n",
            "name": "descripcion",
            "default": ""
        },
        "info": {
            "type": "string",
            "desc": "Info",
            "name": "info",
            "default": ""
        },
        "archivos_adjuntos": {
            "type": "string",
            "desc": "Archivos",
            "name": "archivos_adjuntos"
        }
    },
    "display_name": "Datos de la cotizaci\u00f3n"
};

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

	Certife.Cotizaciones.getCachedUFFullFilename = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Cotizaciones", "getCachedUFFullFilename", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Certife.Cotizaciones.getCachedUFDia = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Cotizaciones", "getCachedUFDia", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Certife.Cotizaciones.fetchUFDia = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Cotizaciones", "fetchUFDia", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

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

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

	Certife.Cotizaciones.loadDetalle = async function(id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Cotizaciones", "loadDetalle", function(decoded) {
				mresolve(decoded.data);
			}, id);
		});
	}
		

	Certife.Cotizaciones.saveAll = async function(serialized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Cotizaciones", "saveAll", function(decoded) {
				mresolve(decoded.data);
			}, serialized);
		});
	}
		

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Certife.Rendiciones.deserialize = async function(serialized, r, prop_descs){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Rendiciones", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized, r, prop_descs);
		});
	}
		
Certife.Personas = {};
Certife.Personas.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno",
            "type": "int",
            "name": "id",
            "default": 0
        },
        "nombre": {
            "desc": "Nombre",
            "hint": "El nombre de la persona.",
            "required": false,
            "type": "string",
            "name": "nombre",
            "default": ""
        },
        "rut": {
            "desc": "RUT",
            "type": "string",
            "name": "rut",
            "default": ""
        },
        "cargo": {
            "desc": "Cargo",
            "type": "string",
            "name": "cargo",
            "default": ""
        },
        "telefono": {
            "desc": "Telefono",
            "type": "string",
            "name": "telefono",
            "default": ""
        },
        "email": {
            "desc": "E-Mail",
            "type": "string",
            "name": "email",
            "default": ""
        }
    },
    "display_name": "Datos de la Persona"
};

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

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

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

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

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

	Certife.Personas.getPersonas = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Personas", "getPersonas", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Certife.Personas.getPersonasOptions = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Personas", "getPersonasOptions", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

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

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

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

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

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

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

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

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

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

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

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

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

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

	Certife.Regiones.convertLegacyComunaToV2 = async function(legacy_comuna){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Regiones", "convertLegacyComunaToV2", function(decoded) {
				mresolve(decoded.data);
			}, legacy_comuna);
		});
	}
		

	Certife.Regiones.getAllConstants = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Regiones", "getAllConstants", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		
Certife.Servicios = {};
Certife.Servicios.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno",
            "type": "int",
            "name": "id"
        },
        "categoria_id": {
            "ro": false,
            "desc": "Categoria",
            "type": "int",
            "name": "categoria_id",
            "default": 1
        },
        "nombre": {
            "desc": "Nombre",
            "hint": "El nombre de la persona.",
            "required": false,
            "type": "string",
            "name": "nombre",
            "default": ""
        },
        "descripcion": {
            "desc": "Descripcion",
            "type": "string",
            "name": "descripcion",
            "default": ""
        },
        "precio_uf": {
            "desc": "Precio UF",
            "type": "float",
            "name": "precio_uf",
            "default": 0
        },
        "activo": {
            "desc": "Activo",
            "type": "bool",
            "name": "activo",
            "default": true
        }
    },
    "display_name": "Datos del producto\/servicio"
};

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

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

	Certife.Servicios.getServicios = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Servicios", "getServicios", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Certife.ServiciosTableView.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\ServiciosTableView", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		
Certife.Normas = {};
Certife.Normas.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno",
            "type": "int",
            "name": "id"
        },
        "nombre": {
            "desc": "Nombre",
            "hint": "Nombre de la norma.",
            "required": false,
            "type": "string",
            "name": "nombre",
            "default": ""
        },
        "categoria": {
            "desc": "Categoria",
            "hint": "Nombre de la Categoria.",
            "required": false,
            "type": "string",
            "name": "categoria",
            "default": ""
        },
        "inspeccion": {
            "desc": "Inspecci\u00f3n",
            "hint": "Es norma de inspecci\u00f3n.",
            "type": "bool",
            "name": "inspeccion",
            "default": true
        },
        "evaluacion": {
            "desc": "Evaluaci\u00f3n",
            "hint": "Es norma de evaluaci\u00f3n.",
            "type": "bool",
            "name": "evaluacion",
            "default": true
        },
        "activo": {
            "desc": "Activo",
            "type": "bool",
            "name": "activo",
            "default": true
        }
    },
    "display_name": "Normas"
};

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

	Certife.Normas.getAllNormas = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Normas", "getAllNormas", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Certife.Normas.getNormasEvaluacionOptions = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Normas", "getNormasEvaluacionOptions", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Certife.Normas.getNormasInspeccionOptions = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\Normas", "getNormasInspeccionOptions", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	Certife.OrdenesDeTrabajo.deserialize = async function(serialized){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\OrdenesDeTrabajo", "deserialize", function(decoded) {
				mresolve(decoded.data);
			}, serialized);
		});
	}
		

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

	Certife.OrdenesDeTrabajo.get_schema = async function(r){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\OrdenesDeTrabajo", "get_schema", function(decoded) {
				mresolve(decoded.data);
			}, r);
		});
	}
		

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

	Certife.OrdenesDeTrabajo.loadByCotID = async function(cot_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\OrdenesDeTrabajo", "loadByCotID", function(decoded) {
				mresolve(decoded.data);
			}, cot_id);
		});
	}
		

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

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

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

	Certife.OrdenesDeTrabajo.create = async function(inserted_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\OrdenesDeTrabajo", "create", function(decoded) {
				mresolve(decoded.data);
			}, inserted_id);
		});
	}
		
Certife.OrdenesDeTrabajoTableView = {};

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

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

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

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

	Certife.OrdenesDeTrabajoTableView.sqlSearchConditional = async function(class_name, search_value, params, alternative_identifiers = false, op){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\OrdenesDeTrabajoTableView", "sqlSearchConditional", function(decoded) {
				mresolve(decoded.data);
			}, class_name, search_value, params, alternative_identifiers, op);
		});
	}
		
Certife.User = {};
Certife.User.schema = {
    "fields": {
        "id": {
            "hidden": false,
            "ro": true,
            "desc": "ID",
            "hint": "ID interno asociado con la cuenta",
            "type": "int",
            "name": "id"
        },
        "persona_id": {
            "type": "select",
            "desc": "Persona",
            "hint": "Persona asociada con la cuenta.",
            "required": false,
            "name": "persona_id",
            "default": ""
        },
        "username": {
            "desc": "Nombre de usuario",
            "hint": "El nombre de usuario que\nse utilizara para entrar\nen la pagina.\nValor alfanumerico,\nno puede contener simbolos.",
            "type": "string",
            "name": "username",
            "default": ""
        },
        "password": {
            "type": "password",
            "desc": "Contrase\u00f1a",
            "name": "password",
            "default": ""
        },
        "email": {
            "desc": "E-Mail",
            "type": "string",
            "name": "email",
            "default": ""
        },
        "role_admin": {
            "desc": "Administrador",
            "type": "bool",
            "name": "role_admin",
            "default": false
        },
        "role_inspector": {
            "desc": "Inspector",
            "type": "bool",
            "name": "role_inspector",
            "default": false
        },
        "role_supervisor": {
            "desc": "Supervisor",
            "type": "bool",
            "name": "role_supervisor",
            "default": false
        },
        "role_cotizador": {
            "desc": "Cotizador",
            "type": "bool",
            "name": "role_cotizador",
            "default": false
        },
        "enable": {
            "desc": "Cuenta Activa",
            "hint": "Activa o desactiva la cuenta para\ningresar en la plataforma.",
            "type": "bool",
            "name": "enable",
            "default": true
        }
    },
    "display_name": "Datos del Usuario"
};

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

	Certife.User.load_user_by_id = async function(user_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\User", "load_user_by_id", function(decoded) {
				mresolve(decoded.data);
			}, user_id);
		});
	}
		

	Certife.User.load = async function(user_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\User", "load", function(decoded) {
				mresolve(decoded.data);
			}, user_id);
		});
	}
		

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

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

	Certife.User.delete = async function(user_id){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\User", "delete", function(decoded) {
				mresolve(decoded.data);
			}, user_id);
		});
	}
		

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

	Certife.User.getInspectoresSupervisoresOptions = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\User", "getInspectoresSupervisoresOptions", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Certife.User.getRoledUsers = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\User", "getRoledUsers", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

	Certife.User.getAccessibleFiles = async function(){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\User", "getAccessibleFiles", function(decoded) {
				mresolve(decoded.data);
			});
		});
	}
		

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

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

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

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

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

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

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

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

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

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

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

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

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

	Certife.GranularPermissions.getMergedPermissionsFromUserGroups = async function(class_name, class_fields_assoc_keys, user_groups){
		return new Promise(function(mresolve, mreject){
			g.reflection_request("Certife\\GranularPermissions", "getMergedPermissionsFromUserGroups", function(decoded) {
				mresolve(decoded.data);
			}, class_name, class_fields_assoc_keys, user_groups);
		});
	}