@erpp/react-api-cronos-frontend 1.0.1

package/dist/index.js

@@ -0,0 +1,4796 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIFactory: () => APIFactory,
+  useCreateAdeudo: () => useCreateAdeudo2,
+  useCreateCatAccion: () => useCreateCatAccion2,
+  useCreateCatConceptoPago: () => useCreateCatConceptoPago2,
+  useCreateCatEntidad: () => useCreateCatEntidad2,
+  useCreateCatFechaAgrupacion: () => useCreateCatFechaAgrupacion2,
+  useCreateCatGraficaGrupo: () => useCreateCatGraficaGrupo2,
+  useCreateCatPlaza: () => useCreateCatPlaza2,
+  useCreateCatRolGrupo: () => useCreateCatRolGrupo2,
+  useCreateCatTipoParametro: () => useCreateCatTipoParametro2,
+  useCreateCatTipoServicio: () => useCreateCatTipoServicio2,
+  useCreateCatTipoSuelo: () => useCreateCatTipoSuelo2,
+  useCreateCatTipoTarifa: () => useCreateCatTipoTarifa2,
+  useCreateContribuyente: () => useCreateContribuyente2,
+  useCreateContribuyenteDomicilio: () => useCreateContribuyenteDomicilio2,
+  useCreateDashboardEstilo: () => useCreateDashboardEstilo2,
+  useCreateDashboardGrafica: () => useCreateDashboardGrafica2,
+  useCreateDashboardGraficaElemento: () => useCreateDashboardGraficaElemento2,
+  useCreateDashboardGraficaElementoDetalle: () => useCreateDashboardGraficaElementoDetalle2,
+  useCreateDashboardGraficaElementoParametro: () => useCreateDashboardGraficaElementoParametro2,
+  useCreateDashboardGraficaGrupo: () => useCreateDashboardGraficaGrupo2,
+  useCreateDashboardGraficaGrupoRol: () => useCreateDashboardGraficaGrupoRol2,
+  useCreateDashboardRuta: () => useCreateDashboardRuta2,
+  useCreateGrafica: () => useCreateGrafica2,
+  useCreateGraficaAgrupacion: () => useCreateGraficaAgrupacion2,
+  useCreateGraficaFiltro: () => useCreateGraficaFiltro2,
+  useCreateGraficaParametro: () => useCreateGraficaParametro2,
+  useCreateGraficaParametroDefecto: () => useCreateGraficaParametroDefecto2,
+  useCreateGraficaParametroTipo: () => useCreateGraficaParametroTipo2,
+  useCreateGraficaPorGrupo: () => useCreateGraficaPorGrupo2,
+  useCreateGrupoUsuario: () => useCreateGrupoUsuario2,
+  useCreateModulo: () => useCreateModulo2,
+  useCreatePagos: () => useCreatePagos2,
+  useCreatePermisoAccionEntidad: () => useCreatePermisoAccionEntidad2,
+  useCreatePermisoModulo: () => useCreatePermisoModulo2,
+  useCreatePermisoSubmodulo: () => useCreatePermisoSubmodulo2,
+  useCreatePlazas: () => useCreatePlazas2,
+  useCreateRol: () => useCreateRol2,
+  useCreateRolDashboardRuta: () => useCreateRolDashboardRuta2,
+  useCreateRolGrafica: () => useCreateRolGrafica2,
+  useCreateSubmodulo: () => useCreateSubmodulo2,
+  useCreateTipoGrafica: () => useCreateTipoGrafica2,
+  useCreateTipoRol: () => useCreateTipoRol2,
+  useCreateUsuario: () => useCreateUsuario2,
+  useCreateUsuarioDashboardAcceso: () => useCreateUsuarioDashboardAcceso2,
+  useCreateUsuarioGrafica: () => useCreateUsuarioGrafica2,
+  useCreateUsuarioGraficaExcluida: () => useCreateUsuarioGraficaExcluida2,
+  useCreateUsuarioRol: () => useCreateUsuarioRol2,
+  useDeleteAdeudo: () => useDeleteAdeudo2,
+  useDeleteCatAccion: () => useDeleteCatAccion2,
+  useDeleteCatConceptoPago: () => useDeleteCatConceptoPago2,
+  useDeleteCatEntidad: () => useDeleteCatEntidad2,
+  useDeleteCatFechaAgrupacion: () => useDeleteCatFechaAgrupacion2,
+  useDeleteCatGraficaGrupo: () => useDeleteCatGraficaGrupo2,
+  useDeleteCatPlaza: () => useDeleteCatPlaza2,
+  useDeleteCatRolGrupo: () => useDeleteCatRolGrupo2,
+  useDeleteCatTipoParametro: () => useDeleteCatTipoParametro2,
+  useDeleteCatTipoServicio: () => useDeleteCatTipoServicio2,
+  useDeleteCatTipoSuelo: () => useDeleteCatTipoSuelo2,
+  useDeleteCatTipoTarifa: () => useDeleteCatTipoTarifa2,
+  useDeleteContribuyente: () => useDeleteContribuyente2,
+  useDeleteContribuyenteDomicilio: () => useDeleteContribuyenteDomicilio2,
+  useDeleteDashboardEstilo: () => useDeleteDashboardEstilo2,
+  useDeleteDashboardGrafica: () => useDeleteDashboardGrafica2,
+  useDeleteDashboardGraficaElemento: () => useDeleteDashboardGraficaElemento2,
+  useDeleteDashboardGraficaElementoDetalle: () => useDeleteDashboardGraficaElementoDetalle2,
+  useDeleteDashboardGraficaElementoParametro: () => useDeleteDashboardGraficaElementoParametro2,
+  useDeleteDashboardGraficaGrupo: () => useDeleteDashboardGraficaGrupo2,
+  useDeleteDashboardGraficaGrupoRol: () => useDeleteDashboardGraficaGrupoRol2,
+  useDeleteDashboardRuta: () => useDeleteDashboardRuta2,
+  useDeleteGrafica: () => useDeleteGrafica2,
+  useDeleteGraficaAgrupacion: () => useDeleteGraficaAgrupacion2,
+  useDeleteGraficaFiltro: () => useDeleteGraficaFiltro2,
+  useDeleteGraficaParametro: () => useDeleteGraficaParametro2,
+  useDeleteGraficaParametroDefecto: () => useDeleteGraficaParametroDefecto2,
+  useDeleteGraficaParametroTipo: () => useDeleteGraficaParametroTipo2,
+  useDeleteGraficaPorGrupo: () => useDeleteGraficaPorGrupo2,
+  useDeleteGrupoUsuario: () => useDeleteGrupoUsuario2,
+  useDeleteModulo: () => useDeleteModulo2,
+  useDeletePagos: () => useDeletePagos2,
+  useDeletePermisoAccionEntidad: () => useDeletePermisoAccionEntidad2,
+  useDeletePermisoModulo: () => useDeletePermisoModulo2,
+  useDeletePermisoSubmodulo: () => useDeletePermisoSubmodulo2,
+  useDeletePlazas: () => useDeletePlazas2,
+  useDeleteRol: () => useDeleteRol2,
+  useDeleteRolDashboardRuta: () => useDeleteRolDashboardRuta2,
+  useDeleteRolGrafica: () => useDeleteRolGrafica2,
+  useDeleteSubmodulo: () => useDeleteSubmodulo2,
+  useDeleteTipoGrafica: () => useDeleteTipoGrafica2,
+  useDeleteTipoRol: () => useDeleteTipoRol2,
+  useDeleteUsuario: () => useDeleteUsuario2,
+  useDeleteUsuarioDashboardAcceso: () => useDeleteUsuarioDashboardAcceso2,
+  useDeleteUsuarioGrafica: () => useDeleteUsuarioGrafica2,
+  useDeleteUsuarioGraficaExcluida: () => useDeleteUsuarioGraficaExcluida2,
+  useDeleteUsuarioRol: () => useDeleteUsuarioRol2,
+  useFetchByIdAdeudo: () => useFetchByIdAdeudo2,
+  useFetchByIdCatAccion: () => useFetchByIdCatAccion2,
+  useFetchByIdCatConceptoPago: () => useFetchByIdCatConceptoPago2,
+  useFetchByIdCatEntidad: () => useFetchByIdCatEntidad2,
+  useFetchByIdCatFechaAgrupacion: () => useFetchByIdCatFechaAgrupacion2,
+  useFetchByIdCatGraficaGrupo: () => useFetchByIdCatGraficaGrupo2,
+  useFetchByIdCatPlaza: () => useFetchByIdCatPlaza2,
+  useFetchByIdCatRolGrupo: () => useFetchByIdCatRolGrupo2,
+  useFetchByIdCatTipoParametro: () => useFetchByIdCatTipoParametro2,
+  useFetchByIdCatTipoServicio: () => useFetchByIdCatTipoServicio2,
+  useFetchByIdCatTipoSuelo: () => useFetchByIdCatTipoSuelo2,
+  useFetchByIdCatTipoTarifa: () => useFetchByIdCatTipoTarifa2,
+  useFetchByIdContribuyente: () => useFetchByIdContribuyente2,
+  useFetchByIdContribuyenteDomicilio: () => useFetchByIdContribuyenteDomicilio2,
+  useFetchByIdDashboardEstilo: () => useFetchByIdDashboardEstilo2,
+  useFetchByIdDashboardGrafica: () => useFetchByIdDashboardGrafica2,
+  useFetchByIdDashboardGraficaElemento: () => useFetchByIdDashboardGraficaElemento2,
+  useFetchByIdDashboardGraficaElementoDetalle: () => useFetchByIdDashboardGraficaElementoDetalle2,
+  useFetchByIdDashboardGraficaElementoParametro: () => useFetchByIdDashboardGraficaElementoParametro2,
+  useFetchByIdDashboardGraficaGrupo: () => useFetchByIdDashboardGraficaGrupo2,
+  useFetchByIdDashboardGraficaGrupoRol: () => useFetchByIdDashboardGraficaGrupoRol2,
+  useFetchByIdDashboardRuta: () => useFetchByIdDashboardRuta2,
+  useFetchByIdGrafica: () => useFetchByIdGrafica2,
+  useFetchByIdGraficaAgrupacion: () => useFetchByIdGraficaAgrupacion2,
+  useFetchByIdGraficaFiltro: () => useFetchByIdGraficaFiltro2,
+  useFetchByIdGraficaParametro: () => useFetchByIdGraficaParametro2,
+  useFetchByIdGraficaParametroDefecto: () => useFetchByIdGraficaParametroDefecto2,
+  useFetchByIdGraficaParametroTipo: () => useFetchByIdGraficaParametroTipo2,
+  useFetchByIdGraficaPorGrupo: () => useFetchByIdGraficaPorGrupo2,
+  useFetchByIdGrupoUsuario: () => useFetchByIdGrupoUsuario2,
+  useFetchByIdModulo: () => useFetchByIdModulo2,
+  useFetchByIdPagos: () => useFetchByIdPagos2,
+  useFetchByIdPermisoAccionEntidad: () => useFetchByIdPermisoAccionEntidad2,
+  useFetchByIdPermisoModulo: () => useFetchByIdPermisoModulo2,
+  useFetchByIdPermisoSubmodulo: () => useFetchByIdPermisoSubmodulo2,
+  useFetchByIdPlazas: () => useFetchByIdPlazas2,
+  useFetchByIdRol: () => useFetchByIdRol2,
+  useFetchByIdRolDashboardRuta: () => useFetchByIdRolDashboardRuta2,
+  useFetchByIdRolGrafica: () => useFetchByIdRolGrafica2,
+  useFetchByIdSubmodulo: () => useFetchByIdSubmodulo2,
+  useFetchByIdTipoGrafica: () => useFetchByIdTipoGrafica2,
+  useFetchByIdTipoRol: () => useFetchByIdTipoRol2,
+  useFetchByIdUsuario: () => useFetchByIdUsuario2,
+  useFetchByIdUsuarioDashboardAcceso: () => useFetchByIdUsuarioDashboardAcceso2,
+  useFetchByIdUsuarioGrafica: () => useFetchByIdUsuarioGrafica2,
+  useFetchByIdUsuarioGraficaExcluida: () => useFetchByIdUsuarioGraficaExcluida2,
+  useFetchByIdUsuarioRol: () => useFetchByIdUsuarioRol2,
+  useFetchListAdeudo: () => useFetchListAdeudo2,
+  useFetchListCatAccion: () => useFetchListCatAccion2,
+  useFetchListCatConceptoPago: () => useFetchListCatConceptoPago2,
+  useFetchListCatEntidad: () => useFetchListCatEntidad2,
+  useFetchListCatFechaAgrupacion: () => useFetchListCatFechaAgrupacion2,
+  useFetchListCatGraficaGrupo: () => useFetchListCatGraficaGrupo2,
+  useFetchListCatPlaza: () => useFetchListCatPlaza2,
+  useFetchListCatRolGrupo: () => useFetchListCatRolGrupo2,
+  useFetchListCatTipoParametro: () => useFetchListCatTipoParametro2,
+  useFetchListCatTipoServicio: () => useFetchListCatTipoServicio2,
+  useFetchListCatTipoSuelo: () => useFetchListCatTipoSuelo2,
+  useFetchListCatTipoTarifa: () => useFetchListCatTipoTarifa2,
+  useFetchListContribuyente: () => useFetchListContribuyente2,
+  useFetchListContribuyenteDomicilio: () => useFetchListContribuyenteDomicilio2,
+  useFetchListDashboardEstilo: () => useFetchListDashboardEstilo2,
+  useFetchListDashboardGrafica: () => useFetchListDashboardGrafica2,
+  useFetchListDashboardGraficaElemento: () => useFetchListDashboardGraficaElemento2,
+  useFetchListDashboardGraficaElementoDetalle: () => useFetchListDashboardGraficaElementoDetalle2,
+  useFetchListDashboardGraficaElementoParametro: () => useFetchListDashboardGraficaElementoParametro2,
+  useFetchListDashboardGraficaGrupo: () => useFetchListDashboardGraficaGrupo2,
+  useFetchListDashboardGraficaGrupoRol: () => useFetchListDashboardGraficaGrupoRol2,
+  useFetchListDashboardRuta: () => useFetchListDashboardRuta2,
+  useFetchListGrafica: () => useFetchListGrafica2,
+  useFetchListGraficaAgrupacion: () => useFetchListGraficaAgrupacion2,
+  useFetchListGraficaFiltro: () => useFetchListGraficaFiltro2,
+  useFetchListGraficaParametro: () => useFetchListGraficaParametro2,
+  useFetchListGraficaParametroDefecto: () => useFetchListGraficaParametroDefecto2,
+  useFetchListGraficaParametroTipo: () => useFetchListGraficaParametroTipo2,
+  useFetchListGraficaPorGrupo: () => useFetchListGraficaPorGrupo2,
+  useFetchListGrupoUsuario: () => useFetchListGrupoUsuario2,
+  useFetchListModulo: () => useFetchListModulo2,
+  useFetchListPagos: () => useFetchListPagos2,
+  useFetchListPermisoAccionEntidad: () => useFetchListPermisoAccionEntidad2,
+  useFetchListPermisoModulo: () => useFetchListPermisoModulo2,
+  useFetchListPermisoSubmodulo: () => useFetchListPermisoSubmodulo2,
+  useFetchListPlazas: () => useFetchListPlazas2,
+  useFetchListRol: () => useFetchListRol2,
+  useFetchListRolDashboardRuta: () => useFetchListRolDashboardRuta2,
+  useFetchListRolGrafica: () => useFetchListRolGrafica2,
+  useFetchListSubmodulo: () => useFetchListSubmodulo2,
+  useFetchListTipoGrafica: () => useFetchListTipoGrafica2,
+  useFetchListTipoRol: () => useFetchListTipoRol2,
+  useFetchListUsuario: () => useFetchListUsuario2,
+  useFetchListUsuarioDashboardAcceso: () => useFetchListUsuarioDashboardAcceso2,
+  useFetchListUsuarioGrafica: () => useFetchListUsuarioGrafica2,
+  useFetchListUsuarioGraficaExcluida: () => useFetchListUsuarioGraficaExcluida2,
+  useFetchListUsuarioRol: () => useFetchListUsuarioRol2,
+  useFilterMatchAdeudo: () => useFilterMatchAdeudo2,
+  useFilterMatchCatAccion: () => useFilterMatchCatAccion2,
+  useFilterMatchCatConceptoPago: () => useFilterMatchCatConceptoPago2,
+  useFilterMatchCatEntidad: () => useFilterMatchCatEntidad2,
+  useFilterMatchCatFechaAgrupacion: () => useFilterMatchCatFechaAgrupacion2,
+  useFilterMatchCatGraficaGrupo: () => useFilterMatchCatGraficaGrupo2,
+  useFilterMatchCatPlaza: () => useFilterMatchCatPlaza2,
+  useFilterMatchCatRolGrupo: () => useFilterMatchCatRolGrupo2,
+  useFilterMatchCatTipoParametro: () => useFilterMatchCatTipoParametro2,
+  useFilterMatchCatTipoServicio: () => useFilterMatchCatTipoServicio2,
+  useFilterMatchCatTipoSuelo: () => useFilterMatchCatTipoSuelo2,
+  useFilterMatchCatTipoTarifa: () => useFilterMatchCatTipoTarifa2,
+  useFilterMatchContribuyente: () => useFilterMatchContribuyente2,
+  useFilterMatchContribuyenteDomicilio: () => useFilterMatchContribuyenteDomicilio2,
+  useFilterMatchDashboardEstilo: () => useFilterMatchDashboardEstilo2,
+  useFilterMatchDashboardGrafica: () => useFilterMatchDashboardGrafica2,
+  useFilterMatchDashboardGraficaElemento: () => useFilterMatchDashboardGraficaElemento2,
+  useFilterMatchDashboardGraficaElementoDetalle: () => useFilterMatchDashboardGraficaElementoDetalle2,
+  useFilterMatchDashboardGraficaElementoParametro: () => useFilterMatchDashboardGraficaElementoParametro2,
+  useFilterMatchDashboardGraficaGrupo: () => useFilterMatchDashboardGraficaGrupo2,
+  useFilterMatchDashboardGraficaGrupoRol: () => useFilterMatchDashboardGraficaGrupoRol2,
+  useFilterMatchDashboardRuta: () => useFilterMatchDashboardRuta2,
+  useFilterMatchGrafica: () => useFilterMatchGrafica2,
+  useFilterMatchGraficaAgrupacion: () => useFilterMatchGraficaAgrupacion2,
+  useFilterMatchGraficaFiltro: () => useFilterMatchGraficaFiltro2,
+  useFilterMatchGraficaParametro: () => useFilterMatchGraficaParametro2,
+  useFilterMatchGraficaParametroDefecto: () => useFilterMatchGraficaParametroDefecto2,
+  useFilterMatchGraficaParametroTipo: () => useFilterMatchGraficaParametroTipo2,
+  useFilterMatchGraficaPorGrupo: () => useFilterMatchGraficaPorGrupo2,
+  useFilterMatchGrupoUsuario: () => useFilterMatchGrupoUsuario2,
+  useFilterMatchModulo: () => useFilterMatchModulo2,
+  useFilterMatchPagos: () => useFilterMatchPagos2,
+  useFilterMatchPermisoAccionEntidad: () => useFilterMatchPermisoAccionEntidad2,
+  useFilterMatchPermisoModulo: () => useFilterMatchPermisoModulo2,
+  useFilterMatchPermisoSubmodulo: () => useFilterMatchPermisoSubmodulo2,
+  useFilterMatchPlazas: () => useFilterMatchPlazas2,
+  useFilterMatchRol: () => useFilterMatchRol2,
+  useFilterMatchRolDashboardRuta: () => useFilterMatchRolDashboardRuta2,
+  useFilterMatchRolGrafica: () => useFilterMatchRolGrafica2,
+  useFilterMatchSubmodulo: () => useFilterMatchSubmodulo2,
+  useFilterMatchTipoGrafica: () => useFilterMatchTipoGrafica2,
+  useFilterMatchTipoRol: () => useFilterMatchTipoRol2,
+  useFilterMatchUsuario: () => useFilterMatchUsuario2,
+  useFilterMatchUsuarioDashboardAcceso: () => useFilterMatchUsuarioDashboardAcceso2,
+  useFilterMatchUsuarioGrafica: () => useFilterMatchUsuarioGrafica2,
+  useFilterMatchUsuarioGraficaExcluida: () => useFilterMatchUsuarioGraficaExcluida2,
+  useFilterMatchUsuarioRol: () => useFilterMatchUsuarioRol2,
+  useUpdateAdeudo: () => useUpdateAdeudo2,
+  useUpdateCatAccion: () => useUpdateCatAccion2,
+  useUpdateCatConceptoPago: () => useUpdateCatConceptoPago2,
+  useUpdateCatEntidad: () => useUpdateCatEntidad2,
+  useUpdateCatFechaAgrupacion: () => useUpdateCatFechaAgrupacion2,
+  useUpdateCatGraficaGrupo: () => useUpdateCatGraficaGrupo2,
+  useUpdateCatPlaza: () => useUpdateCatPlaza2,
+  useUpdateCatRolGrupo: () => useUpdateCatRolGrupo2,
+  useUpdateCatTipoParametro: () => useUpdateCatTipoParametro2,
+  useUpdateCatTipoServicio: () => useUpdateCatTipoServicio2,
+  useUpdateCatTipoSuelo: () => useUpdateCatTipoSuelo2,
+  useUpdateCatTipoTarifa: () => useUpdateCatTipoTarifa2,
+  useUpdateContribuyente: () => useUpdateContribuyente2,
+  useUpdateContribuyenteDomicilio: () => useUpdateContribuyenteDomicilio2,
+  useUpdateDashboardEstilo: () => useUpdateDashboardEstilo2,
+  useUpdateDashboardGrafica: () => useUpdateDashboardGrafica2,
+  useUpdateDashboardGraficaElemento: () => useUpdateDashboardGraficaElemento2,
+  useUpdateDashboardGraficaElementoDetalle: () => useUpdateDashboardGraficaElementoDetalle2,
+  useUpdateDashboardGraficaElementoParametro: () => useUpdateDashboardGraficaElementoParametro2,
+  useUpdateDashboardGraficaGrupo: () => useUpdateDashboardGraficaGrupo2,
+  useUpdateDashboardGraficaGrupoRol: () => useUpdateDashboardGraficaGrupoRol2,
+  useUpdateDashboardRuta: () => useUpdateDashboardRuta2,
+  useUpdateGrafica: () => useUpdateGrafica2,
+  useUpdateGraficaAgrupacion: () => useUpdateGraficaAgrupacion2,
+  useUpdateGraficaFiltro: () => useUpdateGraficaFiltro2,
+  useUpdateGraficaParametro: () => useUpdateGraficaParametro2,
+  useUpdateGraficaParametroDefecto: () => useUpdateGraficaParametroDefecto2,
+  useUpdateGraficaParametroTipo: () => useUpdateGraficaParametroTipo2,
+  useUpdateGraficaPorGrupo: () => useUpdateGraficaPorGrupo2,
+  useUpdateGrupoUsuario: () => useUpdateGrupoUsuario2,
+  useUpdateModulo: () => useUpdateModulo2,
+  useUpdatePagos: () => useUpdatePagos2,
+  useUpdatePermisoAccionEntidad: () => useUpdatePermisoAccionEntidad2,
+  useUpdatePermisoModulo: () => useUpdatePermisoModulo2,
+  useUpdatePermisoSubmodulo: () => useUpdatePermisoSubmodulo2,
+  useUpdatePlazas: () => useUpdatePlazas2,
+  useUpdateRol: () => useUpdateRol2,
+  useUpdateRolDashboardRuta: () => useUpdateRolDashboardRuta2,
+  useUpdateRolGrafica: () => useUpdateRolGrafica2,
+  useUpdateSubmodulo: () => useUpdateSubmodulo2,
+  useUpdateTipoGrafica: () => useUpdateTipoGrafica2,
+  useUpdateTipoRol: () => useUpdateTipoRol2,
+  useUpdateUsuario: () => useUpdateUsuario2,
+  useUpdateUsuarioDashboardAcceso: () => useUpdateUsuarioDashboardAcceso2,
+  useUpdateUsuarioGrafica: () => useUpdateUsuarioGrafica2,
+  useUpdateUsuarioGraficaExcluida: () => useUpdateUsuarioGraficaExcluida2,
+  useUpdateUsuarioRol: () => useUpdateUsuarioRol2
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/components/API.ts
+var import_axios = __toESM(require("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 = import_axios.default.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 = import_axios.default.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
+var import_axios2 = __toESM(require("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 import_axios2.default.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 import_axios2.default.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 import_axios2.default.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 import_axios2.default.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 import_axios2.default.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 import_axios2.default.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
+var import_react = require("react");
+
+// src/infrastructure/api/utils/globalErrorLogger.ts
+var import_fs = __toESM(require("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)}
+`;
+      import_fs.default.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] = (0, import_react.useState)(null);
+    const [error, setError] = (0, import_react.useState)(null);
+    const [isFetching, setIsFetching] = (0, import_react.useState)(false);
+    const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+    const fetchData = (0, import_react.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] = (0, import_react.useState)(null);
+    const [error, setError] = (0, import_react.useState)(null);
+    const [isFetching, setIsFetching] = (0, import_react.useState)(false);
+    const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+    const fetchData = (0, import_react.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] = (0, import_react.useState)(false);
+    const [error, setError] = (0, import_react.useState)(null);
+    const [data, setData] = (0, import_react.useState)(null);
+    const mutate = (0, import_react.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] = (0, import_react.useState)(false);
+    const [error, setError] = (0, import_react.useState)(null);
+    const [data, setData] = (0, import_react.useState)(null);
+    const mutate = (0, import_react.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] = (0, import_react.useState)(false);
+    const [error, setError] = (0, import_react.useState)(null);
+    const [success, setSuccess] = (0, import_react.useState)(false);
+    const mutate = (0, import_react.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] = (0, import_react.useState)(null);
+    const [error, setError] = (0, import_react.useState)(null);
+    const [isFetching, setIsFetching] = (0, import_react.useState)(false);
+    const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+    const fetchData = (0, import_react.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIFactory,
+  useCreateAdeudo,
+  useCreateCatAccion,
+  useCreateCatConceptoPago,
+  useCreateCatEntidad,
+  useCreateCatFechaAgrupacion,
+  useCreateCatGraficaGrupo,
+  useCreateCatPlaza,
+  useCreateCatRolGrupo,
+  useCreateCatTipoParametro,
+  useCreateCatTipoServicio,
+  useCreateCatTipoSuelo,
+  useCreateCatTipoTarifa,
+  useCreateContribuyente,
+  useCreateContribuyenteDomicilio,
+  useCreateDashboardEstilo,
+  useCreateDashboardGrafica,
+  useCreateDashboardGraficaElemento,
+  useCreateDashboardGraficaElementoDetalle,
+  useCreateDashboardGraficaElementoParametro,
+  useCreateDashboardGraficaGrupo,
+  useCreateDashboardGraficaGrupoRol,
+  useCreateDashboardRuta,
+  useCreateGrafica,
+  useCreateGraficaAgrupacion,
+  useCreateGraficaFiltro,
+  useCreateGraficaParametro,
+  useCreateGraficaParametroDefecto,
+  useCreateGraficaParametroTipo,
+  useCreateGraficaPorGrupo,
+  useCreateGrupoUsuario,
+  useCreateModulo,
+  useCreatePagos,
+  useCreatePermisoAccionEntidad,
+  useCreatePermisoModulo,
+  useCreatePermisoSubmodulo,
+  useCreatePlazas,
+  useCreateRol,
+  useCreateRolDashboardRuta,
+  useCreateRolGrafica,
+  useCreateSubmodulo,
+  useCreateTipoGrafica,
+  useCreateTipoRol,
+  useCreateUsuario,
+  useCreateUsuarioDashboardAcceso,
+  useCreateUsuarioGrafica,
+  useCreateUsuarioGraficaExcluida,
+  useCreateUsuarioRol,
+  useDeleteAdeudo,
+  useDeleteCatAccion,
+  useDeleteCatConceptoPago,
+  useDeleteCatEntidad,
+  useDeleteCatFechaAgrupacion,
+  useDeleteCatGraficaGrupo,
+  useDeleteCatPlaza,
+  useDeleteCatRolGrupo,
+  useDeleteCatTipoParametro,
+  useDeleteCatTipoServicio,
+  useDeleteCatTipoSuelo,
+  useDeleteCatTipoTarifa,
+  useDeleteContribuyente,
+  useDeleteContribuyenteDomicilio,
+  useDeleteDashboardEstilo,
+  useDeleteDashboardGrafica,
+  useDeleteDashboardGraficaElemento,
+  useDeleteDashboardGraficaElementoDetalle,
+  useDeleteDashboardGraficaElementoParametro,
+  useDeleteDashboardGraficaGrupo,
+  useDeleteDashboardGraficaGrupoRol,
+  useDeleteDashboardRuta,
+  useDeleteGrafica,
+  useDeleteGraficaAgrupacion,
+  useDeleteGraficaFiltro,
+  useDeleteGraficaParametro,
+  useDeleteGraficaParametroDefecto,
+  useDeleteGraficaParametroTipo,
+  useDeleteGraficaPorGrupo,
+  useDeleteGrupoUsuario,
+  useDeleteModulo,
+  useDeletePagos,
+  useDeletePermisoAccionEntidad,
+  useDeletePermisoModulo,
+  useDeletePermisoSubmodulo,
+  useDeletePlazas,
+  useDeleteRol,
+  useDeleteRolDashboardRuta,
+  useDeleteRolGrafica,
+  useDeleteSubmodulo,
+  useDeleteTipoGrafica,
+  useDeleteTipoRol,
+  useDeleteUsuario,
+  useDeleteUsuarioDashboardAcceso,
+  useDeleteUsuarioGrafica,
+  useDeleteUsuarioGraficaExcluida,
+  useDeleteUsuarioRol,
+  useFetchByIdAdeudo,
+  useFetchByIdCatAccion,
+  useFetchByIdCatConceptoPago,
+  useFetchByIdCatEntidad,
+  useFetchByIdCatFechaAgrupacion,
+  useFetchByIdCatGraficaGrupo,
+  useFetchByIdCatPlaza,
+  useFetchByIdCatRolGrupo,
+  useFetchByIdCatTipoParametro,
+  useFetchByIdCatTipoServicio,
+  useFetchByIdCatTipoSuelo,
+  useFetchByIdCatTipoTarifa,
+  useFetchByIdContribuyente,
+  useFetchByIdContribuyenteDomicilio,
+  useFetchByIdDashboardEstilo,
+  useFetchByIdDashboardGrafica,
+  useFetchByIdDashboardGraficaElemento,
+  useFetchByIdDashboardGraficaElementoDetalle,
+  useFetchByIdDashboardGraficaElementoParametro,
+  useFetchByIdDashboardGraficaGrupo,
+  useFetchByIdDashboardGraficaGrupoRol,
+  useFetchByIdDashboardRuta,
+  useFetchByIdGrafica,
+  useFetchByIdGraficaAgrupacion,
+  useFetchByIdGraficaFiltro,
+  useFetchByIdGraficaParametro,
+  useFetchByIdGraficaParametroDefecto,
+  useFetchByIdGraficaParametroTipo,
+  useFetchByIdGraficaPorGrupo,
+  useFetchByIdGrupoUsuario,
+  useFetchByIdModulo,
+  useFetchByIdPagos,
+  useFetchByIdPermisoAccionEntidad,
+  useFetchByIdPermisoModulo,
+  useFetchByIdPermisoSubmodulo,
+  useFetchByIdPlazas,
+  useFetchByIdRol,
+  useFetchByIdRolDashboardRuta,
+  useFetchByIdRolGrafica,
+  useFetchByIdSubmodulo,
+  useFetchByIdTipoGrafica,
+  useFetchByIdTipoRol,
+  useFetchByIdUsuario,
+  useFetchByIdUsuarioDashboardAcceso,
+  useFetchByIdUsuarioGrafica,
+  useFetchByIdUsuarioGraficaExcluida,
+  useFetchByIdUsuarioRol,
+  useFetchListAdeudo,
+  useFetchListCatAccion,
+  useFetchListCatConceptoPago,
+  useFetchListCatEntidad,
+  useFetchListCatFechaAgrupacion,
+  useFetchListCatGraficaGrupo,
+  useFetchListCatPlaza,
+  useFetchListCatRolGrupo,
+  useFetchListCatTipoParametro,
+  useFetchListCatTipoServicio,
+  useFetchListCatTipoSuelo,
+  useFetchListCatTipoTarifa,
+  useFetchListContribuyente,
+  useFetchListContribuyenteDomicilio,
+  useFetchListDashboardEstilo,
+  useFetchListDashboardGrafica,
+  useFetchListDashboardGraficaElemento,
+  useFetchListDashboardGraficaElementoDetalle,
+  useFetchListDashboardGraficaElementoParametro,
+  useFetchListDashboardGraficaGrupo,
+  useFetchListDashboardGraficaGrupoRol,
+  useFetchListDashboardRuta,
+  useFetchListGrafica,
+  useFetchListGraficaAgrupacion,
+  useFetchListGraficaFiltro,
+  useFetchListGraficaParametro,
+  useFetchListGraficaParametroDefecto,
+  useFetchListGraficaParametroTipo,
+  useFetchListGraficaPorGrupo,
+  useFetchListGrupoUsuario,
+  useFetchListModulo,
+  useFetchListPagos,
+  useFetchListPermisoAccionEntidad,
+  useFetchListPermisoModulo,
+  useFetchListPermisoSubmodulo,
+  useFetchListPlazas,
+  useFetchListRol,
+  useFetchListRolDashboardRuta,
+  useFetchListRolGrafica,
+  useFetchListSubmodulo,
+  useFetchListTipoGrafica,
+  useFetchListTipoRol,
+  useFetchListUsuario,
+  useFetchListUsuarioDashboardAcceso,
+  useFetchListUsuarioGrafica,
+  useFetchListUsuarioGraficaExcluida,
+  useFetchListUsuarioRol,
+  useFilterMatchAdeudo,
+  useFilterMatchCatAccion,
+  useFilterMatchCatConceptoPago,
+  useFilterMatchCatEntidad,
+  useFilterMatchCatFechaAgrupacion,
+  useFilterMatchCatGraficaGrupo,
+  useFilterMatchCatPlaza,
+  useFilterMatchCatRolGrupo,
+  useFilterMatchCatTipoParametro,
+  useFilterMatchCatTipoServicio,
+  useFilterMatchCatTipoSuelo,
+  useFilterMatchCatTipoTarifa,
+  useFilterMatchContribuyente,
+  useFilterMatchContribuyenteDomicilio,
+  useFilterMatchDashboardEstilo,
+  useFilterMatchDashboardGrafica,
+  useFilterMatchDashboardGraficaElemento,
+  useFilterMatchDashboardGraficaElementoDetalle,
+  useFilterMatchDashboardGraficaElementoParametro,
+  useFilterMatchDashboardGraficaGrupo,
+  useFilterMatchDashboardGraficaGrupoRol,
+  useFilterMatchDashboardRuta,
+  useFilterMatchGrafica,
+  useFilterMatchGraficaAgrupacion,
+  useFilterMatchGraficaFiltro,
+  useFilterMatchGraficaParametro,
+  useFilterMatchGraficaParametroDefecto,
+  useFilterMatchGraficaParametroTipo,
+  useFilterMatchGraficaPorGrupo,
+  useFilterMatchGrupoUsuario,
+  useFilterMatchModulo,
+  useFilterMatchPagos,
+  useFilterMatchPermisoAccionEntidad,
+  useFilterMatchPermisoModulo,
+  useFilterMatchPermisoSubmodulo,
+  useFilterMatchPlazas,
+  useFilterMatchRol,
+  useFilterMatchRolDashboardRuta,
+  useFilterMatchRolGrafica,
+  useFilterMatchSubmodulo,
+  useFilterMatchTipoGrafica,
+  useFilterMatchTipoRol,
+  useFilterMatchUsuario,
+  useFilterMatchUsuarioDashboardAcceso,
+  useFilterMatchUsuarioGrafica,
+  useFilterMatchUsuarioGraficaExcluida,
+  useFilterMatchUsuarioRol,
+  useUpdateAdeudo,
+  useUpdateCatAccion,
+  useUpdateCatConceptoPago,
+  useUpdateCatEntidad,
+  useUpdateCatFechaAgrupacion,
+  useUpdateCatGraficaGrupo,
+  useUpdateCatPlaza,
+  useUpdateCatRolGrupo,
+  useUpdateCatTipoParametro,
+  useUpdateCatTipoServicio,
+  useUpdateCatTipoSuelo,
+  useUpdateCatTipoTarifa,
+  useUpdateContribuyente,
+  useUpdateContribuyenteDomicilio,
+  useUpdateDashboardEstilo,
+  useUpdateDashboardGrafica,
+  useUpdateDashboardGraficaElemento,
+  useUpdateDashboardGraficaElementoDetalle,
+  useUpdateDashboardGraficaElementoParametro,
+  useUpdateDashboardGraficaGrupo,
+  useUpdateDashboardGraficaGrupoRol,
+  useUpdateDashboardRuta,
+  useUpdateGrafica,
+  useUpdateGraficaAgrupacion,
+  useUpdateGraficaFiltro,
+  useUpdateGraficaParametro,
+  useUpdateGraficaParametroDefecto,
+  useUpdateGraficaParametroTipo,
+  useUpdateGraficaPorGrupo,
+  useUpdateGrupoUsuario,
+  useUpdateModulo,
+  useUpdatePagos,
+  useUpdatePermisoAccionEntidad,
+  useUpdatePermisoModulo,
+  useUpdatePermisoSubmodulo,
+  useUpdatePlazas,
+  useUpdateRol,
+  useUpdateRolDashboardRuta,
+  useUpdateRolGrafica,
+  useUpdateSubmodulo,
+  useUpdateTipoGrafica,
+  useUpdateTipoRol,
+  useUpdateUsuario,
+  useUpdateUsuarioDashboardAcceso,
+  useUpdateUsuarioGrafica,
+  useUpdateUsuarioGraficaExcluida,
+  useUpdateUsuarioRol
+});
+//# sourceMappingURL=index.js.map