@orbe-agro/client-core 5.6.309 → 5.6.310

package/lib/base/services/modules/centralNfe/vinculoOperacao/VinculoOperacaoService.ts

@@ -32,4 +32,11 @@ export async function apiCreateVinculoOperacao(values: any) {
         method: VINCULO_OPERACAO_ENDPOINT.create.httpMethod,
         data: values
     })
+}
+
+export async function apiFindCfopsDisponiveis(cfop: string) {
+    return ApiService.fetchDataWithAxios<any[]>({
+        url: VINCULO_OPERACAO_ENDPOINT.findCfopsDisponiveis.endpoint.replace('{cfop}', cfop),
+        method: VINCULO_OPERACAO_ENDPOINT.findCfopsDisponiveis.httpMethod
+    })
 }

package/lib/base/services/modules/compras/dashboard/DashboardService.ts

@@ -0,0 +1,54 @@
+import ApiService from "@/services/ApiService";
+import endpointConfig from "@base/configs/endpoints.config/endpoints.navigation";
+import {
+    TDashboardComprasDiretasPayload,
+    TDashboardComprasDiretasResponse,
+    TDashboardOpcoesFiltro,
+    TDashboardPedidosPendentesPayload,
+    TDashboardPedidosPendentesResponse,
+    TDashboardRankingsPayload,
+    TDashboardRankingsResponse,
+    TDashboardRequisicaoCompraPayload,
+    TDashboardRequisicaoCompraResponse,
+} from "@base/@types/models/compras/Dashboard";
+
+const DASHBOARD_ENDPOINT = endpointConfig.compras.dashboard;
+
+export async function apiGetDashboardComprasRequisicoes(data: TDashboardRequisicaoCompraPayload) {
+    return ApiService.fetchDataWithAxios<TDashboardRequisicaoCompraResponse>({
+        url: DASHBOARD_ENDPOINT.comprasRequisicoes.endpoint,
+        method: DASHBOARD_ENDPOINT.comprasRequisicoes.httpMethod,
+        data,
+    })
+}
+
+export async function apiGetDashboardRankings(data: TDashboardRankingsPayload) {
+    return ApiService.fetchDataWithAxios<TDashboardRankingsResponse>({
+        url: DASHBOARD_ENDPOINT.rankings.endpoint,
+        method: DASHBOARD_ENDPOINT.rankings.httpMethod,
+        data,
+    })
+}
+
+export async function apiGetDashboardComprasDiretas(data: TDashboardComprasDiretasPayload) {
+    return ApiService.fetchDataWithAxios<TDashboardComprasDiretasResponse>({
+        url: DASHBOARD_ENDPOINT.comprasDiretas.endpoint,
+        method: DASHBOARD_ENDPOINT.comprasDiretas.httpMethod,
+        data,
+    })
+}
+
+export async function apiGetDashboardPedidosPendentes(data: TDashboardPedidosPendentesPayload) {
+    return ApiService.fetchDataWithAxios<TDashboardPedidosPendentesResponse>({
+        url: DASHBOARD_ENDPOINT.pedidosPendentes.endpoint,
+        method: DASHBOARD_ENDPOINT.pedidosPendentes.httpMethod,
+        data,
+    })
+}
+
+export async function apiGetDashboardOpcoesFiltro() {
+    return ApiService.fetchDataWithAxios<TDashboardOpcoesFiltro>({
+        url: DASHBOARD_ENDPOINT.opcoesFiltro.endpoint,
+        method: DASHBOARD_ENDPOINT.opcoesFiltro.httpMethod,
+    })
+}

package/lib/base/services/modules/compras/index.ts

@@ -5,4 +5,6 @@ export * from './cotacao/CotacaoService'
 export * from './ordemCompra/OrdemCompraService'
 export * from './historicoAcao/HistoricoAcaoService'
 export * from './cadastroEstrategiaLiberacaoValor/CadastroEstrategiaLiberacaoValorService'
-export * from './itemRequisicaoCompra/ItemRequisicaoCompraService'
+export * from './itemRequisicaoCompra/ItemRequisicaoCompraService'
+export * from './dashboard/DashboardService'
+export * from './ordemCompra/ItemOrdemCompraService'

