@orbe-agro/client-core-prod 5.6.136 → 5.6.137

package/lib/base/configs/endpoints.config/centralNfe/centralNfe.ts

@@ -8,6 +8,7 @@ import vinculoIva from "./config/vinculoIva"
 import nfeProduto from "./config/nfeProduto"
 import vinculoOperacao from "./config/vinculoOperacao"
 import cfop from "./config/cfop"
+import recepcaoFisica from "./config/recepcaoFisica"
 
 const centralNfe = {
     notificacaoCentralNfe,
@@ -19,7 +20,8 @@ const centralNfe = {
     vinculoIva,
     nfeProduto,
     vinculoOperacao,
-    cfop
+    cfop,
+    recepcaoFisica
 }
 
 export default centralNfe

package/lib/base/configs/endpoints.config/centralNfe/config/recepcaoFisica.ts

@@ -0,0 +1,9 @@
+const RECEPCAO_FISICA_BASE_URL = '/central-nfe/api/recepcao-fisica'
+
+const recepcaoFisica = {
+    create: { endpoint: RECEPCAO_FISICA_BASE_URL, httpMethod: 'post' },
+    findMonitor: { endpoint: `${RECEPCAO_FISICA_BASE_URL}/find-monitor`, httpMethod: 'post' },
+    findOrdensCompra: { endpoint: `${RECEPCAO_FISICA_BASE_URL}/ordens-compra`, httpMethod: 'get' },
+}
+
+export default recepcaoFisica

package/lib/base/configs/endpoints.config/performance/config/ppr.ts

@@ -0,0 +1,8 @@
+const ppr = {
+  centrosCustos: '/performance/api/ppr/centros-custos',
+  aberturaAno: '/performance/api/ppr/centros-custos/abertura-ano',
+  anos: '/performance/api/ppr/centros-custos/anos',
+  updateStatus: '/performance/api/ppr/centros-custos',
+};
+
+export default ppr;

package/lib/base/configs/endpoints.config/performance/performance.ts

@@ -3,13 +3,15 @@ import categoria from './config/categoria';
 import areaAtuacao from './config/areaAtuacao';
 import modeloAvaliacao from './config/modeloAvaliacao';
 import avaliacao from './config/avaliacao';
+import ppr from './config/ppr';
 
 const performance = {
   modeloNota,
   categoria,
   areaAtuacao,
   modeloAvaliacao,
-  avaliacao
+  avaliacao,
+  ppr
 };
 
 export default performance;

package/lib/base/configs/navigation.config/modules.submenu/centralNfe/submenu.centralNfe.ts

@@ -3,6 +3,7 @@ import { ADMIN } from '@/constants/roles.constant'
 import { NavigationTree } from '@/@types/navigation'
 import cadastrosSubmenu from '../../submenu/centralNfe/cadastros.submenu'
 import nfeSubmenu from '../../submenu/centralNfe/config/nfe.submenu'
+import recepcaoFisicaSubmenu from '../../submenu/centralNfe/config/recepcaoFisica.submenu'
 
 const subMenuCentralNfe: NavigationTree =
 {
@@ -15,6 +16,7 @@ const subMenuCentralNfe: NavigationTree =
     authority: [ADMIN],
     subMenu: [
         nfeSubmenu,
+        recepcaoFisicaSubmenu,
         {
             key: 'modules.centralNfe.cadastros',
             path: '',

package/lib/base/configs/navigation.config/submenu/centralNfe/config/recepcaoFisica.submenu.ts

@@ -0,0 +1,16 @@
+import { NAV_ITEM_TYPE_ITEM } from '@/constants/navigation.constant'
+import { ADMIN } from '@/constants/roles.constant'
+import { NavigationTree } from '@/@types/navigation'
+
+const recepcaoFisicaSubmenu: NavigationTree = {
+    key: 'centralNfe.recepcaoFisica.table',
+    path: '/central-nfe/recepcao-fisica',
+    title: 'Monitor - Recepção Física',
+    translateKey: 'nav.modules.centralNfe.recepcaoFisica',
+    icon: 'recepcaoFisica',
+    type: NAV_ITEM_TYPE_ITEM,
+    authority: [ADMIN],
+    subMenu: [],
+}
+
+export default recepcaoFisicaSubmenu

package/lib/base/configs/navigation.config/submenu/performance/config/aberturaAnoPpr.submenu.ts

@@ -0,0 +1,17 @@
+import { NavigationTree } from '@/@types/navigation'
+import { NAV_ITEM_TYPE_ITEM } from '@/constants/navigation.constant'
+import { ADMIN } from '@/constants/roles.constant'
+
+const aberturaAnoPprSubmenu: NavigationTree = {
+    key: 'modules.performance.ppr.aberturaAno',
+    path: '/performance/ppr/abertura-ano',
+    title: 'Abertura de ano',
+    translateKey: 'nav.modules.performance.ppr.aberturaAno.title',
+    icon: '',
+    type: NAV_ITEM_TYPE_ITEM,
+    forceShowTitle: true,
+    authority: [ADMIN],
+    subMenu: [],
+}
+
+export default aberturaAnoPprSubmenu

package/lib/base/configs/navigation.config/submenu/performance/config/avaliacoes.submenu.ts

@@ -0,0 +1,25 @@
+import { NavigationTree } from '@/@types/navigation'
+import { NAV_ITEM_TYPE_COLLAPSE } from '@/constants/navigation.constant'
+import { ADMIN, USER } from '@/constants/roles.constant'
+import subMenuCadastros from '../../../modules.submenu/performance/cadastros/submenu.cadastro'
+import avaliacaoColaboradorSubmenu from './avaliacaoColaborador.submenu'
+import avaliacaoSubmenu from './avaliacao.submenu'
+import comparativoSubmenu from './comparativo.submenu'
+
+const avaliacoesSubmenu: NavigationTree = {
+    key: 'modules.performance.avaliacoes',
+    path: '',
+    title: 'Avaliações',
+    translateKey: 'nav.modules.performance.avaliacoes.title',
+    icon: 'customers',
+    type: NAV_ITEM_TYPE_COLLAPSE,
+    authority: [ADMIN, USER],
+    subMenu: [
+        subMenuCadastros,
+        avaliacaoSubmenu,
+        avaliacaoColaboradorSubmenu,
+        comparativoSubmenu,
+    ],
+}
+
+export default avaliacoesSubmenu

package/lib/base/configs/navigation.config/submenu/performance/config/ppr.submenu.ts

@@ -0,0 +1,19 @@
+import { NavigationTree } from '@/@types/navigation'
+import { NAV_ITEM_TYPE_COLLAPSE } from '@/constants/navigation.constant'
+import { ADMIN } from '@/constants/roles.constant'
+import aberturaAnoPprSubmenu from './aberturaAnoPpr.submenu'
+
+const pprSubmenu: NavigationTree = {
+    key: 'modules.performance.ppr',
+    path: '',
+    title: 'PPR',
+    translateKey: 'nav.modules.performance.ppr.title',
+    icon: 'chart',
+    type: NAV_ITEM_TYPE_COLLAPSE,
+    authority: [ADMIN],
+    subMenu: [
+        aberturaAnoPprSubmenu,
+    ],
+}
+
+export default pprSubmenu

package/lib/base/configs/navigation.config/submenu/performance/performance.submenu.ts

@@ -1,14 +1,10 @@
 import type { NavigationTree } from '@/@types/navigation'
-import subMenuCadastros from '../../modules.submenu/performance/cadastros/submenu.cadastro'
-import avaliacaoColaboradorSubmenu from './config/avaliacaoColaborador.submenu'
-import avaliacaoSubmenu from './config/avaliacao.submenu'
-import comparativoSubmenu from './config/comparativo.submenu'
+import avaliacoesSubmenu from './config/avaliacoes.submenu'
+import pprSubmenu from './config/ppr.submenu'
 
 const performanceSubmenu: NavigationTree[] = [
-    subMenuCadastros,
-    avaliacaoSubmenu,
-    avaliacaoColaboradorSubmenu,
-    comparativoSubmenu,
+    avaliacoesSubmenu,
+    pprSubmenu,
 ]
 
 export default performanceSubmenu

package/lib/base/locales/index.ts

@@ -3,8 +3,8 @@ import en from './lang/en'
 import ptBR from './lang/ptBR'
 
 export function addBaseLocaleResources() {
-    i18n.addResourceBundle('en', 'translation', en)
-    i18n.addResourceBundle('ptBR', 'translation', ptBR)
+    i18n.addResourceBundle('en', 'translation', en, true, true)
+    i18n.addResourceBundle('ptBR', 'translation', ptBR, true, true)
 }
 
 addBaseLocaleResources()

package/lib/base/services/modules/HubFiscal/NfeService.ts

@@ -14,4 +14,19 @@ export async function apiGetPdf(id) {
         url: nfeEndpointConfig.getPdf + id,
         method: 'get',
     })
+}
+
+export async function apiAddObservacao(body) {
+    return ApiService.fetchDataWithAxios({
+        url: nfeEndpointConfig.addObservacao,
+        method: 'post',
+        data: body,
+    })
+}
+
+export async function apiGetEventosNfe(chaveAcesso) {
+    return ApiService.fetchDataWithAxios({
+        url: nfeEndpointConfig.findEventos + chaveAcesso,
+        method: 'get',
+    })
 }

package/lib/base/services/modules/ativos/modelo/ModeloService.ts

@@ -42,3 +42,11 @@ export async function apiFindMonitorAtivosModelo(body?: IFilterParams) {
         data: body,
     })
 }
