@erpp/react-api-cronos-frontend 1.0.1

package/dist/index.mjs

@@ -0,0 +1,4480 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/components/API.ts
+import axios from "axios";
+var API = class {
+  constructor({ urlBase, getTokenCallback }) {
+    this._baseURL = "";
+    this.createDefaultMethods = (axiosInstance) => ({
+      findByFilterMatch: (data = { filter: "", pagination: {}, orderBy: "" }) => axiosInstance.post(`/filter-match`, data),
+      get: ({ id, params = {}, config = {}, where }) => {
+        if (id) {
+          return axiosInstance.get(`/${id}`, __spreadValues({ params }, config));
+        }
+        return axiosInstance.get("/", __spreadValues({
+          params: __spreadProps(__spreadValues({}, params), { where: JSON.stringify(where) })
+        }, config));
+      },
+      post: ({ data, config }) => axiosInstance.post("/", data, config),
+      put: ({ id, data = {}, config = {} }) => {
+        if (id) {
+          return axiosInstance.put(`/${id}`, data, config);
+        }
+        return axiosInstance.put("/", data, config);
+      },
+      delete: ({ id, config = {}, where = {} }) => {
+        if (id) {
+          return axiosInstance.delete(`/${id}`, config);
+        }
+        return axiosInstance.delete("/", __spreadValues({
+          data: { where }
+        }, config));
+      }
+    });
+    this.subpath = (path, factory) => {
+      if (!path) {
+        throw new Error(`API subpath must be defined`);
+      }
+      const axiosInstance = axios.create({
+        baseURL: this.api.defaults.baseURL + path,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      axiosInstance.interceptors.request.use(
+        (config) => {
+          config.headers["Authorization"] = this.api.defaults.headers["Authorization"];
+          return config;
+        },
+        (error) => Promise.reject(error)
+      );
+      axiosInstance.interceptors.response.use(
+        (response) => response,
+        (error) => Promise.reject(error)
+      );
+      const defaultMethods = this.createDefaultMethods(axiosInstance);
+      const overrides = factory ? factory(defaultMethods, axiosInstance) : {};
+      return __spreadValues(__spreadValues({}, defaultMethods), overrides);
+    };
+    this._baseURL = urlBase;
+    this.getTokenCallback = getTokenCallback;
+    this.api = axios.create({
+      baseURL: urlBase,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.api.interceptors.request.use(
+      (config) => {
+        config.headers["Authorization"] = this.getTokenCallback ? this.getTokenCallback() : null;
+        return config;
+      },
+      (error) => {
+        return Promise.reject(error);
+      }
+    );
+    this.api.interceptors.response.use(
+      (response) => {
+        return response;
+      },
+      (error) => {
+        return Promise.reject(error);
+      }
+    );
+  }
+  // Setter para cambiar la baseURL
+  setBaseURL(url) {
+    this._baseURL = url;
+    if (this.api) {
+      this.api.defaults.baseURL = url;
+    }
+  }
+  setGetTokenCallback(callback) {
+    this.getTokenCallback = callback;
+    this.api.defaults.headers["Authorization"] = callback ? callback() : null;
+  }
+};
+
+// src/components/apis/setupAdeudoApi.ts
+var setupAdeudoApi = ({ client }) => {
+  const api = client.subpath("/adeudo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatAccionApi.ts
+var setupCatAccionApi = ({ client }) => {
+  const api = client.subpath("/cat_accion", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatConceptoPagoApi.ts
+var setupCatConceptoPagoApi = ({ client }) => {
+  const api = client.subpath("/cat_concepto_pago", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatEntidadApi.ts
+var setupCatEntidadApi = ({ client }) => {
+  const api = client.subpath("/cat_entidad", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatFechaAgrupacionApi.ts
+var setupCatFechaAgrupacionApi = ({ client }) => {
+  const api = client.subpath("/cat_fecha_agrupacion", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatGraficaGrupoApi.ts
+var setupCatGraficaGrupoApi = ({ client }) => {
+  const api = client.subpath("/cat_grafica_grupo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatPlazaApi.ts
+var setupCatPlazaApi = ({ client }) => {
+  const api = client.subpath("/cat_plaza", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatRolGrupoApi.ts
+var setupCatRolGrupoApi = ({ client }) => {
+  const api = client.subpath("/cat_rol_grupo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatTipoParametroApi.ts
+var setupCatTipoParametroApi = ({ client }) => {
+  const api = client.subpath("/cat_tipo_parametro", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatTipoServicioApi.ts
+var setupCatTipoServicioApi = ({ client }) => {
+  const api = client.subpath("/cat_tipo_servicio", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatTipoSueloApi.ts
+var setupCatTipoSueloApi = ({ client }) => {
+  const api = client.subpath("/cat_tipo_suelo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupCatTipoTarifaApi.ts
+var setupCatTipoTarifaApi = ({ client }) => {
+  const api = client.subpath("/cat_tipo_tarifa", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupContribuyenteApi.ts
+var setupContribuyenteApi = ({ client }) => {
+  const api = client.subpath("/contribuyente", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupContribuyenteDomicilioApi.ts
+var setupContribuyenteDomicilioApi = ({ client }) => {
+  const api = client.subpath("/contribuyente_domicilio", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardEstiloApi.ts
+var setupDashboardEstiloApi = ({ client }) => {
+  const api = client.subpath("/dashboard_estilo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardGraficaApi.ts
+var setupDashboardGraficaApi = ({ client }) => {
+  const api = client.subpath("/dashboard_grafica", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardGraficaElementoApi.ts
+var setupDashboardGraficaElementoApi = ({ client }) => {
+  const api = client.subpath("/dashboard_grafica_elemento", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardGraficaElementoDetalleApi.ts
+var setupDashboardGraficaElementoDetalleApi = ({ client }) => {
+  const api = client.subpath("/dashboard_grafica_elemento_detalle", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardGraficaElementoParametroApi.ts
+var setupDashboardGraficaElementoParametroApi = ({ client }) => {
+  const api = client.subpath("/dashboard_grafica_elemento_parametro", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardGraficaGrupoApi.ts
+var setupDashboardGraficaGrupoApi = ({ client }) => {
+  const api = client.subpath("/dashboard_grafica_grupo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardGraficaGrupoRolApi.ts
+var setupDashboardGraficaGrupoRolApi = ({ client }) => {
+  const api = client.subpath("/dashboard_grafica_grupo_rol", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupDashboardRutaApi.ts
+var setupDashboardRutaApi = ({ client }) => {
+  const api = client.subpath("/dashboard_ruta", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+    usuario: client.subpath("/dashboard_ruta/usuario", () => ({}))
+  }));
+  return api;
+};
+
+// src/components/apis/setupGraficaApi.ts
+var setupGraficaApi = ({ client }) => {
+  const api = client.subpath("/grafica", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupGraficaAgrupacionApi.ts
+var setupGraficaAgrupacionApi = ({ client }) => {
+  const api = client.subpath("/grafica_agrupacion", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupGraficaFiltroApi.ts
+var setupGraficaFiltroApi = ({ client }) => {
+  const api = client.subpath("/grafica_filtro", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupGraficaParametroApi.ts
+var setupGraficaParametroApi = ({ client }) => {
+  const api = client.subpath("/grafica_parametro", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupGraficaParametroDefectoApi.ts
+var setupGraficaParametroDefectoApi = ({ client }) => {
+  const api = client.subpath("/grafica_parametro_defecto", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupGraficaParametroTipoApi.ts
+var setupGraficaParametroTipoApi = ({ client }) => {
+  const api = client.subpath("/grafica_parametro_tipo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupGraficaPorGrupoApi.ts
+var setupGraficaPorGrupoApi = ({ client }) => {
+  const api = client.subpath("/grafica_por_grupo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupGrupoUsuarioApi.ts
+var setupGrupoUsuarioApi = ({ client }) => {
+  const api = client.subpath("/grupo_usuario", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupModuloApi.ts
+var setupModuloApi = ({ client }) => {
+  const api = client.subpath("/modulo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupPagosApi.ts
+var setupPagosApi = ({ client }) => {
+  const api = client.subpath("/pagos", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupPermisoAccionEntidadApi.ts
+var setupPermisoAccionEntidadApi = ({ client }) => {
+  const api = client.subpath("/permiso_accion_entidad", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupPermisoModuloApi.ts
+var setupPermisoModuloApi = ({ client }) => {
+  const api = client.subpath("/permiso_modulo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupPermisoSubmoduloApi.ts
+var setupPermisoSubmoduloApi = ({ client }) => {
+  const api = client.subpath("/permiso_submodulo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupPlazasApi.ts
+var setupPlazasApi = ({ client }) => {
+  const api = client.subpath("/plazas", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupRolApi.ts
+var setupRolApi = ({ client }) => {
+  const api = client.subpath("/rol", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupRolDashboardRutaApi.ts
+var setupRolDashboardRutaApi = ({ client }) => {
+  const api = client.subpath("/rol_dashboard_ruta", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupRolGraficaApi.ts
+var setupRolGraficaApi = ({ client }) => {
+  const api = client.subpath("/rol_grafica", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupSubmoduloApi.ts
+var setupSubmoduloApi = ({ client }) => {
+  const api = client.subpath("/submodulo", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupTipoGraficaApi.ts
+var setupTipoGraficaApi = ({ client }) => {
+  const api = client.subpath("/tipo_grafica", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupTipoRolApi.ts
+var setupTipoRolApi = ({ client }) => {
+  const api = client.subpath("/tipo_rol", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupUsuarioApi.ts
+var setupUsuarioApi = ({ client }) => {
+  const api = client.subpath("/usuario", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupUsuarioDashboardAccesoApi.ts
+var setupUsuarioDashboardAccesoApi = ({ client }) => {
+  const api = client.subpath("/usuario_dashboard_acceso", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupUsuarioGraficaApi.ts
+var setupUsuarioGraficaApi = ({ client }) => {
+  const api = client.subpath("/usuario_grafica", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupUsuarioGraficaExcluidaApi.ts
+var setupUsuarioGraficaExcluidaApi = ({ client }) => {
+  const api = client.subpath("/usuario_grafica_excluida", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/components/apis/setupUsuarioRolApi.ts
+var setupUsuarioRolApi = ({ client }) => {
+  const api = client.subpath("/usuario_rol", (sub, axios3) => ({
+    // Agregar métodos personalizados aquí
+  }));
+  return api;
+};
+
+// src/factories/APIFactory.ts
+var APIFactory = class {
+  constructor({ urlBase, getTokenCallback }) {
+    this.urlBase = urlBase;
+    this.getTokenCallback = getTokenCallback;
+    const client = new API({ urlBase, getTokenCallback });
+    this.axiosInstance = client.api;
+    this.adeudo = setupAdeudoApi({ client });
+    this.cat_accion = setupCatAccionApi({ client });
+    this.cat_concepto_pago = setupCatConceptoPagoApi({ client });
+    this.cat_entidad = setupCatEntidadApi({ client });
+    this.cat_fecha_agrupacion = setupCatFechaAgrupacionApi({ client });
+    this.cat_grafica_grupo = setupCatGraficaGrupoApi({ client });
+    this.cat_plaza = setupCatPlazaApi({ client });
+    this.cat_rol_grupo = setupCatRolGrupoApi({ client });
+    this.cat_tipo_parametro = setupCatTipoParametroApi({ client });
+    this.cat_tipo_servicio = setupCatTipoServicioApi({ client });
+    this.cat_tipo_suelo = setupCatTipoSueloApi({ client });
+    this.cat_tipo_tarifa = setupCatTipoTarifaApi({ client });
+    this.contribuyente = setupContribuyenteApi({ client });
+    this.contribuyente_domicilio = setupContribuyenteDomicilioApi({ client });
+    this.dashboard_estilo = setupDashboardEstiloApi({ client });
+    this.dashboard_grafica = setupDashboardGraficaApi({ client });
+    this.dashboard_grafica_elemento = setupDashboardGraficaElementoApi({ client });
+    this.dashboard_grafica_elemento_detalle = setupDashboardGraficaElementoDetalleApi({ client });
+    this.dashboard_grafica_elemento_parametro = setupDashboardGraficaElementoParametroApi({ client });
+    this.dashboard_grafica_grupo = setupDashboardGraficaGrupoApi({ client });
+    this.dashboard_grafica_grupo_rol = setupDashboardGraficaGrupoRolApi({ client });
+    this.dashboard_ruta = setupDashboardRutaApi({ client });
+    this.grafica = setupGraficaApi({ client });
+    this.grafica_agrupacion = setupGraficaAgrupacionApi({ client });
+    this.grafica_filtro = setupGraficaFiltroApi({ client });
+    this.grafica_parametro = setupGraficaParametroApi({ client });
+    this.grafica_parametro_defecto = setupGraficaParametroDefectoApi({ client });
+    this.grafica_parametro_tipo = setupGraficaParametroTipoApi({ client });
+    this.grafica_por_grupo = setupGraficaPorGrupoApi({ client });
+    this.grupo_usuario = setupGrupoUsuarioApi({ client });
+    this.modulo = setupModuloApi({ client });
+    this.pagos = setupPagosApi({ client });
+    this.permiso_accion_entidad = setupPermisoAccionEntidadApi({ client });
+    this.permiso_modulo = setupPermisoModuloApi({ client });
+    this.permiso_submodulo = setupPermisoSubmoduloApi({ client });
+    this.plazas = setupPlazasApi({ client });
+    this.rol = setupRolApi({ client });
+    this.rol_dashboard_ruta = setupRolDashboardRutaApi({ client });
+    this.rol_grafica = setupRolGraficaApi({ client });
+    this.submodulo = setupSubmoduloApi({ client });
+    this.tipo_grafica = setupTipoGraficaApi({ client });
+    this.tipo_rol = setupTipoRolApi({ client });
+    this.usuario = setupUsuarioApi({ client });
+    this.usuario_dashboard_acceso = setupUsuarioDashboardAccesoApi({ client });
+    this.usuario_grafica = setupUsuarioGraficaApi({ client });
+    this.usuario_grafica_excluida = setupUsuarioGraficaExcluidaApi({ client });
+    this.usuario_rol = setupUsuarioRolApi({ client });
+  }
+  getAvailableAPIs() {
+    return Object.entries(this).filter(([key, value]) => typeof value === "object" && value !== null && "get" in value).map(([key]) => key);
+  }
+};
+
+// src/infrastructure/api/base/APIClientBase.ts
+import axios2 from "axios";
+var ApiClientContext = class {
+};
+ApiClientContext.baseUrl = "https://api.ejemplo.com";
+ApiClientContext.token = "TOKEN_GLOBAL_POR_DEFECTO";
+var APIClientBase = class {
+  constructor({ endpoint }) {
+    this.endpoint = endpoint;
+  }
+  getAxiosConfig(params) {
+    const query = __spreadValues({}, params);
+    if ((query == null ? void 0 : query.where) && typeof query.where === "object") {
+      query.where = JSON.stringify(query.where);
+    }
+    return {
+      baseURL: ApiClientContext.baseUrl,
+      headers: {
+        Authorization: `Bearer ${ApiClientContext.token}`,
+        Accept: "application/json"
+      },
+      params: query
+    };
+  }
+  async getById({ id, params }) {
+    try {
+      const response = await axios2.get(`${this.endpoint}/${id}`, this.getAxiosConfig(params));
+      return response.data;
+    } catch (error) {
+      console.error(`Error GET ${this.endpoint}/${id}:`, error.message);
+      return null;
+    }
+  }
+  async create({ data, params }) {
+    try {
+      const response = await axios2.post(this.endpoint, data, this.getAxiosConfig(params));
+      return response.data;
+    } catch (error) {
+      console.error(`Error POST ${this.endpoint}:`, error.message);
+      return null;
+    }
+  }
+  async update({ id, data, params }) {
+    try {
+      const response = await axios2.put(`${this.endpoint}/${id}`, data, this.getAxiosConfig(params));
+      return response.data;
+    } catch (error) {
+      console.error(`Error PUT ${this.endpoint}/${id}:`, error.message);
+      return null;
+    }
+  }
+  async delete({ id, params }) {
+    try {
+      await axios2.delete(`${this.endpoint}/${id}`, this.getAxiosConfig(params));
+      return true;
+    } catch (error) {
+      console.error(`Error DELETE ${this.endpoint}/${id}:`, error.message);
+      return false;
+    }
+  }
+  async query({ params }) {
+    try {
+      const url = `${this.endpoint}/query`;
+      const response = await axios2.get(url, this.getAxiosConfig(params));
+      return response.data;
+    } catch (error) {
+      console.error(`Error GET ${this.endpoint} con query:`, error.message);
+      return null;
+    }
+  }
+  async filterMatch({ body, params }) {
+    try {
+      const url = `${this.endpoint}/filter-match`;
+      const response = await axios2.post(url, body, this.getAxiosConfig(params));
+      return response.data;
+    } catch (error) {
+      console.error(`Error POST ${this.endpoint} filter-match:`, error.message);
+      return null;
+    }
+  }
+};
+
+// src/infrastructure/api/clients/AdeudoAPI.ts
+var AdeudoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "adeudo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Adeudo
+};
+var AdeudoAPI_default = AdeudoAPI;
+
+// src/infrastructure/api/utils/createApiHooks.ts
+import { useState, useCallback } from "react";
+
+// src/infrastructure/api/utils/globalErrorLogger.ts
+import fs from "fs";
+var GlobalErrorLogger = class {
+  constructor() {
+    this.handler = null;
+  }
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  log(error, context) {
+    if (this.handler) {
+      this.handler(error, context);
+      return;
+    }
+    if (typeof window !== "undefined" && window.localStorage) {
+      const logs = JSON.parse(localStorage.getItem("api_error_logs") || "[]");
+      logs.push({
+        error: (error == null ? void 0 : error.message) || String(error),
+        context,
+        date: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      localStorage.setItem("api_error_logs", JSON.stringify(logs));
+    } else {
+      const logEntry = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${context || "API"}: ${(error == null ? void 0 : error.message) || String(error)}
+`;
+      fs.appendFileSync("api_error_logs.txt", logEntry);
+    }
+  }
+};
+var globalErrorLogger = new GlobalErrorLogger();
+
+// src/infrastructure/api/utils/createApiHooks.ts
+function createApiHooksBase(client) {
+  function useFetchById(params) {
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isFetching, setIsFetching] = useState(false);
+    const [isLoading, setIsLoading] = useState(true);
+    const fetchData = useCallback(async () => {
+      setIsFetching(true);
+      try {
+        const result = await client.getById(params);
+        setData(result);
+        setError(null);
+      } catch (err) {
+        setError(err);
+        globalErrorLogger.log(err, "useFetchById");
+      } finally {
+        setIsFetching(false);
+        setIsLoading(false);
+      }
+    }, [JSON.stringify(params)]);
+    return { data, error, isFetching, isLoading, refetch: fetchData };
+  }
+  function useFetchList(params) {
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isFetching, setIsFetching] = useState(false);
+    const [isLoading, setIsLoading] = useState(true);
+    const fetchData = useCallback(async () => {
+      setIsFetching(true);
+      try {
+        const result = await client.query(params);
+        setData(result);
+        setError(null);
+      } catch (err) {
+        setError(err);
+        globalErrorLogger.log(err, "useFetchList");
+      } finally {
+        setIsFetching(false);
+        setIsLoading(false);
+      }
+    }, [JSON.stringify(params)]);
+    return { data, error, isFetching, isLoading, refetch: fetchData };
+  }
+  function useCreate() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [data, setData] = useState(null);
+    const mutate = useCallback(async (params) => {
+      setIsLoading(true);
+      try {
+        const result = await client.create(params);
+        setData(result);
+        setError(null);
+        return result;
+      } catch (err) {
+        setError(err);
+        globalErrorLogger.log(err, "useCreate");
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    }, []);
+    return { mutate, isLoading, error, data };
+  }
+  function useUpdate() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [data, setData] = useState(null);
+    const mutate = useCallback(async (params) => {
+      setIsLoading(true);
+      try {
+        const result = await client.update(params);
+        setData(result);
+        setError(null);
+        return result;
+      } catch (err) {
+        setError(err);
+        globalErrorLogger.log(err, "useUpdate");
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    }, []);
+    return { mutate, isLoading, error, data };
+  }
+  function useDelete() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [success, setSuccess] = useState(false);
+    const mutate = useCallback(async (params) => {
+      setIsLoading(true);
+      try {
+        const result = await client.delete(params);
+        setSuccess(result);
+        setError(null);
+        return result;
+      } catch (err) {
+        setError(err);
+        globalErrorLogger.log(err, "useDelete");
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    }, []);
+    return { mutate, isLoading, error, success };
+  }
+  function useFilterMatch(params) {
+    const [data, setData] = useState(null);
+    const [error, setError] = useState(null);
+    const [isFetching, setIsFetching] = useState(false);
+    const [isLoading, setIsLoading] = useState(true);
+    const fetchData = useCallback(async () => {
+      setIsFetching(true);
+      try {
+        const result = await client.filterMatch(params);
+        setData(result);
+        setError(null);
+      } catch (err) {
+        setError(err);
+        globalErrorLogger.log(err, "useFilterMatch");
+      } finally {
+        setIsFetching(false);
+        setIsLoading(false);
+      }
+    }, [JSON.stringify(params)]);
+    return { data, error, isFetching, isLoading, refetch: fetchData };
+  }
+  return {
+    useFetchById,
+    useFetchList,
+    useCreate,
+    useUpdate,
+    useDelete,
+    useFilterMatch
+  };
+}
+function apiHooks(client) {
+  return createApiHooksBase(client);
+}
+
+// src/infrastructure/api/hooks/custom/AdeudoHooksCustom.ts
+var adeudoHooksCustom = (adeudoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<AdeudoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await adeudoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching adeudo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var AdeudoHooksCustom_default = adeudoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useAdeudoAPI.ts
+var createAPIAdeudo = () => {
+  const client = new AdeudoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = AdeudoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdAdeudo,
+  useFetchList: useFetchListAdeudo,
+  useCreate: useCreateAdeudo,
+  useUpdate: useUpdateAdeudo,
+  useDelete: useDeleteAdeudo,
+  useFilterMatch: useFilterMatchAdeudo
+} = createAPIAdeudo();
+var useAdeudoAPI_default = createAPIAdeudo;
+
+// src/infrastructure/api/clients/CatAccionAPI.ts
+var CatAccionAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_accion"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatAccion
+};
+var CatAccionAPI_default = CatAccionAPI;
+
+// src/infrastructure/api/hooks/custom/CatAccionHooksCustom.ts
+var catAccionHooksCustom = (catAccionClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatAccionDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catAccionClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catAccion by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatAccionHooksCustom_default = catAccionHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatAccionAPI.ts
+var createAPICatAccion = () => {
+  const client = new CatAccionAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatAccionHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatAccion,
+  useFetchList: useFetchListCatAccion,
+  useCreate: useCreateCatAccion,
+  useUpdate: useUpdateCatAccion,
+  useDelete: useDeleteCatAccion,
+  useFilterMatch: useFilterMatchCatAccion
+} = createAPICatAccion();
+var useCatAccionAPI_default = createAPICatAccion;
+
+// src/infrastructure/api/clients/CatConceptoPagoAPI.ts
+var CatConceptoPagoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_concepto_pago"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatConceptoPago
+};
+var CatConceptoPagoAPI_default = CatConceptoPagoAPI;
+
+// src/infrastructure/api/hooks/custom/CatConceptoPagoHooksCustom.ts
+var catConceptoPagoHooksCustom = (catConceptoPagoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatConceptoPagoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catConceptoPagoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catConceptoPago by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatConceptoPagoHooksCustom_default = catConceptoPagoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatConceptoPagoAPI.ts
+var createAPICatConceptoPago = () => {
+  const client = new CatConceptoPagoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatConceptoPagoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatConceptoPago,
+  useFetchList: useFetchListCatConceptoPago,
+  useCreate: useCreateCatConceptoPago,
+  useUpdate: useUpdateCatConceptoPago,
+  useDelete: useDeleteCatConceptoPago,
+  useFilterMatch: useFilterMatchCatConceptoPago
+} = createAPICatConceptoPago();
+var useCatConceptoPagoAPI_default = createAPICatConceptoPago;
+
+// src/infrastructure/api/clients/CatEntidadAPI.ts
+var CatEntidadAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_entidad"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatEntidad
+};
+var CatEntidadAPI_default = CatEntidadAPI;
+
+// src/infrastructure/api/hooks/custom/CatEntidadHooksCustom.ts
+var catEntidadHooksCustom = (catEntidadClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatEntidadDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catEntidadClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catEntidad by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatEntidadHooksCustom_default = catEntidadHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatEntidadAPI.ts
+var createAPICatEntidad = () => {
+  const client = new CatEntidadAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatEntidadHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatEntidad,
+  useFetchList: useFetchListCatEntidad,
+  useCreate: useCreateCatEntidad,
+  useUpdate: useUpdateCatEntidad,
+  useDelete: useDeleteCatEntidad,
+  useFilterMatch: useFilterMatchCatEntidad
+} = createAPICatEntidad();
+var useCatEntidadAPI_default = createAPICatEntidad;
+
+// src/infrastructure/api/clients/CatFechaAgrupacionAPI.ts
+var CatFechaAgrupacionAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_fecha_agrupacion"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatFechaAgrupacion
+};
+var CatFechaAgrupacionAPI_default = CatFechaAgrupacionAPI;
+
+// src/infrastructure/api/hooks/custom/CatFechaAgrupacionHooksCustom.ts
+var catFechaAgrupacionHooksCustom = (catFechaAgrupacionClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatFechaAgrupacionDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catFechaAgrupacionClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catFechaAgrupacion by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatFechaAgrupacionHooksCustom_default = catFechaAgrupacionHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatFechaAgrupacionAPI.ts
+var createAPICatFechaAgrupacion = () => {
+  const client = new CatFechaAgrupacionAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatFechaAgrupacionHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatFechaAgrupacion,
+  useFetchList: useFetchListCatFechaAgrupacion,
+  useCreate: useCreateCatFechaAgrupacion,
+  useUpdate: useUpdateCatFechaAgrupacion,
+  useDelete: useDeleteCatFechaAgrupacion,
+  useFilterMatch: useFilterMatchCatFechaAgrupacion
+} = createAPICatFechaAgrupacion();
+var useCatFechaAgrupacionAPI_default = createAPICatFechaAgrupacion;
+
+// src/infrastructure/api/clients/CatGraficaGrupoAPI.ts
+var CatGraficaGrupoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_grafica_grupo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatGraficaGrupo
+};
+var CatGraficaGrupoAPI_default = CatGraficaGrupoAPI;
+
+// src/infrastructure/api/hooks/custom/CatGraficaGrupoHooksCustom.ts
+var catGraficaGrupoHooksCustom = (catGraficaGrupoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatGraficaGrupoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catGraficaGrupoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catGraficaGrupo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatGraficaGrupoHooksCustom_default = catGraficaGrupoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatGraficaGrupoAPI.ts
+var createAPICatGraficaGrupo = () => {
+  const client = new CatGraficaGrupoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatGraficaGrupoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatGraficaGrupo,
+  useFetchList: useFetchListCatGraficaGrupo,
+  useCreate: useCreateCatGraficaGrupo,
+  useUpdate: useUpdateCatGraficaGrupo,
+  useDelete: useDeleteCatGraficaGrupo,
+  useFilterMatch: useFilterMatchCatGraficaGrupo
+} = createAPICatGraficaGrupo();
+var useCatGraficaGrupoAPI_default = createAPICatGraficaGrupo;
+
+// src/infrastructure/api/clients/CatPlazaAPI.ts
+var CatPlazaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_plaza"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatPlaza
+};
+var CatPlazaAPI_default = CatPlazaAPI;
+
+// src/infrastructure/api/hooks/custom/CatPlazaHooksCustom.ts
+var catPlazaHooksCustom = (catPlazaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatPlazaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catPlazaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catPlaza by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatPlazaHooksCustom_default = catPlazaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatPlazaAPI.ts
+var createAPICatPlaza = () => {
+  const client = new CatPlazaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatPlazaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatPlaza,
+  useFetchList: useFetchListCatPlaza,
+  useCreate: useCreateCatPlaza,
+  useUpdate: useUpdateCatPlaza,
+  useDelete: useDeleteCatPlaza,
+  useFilterMatch: useFilterMatchCatPlaza
+} = createAPICatPlaza();
+var useCatPlazaAPI_default = createAPICatPlaza;
+
+// src/infrastructure/api/clients/CatRolGrupoAPI.ts
+var CatRolGrupoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_rol_grupo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatRolGrupo
+};
+var CatRolGrupoAPI_default = CatRolGrupoAPI;
+
+// src/infrastructure/api/hooks/custom/CatRolGrupoHooksCustom.ts
+var catRolGrupoHooksCustom = (catRolGrupoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatRolGrupoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catRolGrupoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catRolGrupo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatRolGrupoHooksCustom_default = catRolGrupoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatRolGrupoAPI.ts
+var createAPICatRolGrupo = () => {
+  const client = new CatRolGrupoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatRolGrupoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatRolGrupo,
+  useFetchList: useFetchListCatRolGrupo,
+  useCreate: useCreateCatRolGrupo,
+  useUpdate: useUpdateCatRolGrupo,
+  useDelete: useDeleteCatRolGrupo,
+  useFilterMatch: useFilterMatchCatRolGrupo
+} = createAPICatRolGrupo();
+var useCatRolGrupoAPI_default = createAPICatRolGrupo;
+
+// src/infrastructure/api/clients/CatTipoParametroAPI.ts
+var CatTipoParametroAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_tipo_parametro"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatTipoParametro
+};
+var CatTipoParametroAPI_default = CatTipoParametroAPI;
+
+// src/infrastructure/api/hooks/custom/CatTipoParametroHooksCustom.ts
+var catTipoParametroHooksCustom = (catTipoParametroClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatTipoParametroDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catTipoParametroClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catTipoParametro by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatTipoParametroHooksCustom_default = catTipoParametroHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatTipoParametroAPI.ts
+var createAPICatTipoParametro = () => {
+  const client = new CatTipoParametroAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatTipoParametroHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatTipoParametro,
+  useFetchList: useFetchListCatTipoParametro,
+  useCreate: useCreateCatTipoParametro,
+  useUpdate: useUpdateCatTipoParametro,
+  useDelete: useDeleteCatTipoParametro,
+  useFilterMatch: useFilterMatchCatTipoParametro
+} = createAPICatTipoParametro();
+var useCatTipoParametroAPI_default = createAPICatTipoParametro;
+
+// src/infrastructure/api/clients/CatTipoServicioAPI.ts
+var CatTipoServicioAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_tipo_servicio"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatTipoServicio
+};
+var CatTipoServicioAPI_default = CatTipoServicioAPI;
+
+// src/infrastructure/api/hooks/custom/CatTipoServicioHooksCustom.ts
+var catTipoServicioHooksCustom = (catTipoServicioClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatTipoServicioDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catTipoServicioClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catTipoServicio by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatTipoServicioHooksCustom_default = catTipoServicioHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatTipoServicioAPI.ts
+var createAPICatTipoServicio = () => {
+  const client = new CatTipoServicioAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatTipoServicioHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatTipoServicio,
+  useFetchList: useFetchListCatTipoServicio,
+  useCreate: useCreateCatTipoServicio,
+  useUpdate: useUpdateCatTipoServicio,
+  useDelete: useDeleteCatTipoServicio,
+  useFilterMatch: useFilterMatchCatTipoServicio
+} = createAPICatTipoServicio();
+var useCatTipoServicioAPI_default = createAPICatTipoServicio;
+
+// src/infrastructure/api/clients/CatTipoSueloAPI.ts
+var CatTipoSueloAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_tipo_suelo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatTipoSuelo
+};
+var CatTipoSueloAPI_default = CatTipoSueloAPI;
+
+// src/infrastructure/api/hooks/custom/CatTipoSueloHooksCustom.ts
+var catTipoSueloHooksCustom = (catTipoSueloClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatTipoSueloDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catTipoSueloClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catTipoSuelo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatTipoSueloHooksCustom_default = catTipoSueloHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatTipoSueloAPI.ts
+var createAPICatTipoSuelo = () => {
+  const client = new CatTipoSueloAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatTipoSueloHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatTipoSuelo,
+  useFetchList: useFetchListCatTipoSuelo,
+  useCreate: useCreateCatTipoSuelo,
+  useUpdate: useUpdateCatTipoSuelo,
+  useDelete: useDeleteCatTipoSuelo,
+  useFilterMatch: useFilterMatchCatTipoSuelo
+} = createAPICatTipoSuelo();
+var useCatTipoSueloAPI_default = createAPICatTipoSuelo;
+
+// src/infrastructure/api/clients/CatTipoTarifaAPI.ts
+var CatTipoTarifaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "cat_tipo_tarifa"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de CatTipoTarifa
+};
+var CatTipoTarifaAPI_default = CatTipoTarifaAPI;
+
+// src/infrastructure/api/hooks/custom/CatTipoTarifaHooksCustom.ts
+var catTipoTarifaHooksCustom = (catTipoTarifaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<CatTipoTarifaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await catTipoTarifaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching catTipoTarifa by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var CatTipoTarifaHooksCustom_default = catTipoTarifaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useCatTipoTarifaAPI.ts
+var createAPICatTipoTarifa = () => {
+  const client = new CatTipoTarifaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = CatTipoTarifaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdCatTipoTarifa,
+  useFetchList: useFetchListCatTipoTarifa,
+  useCreate: useCreateCatTipoTarifa,
+  useUpdate: useUpdateCatTipoTarifa,
+  useDelete: useDeleteCatTipoTarifa,
+  useFilterMatch: useFilterMatchCatTipoTarifa
+} = createAPICatTipoTarifa();
+var useCatTipoTarifaAPI_default = createAPICatTipoTarifa;
+
+// src/infrastructure/api/clients/ContribuyenteAPI.ts
+var ContribuyenteAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "contribuyente"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Contribuyente
+};
+var ContribuyenteAPI_default = ContribuyenteAPI;
+
+// src/infrastructure/api/hooks/custom/ContribuyenteHooksCustom.ts
+var contribuyenteHooksCustom = (contribuyenteClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<ContribuyenteDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await contribuyenteClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching contribuyente by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var ContribuyenteHooksCustom_default = contribuyenteHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useContribuyenteAPI.ts
+var createAPIContribuyente = () => {
+  const client = new ContribuyenteAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = ContribuyenteHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdContribuyente,
+  useFetchList: useFetchListContribuyente,
+  useCreate: useCreateContribuyente,
+  useUpdate: useUpdateContribuyente,
+  useDelete: useDeleteContribuyente,
+  useFilterMatch: useFilterMatchContribuyente
+} = createAPIContribuyente();
+var useContribuyenteAPI_default = createAPIContribuyente;
+
+// src/infrastructure/api/clients/ContribuyenteDomicilioAPI.ts
+var ContribuyenteDomicilioAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "contribuyente_domicilio"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de ContribuyenteDomicilio
+};
+var ContribuyenteDomicilioAPI_default = ContribuyenteDomicilioAPI;
+
+// src/infrastructure/api/hooks/custom/ContribuyenteDomicilioHooksCustom.ts
+var contribuyenteDomicilioHooksCustom = (contribuyenteDomicilioClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<ContribuyenteDomicilioDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await contribuyenteDomicilioClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching contribuyenteDomicilio by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var ContribuyenteDomicilioHooksCustom_default = contribuyenteDomicilioHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useContribuyenteDomicilioAPI.ts
+var createAPIContribuyenteDomicilio = () => {
+  const client = new ContribuyenteDomicilioAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = ContribuyenteDomicilioHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdContribuyenteDomicilio,
+  useFetchList: useFetchListContribuyenteDomicilio,
+  useCreate: useCreateContribuyenteDomicilio,
+  useUpdate: useUpdateContribuyenteDomicilio,
+  useDelete: useDeleteContribuyenteDomicilio,
+  useFilterMatch: useFilterMatchContribuyenteDomicilio
+} = createAPIContribuyenteDomicilio();
+var useContribuyenteDomicilioAPI_default = createAPIContribuyenteDomicilio;
+
+// src/infrastructure/api/clients/DashboardEstiloAPI.ts
+var DashboardEstiloAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_estilo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardEstilo
+};
+var DashboardEstiloAPI_default = DashboardEstiloAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardEstiloHooksCustom.ts
+var dashboardEstiloHooksCustom = (dashboardEstiloClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardEstiloDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardEstiloClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardEstilo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardEstiloHooksCustom_default = dashboardEstiloHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardEstiloAPI.ts
+var createAPIDashboardEstilo = () => {
+  const client = new DashboardEstiloAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardEstiloHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardEstilo,
+  useFetchList: useFetchListDashboardEstilo,
+  useCreate: useCreateDashboardEstilo,
+  useUpdate: useUpdateDashboardEstilo,
+  useDelete: useDeleteDashboardEstilo,
+  useFilterMatch: useFilterMatchDashboardEstilo
+} = createAPIDashboardEstilo();
+var useDashboardEstiloAPI_default = createAPIDashboardEstilo;
+
+// src/infrastructure/api/clients/DashboardGraficaAPI.ts
+var DashboardGraficaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_grafica"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardGrafica
+};
+var DashboardGraficaAPI_default = DashboardGraficaAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardGraficaHooksCustom.ts
+var dashboardGraficaHooksCustom = (dashboardGraficaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardGraficaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardGraficaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardGrafica by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardGraficaHooksCustom_default = dashboardGraficaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardGraficaAPI.ts
+var createAPIDashboardGrafica = () => {
+  const client = new DashboardGraficaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardGraficaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardGrafica,
+  useFetchList: useFetchListDashboardGrafica,
+  useCreate: useCreateDashboardGrafica,
+  useUpdate: useUpdateDashboardGrafica,
+  useDelete: useDeleteDashboardGrafica,
+  useFilterMatch: useFilterMatchDashboardGrafica
+} = createAPIDashboardGrafica();
+var useDashboardGraficaAPI_default = createAPIDashboardGrafica;
+
+// src/infrastructure/api/clients/DashboardGraficaElementoAPI.ts
+var DashboardGraficaElementoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_grafica_elemento"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardGraficaElemento
+};
+var DashboardGraficaElementoAPI_default = DashboardGraficaElementoAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardGraficaElementoHooksCustom.ts
+var dashboardGraficaElementoHooksCustom = (dashboardGraficaElementoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardGraficaElementoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardGraficaElementoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardGraficaElemento by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardGraficaElementoHooksCustom_default = dashboardGraficaElementoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardGraficaElementoAPI.ts
+var createAPIDashboardGraficaElemento = () => {
+  const client = new DashboardGraficaElementoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardGraficaElementoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardGraficaElemento,
+  useFetchList: useFetchListDashboardGraficaElemento,
+  useCreate: useCreateDashboardGraficaElemento,
+  useUpdate: useUpdateDashboardGraficaElemento,
+  useDelete: useDeleteDashboardGraficaElemento,
+  useFilterMatch: useFilterMatchDashboardGraficaElemento
+} = createAPIDashboardGraficaElemento();
+var useDashboardGraficaElementoAPI_default = createAPIDashboardGraficaElemento;
+
+// src/infrastructure/api/clients/DashboardGraficaElementoDetalleAPI.ts
+var DashboardGraficaElementoDetalleAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_grafica_elemento_detalle"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardGraficaElementoDetalle
+};
+var DashboardGraficaElementoDetalleAPI_default = DashboardGraficaElementoDetalleAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardGraficaElementoDetalleHooksCustom.ts
+var dashboardGraficaElementoDetalleHooksCustom = (dashboardGraficaElementoDetalleClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardGraficaElementoDetalleDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardGraficaElementoDetalleClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardGraficaElementoDetalle by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardGraficaElementoDetalleHooksCustom_default = dashboardGraficaElementoDetalleHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardGraficaElementoDetalleAPI.ts
+var createAPIDashboardGraficaElementoDetalle = () => {
+  const client = new DashboardGraficaElementoDetalleAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardGraficaElementoDetalleHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardGraficaElementoDetalle,
+  useFetchList: useFetchListDashboardGraficaElementoDetalle,
+  useCreate: useCreateDashboardGraficaElementoDetalle,
+  useUpdate: useUpdateDashboardGraficaElementoDetalle,
+  useDelete: useDeleteDashboardGraficaElementoDetalle,
+  useFilterMatch: useFilterMatchDashboardGraficaElementoDetalle
+} = createAPIDashboardGraficaElementoDetalle();
+var useDashboardGraficaElementoDetalleAPI_default = createAPIDashboardGraficaElementoDetalle;
+
+// src/infrastructure/api/clients/DashboardGraficaElementoParametroAPI.ts
+var DashboardGraficaElementoParametroAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_grafica_elemento_parametro"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardGraficaElementoParametro
+};
+var DashboardGraficaElementoParametroAPI_default = DashboardGraficaElementoParametroAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardGraficaElementoParametroHooksCustom.ts
+var dashboardGraficaElementoParametroHooksCustom = (dashboardGraficaElementoParametroClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardGraficaElementoParametroDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardGraficaElementoParametroClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardGraficaElementoParametro by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardGraficaElementoParametroHooksCustom_default = dashboardGraficaElementoParametroHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardGraficaElementoParametroAPI.ts
+var createAPIDashboardGraficaElementoParametro = () => {
+  const client = new DashboardGraficaElementoParametroAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardGraficaElementoParametroHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardGraficaElementoParametro,
+  useFetchList: useFetchListDashboardGraficaElementoParametro,
+  useCreate: useCreateDashboardGraficaElementoParametro,
+  useUpdate: useUpdateDashboardGraficaElementoParametro,
+  useDelete: useDeleteDashboardGraficaElementoParametro,
+  useFilterMatch: useFilterMatchDashboardGraficaElementoParametro
+} = createAPIDashboardGraficaElementoParametro();
+var useDashboardGraficaElementoParametroAPI_default = createAPIDashboardGraficaElementoParametro;
+
+// src/infrastructure/api/clients/DashboardGraficaGrupoAPI.ts
+var DashboardGraficaGrupoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_grafica_grupo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardGraficaGrupo
+};
+var DashboardGraficaGrupoAPI_default = DashboardGraficaGrupoAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardGraficaGrupoHooksCustom.ts
+var dashboardGraficaGrupoHooksCustom = (dashboardGraficaGrupoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardGraficaGrupoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardGraficaGrupoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardGraficaGrupo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardGraficaGrupoHooksCustom_default = dashboardGraficaGrupoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardGraficaGrupoAPI.ts
+var createAPIDashboardGraficaGrupo = () => {
+  const client = new DashboardGraficaGrupoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardGraficaGrupoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardGraficaGrupo,
+  useFetchList: useFetchListDashboardGraficaGrupo,
+  useCreate: useCreateDashboardGraficaGrupo,
+  useUpdate: useUpdateDashboardGraficaGrupo,
+  useDelete: useDeleteDashboardGraficaGrupo,
+  useFilterMatch: useFilterMatchDashboardGraficaGrupo
+} = createAPIDashboardGraficaGrupo();
+var useDashboardGraficaGrupoAPI_default = createAPIDashboardGraficaGrupo;
+
+// src/infrastructure/api/clients/DashboardGraficaGrupoRolAPI.ts
+var DashboardGraficaGrupoRolAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_grafica_grupo_rol"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardGraficaGrupoRol
+};
+var DashboardGraficaGrupoRolAPI_default = DashboardGraficaGrupoRolAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardGraficaGrupoRolHooksCustom.ts
+var dashboardGraficaGrupoRolHooksCustom = (dashboardGraficaGrupoRolClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardGraficaGrupoRolDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardGraficaGrupoRolClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardGraficaGrupoRol by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardGraficaGrupoRolHooksCustom_default = dashboardGraficaGrupoRolHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardGraficaGrupoRolAPI.ts
+var createAPIDashboardGraficaGrupoRol = () => {
+  const client = new DashboardGraficaGrupoRolAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardGraficaGrupoRolHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardGraficaGrupoRol,
+  useFetchList: useFetchListDashboardGraficaGrupoRol,
+  useCreate: useCreateDashboardGraficaGrupoRol,
+  useUpdate: useUpdateDashboardGraficaGrupoRol,
+  useDelete: useDeleteDashboardGraficaGrupoRol,
+  useFilterMatch: useFilterMatchDashboardGraficaGrupoRol
+} = createAPIDashboardGraficaGrupoRol();
+var useDashboardGraficaGrupoRolAPI_default = createAPIDashboardGraficaGrupoRol;
+
+// src/infrastructure/api/clients/DashboardRutaAPI.ts
+var DashboardRutaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "dashboard_ruta"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de DashboardRuta
+};
+var DashboardRutaAPI_default = DashboardRutaAPI;
+
+// src/infrastructure/api/hooks/custom/DashboardRutaHooksCustom.ts
+var dashboardRutaHooksCustom = (dashboardRutaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<DashboardRutaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await dashboardRutaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching dashboardRuta by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var DashboardRutaHooksCustom_default = dashboardRutaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useDashboardRutaAPI.ts
+var createAPIDashboardRuta = () => {
+  const client = new DashboardRutaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = DashboardRutaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdDashboardRuta,
+  useFetchList: useFetchListDashboardRuta,
+  useCreate: useCreateDashboardRuta,
+  useUpdate: useUpdateDashboardRuta,
+  useDelete: useDeleteDashboardRuta,
+  useFilterMatch: useFilterMatchDashboardRuta
+} = createAPIDashboardRuta();
+var useDashboardRutaAPI_default = createAPIDashboardRuta;
+
+// src/infrastructure/api/clients/GraficaAgrupacionAPI.ts
+var GraficaAgrupacionAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grafica_agrupacion"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de GraficaAgrupacion
+};
+var GraficaAgrupacionAPI_default = GraficaAgrupacionAPI;
+
+// src/infrastructure/api/hooks/custom/GraficaAgrupacionHooksCustom.ts
+var graficaAgrupacionHooksCustom = (graficaAgrupacionClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GraficaAgrupacionDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await graficaAgrupacionClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching graficaAgrupacion by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GraficaAgrupacionHooksCustom_default = graficaAgrupacionHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGraficaAgrupacionAPI.ts
+var createAPIGraficaAgrupacion = () => {
+  const client = new GraficaAgrupacionAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GraficaAgrupacionHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGraficaAgrupacion,
+  useFetchList: useFetchListGraficaAgrupacion,
+  useCreate: useCreateGraficaAgrupacion,
+  useUpdate: useUpdateGraficaAgrupacion,
+  useDelete: useDeleteGraficaAgrupacion,
+  useFilterMatch: useFilterMatchGraficaAgrupacion
+} = createAPIGraficaAgrupacion();
+var useGraficaAgrupacionAPI_default = createAPIGraficaAgrupacion;
+
+// src/infrastructure/api/clients/GraficaAPI.ts
+var GraficaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grafica"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Grafica
+};
+var GraficaAPI_default = GraficaAPI;
+
+// src/infrastructure/api/hooks/custom/GraficaHooksCustom.ts
+var graficaHooksCustom = (graficaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GraficaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await graficaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching grafica by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GraficaHooksCustom_default = graficaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGraficaAPI.ts
+var createAPIGrafica = () => {
+  const client = new GraficaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GraficaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGrafica,
+  useFetchList: useFetchListGrafica,
+  useCreate: useCreateGrafica,
+  useUpdate: useUpdateGrafica,
+  useDelete: useDeleteGrafica,
+  useFilterMatch: useFilterMatchGrafica
+} = createAPIGrafica();
+var useGraficaAPI_default = createAPIGrafica;
+
+// src/infrastructure/api/clients/GraficaFiltroAPI.ts
+var GraficaFiltroAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grafica_filtro"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de GraficaFiltro
+};
+var GraficaFiltroAPI_default = GraficaFiltroAPI;
+
+// src/infrastructure/api/hooks/custom/GraficaFiltroHooksCustom.ts
+var graficaFiltroHooksCustom = (graficaFiltroClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GraficaFiltroDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await graficaFiltroClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching graficaFiltro by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GraficaFiltroHooksCustom_default = graficaFiltroHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGraficaFiltroAPI.ts
+var createAPIGraficaFiltro = () => {
+  const client = new GraficaFiltroAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GraficaFiltroHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGraficaFiltro,
+  useFetchList: useFetchListGraficaFiltro,
+  useCreate: useCreateGraficaFiltro,
+  useUpdate: useUpdateGraficaFiltro,
+  useDelete: useDeleteGraficaFiltro,
+  useFilterMatch: useFilterMatchGraficaFiltro
+} = createAPIGraficaFiltro();
+var useGraficaFiltroAPI_default = createAPIGraficaFiltro;
+
+// src/infrastructure/api/clients/GraficaParametroAPI.ts
+var GraficaParametroAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grafica_parametro"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de GraficaParametro
+};
+var GraficaParametroAPI_default = GraficaParametroAPI;
+
+// src/infrastructure/api/hooks/custom/GraficaParametroHooksCustom.ts
+var graficaParametroHooksCustom = (graficaParametroClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GraficaParametroDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await graficaParametroClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching graficaParametro by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GraficaParametroHooksCustom_default = graficaParametroHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGraficaParametroAPI.ts
+var createAPIGraficaParametro = () => {
+  const client = new GraficaParametroAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GraficaParametroHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGraficaParametro,
+  useFetchList: useFetchListGraficaParametro,
+  useCreate: useCreateGraficaParametro,
+  useUpdate: useUpdateGraficaParametro,
+  useDelete: useDeleteGraficaParametro,
+  useFilterMatch: useFilterMatchGraficaParametro
+} = createAPIGraficaParametro();
+var useGraficaParametroAPI_default = createAPIGraficaParametro;
+
+// src/infrastructure/api/clients/GraficaParametroDefectoAPI.ts
+var GraficaParametroDefectoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grafica_parametro_defecto"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de GraficaParametroDefecto
+};
+var GraficaParametroDefectoAPI_default = GraficaParametroDefectoAPI;
+
+// src/infrastructure/api/hooks/custom/GraficaParametroDefectoHooksCustom.ts
+var graficaParametroDefectoHooksCustom = (graficaParametroDefectoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GraficaParametroDefectoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await graficaParametroDefectoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching graficaParametroDefecto by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GraficaParametroDefectoHooksCustom_default = graficaParametroDefectoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGraficaParametroDefectoAPI.ts
+var createAPIGraficaParametroDefecto = () => {
+  const client = new GraficaParametroDefectoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GraficaParametroDefectoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGraficaParametroDefecto,
+  useFetchList: useFetchListGraficaParametroDefecto,
+  useCreate: useCreateGraficaParametroDefecto,
+  useUpdate: useUpdateGraficaParametroDefecto,
+  useDelete: useDeleteGraficaParametroDefecto,
+  useFilterMatch: useFilterMatchGraficaParametroDefecto
+} = createAPIGraficaParametroDefecto();
+var useGraficaParametroDefectoAPI_default = createAPIGraficaParametroDefecto;
+
+// src/infrastructure/api/clients/GraficaParametroTipoAPI.ts
+var GraficaParametroTipoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grafica_parametro_tipo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de GraficaParametroTipo
+};
+var GraficaParametroTipoAPI_default = GraficaParametroTipoAPI;
+
+// src/infrastructure/api/hooks/custom/GraficaParametroTipoHooksCustom.ts
+var graficaParametroTipoHooksCustom = (graficaParametroTipoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GraficaParametroTipoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await graficaParametroTipoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching graficaParametroTipo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GraficaParametroTipoHooksCustom_default = graficaParametroTipoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGraficaParametroTipoAPI.ts
+var createAPIGraficaParametroTipo = () => {
+  const client = new GraficaParametroTipoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GraficaParametroTipoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGraficaParametroTipo,
+  useFetchList: useFetchListGraficaParametroTipo,
+  useCreate: useCreateGraficaParametroTipo,
+  useUpdate: useUpdateGraficaParametroTipo,
+  useDelete: useDeleteGraficaParametroTipo,
+  useFilterMatch: useFilterMatchGraficaParametroTipo
+} = createAPIGraficaParametroTipo();
+var useGraficaParametroTipoAPI_default = createAPIGraficaParametroTipo;
+
+// src/infrastructure/api/clients/GraficaPorGrupoAPI.ts
+var GraficaPorGrupoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grafica_por_grupo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de GraficaPorGrupo
+};
+var GraficaPorGrupoAPI_default = GraficaPorGrupoAPI;
+
+// src/infrastructure/api/hooks/custom/GraficaPorGrupoHooksCustom.ts
+var graficaPorGrupoHooksCustom = (graficaPorGrupoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GraficaPorGrupoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await graficaPorGrupoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching graficaPorGrupo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GraficaPorGrupoHooksCustom_default = graficaPorGrupoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGraficaPorGrupoAPI.ts
+var createAPIGraficaPorGrupo = () => {
+  const client = new GraficaPorGrupoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GraficaPorGrupoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGraficaPorGrupo,
+  useFetchList: useFetchListGraficaPorGrupo,
+  useCreate: useCreateGraficaPorGrupo,
+  useUpdate: useUpdateGraficaPorGrupo,
+  useDelete: useDeleteGraficaPorGrupo,
+  useFilterMatch: useFilterMatchGraficaPorGrupo
+} = createAPIGraficaPorGrupo();
+var useGraficaPorGrupoAPI_default = createAPIGraficaPorGrupo;
+
+// src/infrastructure/api/clients/GrupoUsuarioAPI.ts
+var GrupoUsuarioAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "grupo_usuario"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de GrupoUsuario
+};
+var GrupoUsuarioAPI_default = GrupoUsuarioAPI;
+
+// src/infrastructure/api/hooks/custom/GrupoUsuarioHooksCustom.ts
+var grupoUsuarioHooksCustom = (grupoUsuarioClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<GrupoUsuarioDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await grupoUsuarioClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching grupoUsuario by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var GrupoUsuarioHooksCustom_default = grupoUsuarioHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useGrupoUsuarioAPI.ts
+var createAPIGrupoUsuario = () => {
+  const client = new GrupoUsuarioAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = GrupoUsuarioHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdGrupoUsuario,
+  useFetchList: useFetchListGrupoUsuario,
+  useCreate: useCreateGrupoUsuario,
+  useUpdate: useUpdateGrupoUsuario,
+  useDelete: useDeleteGrupoUsuario,
+  useFilterMatch: useFilterMatchGrupoUsuario
+} = createAPIGrupoUsuario();
+var useGrupoUsuarioAPI_default = createAPIGrupoUsuario;
+
+// src/infrastructure/api/clients/ModuloAPI.ts
+var ModuloAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "modulo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Modulo
+};
+var ModuloAPI_default = ModuloAPI;
+
+// src/infrastructure/api/hooks/custom/ModuloHooksCustom.ts
+var moduloHooksCustom = (moduloClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<ModuloDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await moduloClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching modulo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var ModuloHooksCustom_default = moduloHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useModuloAPI.ts
+var createAPIModulo = () => {
+  const client = new ModuloAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = ModuloHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdModulo,
+  useFetchList: useFetchListModulo,
+  useCreate: useCreateModulo,
+  useUpdate: useUpdateModulo,
+  useDelete: useDeleteModulo,
+  useFilterMatch: useFilterMatchModulo
+} = createAPIModulo();
+var useModuloAPI_default = createAPIModulo;
+
+// src/infrastructure/api/clients/PagosAPI.ts
+var PagosAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "pagos"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Pagos
+};
+var PagosAPI_default = PagosAPI;
+
+// src/infrastructure/api/hooks/custom/PagosHooksCustom.ts
+var pagosHooksCustom = (pagosClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<PagosDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await pagosClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching pagos by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var PagosHooksCustom_default = pagosHooksCustom;
+
+// src/infrastructure/api/hooks/composed/usePagosAPI.ts
+var createAPIPagos = () => {
+  const client = new PagosAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = PagosHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdPagos,
+  useFetchList: useFetchListPagos,
+  useCreate: useCreatePagos,
+  useUpdate: useUpdatePagos,
+  useDelete: useDeletePagos,
+  useFilterMatch: useFilterMatchPagos
+} = createAPIPagos();
+var usePagosAPI_default = createAPIPagos;
+
+// src/infrastructure/api/clients/PermisoAccionEntidadAPI.ts
+var PermisoAccionEntidadAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "permiso_accion_entidad"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de PermisoAccionEntidad
+};
+var PermisoAccionEntidadAPI_default = PermisoAccionEntidadAPI;
+
+// src/infrastructure/api/hooks/custom/PermisoAccionEntidadHooksCustom.ts
+var permisoAccionEntidadHooksCustom = (permisoAccionEntidadClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<PermisoAccionEntidadDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await permisoAccionEntidadClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching permisoAccionEntidad by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var PermisoAccionEntidadHooksCustom_default = permisoAccionEntidadHooksCustom;
+
+// src/infrastructure/api/hooks/composed/usePermisoAccionEntidadAPI.ts
+var createAPIPermisoAccionEntidad = () => {
+  const client = new PermisoAccionEntidadAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = PermisoAccionEntidadHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdPermisoAccionEntidad,
+  useFetchList: useFetchListPermisoAccionEntidad,
+  useCreate: useCreatePermisoAccionEntidad,
+  useUpdate: useUpdatePermisoAccionEntidad,
+  useDelete: useDeletePermisoAccionEntidad,
+  useFilterMatch: useFilterMatchPermisoAccionEntidad
+} = createAPIPermisoAccionEntidad();
+var usePermisoAccionEntidadAPI_default = createAPIPermisoAccionEntidad;
+
+// src/infrastructure/api/clients/PermisoModuloAPI.ts
+var PermisoModuloAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "permiso_modulo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de PermisoModulo
+};
+var PermisoModuloAPI_default = PermisoModuloAPI;
+
+// src/infrastructure/api/hooks/custom/PermisoModuloHooksCustom.ts
+var permisoModuloHooksCustom = (permisoModuloClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<PermisoModuloDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await permisoModuloClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching permisoModulo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var PermisoModuloHooksCustom_default = permisoModuloHooksCustom;
+
+// src/infrastructure/api/hooks/composed/usePermisoModuloAPI.ts
+var createAPIPermisoModulo = () => {
+  const client = new PermisoModuloAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = PermisoModuloHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdPermisoModulo,
+  useFetchList: useFetchListPermisoModulo,
+  useCreate: useCreatePermisoModulo,
+  useUpdate: useUpdatePermisoModulo,
+  useDelete: useDeletePermisoModulo,
+  useFilterMatch: useFilterMatchPermisoModulo
+} = createAPIPermisoModulo();
+var usePermisoModuloAPI_default = createAPIPermisoModulo;
+
+// src/infrastructure/api/clients/PermisoSubmoduloAPI.ts
+var PermisoSubmoduloAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "permiso_submodulo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de PermisoSubmodulo
+};
+var PermisoSubmoduloAPI_default = PermisoSubmoduloAPI;
+
+// src/infrastructure/api/hooks/custom/PermisoSubmoduloHooksCustom.ts
+var permisoSubmoduloHooksCustom = (permisoSubmoduloClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<PermisoSubmoduloDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await permisoSubmoduloClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching permisoSubmodulo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var PermisoSubmoduloHooksCustom_default = permisoSubmoduloHooksCustom;
+
+// src/infrastructure/api/hooks/composed/usePermisoSubmoduloAPI.ts
+var createAPIPermisoSubmodulo = () => {
+  const client = new PermisoSubmoduloAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = PermisoSubmoduloHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdPermisoSubmodulo,
+  useFetchList: useFetchListPermisoSubmodulo,
+  useCreate: useCreatePermisoSubmodulo,
+  useUpdate: useUpdatePermisoSubmodulo,
+  useDelete: useDeletePermisoSubmodulo,
+  useFilterMatch: useFilterMatchPermisoSubmodulo
+} = createAPIPermisoSubmodulo();
+var usePermisoSubmoduloAPI_default = createAPIPermisoSubmodulo;
+
+// src/infrastructure/api/clients/PlazasAPI.ts
+var PlazasAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "plazas"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Plazas
+};
+var PlazasAPI_default = PlazasAPI;
+
+// src/infrastructure/api/hooks/custom/PlazasHooksCustom.ts
+var plazasHooksCustom = (plazasClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<PlazasDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await plazasClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching plazas by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var PlazasHooksCustom_default = plazasHooksCustom;
+
+// src/infrastructure/api/hooks/composed/usePlazasAPI.ts
+var createAPIPlazas = () => {
+  const client = new PlazasAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = PlazasHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdPlazas,
+  useFetchList: useFetchListPlazas,
+  useCreate: useCreatePlazas,
+  useUpdate: useUpdatePlazas,
+  useDelete: useDeletePlazas,
+  useFilterMatch: useFilterMatchPlazas
+} = createAPIPlazas();
+var usePlazasAPI_default = createAPIPlazas;
+
+// src/infrastructure/api/clients/RolAPI.ts
+var RolAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "rol"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Rol
+};
+var RolAPI_default = RolAPI;
+
+// src/infrastructure/api/hooks/custom/RolHooksCustom.ts
+var rolHooksCustom = (rolClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<RolDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await rolClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching rol by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var RolHooksCustom_default = rolHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useRolAPI.ts
+var createAPIRol = () => {
+  const client = new RolAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = RolHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdRol,
+  useFetchList: useFetchListRol,
+  useCreate: useCreateRol,
+  useUpdate: useUpdateRol,
+  useDelete: useDeleteRol,
+  useFilterMatch: useFilterMatchRol
+} = createAPIRol();
+var useRolAPI_default = createAPIRol;
+
+// src/infrastructure/api/clients/RolDashboardRutaAPI.ts
+var RolDashboardRutaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "rol_dashboard_ruta"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de RolDashboardRuta
+};
+var RolDashboardRutaAPI_default = RolDashboardRutaAPI;
+
+// src/infrastructure/api/hooks/custom/RolDashboardRutaHooksCustom.ts
+var rolDashboardRutaHooksCustom = (rolDashboardRutaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<RolDashboardRutaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await rolDashboardRutaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching rolDashboardRuta by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var RolDashboardRutaHooksCustom_default = rolDashboardRutaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useRolDashboardRutaAPI.ts
+var createAPIRolDashboardRuta = () => {
+  const client = new RolDashboardRutaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = RolDashboardRutaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdRolDashboardRuta,
+  useFetchList: useFetchListRolDashboardRuta,
+  useCreate: useCreateRolDashboardRuta,
+  useUpdate: useUpdateRolDashboardRuta,
+  useDelete: useDeleteRolDashboardRuta,
+  useFilterMatch: useFilterMatchRolDashboardRuta
+} = createAPIRolDashboardRuta();
+var useRolDashboardRutaAPI_default = createAPIRolDashboardRuta;
+
+// src/infrastructure/api/clients/RolGraficaAPI.ts
+var RolGraficaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "rol_grafica"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de RolGrafica
+};
+var RolGraficaAPI_default = RolGraficaAPI;
+
+// src/infrastructure/api/hooks/custom/RolGraficaHooksCustom.ts
+var rolGraficaHooksCustom = (rolGraficaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<RolGraficaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await rolGraficaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching rolGrafica by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var RolGraficaHooksCustom_default = rolGraficaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useRolGraficaAPI.ts
+var createAPIRolGrafica = () => {
+  const client = new RolGraficaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = RolGraficaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdRolGrafica,
+  useFetchList: useFetchListRolGrafica,
+  useCreate: useCreateRolGrafica,
+  useUpdate: useUpdateRolGrafica,
+  useDelete: useDeleteRolGrafica,
+  useFilterMatch: useFilterMatchRolGrafica
+} = createAPIRolGrafica();
+var useRolGraficaAPI_default = createAPIRolGrafica;
+
+// src/infrastructure/api/clients/SubmoduloAPI.ts
+var SubmoduloAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "submodulo"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Submodulo
+};
+var SubmoduloAPI_default = SubmoduloAPI;
+
+// src/infrastructure/api/hooks/custom/SubmoduloHooksCustom.ts
+var submoduloHooksCustom = (submoduloClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<SubmoduloDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await submoduloClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching submodulo by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var SubmoduloHooksCustom_default = submoduloHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useSubmoduloAPI.ts
+var createAPISubmodulo = () => {
+  const client = new SubmoduloAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = SubmoduloHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdSubmodulo,
+  useFetchList: useFetchListSubmodulo,
+  useCreate: useCreateSubmodulo,
+  useUpdate: useUpdateSubmodulo,
+  useDelete: useDeleteSubmodulo,
+  useFilterMatch: useFilterMatchSubmodulo
+} = createAPISubmodulo();
+var useSubmoduloAPI_default = createAPISubmodulo;
+
+// src/infrastructure/api/clients/TipoGraficaAPI.ts
+var TipoGraficaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "tipo_grafica"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de TipoGrafica
+};
+var TipoGraficaAPI_default = TipoGraficaAPI;
+
+// src/infrastructure/api/hooks/custom/TipoGraficaHooksCustom.ts
+var tipoGraficaHooksCustom = (tipoGraficaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<TipoGraficaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await tipoGraficaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching tipoGrafica by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var TipoGraficaHooksCustom_default = tipoGraficaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useTipoGraficaAPI.ts
+var createAPITipoGrafica = () => {
+  const client = new TipoGraficaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = TipoGraficaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdTipoGrafica,
+  useFetchList: useFetchListTipoGrafica,
+  useCreate: useCreateTipoGrafica,
+  useUpdate: useUpdateTipoGrafica,
+  useDelete: useDeleteTipoGrafica,
+  useFilterMatch: useFilterMatchTipoGrafica
+} = createAPITipoGrafica();
+var useTipoGraficaAPI_default = createAPITipoGrafica;
+
+// src/infrastructure/api/clients/TipoRolAPI.ts
+var TipoRolAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "tipo_rol"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de TipoRol
+};
+var TipoRolAPI_default = TipoRolAPI;
+
+// src/infrastructure/api/hooks/custom/TipoRolHooksCustom.ts
+var tipoRolHooksCustom = (tipoRolClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<TipoRolDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await tipoRolClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching tipoRol by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var TipoRolHooksCustom_default = tipoRolHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useTipoRolAPI.ts
+var createAPITipoRol = () => {
+  const client = new TipoRolAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = TipoRolHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdTipoRol,
+  useFetchList: useFetchListTipoRol,
+  useCreate: useCreateTipoRol,
+  useUpdate: useUpdateTipoRol,
+  useDelete: useDeleteTipoRol,
+  useFilterMatch: useFilterMatchTipoRol
+} = createAPITipoRol();
+var useTipoRolAPI_default = createAPITipoRol;
+
+// src/infrastructure/api/clients/UsuarioAPI.ts
+var UsuarioAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "usuario"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de Usuario
+};
+var UsuarioAPI_default = UsuarioAPI;
+
+// src/infrastructure/api/hooks/custom/UsuarioHooksCustom.ts
+var usuarioHooksCustom = (usuarioClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<UsuarioDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await usuarioClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching usuario by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var UsuarioHooksCustom_default = usuarioHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useUsuarioAPI.ts
+var createAPIUsuario = () => {
+  const client = new UsuarioAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = UsuarioHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdUsuario,
+  useFetchList: useFetchListUsuario,
+  useCreate: useCreateUsuario,
+  useUpdate: useUpdateUsuario,
+  useDelete: useDeleteUsuario,
+  useFilterMatch: useFilterMatchUsuario
+} = createAPIUsuario();
+var useUsuarioAPI_default = createAPIUsuario;
+
+// src/infrastructure/api/clients/UsuarioDashboardAccesoAPI.ts
+var UsuarioDashboardAccesoAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "usuario_dashboard_acceso"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de UsuarioDashboardAcceso
+};
+var UsuarioDashboardAccesoAPI_default = UsuarioDashboardAccesoAPI;
+
+// src/infrastructure/api/hooks/custom/UsuarioDashboardAccesoHooksCustom.ts
+var usuarioDashboardAccesoHooksCustom = (usuarioDashboardAccesoClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<UsuarioDashboardAccesoDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await usuarioDashboardAccesoClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching usuarioDashboardAcceso by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var UsuarioDashboardAccesoHooksCustom_default = usuarioDashboardAccesoHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useUsuarioDashboardAccesoAPI.ts
+var createAPIUsuarioDashboardAcceso = () => {
+  const client = new UsuarioDashboardAccesoAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = UsuarioDashboardAccesoHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdUsuarioDashboardAcceso,
+  useFetchList: useFetchListUsuarioDashboardAcceso,
+  useCreate: useCreateUsuarioDashboardAcceso,
+  useUpdate: useUpdateUsuarioDashboardAcceso,
+  useDelete: useDeleteUsuarioDashboardAcceso,
+  useFilterMatch: useFilterMatchUsuarioDashboardAcceso
+} = createAPIUsuarioDashboardAcceso();
+var useUsuarioDashboardAccesoAPI_default = createAPIUsuarioDashboardAcceso;
+
+// src/infrastructure/api/clients/UsuarioGraficaAPI.ts
+var UsuarioGraficaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "usuario_grafica"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de UsuarioGrafica
+};
+var UsuarioGraficaAPI_default = UsuarioGraficaAPI;
+
+// src/infrastructure/api/hooks/custom/UsuarioGraficaHooksCustom.ts
+var usuarioGraficaHooksCustom = (usuarioGraficaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<UsuarioGraficaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await usuarioGraficaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching usuarioGrafica by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var UsuarioGraficaHooksCustom_default = usuarioGraficaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useUsuarioGraficaAPI.ts
+var createAPIUsuarioGrafica = () => {
+  const client = new UsuarioGraficaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = UsuarioGraficaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdUsuarioGrafica,
+  useFetchList: useFetchListUsuarioGrafica,
+  useCreate: useCreateUsuarioGrafica,
+  useUpdate: useUpdateUsuarioGrafica,
+  useDelete: useDeleteUsuarioGrafica,
+  useFilterMatch: useFilterMatchUsuarioGrafica
+} = createAPIUsuarioGrafica();
+var useUsuarioGraficaAPI_default = createAPIUsuarioGrafica;
+
+// src/infrastructure/api/clients/UsuarioGraficaExcluidaAPI.ts
+var UsuarioGraficaExcluidaAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "usuario_grafica_excluida"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de UsuarioGraficaExcluida
+};
+var UsuarioGraficaExcluidaAPI_default = UsuarioGraficaExcluidaAPI;
+
+// src/infrastructure/api/hooks/custom/UsuarioGraficaExcluidaHooksCustom.ts
+var usuarioGraficaExcluidaHooksCustom = (usuarioGraficaExcluidaClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<UsuarioGraficaExcluidaDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await usuarioGraficaExcluidaClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching usuarioGraficaExcluida by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var UsuarioGraficaExcluidaHooksCustom_default = usuarioGraficaExcluidaHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useUsuarioGraficaExcluidaAPI.ts
+var createAPIUsuarioGraficaExcluida = () => {
+  const client = new UsuarioGraficaExcluidaAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = UsuarioGraficaExcluidaHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdUsuarioGraficaExcluida,
+  useFetchList: useFetchListUsuarioGraficaExcluida,
+  useCreate: useCreateUsuarioGraficaExcluida,
+  useUpdate: useUpdateUsuarioGraficaExcluida,
+  useDelete: useDeleteUsuarioGraficaExcluida,
+  useFilterMatch: useFilterMatchUsuarioGraficaExcluida
+} = createAPIUsuarioGraficaExcluida();
+var useUsuarioGraficaExcluidaAPI_default = createAPIUsuarioGraficaExcluida;
+
+// src/infrastructure/api/clients/UsuarioRolAPI.ts
+var UsuarioRolAPI = class extends APIClientBase {
+  constructor() {
+    super({
+      endpoint: "usuario_rol"
+    });
+  }
+  //* Métodos específicos aquí para el api cliente de UsuarioRol
+};
+var UsuarioRolAPI_default = UsuarioRolAPI;
+
+// src/infrastructure/api/hooks/custom/UsuarioRolHooksCustom.ts
+var usuarioRolHooksCustom = (usuarioRolClient) => {
+  return {
+    /* 
+          ejemplo: () => {
+            const [data, setData] = useState<UsuarioRolDTO | null>(null);
+            const [error, setError] = useState<Error | null>(null);
+    
+            const [isFetching, setIsFetching] = useState(false);
+    
+            const fetchData = useCallback(async () => {
+              setIsFetching(true);
+              try {
+                const result = await usuarioRolClient.getById({ id: 'example-id' });
+                setData(result);
+                setError(null);
+              } catch (err: any) {
+                setError(err);
+                console.error("Error fetching usuarioRol by ID:", err);
+              } finally {
+                setIsFetching(false);
+              }
+            }, []);
+    
+            return {
+              data,
+              error,
+              isFetching,
+              fetchData,
+            };
+          }
+        */
+  };
+};
+var UsuarioRolHooksCustom_default = usuarioRolHooksCustom;
+
+// src/infrastructure/api/hooks/composed/useUsuarioRolAPI.ts
+var createAPIUsuarioRol = () => {
+  const client = new UsuarioRolAPI_default();
+  const defaultHooks = apiHooks(client);
+  const extensionHooks = UsuarioRolHooksCustom_default(client);
+  const mergedHooks = __spreadValues(__spreadValues({}, defaultHooks), extensionHooks);
+  return mergedHooks;
+};
+var {
+  useFetchById: useFetchByIdUsuarioRol,
+  useFetchList: useFetchListUsuarioRol,
+  useCreate: useCreateUsuarioRol,
+  useUpdate: useUpdateUsuarioRol,
+  useDelete: useDeleteUsuarioRol,
+  useFilterMatch: useFilterMatchUsuarioRol
+} = createAPIUsuarioRol();
+var useUsuarioRolAPI_default = createAPIUsuarioRol;
+
+// src/exports.ts
+var createAPIAdeudoObj = useAdeudoAPI_default();
+var useFetchByIdAdeudo2 = createAPIAdeudoObj.useFetchById;
+var useFetchListAdeudo2 = createAPIAdeudoObj.useFetchList;
+var useCreateAdeudo2 = createAPIAdeudoObj.useCreate;
+var useUpdateAdeudo2 = createAPIAdeudoObj.useUpdate;
+var useDeleteAdeudo2 = createAPIAdeudoObj.useDelete;
+var useFilterMatchAdeudo2 = createAPIAdeudoObj.useFilterMatch;
+var createAPICatAccionObj = useCatAccionAPI_default();
+var useFetchByIdCatAccion2 = createAPICatAccionObj.useFetchById;
+var useFetchListCatAccion2 = createAPICatAccionObj.useFetchList;
+var useCreateCatAccion2 = createAPICatAccionObj.useCreate;
+var useUpdateCatAccion2 = createAPICatAccionObj.useUpdate;
+var useDeleteCatAccion2 = createAPICatAccionObj.useDelete;
+var useFilterMatchCatAccion2 = createAPICatAccionObj.useFilterMatch;
+var createAPICatConceptoPagoObj = useCatConceptoPagoAPI_default();
+var useFetchByIdCatConceptoPago2 = createAPICatConceptoPagoObj.useFetchById;
+var useFetchListCatConceptoPago2 = createAPICatConceptoPagoObj.useFetchList;
+var useCreateCatConceptoPago2 = createAPICatConceptoPagoObj.useCreate;
+var useUpdateCatConceptoPago2 = createAPICatConceptoPagoObj.useUpdate;
+var useDeleteCatConceptoPago2 = createAPICatConceptoPagoObj.useDelete;
+var useFilterMatchCatConceptoPago2 = createAPICatConceptoPagoObj.useFilterMatch;
+var createAPICatEntidadObj = useCatEntidadAPI_default();
+var useFetchByIdCatEntidad2 = createAPICatEntidadObj.useFetchById;
+var useFetchListCatEntidad2 = createAPICatEntidadObj.useFetchList;
+var useCreateCatEntidad2 = createAPICatEntidadObj.useCreate;
+var useUpdateCatEntidad2 = createAPICatEntidadObj.useUpdate;
+var useDeleteCatEntidad2 = createAPICatEntidadObj.useDelete;
+var useFilterMatchCatEntidad2 = createAPICatEntidadObj.useFilterMatch;
+var createAPICatFechaAgrupacionObj = useCatFechaAgrupacionAPI_default();
+var useFetchByIdCatFechaAgrupacion2 = createAPICatFechaAgrupacionObj.useFetchById;
+var useFetchListCatFechaAgrupacion2 = createAPICatFechaAgrupacionObj.useFetchList;
+var useCreateCatFechaAgrupacion2 = createAPICatFechaAgrupacionObj.useCreate;
+var useUpdateCatFechaAgrupacion2 = createAPICatFechaAgrupacionObj.useUpdate;
+var useDeleteCatFechaAgrupacion2 = createAPICatFechaAgrupacionObj.useDelete;
+var useFilterMatchCatFechaAgrupacion2 = createAPICatFechaAgrupacionObj.useFilterMatch;
+var createAPICatGraficaGrupoObj = useCatGraficaGrupoAPI_default();
+var useFetchByIdCatGraficaGrupo2 = createAPICatGraficaGrupoObj.useFetchById;
+var useFetchListCatGraficaGrupo2 = createAPICatGraficaGrupoObj.useFetchList;
+var useCreateCatGraficaGrupo2 = createAPICatGraficaGrupoObj.useCreate;
+var useUpdateCatGraficaGrupo2 = createAPICatGraficaGrupoObj.useUpdate;
+var useDeleteCatGraficaGrupo2 = createAPICatGraficaGrupoObj.useDelete;
+var useFilterMatchCatGraficaGrupo2 = createAPICatGraficaGrupoObj.useFilterMatch;
+var createAPICatPlazaObj = useCatPlazaAPI_default();
+var useFetchByIdCatPlaza2 = createAPICatPlazaObj.useFetchById;
+var useFetchListCatPlaza2 = createAPICatPlazaObj.useFetchList;
+var useCreateCatPlaza2 = createAPICatPlazaObj.useCreate;
+var useUpdateCatPlaza2 = createAPICatPlazaObj.useUpdate;
+var useDeleteCatPlaza2 = createAPICatPlazaObj.useDelete;
+var useFilterMatchCatPlaza2 = createAPICatPlazaObj.useFilterMatch;
+var createAPICatRolGrupoObj = useCatRolGrupoAPI_default();
+var useFetchByIdCatRolGrupo2 = createAPICatRolGrupoObj.useFetchById;
+var useFetchListCatRolGrupo2 = createAPICatRolGrupoObj.useFetchList;
+var useCreateCatRolGrupo2 = createAPICatRolGrupoObj.useCreate;
+var useUpdateCatRolGrupo2 = createAPICatRolGrupoObj.useUpdate;
+var useDeleteCatRolGrupo2 = createAPICatRolGrupoObj.useDelete;
+var useFilterMatchCatRolGrupo2 = createAPICatRolGrupoObj.useFilterMatch;
+var createAPICatTipoParametroObj = useCatTipoParametroAPI_default();
+var useFetchByIdCatTipoParametro2 = createAPICatTipoParametroObj.useFetchById;
+var useFetchListCatTipoParametro2 = createAPICatTipoParametroObj.useFetchList;
+var useCreateCatTipoParametro2 = createAPICatTipoParametroObj.useCreate;
+var useUpdateCatTipoParametro2 = createAPICatTipoParametroObj.useUpdate;
+var useDeleteCatTipoParametro2 = createAPICatTipoParametroObj.useDelete;
+var useFilterMatchCatTipoParametro2 = createAPICatTipoParametroObj.useFilterMatch;
+var createAPICatTipoServicioObj = useCatTipoServicioAPI_default();
+var useFetchByIdCatTipoServicio2 = createAPICatTipoServicioObj.useFetchById;
+var useFetchListCatTipoServicio2 = createAPICatTipoServicioObj.useFetchList;
+var useCreateCatTipoServicio2 = createAPICatTipoServicioObj.useCreate;
+var useUpdateCatTipoServicio2 = createAPICatTipoServicioObj.useUpdate;
+var useDeleteCatTipoServicio2 = createAPICatTipoServicioObj.useDelete;
+var useFilterMatchCatTipoServicio2 = createAPICatTipoServicioObj.useFilterMatch;
+var createAPICatTipoSueloObj = useCatTipoSueloAPI_default();
+var useFetchByIdCatTipoSuelo2 = createAPICatTipoSueloObj.useFetchById;
+var useFetchListCatTipoSuelo2 = createAPICatTipoSueloObj.useFetchList;
+var useCreateCatTipoSuelo2 = createAPICatTipoSueloObj.useCreate;
+var useUpdateCatTipoSuelo2 = createAPICatTipoSueloObj.useUpdate;
+var useDeleteCatTipoSuelo2 = createAPICatTipoSueloObj.useDelete;
+var useFilterMatchCatTipoSuelo2 = createAPICatTipoSueloObj.useFilterMatch;
+var createAPICatTipoTarifaObj = useCatTipoTarifaAPI_default();
+var useFetchByIdCatTipoTarifa2 = createAPICatTipoTarifaObj.useFetchById;
+var useFetchListCatTipoTarifa2 = createAPICatTipoTarifaObj.useFetchList;
+var useCreateCatTipoTarifa2 = createAPICatTipoTarifaObj.useCreate;
+var useUpdateCatTipoTarifa2 = createAPICatTipoTarifaObj.useUpdate;
+var useDeleteCatTipoTarifa2 = createAPICatTipoTarifaObj.useDelete;
+var useFilterMatchCatTipoTarifa2 = createAPICatTipoTarifaObj.useFilterMatch;
+var createAPIContribuyenteObj = useContribuyenteAPI_default();
+var useFetchByIdContribuyente2 = createAPIContribuyenteObj.useFetchById;
+var useFetchListContribuyente2 = createAPIContribuyenteObj.useFetchList;
+var useCreateContribuyente2 = createAPIContribuyenteObj.useCreate;
+var useUpdateContribuyente2 = createAPIContribuyenteObj.useUpdate;
+var useDeleteContribuyente2 = createAPIContribuyenteObj.useDelete;
+var useFilterMatchContribuyente2 = createAPIContribuyenteObj.useFilterMatch;
+var createAPIContribuyenteDomicilioObj = useContribuyenteDomicilioAPI_default();
+var useFetchByIdContribuyenteDomicilio2 = createAPIContribuyenteDomicilioObj.useFetchById;
+var useFetchListContribuyenteDomicilio2 = createAPIContribuyenteDomicilioObj.useFetchList;
+var useCreateContribuyenteDomicilio2 = createAPIContribuyenteDomicilioObj.useCreate;
+var useUpdateContribuyenteDomicilio2 = createAPIContribuyenteDomicilioObj.useUpdate;
+var useDeleteContribuyenteDomicilio2 = createAPIContribuyenteDomicilioObj.useDelete;
+var useFilterMatchContribuyenteDomicilio2 = createAPIContribuyenteDomicilioObj.useFilterMatch;
+var createAPIDashboardEstiloObj = useDashboardEstiloAPI_default();
+var useFetchByIdDashboardEstilo2 = createAPIDashboardEstiloObj.useFetchById;
+var useFetchListDashboardEstilo2 = createAPIDashboardEstiloObj.useFetchList;
+var useCreateDashboardEstilo2 = createAPIDashboardEstiloObj.useCreate;
+var useUpdateDashboardEstilo2 = createAPIDashboardEstiloObj.useUpdate;
+var useDeleteDashboardEstilo2 = createAPIDashboardEstiloObj.useDelete;
+var useFilterMatchDashboardEstilo2 = createAPIDashboardEstiloObj.useFilterMatch;
+var createAPIDashboardGraficaObj = useDashboardGraficaAPI_default();
+var useFetchByIdDashboardGrafica2 = createAPIDashboardGraficaObj.useFetchById;
+var useFetchListDashboardGrafica2 = createAPIDashboardGraficaObj.useFetchList;
+var useCreateDashboardGrafica2 = createAPIDashboardGraficaObj.useCreate;
+var useUpdateDashboardGrafica2 = createAPIDashboardGraficaObj.useUpdate;
+var useDeleteDashboardGrafica2 = createAPIDashboardGraficaObj.useDelete;
+var useFilterMatchDashboardGrafica2 = createAPIDashboardGraficaObj.useFilterMatch;
+var createAPIDashboardGraficaElementoObj = useDashboardGraficaElementoAPI_default();
+var useFetchByIdDashboardGraficaElemento2 = createAPIDashboardGraficaElementoObj.useFetchById;
+var useFetchListDashboardGraficaElemento2 = createAPIDashboardGraficaElementoObj.useFetchList;
+var useCreateDashboardGraficaElemento2 = createAPIDashboardGraficaElementoObj.useCreate;
+var useUpdateDashboardGraficaElemento2 = createAPIDashboardGraficaElementoObj.useUpdate;
+var useDeleteDashboardGraficaElemento2 = createAPIDashboardGraficaElementoObj.useDelete;
+var useFilterMatchDashboardGraficaElemento2 = createAPIDashboardGraficaElementoObj.useFilterMatch;
+var createAPIDashboardGraficaElementoDetalleObj = useDashboardGraficaElementoDetalleAPI_default();
+var useFetchByIdDashboardGraficaElementoDetalle2 = createAPIDashboardGraficaElementoDetalleObj.useFetchById;
+var useFetchListDashboardGraficaElementoDetalle2 = createAPIDashboardGraficaElementoDetalleObj.useFetchList;
+var useCreateDashboardGraficaElementoDetalle2 = createAPIDashboardGraficaElementoDetalleObj.useCreate;
+var useUpdateDashboardGraficaElementoDetalle2 = createAPIDashboardGraficaElementoDetalleObj.useUpdate;
+var useDeleteDashboardGraficaElementoDetalle2 = createAPIDashboardGraficaElementoDetalleObj.useDelete;
+var useFilterMatchDashboardGraficaElementoDetalle2 = createAPIDashboardGraficaElementoDetalleObj.useFilterMatch;
+var createAPIDashboardGraficaElementoParametroObj = useDashboardGraficaElementoParametroAPI_default();
+var useFetchByIdDashboardGraficaElementoParametro2 = createAPIDashboardGraficaElementoParametroObj.useFetchById;
+var useFetchListDashboardGraficaElementoParametro2 = createAPIDashboardGraficaElementoParametroObj.useFetchList;
+var useCreateDashboardGraficaElementoParametro2 = createAPIDashboardGraficaElementoParametroObj.useCreate;
+var useUpdateDashboardGraficaElementoParametro2 = createAPIDashboardGraficaElementoParametroObj.useUpdate;
+var useDeleteDashboardGraficaElementoParametro2 = createAPIDashboardGraficaElementoParametroObj.useDelete;
+var useFilterMatchDashboardGraficaElementoParametro2 = createAPIDashboardGraficaElementoParametroObj.useFilterMatch;
+var createAPIDashboardGraficaGrupoObj = useDashboardGraficaGrupoAPI_default();
+var useFetchByIdDashboardGraficaGrupo2 = createAPIDashboardGraficaGrupoObj.useFetchById;
+var useFetchListDashboardGraficaGrupo2 = createAPIDashboardGraficaGrupoObj.useFetchList;
+var useCreateDashboardGraficaGrupo2 = createAPIDashboardGraficaGrupoObj.useCreate;
+var useUpdateDashboardGraficaGrupo2 = createAPIDashboardGraficaGrupoObj.useUpdate;
+var useDeleteDashboardGraficaGrupo2 = createAPIDashboardGraficaGrupoObj.useDelete;
+var useFilterMatchDashboardGraficaGrupo2 = createAPIDashboardGraficaGrupoObj.useFilterMatch;
+var createAPIDashboardGraficaGrupoRolObj = useDashboardGraficaGrupoRolAPI_default();
+var useFetchByIdDashboardGraficaGrupoRol2 = createAPIDashboardGraficaGrupoRolObj.useFetchById;
+var useFetchListDashboardGraficaGrupoRol2 = createAPIDashboardGraficaGrupoRolObj.useFetchList;
+var useCreateDashboardGraficaGrupoRol2 = createAPIDashboardGraficaGrupoRolObj.useCreate;
+var useUpdateDashboardGraficaGrupoRol2 = createAPIDashboardGraficaGrupoRolObj.useUpdate;
+var useDeleteDashboardGraficaGrupoRol2 = createAPIDashboardGraficaGrupoRolObj.useDelete;
+var useFilterMatchDashboardGraficaGrupoRol2 = createAPIDashboardGraficaGrupoRolObj.useFilterMatch;
+var createAPIDashboardRutaObj = useDashboardRutaAPI_default();
+var useFetchByIdDashboardRuta2 = createAPIDashboardRutaObj.useFetchById;
+var useFetchListDashboardRuta2 = createAPIDashboardRutaObj.useFetchList;
+var useCreateDashboardRuta2 = createAPIDashboardRutaObj.useCreate;
+var useUpdateDashboardRuta2 = createAPIDashboardRutaObj.useUpdate;
+var useDeleteDashboardRuta2 = createAPIDashboardRutaObj.useDelete;
+var useFilterMatchDashboardRuta2 = createAPIDashboardRutaObj.useFilterMatch;
+var createAPIGraficaAgrupacionObj = useGraficaAgrupacionAPI_default();
+var useFetchByIdGraficaAgrupacion2 = createAPIGraficaAgrupacionObj.useFetchById;
+var useFetchListGraficaAgrupacion2 = createAPIGraficaAgrupacionObj.useFetchList;
+var useCreateGraficaAgrupacion2 = createAPIGraficaAgrupacionObj.useCreate;
+var useUpdateGraficaAgrupacion2 = createAPIGraficaAgrupacionObj.useUpdate;
+var useDeleteGraficaAgrupacion2 = createAPIGraficaAgrupacionObj.useDelete;
+var useFilterMatchGraficaAgrupacion2 = createAPIGraficaAgrupacionObj.useFilterMatch;
+var createAPIGraficaObj = useGraficaAPI_default();
+var useFetchByIdGrafica2 = createAPIGraficaObj.useFetchById;
+var useFetchListGrafica2 = createAPIGraficaObj.useFetchList;
+var useCreateGrafica2 = createAPIGraficaObj.useCreate;
+var useUpdateGrafica2 = createAPIGraficaObj.useUpdate;
+var useDeleteGrafica2 = createAPIGraficaObj.useDelete;
+var useFilterMatchGrafica2 = createAPIGraficaObj.useFilterMatch;
+var createAPIGraficaFiltroObj = useGraficaFiltroAPI_default();
+var useFetchByIdGraficaFiltro2 = createAPIGraficaFiltroObj.useFetchById;
+var useFetchListGraficaFiltro2 = createAPIGraficaFiltroObj.useFetchList;
+var useCreateGraficaFiltro2 = createAPIGraficaFiltroObj.useCreate;
+var useUpdateGraficaFiltro2 = createAPIGraficaFiltroObj.useUpdate;
+var useDeleteGraficaFiltro2 = createAPIGraficaFiltroObj.useDelete;
+var useFilterMatchGraficaFiltro2 = createAPIGraficaFiltroObj.useFilterMatch;
+var createAPIGraficaParametroObj = useGraficaParametroAPI_default();
+var useFetchByIdGraficaParametro2 = createAPIGraficaParametroObj.useFetchById;
+var useFetchListGraficaParametro2 = createAPIGraficaParametroObj.useFetchList;
+var useCreateGraficaParametro2 = createAPIGraficaParametroObj.useCreate;
+var useUpdateGraficaParametro2 = createAPIGraficaParametroObj.useUpdate;
+var useDeleteGraficaParametro2 = createAPIGraficaParametroObj.useDelete;
+var useFilterMatchGraficaParametro2 = createAPIGraficaParametroObj.useFilterMatch;
+var createAPIGraficaParametroDefectoObj = useGraficaParametroDefectoAPI_default();
+var useFetchByIdGraficaParametroDefecto2 = createAPIGraficaParametroDefectoObj.useFetchById;
+var useFetchListGraficaParametroDefecto2 = createAPIGraficaParametroDefectoObj.useFetchList;
+var useCreateGraficaParametroDefecto2 = createAPIGraficaParametroDefectoObj.useCreate;
+var useUpdateGraficaParametroDefecto2 = createAPIGraficaParametroDefectoObj.useUpdate;
+var useDeleteGraficaParametroDefecto2 = createAPIGraficaParametroDefectoObj.useDelete;
+var useFilterMatchGraficaParametroDefecto2 = createAPIGraficaParametroDefectoObj.useFilterMatch;
+var createAPIGraficaParametroTipoObj = useGraficaParametroTipoAPI_default();
+var useFetchByIdGraficaParametroTipo2 = createAPIGraficaParametroTipoObj.useFetchById;
+var useFetchListGraficaParametroTipo2 = createAPIGraficaParametroTipoObj.useFetchList;
+var useCreateGraficaParametroTipo2 = createAPIGraficaParametroTipoObj.useCreate;
+var useUpdateGraficaParametroTipo2 = createAPIGraficaParametroTipoObj.useUpdate;
+var useDeleteGraficaParametroTipo2 = createAPIGraficaParametroTipoObj.useDelete;
+var useFilterMatchGraficaParametroTipo2 = createAPIGraficaParametroTipoObj.useFilterMatch;
+var createAPIGraficaPorGrupoObj = useGraficaPorGrupoAPI_default();
+var useFetchByIdGraficaPorGrupo2 = createAPIGraficaPorGrupoObj.useFetchById;
+var useFetchListGraficaPorGrupo2 = createAPIGraficaPorGrupoObj.useFetchList;
+var useCreateGraficaPorGrupo2 = createAPIGraficaPorGrupoObj.useCreate;
+var useUpdateGraficaPorGrupo2 = createAPIGraficaPorGrupoObj.useUpdate;
+var useDeleteGraficaPorGrupo2 = createAPIGraficaPorGrupoObj.useDelete;
+var useFilterMatchGraficaPorGrupo2 = createAPIGraficaPorGrupoObj.useFilterMatch;
+var createAPIGrupoUsuarioObj = useGrupoUsuarioAPI_default();
+var useFetchByIdGrupoUsuario2 = createAPIGrupoUsuarioObj.useFetchById;
+var useFetchListGrupoUsuario2 = createAPIGrupoUsuarioObj.useFetchList;
+var useCreateGrupoUsuario2 = createAPIGrupoUsuarioObj.useCreate;
+var useUpdateGrupoUsuario2 = createAPIGrupoUsuarioObj.useUpdate;
+var useDeleteGrupoUsuario2 = createAPIGrupoUsuarioObj.useDelete;
+var useFilterMatchGrupoUsuario2 = createAPIGrupoUsuarioObj.useFilterMatch;
+var createAPIModuloObj = useModuloAPI_default();
+var useFetchByIdModulo2 = createAPIModuloObj.useFetchById;
+var useFetchListModulo2 = createAPIModuloObj.useFetchList;
+var useCreateModulo2 = createAPIModuloObj.useCreate;
+var useUpdateModulo2 = createAPIModuloObj.useUpdate;
+var useDeleteModulo2 = createAPIModuloObj.useDelete;
+var useFilterMatchModulo2 = createAPIModuloObj.useFilterMatch;
+var createAPIPagosObj = usePagosAPI_default();
+var useFetchByIdPagos2 = createAPIPagosObj.useFetchById;
+var useFetchListPagos2 = createAPIPagosObj.useFetchList;
+var useCreatePagos2 = createAPIPagosObj.useCreate;
+var useUpdatePagos2 = createAPIPagosObj.useUpdate;
+var useDeletePagos2 = createAPIPagosObj.useDelete;
+var useFilterMatchPagos2 = createAPIPagosObj.useFilterMatch;
+var createAPIPermisoAccionEntidadObj = usePermisoAccionEntidadAPI_default();
+var useFetchByIdPermisoAccionEntidad2 = createAPIPermisoAccionEntidadObj.useFetchById;
+var useFetchListPermisoAccionEntidad2 = createAPIPermisoAccionEntidadObj.useFetchList;
+var useCreatePermisoAccionEntidad2 = createAPIPermisoAccionEntidadObj.useCreate;
+var useUpdatePermisoAccionEntidad2 = createAPIPermisoAccionEntidadObj.useUpdate;
+var useDeletePermisoAccionEntidad2 = createAPIPermisoAccionEntidadObj.useDelete;
+var useFilterMatchPermisoAccionEntidad2 = createAPIPermisoAccionEntidadObj.useFilterMatch;
+var createAPIPermisoModuloObj = usePermisoModuloAPI_default();
+var useFetchByIdPermisoModulo2 = createAPIPermisoModuloObj.useFetchById;
+var useFetchListPermisoModulo2 = createAPIPermisoModuloObj.useFetchList;
+var useCreatePermisoModulo2 = createAPIPermisoModuloObj.useCreate;
+var useUpdatePermisoModulo2 = createAPIPermisoModuloObj.useUpdate;
+var useDeletePermisoModulo2 = createAPIPermisoModuloObj.useDelete;
+var useFilterMatchPermisoModulo2 = createAPIPermisoModuloObj.useFilterMatch;
+var createAPIPermisoSubmoduloObj = usePermisoSubmoduloAPI_default();
+var useFetchByIdPermisoSubmodulo2 = createAPIPermisoSubmoduloObj.useFetchById;
+var useFetchListPermisoSubmodulo2 = createAPIPermisoSubmoduloObj.useFetchList;
+var useCreatePermisoSubmodulo2 = createAPIPermisoSubmoduloObj.useCreate;
+var useUpdatePermisoSubmodulo2 = createAPIPermisoSubmoduloObj.useUpdate;
+var useDeletePermisoSubmodulo2 = createAPIPermisoSubmoduloObj.useDelete;
+var useFilterMatchPermisoSubmodulo2 = createAPIPermisoSubmoduloObj.useFilterMatch;
+var createAPIPlazasObj = usePlazasAPI_default();
+var useFetchByIdPlazas2 = createAPIPlazasObj.useFetchById;
+var useFetchListPlazas2 = createAPIPlazasObj.useFetchList;
+var useCreatePlazas2 = createAPIPlazasObj.useCreate;
+var useUpdatePlazas2 = createAPIPlazasObj.useUpdate;
+var useDeletePlazas2 = createAPIPlazasObj.useDelete;
+var useFilterMatchPlazas2 = createAPIPlazasObj.useFilterMatch;
+var createAPIRolObj = useRolAPI_default();
+var useFetchByIdRol2 = createAPIRolObj.useFetchById;
+var useFetchListRol2 = createAPIRolObj.useFetchList;
+var useCreateRol2 = createAPIRolObj.useCreate;
+var useUpdateRol2 = createAPIRolObj.useUpdate;
+var useDeleteRol2 = createAPIRolObj.useDelete;
+var useFilterMatchRol2 = createAPIRolObj.useFilterMatch;
+var createAPIRolDashboardRutaObj = useRolDashboardRutaAPI_default();
+var useFetchByIdRolDashboardRuta2 = createAPIRolDashboardRutaObj.useFetchById;
+var useFetchListRolDashboardRuta2 = createAPIRolDashboardRutaObj.useFetchList;
+var useCreateRolDashboardRuta2 = createAPIRolDashboardRutaObj.useCreate;
+var useUpdateRolDashboardRuta2 = createAPIRolDashboardRutaObj.useUpdate;
+var useDeleteRolDashboardRuta2 = createAPIRolDashboardRutaObj.useDelete;
+var useFilterMatchRolDashboardRuta2 = createAPIRolDashboardRutaObj.useFilterMatch;
+var createAPIRolGraficaObj = useRolGraficaAPI_default();
+var useFetchByIdRolGrafica2 = createAPIRolGraficaObj.useFetchById;
+var useFetchListRolGrafica2 = createAPIRolGraficaObj.useFetchList;
+var useCreateRolGrafica2 = createAPIRolGraficaObj.useCreate;
+var useUpdateRolGrafica2 = createAPIRolGraficaObj.useUpdate;
+var useDeleteRolGrafica2 = createAPIRolGraficaObj.useDelete;
+var useFilterMatchRolGrafica2 = createAPIRolGraficaObj.useFilterMatch;
+var createAPISubmoduloObj = useSubmoduloAPI_default();
+var useFetchByIdSubmodulo2 = createAPISubmoduloObj.useFetchById;
+var useFetchListSubmodulo2 = createAPISubmoduloObj.useFetchList;
+var useCreateSubmodulo2 = createAPISubmoduloObj.useCreate;
+var useUpdateSubmodulo2 = createAPISubmoduloObj.useUpdate;
+var useDeleteSubmodulo2 = createAPISubmoduloObj.useDelete;
+var useFilterMatchSubmodulo2 = createAPISubmoduloObj.useFilterMatch;
+var createAPITipoGraficaObj = useTipoGraficaAPI_default();
+var useFetchByIdTipoGrafica2 = createAPITipoGraficaObj.useFetchById;
+var useFetchListTipoGrafica2 = createAPITipoGraficaObj.useFetchList;
+var useCreateTipoGrafica2 = createAPITipoGraficaObj.useCreate;
+var useUpdateTipoGrafica2 = createAPITipoGraficaObj.useUpdate;
+var useDeleteTipoGrafica2 = createAPITipoGraficaObj.useDelete;
+var useFilterMatchTipoGrafica2 = createAPITipoGraficaObj.useFilterMatch;
+var createAPITipoRolObj = useTipoRolAPI_default();
+var useFetchByIdTipoRol2 = createAPITipoRolObj.useFetchById;
+var useFetchListTipoRol2 = createAPITipoRolObj.useFetchList;
+var useCreateTipoRol2 = createAPITipoRolObj.useCreate;
+var useUpdateTipoRol2 = createAPITipoRolObj.useUpdate;
+var useDeleteTipoRol2 = createAPITipoRolObj.useDelete;
+var useFilterMatchTipoRol2 = createAPITipoRolObj.useFilterMatch;
+var createAPIUsuarioObj = useUsuarioAPI_default();
+var useFetchByIdUsuario2 = createAPIUsuarioObj.useFetchById;
+var useFetchListUsuario2 = createAPIUsuarioObj.useFetchList;
+var useCreateUsuario2 = createAPIUsuarioObj.useCreate;
+var useUpdateUsuario2 = createAPIUsuarioObj.useUpdate;
+var useDeleteUsuario2 = createAPIUsuarioObj.useDelete;
+var useFilterMatchUsuario2 = createAPIUsuarioObj.useFilterMatch;
+var createAPIUsuarioDashboardAccesoObj = useUsuarioDashboardAccesoAPI_default();
+var useFetchByIdUsuarioDashboardAcceso2 = createAPIUsuarioDashboardAccesoObj.useFetchById;
+var useFetchListUsuarioDashboardAcceso2 = createAPIUsuarioDashboardAccesoObj.useFetchList;
+var useCreateUsuarioDashboardAcceso2 = createAPIUsuarioDashboardAccesoObj.useCreate;
+var useUpdateUsuarioDashboardAcceso2 = createAPIUsuarioDashboardAccesoObj.useUpdate;
+var useDeleteUsuarioDashboardAcceso2 = createAPIUsuarioDashboardAccesoObj.useDelete;
+var useFilterMatchUsuarioDashboardAcceso2 = createAPIUsuarioDashboardAccesoObj.useFilterMatch;
+var createAPIUsuarioGraficaObj = useUsuarioGraficaAPI_default();
+var useFetchByIdUsuarioGrafica2 = createAPIUsuarioGraficaObj.useFetchById;
+var useFetchListUsuarioGrafica2 = createAPIUsuarioGraficaObj.useFetchList;
+var useCreateUsuarioGrafica2 = createAPIUsuarioGraficaObj.useCreate;
+var useUpdateUsuarioGrafica2 = createAPIUsuarioGraficaObj.useUpdate;
+var useDeleteUsuarioGrafica2 = createAPIUsuarioGraficaObj.useDelete;
+var useFilterMatchUsuarioGrafica2 = createAPIUsuarioGraficaObj.useFilterMatch;
+var createAPIUsuarioGraficaExcluidaObj = useUsuarioGraficaExcluidaAPI_default();
+var useFetchByIdUsuarioGraficaExcluida2 = createAPIUsuarioGraficaExcluidaObj.useFetchById;
+var useFetchListUsuarioGraficaExcluida2 = createAPIUsuarioGraficaExcluidaObj.useFetchList;
+var useCreateUsuarioGraficaExcluida2 = createAPIUsuarioGraficaExcluidaObj.useCreate;
+var useUpdateUsuarioGraficaExcluida2 = createAPIUsuarioGraficaExcluidaObj.useUpdate;
+var useDeleteUsuarioGraficaExcluida2 = createAPIUsuarioGraficaExcluidaObj.useDelete;
+var useFilterMatchUsuarioGraficaExcluida2 = createAPIUsuarioGraficaExcluidaObj.useFilterMatch;
+var createAPIUsuarioRolObj = useUsuarioRolAPI_default();
+var useFetchByIdUsuarioRol2 = createAPIUsuarioRolObj.useFetchById;
+var useFetchListUsuarioRol2 = createAPIUsuarioRolObj.useFetchList;
+var useCreateUsuarioRol2 = createAPIUsuarioRolObj.useCreate;
+var useUpdateUsuarioRol2 = createAPIUsuarioRolObj.useUpdate;
+var useDeleteUsuarioRol2 = createAPIUsuarioRolObj.useDelete;
+var useFilterMatchUsuarioRol2 = createAPIUsuarioRolObj.useFilterMatch;
+export {
+  APIFactory,
+  useCreateAdeudo2 as useCreateAdeudo,
+  useCreateCatAccion2 as useCreateCatAccion,
+  useCreateCatConceptoPago2 as useCreateCatConceptoPago,
+  useCreateCatEntidad2 as useCreateCatEntidad,
+  useCreateCatFechaAgrupacion2 as useCreateCatFechaAgrupacion,
+  useCreateCatGraficaGrupo2 as useCreateCatGraficaGrupo,
+  useCreateCatPlaza2 as useCreateCatPlaza,
+  useCreateCatRolGrupo2 as useCreateCatRolGrupo,
+  useCreateCatTipoParametro2 as useCreateCatTipoParametro,
+  useCreateCatTipoServicio2 as useCreateCatTipoServicio,
+  useCreateCatTipoSuelo2 as useCreateCatTipoSuelo,
+  useCreateCatTipoTarifa2 as useCreateCatTipoTarifa,
+  useCreateContribuyente2 as useCreateContribuyente,
+  useCreateContribuyenteDomicilio2 as useCreateContribuyenteDomicilio,
+  useCreateDashboardEstilo2 as useCreateDashboardEstilo,
+  useCreateDashboardGrafica2 as useCreateDashboardGrafica,
+  useCreateDashboardGraficaElemento2 as useCreateDashboardGraficaElemento,
+  useCreateDashboardGraficaElementoDetalle2 as useCreateDashboardGraficaElementoDetalle,
+  useCreateDashboardGraficaElementoParametro2 as useCreateDashboardGraficaElementoParametro,
+  useCreateDashboardGraficaGrupo2 as useCreateDashboardGraficaGrupo,
+  useCreateDashboardGraficaGrupoRol2 as useCreateDashboardGraficaGrupoRol,
+  useCreateDashboardRuta2 as useCreateDashboardRuta,
+  useCreateGrafica2 as useCreateGrafica,
+  useCreateGraficaAgrupacion2 as useCreateGraficaAgrupacion,
+  useCreateGraficaFiltro2 as useCreateGraficaFiltro,
+  useCreateGraficaParametro2 as useCreateGraficaParametro,
+  useCreateGraficaParametroDefecto2 as useCreateGraficaParametroDefecto,
+  useCreateGraficaParametroTipo2 as useCreateGraficaParametroTipo,
+  useCreateGraficaPorGrupo2 as useCreateGraficaPorGrupo,
+  useCreateGrupoUsuario2 as useCreateGrupoUsuario,
+  useCreateModulo2 as useCreateModulo,
+  useCreatePagos2 as useCreatePagos,
+  useCreatePermisoAccionEntidad2 as useCreatePermisoAccionEntidad,
+  useCreatePermisoModulo2 as useCreatePermisoModulo,
+  useCreatePermisoSubmodulo2 as useCreatePermisoSubmodulo,
+  useCreatePlazas2 as useCreatePlazas,
+  useCreateRol2 as useCreateRol,
+  useCreateRolDashboardRuta2 as useCreateRolDashboardRuta,
+  useCreateRolGrafica2 as useCreateRolGrafica,
+  useCreateSubmodulo2 as useCreateSubmodulo,
+  useCreateTipoGrafica2 as useCreateTipoGrafica,
+  useCreateTipoRol2 as useCreateTipoRol,
+  useCreateUsuario2 as useCreateUsuario,
+  useCreateUsuarioDashboardAcceso2 as useCreateUsuarioDashboardAcceso,
+  useCreateUsuarioGrafica2 as useCreateUsuarioGrafica,
+  useCreateUsuarioGraficaExcluida2 as useCreateUsuarioGraficaExcluida,
+  useCreateUsuarioRol2 as useCreateUsuarioRol,
+  useDeleteAdeudo2 as useDeleteAdeudo,
+  useDeleteCatAccion2 as useDeleteCatAccion,
+  useDeleteCatConceptoPago2 as useDeleteCatConceptoPago,
+  useDeleteCatEntidad2 as useDeleteCatEntidad,
+  useDeleteCatFechaAgrupacion2 as useDeleteCatFechaAgrupacion,
+  useDeleteCatGraficaGrupo2 as useDeleteCatGraficaGrupo,
+  useDeleteCatPlaza2 as useDeleteCatPlaza,
+  useDeleteCatRolGrupo2 as useDeleteCatRolGrupo,
+  useDeleteCatTipoParametro2 as useDeleteCatTipoParametro,
+  useDeleteCatTipoServicio2 as useDeleteCatTipoServicio,
+  useDeleteCatTipoSuelo2 as useDeleteCatTipoSuelo,
+  useDeleteCatTipoTarifa2 as useDeleteCatTipoTarifa,
+  useDeleteContribuyente2 as useDeleteContribuyente,
+  useDeleteContribuyenteDomicilio2 as useDeleteContribuyenteDomicilio,
+  useDeleteDashboardEstilo2 as useDeleteDashboardEstilo,
+  useDeleteDashboardGrafica2 as useDeleteDashboardGrafica,
+  useDeleteDashboardGraficaElemento2 as useDeleteDashboardGraficaElemento,
+  useDeleteDashboardGraficaElementoDetalle2 as useDeleteDashboardGraficaElementoDetalle,
+  useDeleteDashboardGraficaElementoParametro2 as useDeleteDashboardGraficaElementoParametro,
+  useDeleteDashboardGraficaGrupo2 as useDeleteDashboardGraficaGrupo,
+  useDeleteDashboardGraficaGrupoRol2 as useDeleteDashboardGraficaGrupoRol,
+  useDeleteDashboardRuta2 as useDeleteDashboardRuta,
+  useDeleteGrafica2 as useDeleteGrafica,
+  useDeleteGraficaAgrupacion2 as useDeleteGraficaAgrupacion,
+  useDeleteGraficaFiltro2 as useDeleteGraficaFiltro,
+  useDeleteGraficaParametro2 as useDeleteGraficaParametro,
+  useDeleteGraficaParametroDefecto2 as useDeleteGraficaParametroDefecto,
+  useDeleteGraficaParametroTipo2 as useDeleteGraficaParametroTipo,
+  useDeleteGraficaPorGrupo2 as useDeleteGraficaPorGrupo,
+  useDeleteGrupoUsuario2 as useDeleteGrupoUsuario,
+  useDeleteModulo2 as useDeleteModulo,
+  useDeletePagos2 as useDeletePagos,
+  useDeletePermisoAccionEntidad2 as useDeletePermisoAccionEntidad,
+  useDeletePermisoModulo2 as useDeletePermisoModulo,
+  useDeletePermisoSubmodulo2 as useDeletePermisoSubmodulo,
+  useDeletePlazas2 as useDeletePlazas,
+  useDeleteRol2 as useDeleteRol,
+  useDeleteRolDashboardRuta2 as useDeleteRolDashboardRuta,
+  useDeleteRolGrafica2 as useDeleteRolGrafica,
+  useDeleteSubmodulo2 as useDeleteSubmodulo,
+  useDeleteTipoGrafica2 as useDeleteTipoGrafica,
+  useDeleteTipoRol2 as useDeleteTipoRol,
+  useDeleteUsuario2 as useDeleteUsuario,
+  useDeleteUsuarioDashboardAcceso2 as useDeleteUsuarioDashboardAcceso,
+  useDeleteUsuarioGrafica2 as useDeleteUsuarioGrafica,
+  useDeleteUsuarioGraficaExcluida2 as useDeleteUsuarioGraficaExcluida,
+  useDeleteUsuarioRol2 as useDeleteUsuarioRol,
+  useFetchByIdAdeudo2 as useFetchByIdAdeudo,
+  useFetchByIdCatAccion2 as useFetchByIdCatAccion,
+  useFetchByIdCatConceptoPago2 as useFetchByIdCatConceptoPago,
+  useFetchByIdCatEntidad2 as useFetchByIdCatEntidad,
+  useFetchByIdCatFechaAgrupacion2 as useFetchByIdCatFechaAgrupacion,
+  useFetchByIdCatGraficaGrupo2 as useFetchByIdCatGraficaGrupo,
+  useFetchByIdCatPlaza2 as useFetchByIdCatPlaza,
+  useFetchByIdCatRolGrupo2 as useFetchByIdCatRolGrupo,
+  useFetchByIdCatTipoParametro2 as useFetchByIdCatTipoParametro,
+  useFetchByIdCatTipoServicio2 as useFetchByIdCatTipoServicio,
+  useFetchByIdCatTipoSuelo2 as useFetchByIdCatTipoSuelo,
+  useFetchByIdCatTipoTarifa2 as useFetchByIdCatTipoTarifa,
+  useFetchByIdContribuyente2 as useFetchByIdContribuyente,
+  useFetchByIdContribuyenteDomicilio2 as useFetchByIdContribuyenteDomicilio,
+  useFetchByIdDashboardEstilo2 as useFetchByIdDashboardEstilo,
+  useFetchByIdDashboardGrafica2 as useFetchByIdDashboardGrafica,
+  useFetchByIdDashboardGraficaElemento2 as useFetchByIdDashboardGraficaElemento,
+  useFetchByIdDashboardGraficaElementoDetalle2 as useFetchByIdDashboardGraficaElementoDetalle,
+  useFetchByIdDashboardGraficaElementoParametro2 as useFetchByIdDashboardGraficaElementoParametro,
+  useFetchByIdDashboardGraficaGrupo2 as useFetchByIdDashboardGraficaGrupo,
+  useFetchByIdDashboardGraficaGrupoRol2 as useFetchByIdDashboardGraficaGrupoRol,
+  useFetchByIdDashboardRuta2 as useFetchByIdDashboardRuta,
+  useFetchByIdGrafica2 as useFetchByIdGrafica,
+  useFetchByIdGraficaAgrupacion2 as useFetchByIdGraficaAgrupacion,
+  useFetchByIdGraficaFiltro2 as useFetchByIdGraficaFiltro,
+  useFetchByIdGraficaParametro2 as useFetchByIdGraficaParametro,
+  useFetchByIdGraficaParametroDefecto2 as useFetchByIdGraficaParametroDefecto,
+  useFetchByIdGraficaParametroTipo2 as useFetchByIdGraficaParametroTipo,
+  useFetchByIdGraficaPorGrupo2 as useFetchByIdGraficaPorGrupo,
+  useFetchByIdGrupoUsuario2 as useFetchByIdGrupoUsuario,
+  useFetchByIdModulo2 as useFetchByIdModulo,
+  useFetchByIdPagos2 as useFetchByIdPagos,
+  useFetchByIdPermisoAccionEntidad2 as useFetchByIdPermisoAccionEntidad,
+  useFetchByIdPermisoModulo2 as useFetchByIdPermisoModulo,
+  useFetchByIdPermisoSubmodulo2 as useFetchByIdPermisoSubmodulo,
+  useFetchByIdPlazas2 as useFetchByIdPlazas,
+  useFetchByIdRol2 as useFetchByIdRol,
+  useFetchByIdRolDashboardRuta2 as useFetchByIdRolDashboardRuta,
+  useFetchByIdRolGrafica2 as useFetchByIdRolGrafica,
+  useFetchByIdSubmodulo2 as useFetchByIdSubmodulo,
+  useFetchByIdTipoGrafica2 as useFetchByIdTipoGrafica,
+  useFetchByIdTipoRol2 as useFetchByIdTipoRol,
+  useFetchByIdUsuario2 as useFetchByIdUsuario,
+  useFetchByIdUsuarioDashboardAcceso2 as useFetchByIdUsuarioDashboardAcceso,
+  useFetchByIdUsuarioGrafica2 as useFetchByIdUsuarioGrafica,
+  useFetchByIdUsuarioGraficaExcluida2 as useFetchByIdUsuarioGraficaExcluida,
+  useFetchByIdUsuarioRol2 as useFetchByIdUsuarioRol,
+  useFetchListAdeudo2 as useFetchListAdeudo,
+  useFetchListCatAccion2 as useFetchListCatAccion,
+  useFetchListCatConceptoPago2 as useFetchListCatConceptoPago,
+  useFetchListCatEntidad2 as useFetchListCatEntidad,
+  useFetchListCatFechaAgrupacion2 as useFetchListCatFechaAgrupacion,
+  useFetchListCatGraficaGrupo2 as useFetchListCatGraficaGrupo,
+  useFetchListCatPlaza2 as useFetchListCatPlaza,
+  useFetchListCatRolGrupo2 as useFetchListCatRolGrupo,
+  useFetchListCatTipoParametro2 as useFetchListCatTipoParametro,
+  useFetchListCatTipoServicio2 as useFetchListCatTipoServicio,
+  useFetchListCatTipoSuelo2 as useFetchListCatTipoSuelo,
+  useFetchListCatTipoTarifa2 as useFetchListCatTipoTarifa,
+  useFetchListContribuyente2 as useFetchListContribuyente,
+  useFetchListContribuyenteDomicilio2 as useFetchListContribuyenteDomicilio,
+  useFetchListDashboardEstilo2 as useFetchListDashboardEstilo,
+  useFetchListDashboardGrafica2 as useFetchListDashboardGrafica,
+  useFetchListDashboardGraficaElemento2 as useFetchListDashboardGraficaElemento,
+  useFetchListDashboardGraficaElementoDetalle2 as useFetchListDashboardGraficaElementoDetalle,
+  useFetchListDashboardGraficaElementoParametro2 as useFetchListDashboardGraficaElementoParametro,
+  useFetchListDashboardGraficaGrupo2 as useFetchListDashboardGraficaGrupo,
+  useFetchListDashboardGraficaGrupoRol2 as useFetchListDashboardGraficaGrupoRol,
+  useFetchListDashboardRuta2 as useFetchListDashboardRuta,
+  useFetchListGrafica2 as useFetchListGrafica,
+  useFetchListGraficaAgrupacion2 as useFetchListGraficaAgrupacion,
+  useFetchListGraficaFiltro2 as useFetchListGraficaFiltro,
+  useFetchListGraficaParametro2 as useFetchListGraficaParametro,
+  useFetchListGraficaParametroDefecto2 as useFetchListGraficaParametroDefecto,
+  useFetchListGraficaParametroTipo2 as useFetchListGraficaParametroTipo,
+  useFetchListGraficaPorGrupo2 as useFetchListGraficaPorGrupo,
+  useFetchListGrupoUsuario2 as useFetchListGrupoUsuario,
+  useFetchListModulo2 as useFetchListModulo,
+  useFetchListPagos2 as useFetchListPagos,
+  useFetchListPermisoAccionEntidad2 as useFetchListPermisoAccionEntidad,
+  useFetchListPermisoModulo2 as useFetchListPermisoModulo,
+  useFetchListPermisoSubmodulo2 as useFetchListPermisoSubmodulo,
+  useFetchListPlazas2 as useFetchListPlazas,
+  useFetchListRol2 as useFetchListRol,
+  useFetchListRolDashboardRuta2 as useFetchListRolDashboardRuta,
+  useFetchListRolGrafica2 as useFetchListRolGrafica,
+  useFetchListSubmodulo2 as useFetchListSubmodulo,
+  useFetchListTipoGrafica2 as useFetchListTipoGrafica,
+  useFetchListTipoRol2 as useFetchListTipoRol,
+  useFetchListUsuario2 as useFetchListUsuario,
+  useFetchListUsuarioDashboardAcceso2 as useFetchListUsuarioDashboardAcceso,
+  useFetchListUsuarioGrafica2 as useFetchListUsuarioGrafica,
+  useFetchListUsuarioGraficaExcluida2 as useFetchListUsuarioGraficaExcluida,
+  useFetchListUsuarioRol2 as useFetchListUsuarioRol,
+  useFilterMatchAdeudo2 as useFilterMatchAdeudo,
+  useFilterMatchCatAccion2 as useFilterMatchCatAccion,
+  useFilterMatchCatConceptoPago2 as useFilterMatchCatConceptoPago,
+  useFilterMatchCatEntidad2 as useFilterMatchCatEntidad,
+  useFilterMatchCatFechaAgrupacion2 as useFilterMatchCatFechaAgrupacion,
+  useFilterMatchCatGraficaGrupo2 as useFilterMatchCatGraficaGrupo,
+  useFilterMatchCatPlaza2 as useFilterMatchCatPlaza,
+  useFilterMatchCatRolGrupo2 as useFilterMatchCatRolGrupo,
+  useFilterMatchCatTipoParametro2 as useFilterMatchCatTipoParametro,
+  useFilterMatchCatTipoServicio2 as useFilterMatchCatTipoServicio,
+  useFilterMatchCatTipoSuelo2 as useFilterMatchCatTipoSuelo,
+  useFilterMatchCatTipoTarifa2 as useFilterMatchCatTipoTarifa,
+  useFilterMatchContribuyente2 as useFilterMatchContribuyente,
+  useFilterMatchContribuyenteDomicilio2 as useFilterMatchContribuyenteDomicilio,
+  useFilterMatchDashboardEstilo2 as useFilterMatchDashboardEstilo,
+  useFilterMatchDashboardGrafica2 as useFilterMatchDashboardGrafica,
+  useFilterMatchDashboardGraficaElemento2 as useFilterMatchDashboardGraficaElemento,
+  useFilterMatchDashboardGraficaElementoDetalle2 as useFilterMatchDashboardGraficaElementoDetalle,
+  useFilterMatchDashboardGraficaElementoParametro2 as useFilterMatchDashboardGraficaElementoParametro,
+  useFilterMatchDashboardGraficaGrupo2 as useFilterMatchDashboardGraficaGrupo,
+  useFilterMatchDashboardGraficaGrupoRol2 as useFilterMatchDashboardGraficaGrupoRol,
+  useFilterMatchDashboardRuta2 as useFilterMatchDashboardRuta,
+  useFilterMatchGrafica2 as useFilterMatchGrafica,
+  useFilterMatchGraficaAgrupacion2 as useFilterMatchGraficaAgrupacion,
+  useFilterMatchGraficaFiltro2 as useFilterMatchGraficaFiltro,
+  useFilterMatchGraficaParametro2 as useFilterMatchGraficaParametro,
+  useFilterMatchGraficaParametroDefecto2 as useFilterMatchGraficaParametroDefecto,
+  useFilterMatchGraficaParametroTipo2 as useFilterMatchGraficaParametroTipo,
+  useFilterMatchGraficaPorGrupo2 as useFilterMatchGraficaPorGrupo,
+  useFilterMatchGrupoUsuario2 as useFilterMatchGrupoUsuario,
+  useFilterMatchModulo2 as useFilterMatchModulo,
+  useFilterMatchPagos2 as useFilterMatchPagos,
+  useFilterMatchPermisoAccionEntidad2 as useFilterMatchPermisoAccionEntidad,
+  useFilterMatchPermisoModulo2 as useFilterMatchPermisoModulo,
+  useFilterMatchPermisoSubmodulo2 as useFilterMatchPermisoSubmodulo,
+  useFilterMatchPlazas2 as useFilterMatchPlazas,
+  useFilterMatchRol2 as useFilterMatchRol,
+  useFilterMatchRolDashboardRuta2 as useFilterMatchRolDashboardRuta,
+  useFilterMatchRolGrafica2 as useFilterMatchRolGrafica,
+  useFilterMatchSubmodulo2 as useFilterMatchSubmodulo,
+  useFilterMatchTipoGrafica2 as useFilterMatchTipoGrafica,
+  useFilterMatchTipoRol2 as useFilterMatchTipoRol,
+  useFilterMatchUsuario2 as useFilterMatchUsuario,
+  useFilterMatchUsuarioDashboardAcceso2 as useFilterMatchUsuarioDashboardAcceso,
+  useFilterMatchUsuarioGrafica2 as useFilterMatchUsuarioGrafica,
+  useFilterMatchUsuarioGraficaExcluida2 as useFilterMatchUsuarioGraficaExcluida,
+  useFilterMatchUsuarioRol2 as useFilterMatchUsuarioRol,
+  useUpdateAdeudo2 as useUpdateAdeudo,
+  useUpdateCatAccion2 as useUpdateCatAccion,
+  useUpdateCatConceptoPago2 as useUpdateCatConceptoPago,
+  useUpdateCatEntidad2 as useUpdateCatEntidad,
+  useUpdateCatFechaAgrupacion2 as useUpdateCatFechaAgrupacion,
+  useUpdateCatGraficaGrupo2 as useUpdateCatGraficaGrupo,
+  useUpdateCatPlaza2 as useUpdateCatPlaza,
+  useUpdateCatRolGrupo2 as useUpdateCatRolGrupo,
+  useUpdateCatTipoParametro2 as useUpdateCatTipoParametro,
+  useUpdateCatTipoServicio2 as useUpdateCatTipoServicio,
+  useUpdateCatTipoSuelo2 as useUpdateCatTipoSuelo,
+  useUpdateCatTipoTarifa2 as useUpdateCatTipoTarifa,
+  useUpdateContribuyente2 as useUpdateContribuyente,
+  useUpdateContribuyenteDomicilio2 as useUpdateContribuyenteDomicilio,
+  useUpdateDashboardEstilo2 as useUpdateDashboardEstilo,
+  useUpdateDashboardGrafica2 as useUpdateDashboardGrafica,
+  useUpdateDashboardGraficaElemento2 as useUpdateDashboardGraficaElemento,
+  useUpdateDashboardGraficaElementoDetalle2 as useUpdateDashboardGraficaElementoDetalle,
+  useUpdateDashboardGraficaElementoParametro2 as useUpdateDashboardGraficaElementoParametro,
+  useUpdateDashboardGraficaGrupo2 as useUpdateDashboardGraficaGrupo,
+  useUpdateDashboardGraficaGrupoRol2 as useUpdateDashboardGraficaGrupoRol,
+  useUpdateDashboardRuta2 as useUpdateDashboardRuta,
+  useUpdateGrafica2 as useUpdateGrafica,
+  useUpdateGraficaAgrupacion2 as useUpdateGraficaAgrupacion,
+  useUpdateGraficaFiltro2 as useUpdateGraficaFiltro,
+  useUpdateGraficaParametro2 as useUpdateGraficaParametro,
+  useUpdateGraficaParametroDefecto2 as useUpdateGraficaParametroDefecto,
+  useUpdateGraficaParametroTipo2 as useUpdateGraficaParametroTipo,
+  useUpdateGraficaPorGrupo2 as useUpdateGraficaPorGrupo,
+  useUpdateGrupoUsuario2 as useUpdateGrupoUsuario,
+  useUpdateModulo2 as useUpdateModulo,
+  useUpdatePagos2 as useUpdatePagos,
+  useUpdatePermisoAccionEntidad2 as useUpdatePermisoAccionEntidad,
+  useUpdatePermisoModulo2 as useUpdatePermisoModulo,
+  useUpdatePermisoSubmodulo2 as useUpdatePermisoSubmodulo,
+  useUpdatePlazas2 as useUpdatePlazas,
+  useUpdateRol2 as useUpdateRol,
+  useUpdateRolDashboardRuta2 as useUpdateRolDashboardRuta,
+  useUpdateRolGrafica2 as useUpdateRolGrafica,
+  useUpdateSubmodulo2 as useUpdateSubmodulo,
+  useUpdateTipoGrafica2 as useUpdateTipoGrafica,
+  useUpdateTipoRol2 as useUpdateTipoRol,
+  useUpdateUsuario2 as useUpdateUsuario,
+  useUpdateUsuarioDashboardAcceso2 as useUpdateUsuarioDashboardAcceso,
+  useUpdateUsuarioGrafica2 as useUpdateUsuarioGrafica,
+  useUpdateUsuarioGraficaExcluida2 as useUpdateUsuarioGraficaExcluida,
+  useUpdateUsuarioRol2 as useUpdateUsuarioRol
+};
+//# sourceMappingURL=index.mjs.map