package/lib/base/services/modules/compras/ordemCompra/ItemOrdemCompraService.ts

@@ -0,0 +1,12 @@
+import ApiService from '@/services/ApiService'
+import endpointConfig from '@base/configs/endpoints.config/endpoints.navigation'
+
+const ITEM_ORDEM_COMPRA_ENDPOINT = endpointConfig.compras.itemOrdemCompra
+
+export async function apiCancelar(body) {
+    return ApiService.fetchDataWithAxios<any>({
+        url: ITEM_ORDEM_COMPRA_ENDPOINT.cancelar.endpoint,
+        method: ITEM_ORDEM_COMPRA_ENDPOINT.cancelar.httpMethod,
+        data: body,
+    })
+}

package/lib/base/services/modules/dm/municipio/MunicipioService.tsx

@@ -41,3 +41,10 @@ export async function apiFindMunicipioByUf(uf: string) {
         method: MUNICIPIO_ENDPOINT.findMunicipioByUf.httpMethod,
     })
 }
+
+export async function apiFindMunicipioById(id: string) {
+    return ApiService.fetchDataWithAxios<TMunicipio>({
+        url: MUNICIPIO_ENDPOINT.findById.endpoint + `/${id}`,
+        method: MUNICIPIO_ENDPOINT.findById.httpMethod,
+    })
+}

package/lib/base/services/modules/originacao/analisePenhorAlienacao/analisePenhorAlienacaoService.ts

@@ -1,6 +1,8 @@
 import ApiService from "@/services/ApiService";
 import { TQueryResponse } from "@base/@types/api";
 import { TLancarPenhoresRequest } from "@base/@types/api/request/originacao/TLancarPenhoresRequest";
+import { TUpdateStatusCertidoesRequest } from "@base/@types/api/request/originacao/TUpdateStatusCertidoesRequest";
+import { TValidarBaixaPenhorRequest } from "@base/@types/api/request/originacao/TValidarBaixaPenhorRequest";
 import { TFindAllAnalisePenhorAlienacaoResponse } from "@base/@types/api/response/originacao/TFindAllAnalisePenhorAlienacaoResponse";
 import endpointNavigationConfig from "@base/configs/endpoints.config/endpoints.navigation";
 
@@ -39,7 +41,7 @@ export async function apiLancarPenhores(id: number | string, data: TLancarPenhor
 export async function apiUploadFileDadosPenhores(id: number | string, file: File) {
     const formData = new FormData();
     formData.append("file", file);
-    
+
     return ApiService.fetchDataWithAxios<void, FormData>({
         url: ANALISE_PENHOR_ALIENACAO_ORIGINACAO_ENDPOINT.uploadFileDadosPenhores(String(id)),
         method: "patch",
@@ -53,4 +55,36 @@ export async function apiGetFileDadosPenhores(url: string) {
     method: "get",
     responseType: "blob"
   });
-}
+}
+
+export async function apiGetArquivoDadosPenhores(id: number | string) {
+  return ApiService.fetchDataWithAxios<Blob>({
+    url: ANALISE_PENHOR_ALIENACAO_ORIGINACAO_ENDPOINT.getArquivoPenhor(String(id)),
+    method: "get",
+    responseType: "blob"
+  });
+}
+
+export async function apiValidarBaixaPenhor(id: number | string, data: TValidarBaixaPenhorRequest) {
+  return ApiService.fetchDataWithAxios<void, TValidarBaixaPenhorRequest>({
+    url: ANALISE_PENHOR_ALIENACAO_ORIGINACAO_ENDPOINT.validarBaixaPenhor(String(id)),
+    method: "patch",
+    data,
+  });
+}
+
+export async function apiGetDocumentoCertidao(id: number | string, documentoId: number | string) {
+  return ApiService.fetchDataWithAxios<Blob>({
+    url: ANALISE_PENHOR_ALIENACAO_ORIGINACAO_ENDPOINT.getDocumentoCertidao(String(id), String(documentoId)),
+    method: "get",
+    responseType: "blob"
+  });
+}
+
+export async function apiUpdateStatusCertidoes(id: number | string, data: TUpdateStatusCertidoesRequest) {
+  return ApiService.fetchDataWithAxios<void, TUpdateStatusCertidoesRequest>({
+    url: ANALISE_PENHOR_ALIENACAO_ORIGINACAO_ENDPOINT.updateStatusCertidoes(String(id)),
+    method: "patch",
+    data,
+  });
+}

package/lib/base/services/modules/originacao/envioFiscal/envioFiscalService.ts

@@ -12,6 +12,13 @@ export async function apiUpdateEnvioFiscal(id: string | number, data: TUpdateEnv
   });
 }
 