+
+export async function apiFindByModeloAndTipo(body: { modelo?: string; tipoId?: number | null }) {
+    return ApiService.fetchDataWithAxios<any[]>({
+        url: MODELO_ENDPOINT.findByModeloAndTipo.endpoint,
+        method: MODELO_ENDPOINT.findByModeloAndTipo.method,
+        data: body,
+    })
+}

package/lib/base/services/modules/bayer/retencaoBayerService.ts

@@ -11,3 +11,10 @@ export async function apiFindAllRetencao(params?: string) {
         method: 'get',
     });
 }
+
+export async function apiFinalizarCancelamentoRetencao(id: number) {
+    return ApiService.fetchDataWithAxios<void>({
+        url: RETENCAO_BAYER_ENDPOINT.finalizarCancelamento(id),
+        method: 'put',
+    });
+}

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

@@ -3,4 +3,5 @@ export * from './intervaloPrecoXml/IntervaloPrecoXmlService'
 export * from './vinculoUnidadeMedida/VinculoUnidadeMedidaService'
 export * from './cnpjLiberadoNota/CnpjLiberadoNotaService'
 export * from './cnpjExcecaoNota/CnpjExcecaoNotaService'
-export * from './nfe/NfeService'
+export * from './nfe/NfeService'
+export * from './recepcaoFisica/RecepcaoFisicaService'

package/lib/base/services/modules/centralNfe/recepcaoFisica/RecepcaoFisicaService.ts

@@ -0,0 +1,32 @@
+import ApiService from "@/services/ApiService";
+import endpointConfig from "@base/configs/endpoints.config/endpoints.navigation";
+
+const RECEPCAO_FISICA_ENDPOINT = endpointConfig.centralNfe.recepcaoFisica;
+
+export async function apiCreateRecepcaoFisica(
+    body: { chaveAcesso: string; ordensCompraPrevisao: string[] },
+    userId: number,
+) {
+    return ApiService.fetchDataWithAxios<void>({
+        url: RECEPCAO_FISICA_ENDPOINT.create.endpoint,
+        method: RECEPCAO_FISICA_ENDPOINT.create.httpMethod,
+        data: body,
+        headers: { 'X-User-Id': userId },
+    })
+}
+
+export async function apiFindMonitorRecepcaoFisica(body: any) {
+    return ApiService.fetchDataWithAxios<any>({
+        url: RECEPCAO_FISICA_ENDPOINT.findMonitor.endpoint,
+        method: RECEPCAO_FISICA_ENDPOINT.findMonitor.httpMethod,
+        data: body,
+    })
+}
+
+export async function apiFindOrdensCompraRecepcaoFisica(cnpj: string) {
+    return ApiService.fetchDataWithAxios<any[]>({
+        url: RECEPCAO_FISICA_ENDPOINT.findOrdensCompra.endpoint,
+        method: RECEPCAO_FISICA_ENDPOINT.findOrdensCompra.httpMethod,
+        params: { cnpj },
+    })
+}