+export async function apiCancelarEnvioFiscal(id: string | number) {
+  return ApiService.fetchDataWithAxios<void>({
+    url: ENVIO_FISCAL_ORIGINACAO_ENDPOINT.cancelar(String(id)),
+    method: "post",
+  });
+}
+
 export async function apiReprovarEnvioFiscal(id: string | number, data: { justificativa: string }) {
   return ApiService.fetchDataWithAxios<void>({
     url: `${ENVIO_FISCAL_ORIGINACAO_ENDPOINT.update(String(id))}/reprovar`,

package/lib/base/services/modules/originacao/index.ts

@@ -21,3 +21,5 @@ export * from './vinculoOperacaoLiquidacao/vinculoOperacaoLiquidacaoService';
 export * from './alteracaoTransgenia/alteracaoTransgeniaService';
 export * from './tarefaLiquidacao/tarefaLiquidacaoService';
 export * from './campoFixo/campoFixoService';
+export * from './relatoriosDinamicos/relatoriosDinamicosService';
+export * from './vinculoTipoFiscalTipoFreteOperacao/vinculoTipoFiscalTipoFreteOperacaoService';

package/lib/base/services/modules/originacao/liquidacao/liquidacaoService.ts

@@ -1,6 +1,7 @@
 import ApiService from '@/services/ApiService'
 import { TQueryResponse } from '@base/@types/api'
 import { TFindAllLiquidacaoResponse } from '@base/@types/api/response/originacao/TFindAllLiquidacaoResponse'
+import { TDadosPenhorLiquidacaoResponse } from '@base/@types/api/response/originacao/TDadosPenhorLiquidacaoResponse'
 import endpointNavigationConfig from '@base/configs/endpoints.config/endpoints.navigation'
 
 const LIQUIDACAO_ORIGINACAO_ENDPOINT = endpointNavigationConfig.originacao.liquidacao;
@@ -13,11 +14,10 @@ export async function apiFindAllLiquidacao(data = {}) {
     })
 }
 
-export async function apiFinalizarLiquidacao(id, data: { statusPenhor: 'POSITIVO' | 'NEGATIVO' }) {
+export async function apiFinalizarLiquidacao(id: number | string) {
     return ApiService.fetchDataWithAxios({
         url: LIQUIDACAO_ORIGINACAO_ENDPOINT.finalizar + id,
         method: 'post',
-        data,
     })
 }
 
@@ -27,3 +27,10 @@ export async function apiRetornoSapLiquidacao(id: number | string) {
         method: 'post',
     })
 }
+
+export async function apiFindDadosPenhorLiquidacao(id: number | string) {
+    return ApiService.fetchDataWithAxios<TDadosPenhorLiquidacaoResponse>({
+        url: LIQUIDACAO_ORIGINACAO_ENDPOINT.dadosPenhor(id),
+        method: 'get',
+    })
+}

package/lib/base/services/modules/originacao/relatoriosDinamicos/relatoriosDinamicosService.ts

@@ -0,0 +1,120 @@
+import ApiService from '@/services/ApiService'
+import { isAxiosError } from 'axios'
+import AxiosBase from '@/services/axios/AxiosBase'
+import endpointNavigationConfig from '@base/configs/endpoints.config/endpoints.navigation'
+import type { TQueryResponse } from '../../../../@types/api'
+import type {
+    TBaseRelatorioDinamico,
+    TCatalogoRelatorioDinamico,
+    TRelatorioDinamicoResponse,
+    TCriarRelatorioDinamicoRequest,
+    TEditarRelatorioDinamicoRequest,
+    TConsultarRelatorioDinamicoRequest,
+    TExportarRelatorioDinamicoRequest,
+    TResultadoRelatorioDinamico,
+} from '../../../../@types/api/response/originacao/TRelatorioDinamicoResponse'
+
+const endpoints = endpointNavigationConfig.originacao.relatoriosDinamicos
+export const apiCatalogoRelatorioDinamico = (base?: TBaseRelatorioDinamico) =>
+    ApiService.fetchDataWithAxios<TCatalogoRelatorioDinamico>({
+        url: endpoints.catalogo(base),
+        method: 'get',
+    })
+export const apiListarRelatoriosDinamicos = (params?: string) =>
+    ApiService.fetchDataWithAxios<TQueryResponse<TRelatorioDinamicoResponse>>({
+        url: endpoints.findAll(params),
+        method: 'get',
+    })
+export const apiObterRelatorioDinamico = (id: string | number) =>
+    ApiService.fetchDataWithAxios<TRelatorioDinamicoResponse>({
+        url: endpoints.findOne(id),
+        method: 'get',
+    })
+export const apiCriarRelatorioDinamico = (
+    data: TCriarRelatorioDinamicoRequest,
+) =>
+    ApiService.fetchDataWithAxios<TRelatorioDinamicoResponse>({
+        url: endpoints.add,
+        method: 'post',
+        data,
+    })
+export const apiEditarRelatorioDinamico = (
+    id: string | number,
+    data: TEditarRelatorioDinamicoRequest,
+    compartilhado: boolean,
+) =>
+    ApiService.fetchDataWithAxios<TRelatorioDinamicoResponse>({
+        url: compartilhado
+            ? endpoints.editarCompartilhado(id)
+            : endpoints.findOne(id),
+        method: 'put',
+        data,
+    })
+export const apiExcluirRelatorioDinamico = (id: string | number) =>
+    ApiService.fetchDataWithAxios<void>({
+        url: endpoints.findOne(id),
+        method: 'delete',
+    })
+export const apiConsultarRelatorioDinamico = (
+    id: string | number,
+    data: TConsultarRelatorioDinamicoRequest,
+) =>
+    ApiService.fetchDataWithAxios<TResultadoRelatorioDinamico>({
+        url: endpoints.consultar(id),
+        method: 'post',
+        data,
+    })
+
+export async function apiExportarRelatorioDinamico(
+    id: string | number,
+    data: TExportarRelatorioDinamicoRequest,
+): Promise<{ arquivo: Blob; nome: string }> {
+    try {
+        const response = await AxiosBase<Blob>({
+            url: endpoints.exportar(id),
+            method: 'post',
+            data,
+            responseType: 'blob',
+        })
+        const disposition = String(
+            response.headers['content-disposition'] ?? '',
+        )
+        const encoded = /filename\*=UTF-8''([^;]+)/i.exec(disposition)?.[1]
+        const plain = /filename="?([^";]+)"?/i.exec(disposition)?.[1]
+        let nome = plain ?? `relatorio-${id}.xlsx`
+        if (encoded) {
+            try {
+                nome = decodeURIComponent(encoded)
+            } catch {
+                nome = `relatorio-${id}.xlsx`
+            }
+        }
+        return { arquivo: response.data, nome: nome.replace(/[\\/]/g, '_') }
+    } catch (error: unknown) {
+        const response = isAxiosError(error) ? error.response : undefined
+        if (response?.data instanceof Blob) {
+            const text = await response.data.text()
+            let message = 'Não foi possível exportar o relatório.'
+            try {
+                const problem: unknown = JSON.parse(text)
+                if (problem && typeof problem === 'object') {
+                    if (
+                        'detail' in problem &&
+                        typeof problem.detail === 'string'
+                    )
+                        message = problem.detail
+                    else if (
+                        'title' in problem &&
+                        typeof problem.title === 'string'
+                    )
+                        message = problem.title
+                }
+            } catch {
+                if (text && text.length < 500 && !text.includes('<html'))
+                    message = text
+            }
+            throw new Error(message)
+        }
+        throw error
+    }
+}