package/lib/base/services/modules/juridico/JuridicoService.ts

@@ -0,0 +1,52 @@
+import { IFilterParams, TQueryResponse } from '@base/@types/api'
+import ApiServiceJ from '@/services/ApiServiceJ'
+import { TTermo } from '@base/@types/api/request/juridico/termos/termo'
+
+export async function apiGetTermos(body?: IFilterParams) {
+    const response = await ApiServiceJ.fetchDataWithAxios<TTermo[]>({
+        url: '/juridico/api/juridico/termos/listar',
+        method: 'get',
+        serviceKeyEnvName: 'JURIDICO_API_KEY',
+    })
+    
+    // Aplicar filtros no frontend (já que o backend não suporta filtros)
+    let filteredResponse = response || []
+    
+    if (body) {
+        if (body.id) {
+            filteredResponse = filteredResponse.filter((termo: TTermo) =>
+                termo.id?.toString().includes(body.id as string)
+            )
+        }
+        if (body.fornecedor) {
+            const searchTerm = (body.fornecedor as string).toLowerCase()
+            filteredResponse = filteredResponse.filter((termo: TTermo) =>
+                termo.fornecedor?.nome?.toLowerCase().includes(searchTerm)
+            )
+        }
+        if (body.usuarioCadastro) {
+            const searchTerm = (body.usuarioCadastro as string).toLowerCase()
+            filteredResponse = filteredResponse.filter((termo: TTermo) =>
+                termo.usuarioCadastro?.toLowerCase().includes(searchTerm)
+            )
+        }
+        if (body.dataCadastro) {
+            const searchDate = body.dataCadastro as string
+            filteredResponse = filteredResponse.filter((termo: TTermo) => {
+                if (!termo.dataCadastro) return false
+                const termoDate = new Date(termo.dataCadastro).toISOString().split('T')[0]
+                return termoDate === searchDate
+            })
+        }
+    }
+    
+    const paginatedResponse = {
+        content: filteredResponse,
+        size: filteredResponse.length,
+        totalElements: filteredResponse.length,
+        totalPages: 1,
+        number: 0
+    }
+    
+    return paginatedResponse as TQueryResponse<TTermo>
+}

package/lib/base/services/modules/juridico/docusignService.ts