package/lib/base/services/modules/originacao/termoFunrural/termoFunruralService.ts

@@ -1,13 +1,22 @@
-import { IFilterParams, TQueryResponse } from '@base/@types/api'
 import endpointConfig from "@base/configs/endpoints.config/endpoints.navigation";
 import ApiService from '@/services/ApiService'
-import { TTermoFunrural } from '@base/@types/models/originacao/termoFunrural';
-import { TFindAllMetricsTermoFunruralResponse } from '@base/@types/api/response/originacao/TFindAllMetricsTermoFunruralResponse';
+// Os tipos usam caminhos relativos para que o .d.ts gerado resolva nos projetos que consomem a lib
+// (o alias @base não existe fora do client-core e deixaria as assinaturas como `any`).
+import type { TQueryResponse } from '../../../../@types/api'
+import type {
+    TTermoFunrural,
+    TTipoAssinaturaTermoFunrural,
+    TTipoRecolhimentoTermoFunrural,
+} from '../../../../@types/models/originacao/termoFunrural';
+import type { TCreateTermoFunruralRequest } from '../../../../@types/api/request/originacao/TCreateTermoFunruralRequest';
+import type { TExisteTermoFunruralResponse } from '../../../../@types/api/response/originacao/TExisteTermoFunruralResponse';
+import type { TDisponibilidadeOpcaoTermoFunruralResponse } from '../../../../@types/api/response/originacao/TDisponibilidadeOpcaoTermoFunruralResponse';
+import type { TFindAllMetricsTermoFunruralResponse } from '../../../../@types/api/response/originacao/TFindAllMetricsTermoFunruralResponse';
 
 const TERMO_FUNRURAL_PROJECT_ENDPOINT = endpointConfig.originacao.termoFunrural;
 
-export async function apiAddTermoFunrural(body: TTermoFunrural) {
-    return ApiService.fetchDataWithAxios<TQueryResponse<TTermoFunrural>>({
+export async function apiAddTermoFunrural(body: TCreateTermoFunruralRequest) {
+    return ApiService.fetchDataWithAxios<TTermoFunrural>({
         url: TERMO_FUNRURAL_PROJECT_ENDPOINT.add.endpoint,
         method: TERMO_FUNRURAL_PROJECT_ENDPOINT.add.method,
         data: body,
@@ -44,19 +53,19 @@ export async function apiReprovarTermoFunrural(id: number, motivo: string) {
     });
 }
 
-export async function apiAprovarTermoFunrural(id: number) {
-    return ApiService.fetchDataWithAxios<TTermoFunrural>({
+// O backend responde 204 e exige corpo (AprovarTermoFunruralRequest), mesmo com o motivo opcional.
+export async function apiAprovarTermoFunrural(id: number, motivo?: string) {
+    return ApiService.fetchDataWithAxios<void>({
         url: TERMO_FUNRURAL_PROJECT_ENDPOINT.aprovar.endpoint + `/${id}`,
         method: TERMO_FUNRURAL_PROJECT_ENDPOINT.aprovar.method,
-        data: { id },
+        data: { motivo: motivo ?? null },
     });
 }
 
 export async function apiReabrirTermoFunrural(id: number) {
-    return ApiService.fetchDataWithAxios<TTermoFunrural>({
+    return ApiService.fetchDataWithAxios<void>({
         url: TERMO_FUNRURAL_PROJECT_ENDPOINT.reabrir.endpoint + `/${id}`,
         method: TERMO_FUNRURAL_PROJECT_ENDPOINT.reabrir.method,
-        data: { id },
     });
 }
 
@@ -71,16 +80,42 @@ export async function apiUploadArquivoAssinado(id: number, formData: FormData) {
     });
 }
 
-export async function apiExistePorCpfTermoFunrural(cpf: string, ano: number) {
-    return ApiService.fetchDataWithAxios<boolean>({
-        url: TERMO_FUNRURAL_PROJECT_ENDPOINT.existePorCpf.endpoint + `?cpf=${cpf}&ano=${ano}`,
+// Termo de Funrural é vitalício (OA-2000): a checagem agora considera apenas o CPF, sem recorte por ano.
+export async function apiExistePorCpfTermoFunrural(cpf: string) {
+    return ApiService.fetchDataWithAxios<TExisteTermoFunruralResponse>({
+        url: TERMO_FUNRURAL_PROJECT_ENDPOINT.existePorCpf.endpoint + `?cpf=${cpf}`,
         method: TERMO_FUNRURAL_PROJECT_ENDPOINT.existePorCpf.method,
     });
 }
 
+// Informa quais tipos de assinatura (envio) o produtor pode escolher ao emitir o termo e, para os bloqueados, o motivo.
+export async function apiVerificarTiposAssinaturaTermoFunrural(produtorId: number) {
+    return ApiService.fetchDataWithAxios<TDisponibilidadeOpcaoTermoFunruralResponse<TTipoAssinaturaTermoFunrural>[]>({
+        url: TERMO_FUNRURAL_PROJECT_ENDPOINT.verificarTiposAssinatura.endpoint + `?produtorId=${produtorId}`,
+        method: TERMO_FUNRURAL_PROJECT_ENDPOINT.verificarTiposAssinatura.method,
+    });
+}
+
+// Informa quais tipos de recolhimento o produtor pode escolher ao emitir o termo e, para os bloqueados, o motivo.
+export async function apiVerificarTiposRecolhimentoTermoFunrural(produtorId: number) {
+    return ApiService.fetchDataWithAxios<TDisponibilidadeOpcaoTermoFunruralResponse<TTipoRecolhimentoTermoFunrural>[]>({
+        url: TERMO_FUNRURAL_PROJECT_ENDPOINT.verificarTiposRecolhimento.endpoint + `?produtorId=${produtorId}`,
+        method: TERMO_FUNRURAL_PROJECT_ENDPOINT.verificarTiposRecolhimento.method,
+    });
+}
+
 export async function apiFindTermoFunruralMetrics() {
     return ApiService.fetchDataWithAxios<TFindAllMetricsTermoFunruralResponse>({
         url: TERMO_FUNRURAL_PROJECT_ENDPOINT.findAllMetrics.endpoint,
         method: TERMO_FUNRURAL_PROJECT_ENDPOINT.findAllMetrics.method,
     });
 }
+
+// Conclui a análise da Área CRM do Termo Funrural (OA-2000), alterando statusCrm para CONCLUIDO_SAP_ORBEAGRO.
+// O usuário é identificado pelo header X-User-Id, injetado automaticamente pelo interceptor do Axios.
+export async function apiConcluirCrmTermoFunrural(id: number) {
+    return ApiService.fetchDataWithAxios<void>({
+        url: TERMO_FUNRURAL_PROJECT_ENDPOINT.concluirCrm.endpoint + `${id}`,
+        method: TERMO_FUNRURAL_PROJECT_ENDPOINT.concluirCrm.method,
+    });
+}

package/lib/base/services/modules/originacao/vinculoTipoFiscalTipoFreteOperacao/vinculoTipoFiscalTipoFreteOperacaoService.ts

@@ -0,0 +1,45 @@
+import ApiService from '../../../../../@ecme/services/ApiService';
+import type { TQueryResponse } from '../../../../@types/api';
+import type { TCreateVinculoTipoFiscalTipoFreteOperacaoRequest } from '../../../../@types/api/request/originacao/TCreateVinculoTipoFiscalTipoFreteOperacaoRequest';
+import type { TUpdateVinculoTipoFiscalTipoFreteOperacaoRequest } from '../../../../@types/api/request/originacao/TUpdateVinculoTipoFiscalTipoFreteOperacaoRequest';
+import type { TVinculoTipoFiscalTipoFreteOperacaoResponse } from '../../../../@types/api/response/originacao/TVinculoTipoFiscalTipoFreteOperacaoResponse';
+import endpointNavigationConfig from '../../../../configs/endpoints.config/endpoints.navigation';
+
+const ENDPOINT = endpointNavigationConfig.originacao.vinculoTipoFiscalTipoFreteOperacao;
+
+export async function apiFindAllVinculoTipoFiscalTipoFreteOperacao(params?: string): Promise<TQueryResponse<TVinculoTipoFiscalTipoFreteOperacaoResponse>> {
+    return ApiService.fetchDataWithAxios<TQueryResponse<TVinculoTipoFiscalTipoFreteOperacaoResponse>>({
+        url: ENDPOINT.findAll(params),
+        method: 'get',
+    });
+}
+
+export async function apiFindByIdVinculoTipoFiscalTipoFreteOperacao(id: number | string): Promise<TVinculoTipoFiscalTipoFreteOperacaoResponse> {
+    return ApiService.fetchDataWithAxios<TVinculoTipoFiscalTipoFreteOperacaoResponse>({
+        url: ENDPOINT.findOne(String(id)),
+        method: 'get',
+    });
+}
+
+export async function apiCreateVinculoTipoFiscalTipoFreteOperacao(payload: TCreateVinculoTipoFiscalTipoFreteOperacaoRequest): Promise<void> {
+    await ApiService.fetchDataWithAxios<void>({
+        url: ENDPOINT.add,
+        method: 'post',
+        data: payload,
+    });
+}
+
+export async function apiUpdateVinculoTipoFiscalTipoFreteOperacao(id: number | string, payload: TUpdateVinculoTipoFiscalTipoFreteOperacaoRequest): Promise<void> {
+    await ApiService.fetchDataWithAxios<void>({
+        url: ENDPOINT.edit(String(id)),
+        method: 'put',
+        data: payload,
+    });
+}
+
+export async function apiDesativarVinculoTipoFiscalTipoFreteOperacao(id: number | string): Promise<void> {
+    await ApiService.fetchDataWithAxios<void>({
+        url: ENDPOINT.delete(String(id)),
+        method: 'delete',
+    });
+}

package/lib/base/services/modules/racao/carga/CargaService.ts

@@ -1,6 +1,6 @@
 import ApiService from "@/services/ApiService";
 import { IFilterParams, TQueryResponse } from "@base/@types/api";
-import { TCarga, TAprovarRacaoCarga } from "@base/@types/models/racao/carga";
+import { TCarga, TAprovarRacaoCarga, TContadoresCarga, TContadoresEtapaAgendamentoCarga } from "@base/@types/models/racao/carga";
 import endpointConfig from "@base/configs/endpoints.config/endpoints.navigation";
 
 const CARGA_ENDPOINT = endpointConfig.racao.carga;
@@ -65,3 +65,17 @@ export async function apiFindOrdensDisponiveisRacaoCarga(vendedorId: number, cen
         method: CARGA_ENDPOINT.findOrdensDisponiveis.method,
     })
 }
+
+export async function apiFindContadoresRacaoCarga() {
+    return ApiService.fetchDataWithAxios<TContadoresCarga>({
+        url: CARGA_ENDPOINT.findContadores.endpoint,
+        method: CARGA_ENDPOINT.findContadores.method,
+    })
+}
+
+export async function apiFindContadoresEtapaAgendamentoRacaoCarga() {
+    return ApiService.fetchDataWithAxios<TContadoresEtapaAgendamentoCarga>({
+        url: CARGA_ENDPOINT.findContadoresEtapaAgendamento.endpoint,
+        method: CARGA_ENDPOINT.findContadoresEtapaAgendamento.method,
+    })
+}

package/lib/base/services/modules/template/example/ExampleService.ts

@@ -1,27 +1,45 @@
 import ApiService from "@/services/ApiService";
-import { IFilterParams, TQueryResponse } from "@base/@types";
-import { endpointsConfig } from "@base/configs";
+import { IFilterParams, TQueryResponse } from "@base/@types/api";
+import { TExample } from "@base/@types/models/template/example";
+import endpointConfig from "@base/configs/endpoints.config/endpoints.navigation";
 
-export async function apiGetTemplateExample(body?: IFilterParams) {
-  return ApiService.fetchDataWithAxios<TQueryResponse<any>>({
-    url: endpointsConfig.template.example.findMonitor.endpoint,
-    method: "post",
+//EXAMPLE_ENDPOINT
+const EXAMPLE_ENDPOINT = endpointConfig.template.example;
+
+export async function apiGetTemplateExample(id: number) {
+  return ApiService.fetchDataWithAxios<TExample>({
+    url: EXAMPLE_ENDPOINT.findOne.endpoint + `${id}`,
+    method: EXAMPLE_ENDPOINT.findOne.method,
+  })
+}
+
+export async function apiAddTemplateExample(body: TExample) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExample>>({
+    url: EXAMPLE_ENDPOINT.add.endpoint,
+    method: EXAMPLE_ENDPOINT.add.method,
     data: body,
-  });
+  })
 }
 
-export async function apiUpdateTemplateExample(data?: any) {
-  return ApiService.fetchDataWithAxios<TQueryResponse<any>>({
-    url: endpointsConfig.template.example.update.endpoint,
-    method: "post",
-    data,
-  });
+export async function apiUpdateTemplateExample(body: TExample) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExample>>({
+    url: EXAMPLE_ENDPOINT.update.endpoint,
+    method: EXAMPLE_ENDPOINT.update.method,
+    data: body,
+  })
 }
 
-export async function apiAddTemplateExample(data?: any) {
-  return ApiService.fetchDataWithAxios<TQueryResponse<any>>({
-    url: endpointsConfig.template.example.add.endpoint,
-    method: "post",
-    data,
-  });
+export async function apiDeleteTemplateExample(id: number) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExample>>({
+    url: EXAMPLE_ENDPOINT.delete.endpoint + `${id}`,
+    method: EXAMPLE_ENDPOINT.delete.method,
+  })
+}
+
+export async function apiFindMonitorTemplateExample(body?: IFilterParams) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExample>>({
+    url: EXAMPLE_ENDPOINT.findMonitor.endpoint,
+    method: EXAMPLE_ENDPOINT.findMonitor.method,
+    data: body,
+  })
 }

package/lib/base/services/modules/template/exampleObject/ExampleObjectService.ts

@@ -0,0 +1,45 @@
+import ApiService from "@/services/ApiService";
+import { IFilterParams, TQueryResponse } from "@base/@types/api";
+import { TExampleObject } from "@base/@types/models/template/exampleObject";
+import endpointConfig from "@base/configs/endpoints.config/endpoints.navigation";
+
+//EXAMPLE_OBJECT_ENDPOINT
+const EXAMPLE_OBJECT_ENDPOINT = endpointConfig.template.exampleObject;
+
+export async function apiGetTemplateExampleObject(id: number) {
+  return ApiService.fetchDataWithAxios<TExampleObject>({
+    url: EXAMPLE_OBJECT_ENDPOINT.findOne.endpoint + `${id}`,
+    method: EXAMPLE_OBJECT_ENDPOINT.findOne.method,
+  })
+}
+
+export async function apiAddTemplateExampleObject(body: TExampleObject) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExampleObject>>({
+    url: EXAMPLE_OBJECT_ENDPOINT.add.endpoint,
+    method: EXAMPLE_OBJECT_ENDPOINT.add.method,
+    data: body,
+  })
+}
+
+export async function apiUpdateTemplateExampleObject(body: TExampleObject) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExampleObject>>({
+    url: EXAMPLE_OBJECT_ENDPOINT.update.endpoint,
+    method: EXAMPLE_OBJECT_ENDPOINT.update.method,
+    data: body,
+  })
+}
+
+export async function apiDeleteTemplateExampleObject(id: number) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExampleObject>>({
+    url: EXAMPLE_OBJECT_ENDPOINT.delete.endpoint + `${id}`,
+    method: EXAMPLE_OBJECT_ENDPOINT.delete.method,
+  })
+}
+
+export async function apiFindMonitorTemplateExampleObject(body?: IFilterParams) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TExampleObject>>({
+    url: EXAMPLE_OBJECT_ENDPOINT.findMonitor.endpoint,
+    method: EXAMPLE_OBJECT_ENDPOINT.findMonitor.method,
+    data: body,
+  })
+}

package/lib/base/services/modules/template/index.ts

@@ -1,2 +1,2 @@
-export * from './example/ExampleObjectService';
-export * from './example/ExampleService';
+export * from './example/ExampleService';
+export * from './exampleObject/ExampleObjectService';