@@ -0,0 +1,154 @@
+import ApiServiceJ from '@/services/ApiServiceJ'
+
+export type TSignerUpdate = {
+    email: string
+    recipientId: string
+    name?: string
+}
+
+export type TSendEnvelopeRequest = {
+    subject: string
+    signers: { email: string; name: string }[]
+    documentBase64: string
+    documentId?: string
+}
+
+export type TEnvelopeOutput = {
+    envelopeId: string
+    status?: string
+    updatedDateTime?: string
+}
+
+export const docusignService = {
+    sendEnvelope: async (payload: TSendEnvelopeRequest): Promise<TEnvelopeOutput> => {
+        const request = {
+            brandId: '',
+            emailSubject: payload.subject,
+            status: 'sent',
+            createdDateTime: new Date().toISOString(),
+            completedDateTime: null,
+            deletedDateTime: null,
+            deliveredDateTime: null,
+            sentDateTime: null,
+            documents: [
+                {
+                    documentId: payload.documentId,
+                    name: 'Termo',
+                    fileExtension: 'pdf',
+                    documentBase64: payload.documentBase64,
+                },
+            ],
+            recipients: {
+                signers: payload.signers.map((s, idx) => ({
+                    emailBody: '',
+                    emailSubject: payload.subject,
+                    email: s.email,
+                    name: s.name,
+                    recipientId: String(idx + 1),
+                    routingOrder: String(idx + 1),
+                    signHereTabs: [],
+                })),
+            },
+        }
+
+        console.log('[DocuSign] POST /send-envelopeId — request:', request)
+
+        try {
+            const response = await ApiServiceJ.fetchDataWithAxios<{
+                status?: string
+                envelopeId: string
+            }, typeof request>({
+                url: '/docusign/api/docusign/send-envelopeId',
+                method: 'POST',
+                data: request,
+                headers: { 'Content-Type': 'application/json' },
+                serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+            })
+
+            console.log('[DocuSign] POST /send-envelopeId — response:', response)
+
+            return {
+                envelopeId: response.envelopeId,
+                status: response.status,
+            }
+        } catch (err) {
+            console.error('[DocuSign] POST /send-envelopeId — error:', err)
+            throw err
+        }
+    },
+
+    listEnvelopes: async (date: string, status: string): Promise<TEnvelopeOutput[]> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{
+            resultSetSize: string
+            totalSetSize: string
+            envelopes: Array<{
+                createdDateTime: string
+                statusChangedDateTime?: string
+                envelopeId: string
+                status: string
+            }>
+        }, Record<string, unknown>>({
+            url: `/docusign/api/docusign/list-status-envelopeId/${date}`,
+            method: 'GET',
+            params: { status },
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+
+        return (response.envelopes || []).map((e) => ({
+            envelopeId: e.envelopeId,
+            status: e.status,
+            updatedDateTime: e.statusChangedDateTime ?? e.createdDateTime,
+        }))
+    },
+
+    listRecipients: async (envelopeId: string) => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{
+            signers: Array<{ name: string; email: string; status?: string }>
+        }, Record<string, unknown>>({
+            url: `/docusign/api/docusign/list-status-recipients/${envelopeId}`,
+            method: 'GET',
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+
+        return response.signers || []
+    },
+
+    voidEnvelope: async (envelopeId: string, reason: string) => {
+        await ApiServiceJ.fetchDataWithAxios<void, Record<string, unknown>>({
+            url: `/docusign/api/docusign/voided-envelope/${envelopeId}`,
+            method: 'PUT',
+            params: { voidedReason: reason },
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+    },
+
+    updateRecipients: async (envelopeId: string, signers: TSignerUpdate[]) => {
+        const request = {
+            signers: signers.map((s) => ({
+                email: s.email,
+                recipientId: s.recipientId,
+            })),
+        }
+
+        await ApiServiceJ.fetchDataWithAxios<void, typeof request>({
+            url: `/docusign/api/docusign/update-email/${envelopeId}`,
+            method: 'PUT',
+            data: request,
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+    },
+
+    downloadSignedPdf: async (envelopeId: string, documentId: string): Promise<ArrayBuffer> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{ pdfBase64: string }>({
+            url: `/docusign/api/docusign/download-pdf/${envelopeId}/${documentId}`,
+            method: 'GET',
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+        const b64 = response?.pdfBase64 || ''
+        const binary = atob(b64)
+        const len = binary.length
+        const bytes = new Uint8Array(len)
+        for (let i = 0; i < len; i++) bytes[i] = binary.charCodeAt(i)
+        return bytes.buffer
+    },
+}

package/lib/base/services/modules/juridico/municipiosService.ts

@@ -0,0 +1,46 @@
+import ApiService from '@/services/ApiService'
+import { TQueryResponse } from '@base/@types/api'
+
+export const municipiosService = {
+    getAll: async (): Promise<any[]> => {
+        try {
+            console.log('Fazendo requisição para /dados-mestres/api/municipio/find')
+            
+            // Usando o ApiService padrão do projeto que já inclui o X-Service-Token
+            const response = await ApiService.fetchDataWithAxios<TQueryResponse<any>>({
+                url: '/dados-mestres/api/municipio/find',
+                method: 'POST',
+                data: {
+                    id: null,
+                    municipio: null,
+                    codigo: null,
+                    pageable: {
+                        pageNumber: 1,
+                        pageSize: 10000,
+                        sort: [{
+                            sortField: 'municipio',
+                            sortOrder: 'asc'
+                        }]
+                    }
+                }
+            })
+            
+            console.log('Resposta da API:', response)
+            
+            // A resposta é paginada, então pegamos o conteúdo
+            const municipios = response.content || []
+            
+            // Mapear para o formato esperado pelo frontend
+            return municipios.map((municipio: any) => ({
+                id: municipio.id,
+                nome: municipio.municipio,
+                uf: municipio.uf,
+                codigo: municipio.codigo,
+                ativo: true // Assumindo que todos os retornados estão ativos
+            }))
+        } catch (error) {
+            console.error('Error fetching municipalities:', error)
+            return []
+        }
+    }
+}

package/lib/base/services/modules/juridico/termosService.ts

@@ -0,0 +1,118 @@
+import ApiServiceJ from '@/services/ApiServiceJ'
+import { TTermo } from '@base/@types/api/request/juridico/termos/termo'
+import { TTermoFormSchema } from '@base/@types/api/request/juridico/termos/types'
+
+
+const BASE_URL = '/juridico/api/juridico/termos'
+
+export const termosService = {
+    create: async (termo: TTermoFormSchema): Promise<{ id: number }> => {
+        try {
+            console.log('Payload being sent:', termo)
+            
+            const response = await ApiServiceJ.fetchDataWithAxios<{ id: number }, TTermoFormSchema>({
+                url: BASE_URL,
+                method: 'POST',
+                data: termo,
+                serviceKeyEnvName: 'JURIDICO_API_KEY',
+            })
+            return response
+        } catch (error: any) {
+            console.error('Detailed error:', error.response?.data)
+            throw error
+        }
+    },
+    
+    downloadPdf: async (id: number): Promise<ArrayBuffer> => {
+        console.log('Chamando download com ID:', id)
+        try {
+            const response = await ApiServiceJ.fetchDataWithAxios<ArrayBuffer>({
+                url: `${BASE_URL}/download/${id}`,
+                method: 'GET',
+                responseType: 'arraybuffer',
+                headers: {
+                    'Accept': 'application/pdf, application/json;q=0.9, */*;q=0.8'
+                },
+                serviceKeyEnvName: 'JURIDICO_API_KEY',
+            })
+            console.log('Resposta recebida:', response)
+            return response
+        } catch (error: any) {
+            console.error('Erro completo:', error)
+            throw error
+        }
+    },
+    downloadPdfDocuSign: async (id: number): Promise<ArrayBuffer> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<ArrayBuffer>({
+            url: `${BASE_URL}/${id}/docusign/download`,
+            method: 'GET',
+            responseType: 'arraybuffer',
+            headers: {
+                'Accept': 'application/pdf, application/json;q=0.9, */*;q=0.8'
+            },
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+        return response
+    },
+    aprovarRejeitar: async (data: {
+        termoId: number;
+        status: 'APROVADO' | 'REJEITADO';
+        justificativaRejeicao?: string;
+    }) => {
+        return ApiServiceJ.fetchDataWithAxios({
+            url: `${BASE_URL}/aprovar-rejeitar`,
+            method: 'PUT',
+            data,
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+
+    getById: async (id: number): Promise<TTermo> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<TTermo>({
+            url: `${BASE_URL}/${id}`,
+            method: 'GET',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+        return response
+    },
+
+    getContratoDocusign: async (id: number): Promise<{ envelopeId: string; contratoId: number }> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{ envelopeId: string; contratoId: number }>({
+            url: `${BASE_URL}/${id}/contrato-docusign`,
+            method: 'GET',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+        return response
+    },
+
+    attachEnvelope: async (id: number, envelopeId: string): Promise<void> => {
+        await ApiServiceJ.fetchDataWithAxios<void, { envelopeId: string }>({
+            url: `${BASE_URL}/${id}/docusign/envelope`,
+            method: 'PUT',
+            data: { envelopeId },
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+    enviarEnvelope: async (id: number): Promise<void> => {
+        await ApiServiceJ.fetchDataWithAxios<void>({
+            url: `${BASE_URL}/${id}/docusign/enviar`,
+            method: 'POST',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+    syncStatusDocuSign: async (): Promise<void> => {
+        await ApiServiceJ.fetchDataWithAxios<void>({
+            url: `${BASE_URL}/docusign/sync-status`,
+            method: 'PUT',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+    getRecipientsStatus: async (id: number): Promise<Array<{ name: string; email: string; status?: string }>> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<Array<{ name: string; email: string; status?: string }>>({
+            url: `${BASE_URL}/${id}/docusign/recipients`,
+            method: 'GET',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+        return response || []
+    },
+}