+ );
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoForm.tsx b/src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoForm.tsx
new file mode 100644
index 0000000..37ac514
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoForm.tsx
@@ -0,0 +1,1004 @@
+'use client';
+
+import React from 'react';
+import z from 'zod';
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { useState } from 'react';
+import { Button } from '@/components/ui/button';
+import {
+ Dialog,
+ DialogClose,
+ DialogContent,
+ DialogDescription,
+ DialogFooter,
+ DialogHeader,
+ DialogTitle,
+} from '@/components/ui/dialog';
+import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
+import { CirclePlus, DollarSign, Settings, SquarePen, Trash } from 'lucide-react';
+import {
+ Form,
+ FormControl,
+ FormField,
+ FormItem,
+ FormLabel,
+ FormMessage,
+} from '@/components/ui/form';
+import { Input } from '@/components/ui/input';
+import { Checkbox } from '@/components/ui/checkbox';
+import {
+ Select,
+ SelectContent,
+ SelectItem,
+ SelectTrigger,
+ SelectValue,
+} from '@/components/ui/select';
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from '@/components/ui/table';
+
+import { TServicoTipoSchema, TServicoTipoFormValues } from '../../_schemas/TServicoTipoSchema';
+import { useEffect } from 'react';
+import GMarcacaoTipoSelect from '@/packages/administrativo/components/GMarcacaoTipo/GMarcacaoTipoSelect';
+import GEmolumentoSelect from '@/packages/administrativo/components/GEmolumento/GEmolumentoSelect';
+import { useGEmolumentoItemReadHook } from '@/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento_item/useGEmolumentoItemReadHook';
+import { GEmolumentoItemReadInterface } from '@/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemReadInterface';
+import CategoriaServicoSelect from '@/shared/components/categoriaServicoSelect/CategoriaServicoSelect';
+import CCaixaServicoSelect from '@/packages/administrativo/components/CCaixaServico/CCaixaServicoSelect';
+import { TServicoTipoSaveData } from '../../_data/TServicoTipo/TServicoTipoSaveData';
+import TTBReconhecimentoTipoSelect from '@/packages/administrativo/components/TTBReconhecimentoTipo/TTBReconhecimentoTipoSelect';
+import { ConfirmacaoCheckBox } from '@/shared/components/confirmacao/ConfirmacaoCheckBox';
+import ConfirmacaoSelect from '@/shared/components/confirmacao/ConfirmacaoSelect';
+import { TipoPessoaSelect } from '@/shared/components/tipoPessoa/tipoPessoaSelect';
+import { useTServicoEtiquetaReadHook } from '@/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaReadHook';
+import { useTServicoEtiquetaSaveHook } from '@/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaSaveHook';
+import { useTServicoEtiquetaRemoveHook } from '@/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaRemoveHook';
+
+// Propriedades esperadas pelo componente
+interface Props {
+ isOpen: boolean;
+ data: TServicoTipoFormValues | null;
+ onClose: (item: null, isFormStatus: boolean) => void;
+ onSave: (data: TServicoTipoFormValues) => void;
+}
+
+// Componente principal do formulário
+export default function TServicoTipoForm({ isOpen, data, onClose, onSave }: Props) {
+ // Inicializa o react-hook-form com validação via Zod
+ const form = useForm({
+ resolver: zodResolver(TServicoTipoSchema),
+ defaultValues: {
+ servico_tipo_id: 0,
+ emolumento_id: 0,
+ emolumento_obrigatorio: 0,
+ descricao: '',
+ maximo_pessoa: 0,
+ tipo_item: '',
+ frenteverso: 'N',
+ averbacao: 'N',
+ transferencia_veiculo: 'N',
+ usar_a4: 'N',
+ etiqueta_unica: 'N',
+ situacao: 'A',
+ selar: 'N',
+ valor_emolumento: 0,
+ valor_taxa_judiciaria: 0,
+ fundesp_valor: 0,
+ valor_total: 0,
+ tipo_pessoa: 'F', // ou "J"
+ } as unknown as TServicoTipoFormValues,
+ });
+
+ // Carrega o ID caso esteja informado no form
+ const servico_tipo_id = form.getValues('servico_tipo_id') || 0;
+
+ // Hook responsável por buscar emolumentos no backend
+ const { tServicoEtiqueta, fetchTServicoEtiqueta } = useTServicoEtiquetaReadHook();
+
+ // Hook responsável em salvar o a etiqueta selecionada
+ const { tServicoEtiquetaSave, fetchTServicoEtiquetaSave } = useTServicoEtiquetaSaveHook();
+
+ // Hook responsável em excluir a etiqueta selecionada
+ const { fetchTServicoEtiquetaRemove } = useTServicoEtiquetaRemoveHook();
+
+ // Estado para gerenciar os itens da tabela de etiquetas/carimbos
+ const [itensTabela, setItensTabela] = useState<
+ { servico_etiqueta_id: string | number; descricao: string }[]
+ >([]);
+
+ // Carrega os dados de emolumentos apenas uma vez ao montar o componente
+ React.useEffect(() => {
+ // Função para consumir o endpoint da api
+ const loadData = async () => {
+ // Verifica se o ID do serviço tipo foi informado
+ if (servico_tipo_id > 0) {
+ // Consumo o endpoint da api
+ await fetchTServicoEtiqueta({ servico_tipo_id });
+ }
+ };
+
+ // Chama a função para consumir o endpoint da api
+ loadData();
+ }, [servico_tipo_id]);
+
+ // Atualiza itensTabela sempre que tServicoEtiqueta for carregado
+ React.useEffect(() => {
+ // Verifica se a consulta retornou os dados como objeto
+ if (Array.isArray(tServicoEtiqueta) && tServicoEtiqueta.length > 0) {
+ // Lista os itens
+ const mapped = tServicoEtiqueta.map((item) => ({
+ servico_etiqueta_id: Number(item.servico_etiqueta_id ?? 0),
+ descricao: String(item.descricao ?? 'Sem descrição'),
+ }));
+
+ setItensTabela(mapped);
+ } else {
+ setItensTabela([]);
+ }
+ }, [tServicoEtiqueta]);
+
+ // Função para adicionar um novo item à tabela Etiquetas/Carimbos
+ const handleAddEtiquetaCarimbo = async () => {
+ // Captura o valor selecionado do formulário
+ const valorSelecionado = form.getValues('etiquetas_carimbos');
+
+ // Se não houver valor selecionado, não faz nada
+ if (!valorSelecionado) return;
+
+ // Verifica se o item já se encontra na tabela
+ const alreadyExists = itensTabela.some(
+ (p) => String(p.descricao).trim() === String(valorSelecionado.value).trim(),
+ );
+
+ // Caso o item já esteja na tabela, para o procedimento
+ if (alreadyExists) {
+ return;
+ }
+
+ // --- Envio opcional para API ---
+ try {
+ // Verifica se o ID do serviço tipo foi informado
+ if (servico_tipo_id > 0) {
+ // Monta o objeto do item selecionado
+ const data = {
+ etiqueta_modelo_id: valorSelecionado.key,
+ servico_tipo_id: servico_tipo_id,
+ };
+
+ // Consumo o endpoint da api
+ const response = await fetchTServicoEtiquetaSave(data);
+
+ // Verifica se tServicoEtiquetaSave é um objeto válido (não null e não array)
+ if (response && typeof response === 'object' && !Array.isArray(response)) {
+ // Monta o objeto com um único item para a tabela
+ const item = {
+ servico_etiqueta_id: Number(response.servico_etiqueta_id) ?? 0,
+ descricao: String(valorSelecionado.value) ?? 'Sem descrição',
+ };
+
+ // Adiciona o item na tabela
+ setItensTabela((prev) => {
+ const idAtual = String(response.servico_etiqueta_id ?? '');
+ const exists = prev.some((p) => String(p.servico_etiqueta_id ?? '') === idAtual);
+ return exists ? prev : [...prev, item];
+ });
+ }
+ }
+
+ // Se ocorrer erros, informo
+ } catch (error) {
+ console.log('Erro ao enviar o serviço para a API: ' + error);
+ }
+ };
+
+ // Função para remover um item da tabela
+ const handleRemoveItem = async (servico_etiqueta_id: number) => {
+ try {
+ // Verifica se o ID da etiqueta tipo foi informado
+ if (servico_etiqueta_id > 0) {
+ // Monta o objeto do item selecionado
+ const data = {
+ servico_etiqueta_id: servico_etiqueta_id,
+ };
+
+ // Consumo o endpoint da api
+ await fetchTServicoEtiquetaRemove(data);
+ }
+
+ // Atualiza a tabela no form
+ setItensTabela((prev) =>
+ prev.filter((p) => Number(p.servico_etiqueta_id) !== servico_etiqueta_id),
+ );
+
+ // Se ocorrer erros, informo
+ } catch (error) {
+ console.log('Erro ao enviar o serviço para a API: ' + error);
+ }
+ };
+
+ // Parâmetros para o hook de leitura de emolumento_item
+ // Inicializa com valores padrão (0) para evitar uso de propriedades não declaradas.
+ const gEmolumentoItemReadParams: GEmolumentoItemReadInterface = { emolumento_id: 0, valor: 0 };
+
+ // Estados locais
+ const [open, setOpen] = React.useState(false);
+ const [isLoading, setIsLoading] = React.useState(false);
+
+ // Hook que realiza a leitura do emolumento_item
+ const { gGEmolumentoItem, fetchGEmolumentoItem } = useGEmolumentoItemReadHook();
+
+ // Busca os dados ao montar o componente (somente se houver ID válido)
+ React.useEffect(() => {
+ const loadData = async () => {
+ // Validação: só executa se houver emolumento_id informado e válido
+ if (
+ !gEmolumentoItemReadParams?.emolumento_id || // se não existir o campo
+ isNaN(Number(gEmolumentoItemReadParams.emolumento_id)) || // se não for número
+ Number(gEmolumentoItemReadParams.emolumento_id) <= 0 // se for zero ou negativo
+ ) {
+ return; // encerra sem executar a busca
+ }
+
+ // Executa a busca apenas se ainda não houver dados carregados
+ if (!gGEmolumentoItem.length) {
+ setIsLoading(true);
+ await fetchGEmolumentoItem(gEmolumentoItemReadParams);
+ setIsLoading(false);
+ }
+ };
+
+ loadData();
+ }, [gEmolumentoItemReadParams.emolumento_id]);
+
+ // Captura o ID do serviço para uso local
+ const servicoTipoId = Number(form.watch('servico_tipo_id') || data?.servico_tipo_id || 0);
+
+ // Função chamada ao clicar em "Salvar"
+ const handleSave = async (formData: TServicoTipoFormValues) => {
+ try {
+ // Se o form não trouxe o ID, tenta puxar de `data`
+ const servico_tipo_id =
+ formData.servico_tipo_id || data?.servico_tipo_id || form.getValues('servico_tipo_id') || 0;
+
+ // Atualiza o valor dentro do formData
+ formData.servico_tipo_id = Number(servico_tipo_id);
+
+ // Intercepta e trata o valor de emolumento_id
+ const emolumentoId = Number(formData.emolumento_id ?? 0);
+ formData.emolumento_id = emolumentoId === 0 ? null : emolumentoId;
+
+ // Intercepta e trata o valor de emolumento_obrigatorio
+ const emolumentoObrigatorio = Number(formData.emolumento_obrigatorio ?? 0);
+ formData.emolumento_obrigatorio = emolumentoObrigatorio === 0 ? null : emolumentoObrigatorio;
+
+ // Detecta automaticamente se é edição
+ const isEditing = !!formData.servico_tipo_id && Number(formData.servico_tipo_id) > 0;
+
+ // Envia os dados para o módulo com o método correto
+ const response = await TServicoTipoSaveData({
+ ...formData,
+ metodo: isEditing ? 'PUT' : 'POST', // 💡 Definição explícita do método
+ });
+
+ // Atualiza o formulário apenas se o retorno for válido
+ if (response?.data?.servico_tipo_id) {
+ const novoId = response.data.servico_tipo_id;
+ form.setValue('servico_tipo_id', novoId); // mantém o ID atualizado
+
+ // Merge dos dados para preservar valores locais
+ form.reset({ ...form.getValues(), ...response.data });
+
+ console.log(`Serviço ${isEditing ? 'atualizado' : 'criado'} com sucesso (ID: ${novoId})`);
+ } else {
+ console.log('Erro ao salvar o tipo de serviço.');
+ }
+ } catch (error) {
+ console.log('Erro ao salvar:', error);
+ }
+ };
+
+ // Carrega os dados apenas quando o modal
+ // abrir e houver um registro para editar
+ useEffect(() => {
+ // Remove as etiquetas selecionadas
+ setItensTabela([]);
+
+ if (isOpen && data && Number(data.servico_tipo_id ?? 0) > 0) {
+ /** Carrega os dados no formulário */
+ form.reset(data); // edição
+ } else if (isOpen && !data) {
+ /** Reseta os campos do formulário */
+ form.reset({
+ servico_tipo_id: 0,
+ emolumento_id: 0,
+ emolumento_obrigatorio: 0,
+ descricao: '',
+ maximo_pessoa: 0,
+ tipo_item: '',
+ frenteverso: 'N',
+ averbacao: 'N',
+ transferencia_veiculo: 'N',
+ usar_a4: 'N',
+ etiqueta_unica: 'N',
+ situacao: 'A',
+ selar: 'N',
+ valor_emolumento: 0,
+ valor_taxa_judiciaria: 0,
+ fundesp_valor: 0,
+ valor_total: 0,
+ tipo_pessoa: 'F',
+ });
+ }
+ }, [isOpen, data]);
+
+ function onError(errors: any) {
+ console.log('Erros de validação:', errors);
+ }
+
+ return (
+
+ );
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoTable.tsx b/src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoTable.tsx
new file mode 100644
index 0000000..d0c6e0a
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoTable.tsx
@@ -0,0 +1,101 @@
+'use client';
+
+import { Button } from '@/components/ui/button';
+import {
+ DropdownMenu,
+ DropdownMenuContent,
+ DropdownMenuGroup,
+ DropdownMenuItem,
+ DropdownMenuSeparator,
+ DropdownMenuTrigger,
+} from '@/components/ui/dropdown-menu';
+import {
+ Table,
+ TableBody,
+ TableCell,
+ TableHead,
+ TableHeader,
+ TableRow,
+} from '@/components/ui/table';
+
+import { EllipsisIcon, PencilIcon, Trash2Icon } from 'lucide-react';
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Import alterado
+
+// Tipagem das props do componente da tabela
+interface TServicoTipoTableProps {
+ // Nome da interface alterado
+ data: TServicoTipoInterface[]; // lista de tipos de serviço
+ onEdit: (item: TServicoTipoInterface, isEditingFormStatus: boolean) => void; // callback para edição
+ onDelete: (item: TServicoTipoInterface, isEditingFormStatus: boolean) => void; // callback para exclusão
+}
+
+/**
+ * Componente principal da tabela de Tipos de Serviço
+ */
+export default function TServicoTipoTable({ data, onEdit, onDelete }: TServicoTipoTableProps) {
+ return (
+
+ {/* Cabeçalho da tabela */}
+
+
+ #
+ {/* As colunas IBGE e UF foram removidas */}
+ Descrição
+
+
+
+
+ {/* Corpo da tabela */}
+
+ {data.map((item) => (
+ // Assumindo que o ID do Tipo de Serviço é 'servico_tipo_id'
+
+ {/* ID do Tipo de Serviço */}
+ {item.servico_tipo_id}
+
+ {/* Nome/descrição do Tipo de Serviço (descricao) */}
+ {item.descricao}
+ {/* As células de IBGE e UF foram removidas */}
+
+ {/* Ações (menu dropdown) */}
+
+
+ {/* Botão de disparo do menu */}
+
+
+
+
+ {/* Conteúdo do menu */}
+
+
+ {/* Opção editar */}
+ onEdit(item, true)}
+ >
+
+ Editar
+
+
+
+
+ {/* Opção remover */}
+ onDelete(item, true)}
+ >
+
+ Remover
+
+
+
+
+
+
+ ))}
+
+
+ );
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/CCaixaServico/CCaixaServicoIndexData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/CCaixaServico/CCaixaServicoIndexData.ts
new file mode 100644
index 0000000..09372dc
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/CCaixaServico/CCaixaServicoIndexData.ts
@@ -0,0 +1,27 @@
+// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a classe de serviço que gerencia requisições HTTP para a API
+import API from '@/shared/services/api/Api';
+
+// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
+import { CCaixaServicoReadInterface } from '../../_interfaces/CCaixaServicoReadInterface';
+
+// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
+async function executeCCaixaServicoIndexData(data: CCaixaServicoReadInterface) {
+ // Cria uma nova instância da classe API para enviar a requisição
+ const api = new API();
+
+ // Concatena o endpoint com a query string (caso existam parâmetros)
+ const endpoint = `administrativo/c_caixa_servico/sistema/${data.sistema_id}`;
+
+ // Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
+ return await api.send({
+ method: Methods.GET,
+ endpoint: endpoint,
+ });
+}
+
+// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const CCaixaServicoIndexData = withClientErrorHandler(executeCCaixaServicoIndexData);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/GEmolumento/GEmolumentoIndexData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/GEmolumento/GEmolumentoIndexData.ts
new file mode 100644
index 0000000..422fb54
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/GEmolumento/GEmolumentoIndexData.ts
@@ -0,0 +1,27 @@
+// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a classe de serviço que gerencia requisições HTTP para a API
+import API from '@/shared/services/api/Api';
+
+// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
+import { GEmolumentoReadInterface } from '../../_interfaces/GEmolumentoReadInterface';
+
+// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
+async function executeGEmolumentoIndexData(data: GEmolumentoReadInterface) {
+ // Cria uma nova instância da classe API para enviar a requisição
+ const api = new API();
+
+ // Concatena o endpoint com a query string (caso existam parâmetros)
+ const endpoint = `administrativo/g_emolumento/${data.sistema_id}`;
+
+ // Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
+ return await api.send({
+ method: Methods.GET,
+ endpoint: endpoint,
+ });
+}
+
+// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const GEmolumentoIndexData = withClientErrorHandler(executeGEmolumentoIndexData);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/GEmolumentoItem/GEmolumentoItemValorData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/GEmolumentoItem/GEmolumentoItemValorData.ts
new file mode 100644
index 0000000..96da087
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/GEmolumentoItem/GEmolumentoItemValorData.ts
@@ -0,0 +1,27 @@
+// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a classe de serviço que gerencia requisições HTTP para a API
+import API from '@/shared/services/api/Api';
+
+// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
+import { GEmolumentoItemReadInterface } from '../../_interfaces/GEmolumentoItemReadInterface';
+
+// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
+async function executeGEmolumentoItemValorData(data: GEmolumentoItemReadInterface) {
+ // Cria uma nova instância da classe API para enviar a requisição
+ const api = new API();
+
+ // Concatena o endpoint com a query string (caso existam parâmetros)
+ const endpoint = `administrativo/g_emolumento_item/faixa/${data.emolumento_id}/${data.valor}`;
+
+ // Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
+ return await api.send({
+ method: Methods.GET,
+ endpoint: endpoint,
+ });
+}
+
+// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const GEmolumentoItemValorData = withClientErrorHandler(executeGEmolumentoItemValorData);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/GMarcacaoTipo/GMarcacaoTipoIndexData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/GMarcacaoTipo/GMarcacaoTipoIndexData.ts
new file mode 100644
index 0000000..4914f59
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/GMarcacaoTipo/GMarcacaoTipoIndexData.ts
@@ -0,0 +1,33 @@
+// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a classe de serviço que gerencia requisições HTTP para a API
+import API from '@/shared/services/api/Api';
+
+// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
+import { GMarcacaoTipoReadInterface } from '../../_interfaces/GMarcacaoTipoReadInterface';
+
+// Importa a função genérica que monta a query string dinamicamente
+import { buildQueryString } from '@/shared/actions/api/buildQueryString';
+
+// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
+async function executeGMarcacaoTipoIndexData(data: GMarcacaoTipoReadInterface) {
+ // Cria uma nova instância da classe API para enviar a requisição
+ const api = new API();
+
+ // Monta a query string reutilizando a função genérica
+ const queryString = buildQueryString(data);
+
+ // Concatena o endpoint com a query string (caso existam parâmetros)
+ const endpoint = `administrativo/g_marcacao_tipo/grupo${queryString}`;
+
+ // Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
+ return await api.send({
+ method: Methods.GET,
+ endpoint: endpoint,
+ });
+}
+
+// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const GMarcacaoTipoIndexData = withClientErrorHandler(executeGMarcacaoTipoIndexData);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaReadData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaReadData.ts
new file mode 100644
index 0000000..7988274
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaReadData.ts
@@ -0,0 +1,26 @@
+// Importa o serviço de API que será utilizado para realizar requisições HTTP
+import API from '@/shared/services/api/Api'; //
+
+// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
+
+// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
+
+// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
+
+// Função assíncrona que implementa a lógica de localizar um tipo de serviço
+async function executeTServicoEtiquetaService(data: TServicoEtiquetaInterface) {
+ // Instancia o cliente da API para enviar a requisição
+ const api = new API(); //
+
+ // Executa a requisição para a API com o método apropriado e envia o ID no endpoint
+ return await api.send({
+ method: Methods.GET, // Verbo GET para consulta
+ endpoint: `administrativo/t_servico_etiqueta/servico_tipo/${data.servico_tipo_id}`, // Endpoint e ID alterados
+ });
+}
+
+// Exporta a função de Readr tipo de serviço já encapsulada com tratamento de erros
+export const TServicoEtiquetaReadData = withClientErrorHandler(executeTServicoEtiquetaService); // Nome da exportação alterado
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaRemoveData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaRemoveData.ts
new file mode 100644
index 0000000..bbbc1f7
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaRemoveData.ts
@@ -0,0 +1,28 @@
+// Importa o serviço de API que será utilizado para realizar requisições HTTP
+import API from '@/shared/services/api/Api'; //
+
+// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
+
+// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface'; // Alterado de GCidadeInterface
+
+// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
+
+// Função assíncrona que implementa a lógica de remover um tipo de serviço
+async function executeTServicoEtiquetaRemoveData(data: TServicoEtiquetaInterface) {
+ // Nome da função alterado
+
+ // Instancia o cliente da API para enviar a requisição
+ const api = new API(); //
+
+ // Executa a requisição para a API com o método apropriado e envia o ID no endpoint
+ return await api.send({
+ method: Methods.DELETE, // Verbo DELETE para exclusão
+ endpoint: `administrativo/t_servico_etiqueta/${data.servico_etiqueta_id}`, // Endpoint e ID alterados
+ });
+}
+
+// Exporta a função de remover tipo de serviço já encapsulada com tratamento de erros
+export const TServicoEtiquetaRemoveData = withClientErrorHandler(executeTServicoEtiquetaRemoveData); // Nome da exportação alterado
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaSaveData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaSaveData.ts
new file mode 100644
index 0000000..0c32e70
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaSaveData.ts
@@ -0,0 +1,35 @@
+// Importa o serviço de API que será utilizado para realizar requisições HTTP
+import API from '@/shared/services/api/Api'; //
+
+// Importa o esquema de validação de dados para tipos de serviço
+import { TServicoEtiquetaFormValues } from '../../_schemas/TServicoEtiquetaSchema';
+
+// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
+
+// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface'; // Interface alterada
+
+// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
+
+// Função assíncrona que implementa a lógica de salvar (criar/atualizar) um tipo de serviço
+async function executeTServicoEtiquetaSaveData(data: TServicoEtiquetaFormValues) {
+ try {
+ // Instancia o cliente da API para enviar a requisição
+ const api = new API(); //
+
+ // Executa a requisição para a API com o método apropriado e envia os dados no corpo
+ return await api.send({
+ method: Methods.POST, // PUT se atualizar, POST se criar
+ endpoint: `administrativo/t_servico_etiqueta`, // Endpoint e ID alterados
+ body: data, // payload enviado para a API
+ });
+ } catch (error) {
+ console.error('Erro no TServicoEtiquetaSaveData:', error);
+ throw error; // propaga erro para o form
+ }
+}
+
+// Exporta a função de salvar tipo de serviço já encapsulada com tratamento de erros
+export const TServicoEtiquetaSaveData = withClientErrorHandler(executeTServicoEtiquetaSaveData); // Nome da exportação alterado
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoEditData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoEditData.ts
new file mode 100644
index 0000000..ab2d56d
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoEditData.ts
@@ -0,0 +1,26 @@
+// Importa o serviço de API que será utilizado para realizar requisições HTTP
+import API from '@/shared/services/api/Api'; //
+
+// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
+
+// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Alterado de GCidadeInterface
+
+// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
+
+// Função assíncrona que implementa a lógica de localizar um tipo de serviço
+async function executeTServicoTipoEditService(data: TServicoTipoInterface) {
+ // Instancia o cliente da API para enviar a requisição
+ const api = new API(); //
+
+ // Executa a requisição para a API com o método apropriado e envia o ID no endpoint
+ return await api.send({
+ method: Methods.GET, // Verbo GET para consulta
+ endpoint: `administrativo/t_servico_tipo/${data.servico_tipo_id}`, // Endpoint e ID alterados
+ });
+}
+
+// Exporta a função de Readr tipo de serviço já encapsulada com tratamento de erros
+export const TServicoTipoEditData = withClientErrorHandler(executeTServicoTipoEditService); // Nome da exportação alterado
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoIndexData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoIndexData.ts
new file mode 100644
index 0000000..7003e6e
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoIndexData.ts
@@ -0,0 +1,23 @@
+// Importa o serviço de API que será utilizado para realizar requisições HTTP
+import API from '@/shared/services/api/Api'; //
+
+// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
+
+// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
+
+// Função assíncrona que implementa a lógica de buscar todos os tipos de serviço (GET)
+async function executeTServicoTipoIndexData() {
+ // Instancia o cliente da API para enviar a requisição
+ const api = new API(); //
+
+ // Executa a requisição para a API com o método apropriado e o endpoint da tabela t_servico_tipo
+ return await api.send({
+ method: Methods.GET, // GET listar todos os itens
+ endpoint: `administrativo/t_servico_tipo/`, // Endpoint atualizado
+ });
+}
+
+// Exporta a função de listar tipos de serviço já encapsulada com tratamento de erros
+export const TServicoTipoIndexData = withClientErrorHandler(executeTServicoTipoIndexData);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoRemoveData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoRemoveData.ts
new file mode 100644
index 0000000..aa5c6c3
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoRemoveData.ts
@@ -0,0 +1,28 @@
+// Importa o serviço de API que será utilizado para realizar requisições HTTP
+import API from '@/shared/services/api/Api'; //
+
+// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
+
+// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Alterado de GCidadeInterface
+
+// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
+
+// Função assíncrona que implementa a lógica de remover um tipo de serviço
+async function executeTServicoTipoRemoveData(data: TServicoTipoInterface) {
+ // Nome da função alterado
+
+ // Instancia o cliente da API para enviar a requisição
+ const api = new API(); //
+
+ // Executa a requisição para a API com o método apropriado e envia o ID no endpoint
+ return await api.send({
+ method: Methods.DELETE, // Verbo DELETE para exclusão
+ endpoint: `administrativo/t_servico_tipo/${data.servico_tipo_id}`, // Endpoint e ID alterados
+ });
+}
+
+// Exporta a função de remover tipo de serviço já encapsulada com tratamento de erros
+export const TServicoTipoRemoveData = withClientErrorHandler(executeTServicoTipoRemoveData); // Nome da exportação alterado
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoSaveData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoSaveData.ts
new file mode 100644
index 0000000..53f6d83
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoSaveData.ts
@@ -0,0 +1,45 @@
+// Importa o serviço de API que será utilizado para realizar requisições HTTP
+import API from '@/shared/services/api/Api'; //
+
+// Importa o esquema de validação de dados para tipos de serviço
+import { TServicoTipoFormValues } from '../../_schemas/TServicoTipoSchema';
+
+// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
+
+// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Interface alterada
+
+// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
+
+// Função assíncrona que implementa a lógica de salvar (criar/atualizar) um tipo de serviço
+async function executeTServicoTipoSaveData(
+ data: TServicoTipoFormValues & { metodo?: 'POST' | 'PUT' },
+) {
+ // Verifica se existe ID do tipo de serviço para decidir se é atualização (PUT) ou criação (POST)
+ const isEditing = !!data.servico_tipo_id && Number(data.servico_tipo_id) > 0;
+
+ // Define método: prioridade para valor passado manualmente (metodo)
+ const method = data.metodo ?? (isEditing ? 'PUT' : 'POST');
+
+ try {
+ console.log(data);
+
+ // Instancia o cliente da API para enviar a requisição
+ const api = new API(); //
+
+ // Executa a requisição para a API com o método apropriado e envia os dados no corpo
+ return await api.send({
+ method: isEditing ? Methods.PUT : Methods.POST, // PUT se atualizar, POST se criar
+ endpoint: `administrativo/t_servico_tipo/${data.servico_tipo_id || ''}`, // Endpoint e ID alterados
+ body: data, // payload enviado para a API
+ });
+ } catch (error) {
+ console.error('Erro no TServicoTipoSaveData:', error);
+ throw error; // propaga erro para o form
+ }
+}
+
+// Exporta a função de salvar tipo de serviço já encapsulada com tratamento de erros
+export const TServicoTipoSaveData = withClientErrorHandler(executeTServicoTipoSaveData); // Nome da exportação alterado
diff --git a/src/app/(protected)/(cadastros)/cadastros/_data/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndexData.ts b/src/app/(protected)/(cadastros)/cadastros/_data/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndexData.ts
new file mode 100644
index 0000000..659c993
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_data/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndexData.ts
@@ -0,0 +1,29 @@
+// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a classe de serviço que gerencia requisições HTTP para a API
+import API from '@/shared/services/api/Api';
+
+// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
+import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
+import { TTBReconhecimentoTipoReadInterface } from '../../_interfaces/TTBReconhecimentoTipoReadInterface';
+
+// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
+async function executeTTBReconhecimentoTipoIndexData(data: TTBReconhecimentoTipoReadInterface) {
+ // Cria uma nova instância da classe API para enviar a requisição
+ const api = new API();
+
+ // Concatena o endpoint com a query string (caso existam parâmetros)
+ const endpoint = `administrativo/t_tb_reconhecimentotipo/`;
+
+ // Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
+ return await api.send({
+ method: Methods.GET,
+ endpoint: endpoint,
+ });
+}
+
+// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const TTBReconhecimentoTipoIndexData = withClientErrorHandler(
+ executeTTBReconhecimentoTipoIndexData,
+);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/c_caixa_servico/useCCaixaServicoReadHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/c_caixa_servico/useCCaixaServicoReadHook.ts
new file mode 100644
index 0000000..5288571
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/c_caixa_servico/useCCaixaServicoReadHook.ts
@@ -0,0 +1,39 @@
+// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Importa hooks do React para gerenciamento de estado e memorização de valores
+import { useMemo, useState } from 'react';
+
+// Importa a interface que define a estrutura dos dados de "CCaixaServico"
+import { CCaixaServicoReadInterface } from '../../_interfaces/CCaixaServicoReadInterface';
+
+// Importa o serviço responsável por buscar os dados de "CCaixaServico" na API
+import { CCaixaServicoIndexService } from '../../_services/c_caixa_servico/CCaixaServicoIndexService';
+import { CCaixaServicoInterface } from '../../_interfaces/CCaixaServicoInterface';
+
+// Hook personalizado para leitura (consulta) dos tipos de marcação
+export const useCCaixaServicoReadHook = () => {
+ // Obtém a função que atualiza a resposta global do sistema
+ const { setResponse } = useResponse();
+
+ // Define o estado local que armazenará a lista de tipos de marcação
+ const [cCaixaServico, setCCaixaServico] = useState([]);
+
+ // Função responsável por buscar os dados da API e atualizar o estado
+ const fetchCCaixaServico = async (data: CCaixaServicoReadInterface) => {
+ // Executa o serviço que faz a requisição à API
+ const response = await CCaixaServicoIndexService(data);
+
+ // Atualiza o estado local com os dados retornados
+ setCCaixaServico(response.data);
+
+ // Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
+ setResponse(response);
+ };
+
+ // Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
+ return useMemo(
+ () => ({ cCaixaServico, fetchCCaixaServico }),
+ [cCaixaServico, fetchCCaixaServico],
+ );
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento/useGEmolumentoReadHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento/useGEmolumentoReadHook.ts
new file mode 100644
index 0000000..b18cc96
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento/useGEmolumentoReadHook.ts
@@ -0,0 +1,36 @@
+// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Importa hooks do React para gerenciamento de estado e memorização de valores
+import { useMemo, useState } from 'react';
+
+// Importa a interface que define a estrutura dos dados de "GEmolumento"
+import { GEmolumentoReadInterface } from '../../_interfaces/GEmolumentoReadInterface';
+
+// Importa o serviço responsável por buscar os dados de "GEmolumento" na API
+import { GEmolumentoIndexService } from '../../_services/g_emolumento/GEmolumentoIndexService';
+import { GEmolumentoInterface } from '../../_interfaces/GEmolumentoInterface';
+
+// Hook personalizado para leitura (consulta) dos emolumentos
+export const useGEmolumentoReadHook = () => {
+ // Obtém a função que atualiza a resposta global do sistema
+ const { setResponse } = useResponse();
+
+ // Define o estado local que armazenará a lista de emolumentos
+ const [gEmolumento, setGEmolumento] = useState([]);
+
+ // Função responsável por buscar os dados da API e atualizar o estado
+ const fetchGEmolumento = async (data: GEmolumentoReadInterface) => {
+ // Executa o serviço que faz a requisição à API
+ const response = await GEmolumentoIndexService(data);
+
+ // Atualiza o estado local com os dados retornados
+ setGEmolumento(response.data);
+
+ // Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
+ setResponse(response);
+ };
+
+ // Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
+ return useMemo(() => ({ gEmolumento, fetchGEmolumento }), [gEmolumento, fetchGEmolumento]);
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento_item/useGEmolumentoItemReadHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento_item/useGEmolumentoItemReadHook.ts
new file mode 100644
index 0000000..000908a
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento_item/useGEmolumentoItemReadHook.ts
@@ -0,0 +1,41 @@
+// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Importa hooks do React para gerenciamento de estado e memorização de valores
+import { useMemo, useState } from 'react';
+
+// Importa a interface que define a estrutura dos dados de "gEmolumentoItem"
+import { GEmolumentoItemReadInterface } from '../../_interfaces/GEmolumentoItemReadInterface';
+
+// Importa o serviço responsável por buscar os dados de "GEmolumentoItem" na API
+import { GEmolumentoItemValorService } from '../../_services/g_emolumento_item/GEmolumentoItemValorService';
+import { GEmolumentoItemInterface } from '../../_interfaces/GEmolumentoItemInterface';
+
+// Hook personalizado para leitura (consulta) dos emolumentos
+export const useGEmolumentoItemReadHook = () => {
+ const { setResponse } = useResponse();
+ const [gGEmolumentoItem, setGEmolumentoItem] = useState([]);
+
+ const fetchGEmolumentoItem = async (data: GEmolumentoItemReadInterface) => {
+ try {
+ const response = await GEmolumentoItemValorService(data);
+
+ // Atualiza estado e contexto
+ setGEmolumentoItem(response.data);
+ setResponse(response);
+
+ // Retorna a resposta completa (para uso externo)
+ return response;
+ } catch (error) {
+ console.error('Erro ao buscar item de emolumento:', error);
+ setResponse({
+ message: 'Erro ao buscar item de emolumento',
+ error: error instanceof Error ? error.message : String(error),
+ });
+ return null; // Retorna nulo para segurança
+ }
+ };
+
+ // Retorna função e dados memorizados
+ return useMemo(() => ({ gGEmolumentoItem, fetchGEmolumentoItem }), [gGEmolumentoItem]);
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/g_marcacao_tipo/useGMarcacaoTipoReadHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/g_marcacao_tipo/useGMarcacaoTipoReadHook.ts
new file mode 100644
index 0000000..b7f99e1
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/g_marcacao_tipo/useGMarcacaoTipoReadHook.ts
@@ -0,0 +1,39 @@
+// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Importa hooks do React para gerenciamento de estado e memorização de valores
+import { useMemo, useState } from 'react';
+
+// Importa a interface que define a estrutura dos dados de "GMarcacaoTipo"
+import { GMarcacaoTipoReadInterface } from '../../_interfaces/GMarcacaoTipoReadInterface';
+import { GMarcacaoTipoInterface } from '../../_interfaces/GMarcacaoTipoInterface';
+
+// Importa o serviço responsável por buscar os dados de "GMarcacaoTipo" na API
+import { GMarcacaoTipoIndexService } from '../../_services/g_marcacao_tipo/GMarcacaoTipoIndexService';
+
+// Hook personalizado para leitura (consulta) dos tipos de marcação
+export const useGMarcacaoTipoReadHook = () => {
+ // Obtém a função que atualiza a resposta global do sistema
+ const { setResponse } = useResponse();
+
+ // Define o estado local que armazenará a lista de tipos de marcação
+ const [gMarcacaoTipo, setGMarcacaoTipo] = useState([]);
+
+ // Função responsável por buscar os dados da API e atualizar o estado
+ const fetchGMarcacaoTipo = async (data: GMarcacaoTipoReadInterface) => {
+ // Executa o serviço que faz a requisição à API
+ const response = await GMarcacaoTipoIndexService(data);
+
+ // Atualiza o estado local com os dados retornados
+ setGMarcacaoTipo(response.data);
+
+ // Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
+ setResponse(response);
+ };
+
+ // Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
+ return useMemo(
+ () => ({ gMarcacaoTipo, fetchGMarcacaoTipo }),
+ [gMarcacaoTipo, fetchGMarcacaoTipo],
+ );
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaReadHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaReadHook.ts
new file mode 100644
index 0000000..3c5369d
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaReadHook.ts
@@ -0,0 +1,43 @@
+// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Importa hooks do React para gerenciamento de estado e memorização de valores
+import { useCallback, useState } from 'react';
+
+// Importa a interface que define a estrutura dos dados de "TServicoEtiqueta"
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
+
+// Importa o serviço responsável por buscar os dados de "TServicoEtiqueta" na API
+import { TServicoEtiquetaServicoIdService } from '../../_services/t_servico_etiqueta/TServicoEtiquetaServicoIdService';
+
+// Hook personalizado para leitura (consulta) dos tipos de marcação
+export const useTServicoEtiquetaReadHook = () => {
+ // Obtém a função que atualiza a resposta global do sistema
+ const { setResponse } = useResponse();
+
+ // Define o estado local que armazenará a lista de tipos de marcação
+ const [tServicoEtiqueta, setTServicoEtiqueta] = useState([]);
+
+ // Função responsável por buscar os dados da API e atualizar o estado
+ const fetchTServicoEtiqueta = useCallback(
+ async (data: TServicoEtiquetaInterface) => {
+ try {
+ // Executa o serviço que faz a requisição à API
+ const response = await TServicoEtiquetaServicoIdService(data);
+
+ // Atualiza o estado local com os dados retornados
+ setTServicoEtiqueta(response.data);
+
+ // Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
+ setResponse(response);
+ } catch (error) {
+ console.error('Erro ao buscar etiquetas:', error);
+ return { data: [] };
+ }
+ },
+ [setResponse],
+ );
+
+ // Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
+ return { tServicoEtiqueta, fetchTServicoEtiqueta };
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaRemoveHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaRemoveHook.ts
new file mode 100644
index 0000000..8d1d8b9
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaRemoveHook.ts
@@ -0,0 +1,25 @@
+import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
+
+// Interface tipada do tipo de serviço
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
+
+// Função que remove o tipo de serviço via API
+import { TServicoEtiquetaRemoveData } from '../../_data/TServicoEtiqueta/TServicoEtiquetaRemoveData';
+
+// Hook customizado para remoção de tipos de serviço
+export const useTServicoEtiquetaRemoveHook = () => {
+ // Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
+ const { setResponse } = useResponse();
+
+ // Função assíncrona que remove um tipo de serviço
+ const fetchTServicoEtiquetaRemove = async (data: TServicoEtiquetaInterface) => {
+ // Chama a função de remoção passando os dados do tipo de serviço
+ const response = await TServicoEtiquetaRemoveData(data);
+
+ // Atualiza o contexto global com a resposta da API
+ setResponse(response);
+ };
+
+ // Retorna a função de remoção para ser usada no componente
+ return { fetchTServicoEtiquetaRemove };
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaSaveHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaSaveHook.ts
new file mode 100644
index 0000000..9f54360
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaSaveHook.ts
@@ -0,0 +1,37 @@
+import { useState } from 'react';
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Interface tipada do serviço etiqueta
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
+
+// Serviço que salva os dados do serviço etiqueta
+import { TServicoEtiquetaSaveService } from '../../_services/t_servico_etiqueta/TServicoEtiquetaSaveService';
+
+export const useTServicoEtiquetaSaveHook = () => {
+ const { setResponse } = useResponse();
+
+ // Estado local para armazenar os dados do serviço etiqueta salvos
+ const [tServicoEtiquetaSave, setTServicoEtiquetaSave] =
+ useState(null);
+
+ /**
+ * Função que executa o salvamento de um serviço etiqueta.
+ * @param data Os dados do serviço etiqueta a serem salvos.
+ */
+ const fetchTServicoEtiquetaSave = async (data: TServicoEtiquetaInterface) => {
+ // Chama o serviço de salvamento
+ const response = await TServicoEtiquetaSaveService(data);
+
+ // Guardar os dados localizados
+ setTServicoEtiquetaSave(response.data);
+
+ // Manda a resposta para o verificador de resposta global
+ ///setResponse(response);
+
+ // Manda a resposta para o verificador de resposta global
+ return response.data;
+ };
+
+ // Retorna o estado e a função de salvamento para uso no componente
+ return { tServicoEtiquetaSave, fetchTServicoEtiquetaSave };
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoEditHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoEditHook.ts
new file mode 100644
index 0000000..b0094f8
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoEditHook.ts
@@ -0,0 +1,25 @@
+import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
+
+// Interface tipada do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
+
+// Função que Edit o tipo de serviço via API
+import { TServicoTipoEditData } from '../../_data/TServicoTipo/TServicoTipoEditData';
+
+// Hook customizado para remoção de tipos de serviço
+export const useTServicoTipoEditHook = () => {
+ // Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
+ const { setResponse } = useResponse();
+
+ // Função assíncrona que Edit um tipo de serviço
+ const editTServicoTipo = async (data: TServicoTipoInterface) => {
+ // Chama a função de remoção passando os dados do tipo de serviço
+ const response = await TServicoTipoEditData(data);
+
+ // Atualiza o contexto global com a resposta da API
+ setResponse(response);
+ };
+
+ // Retorna a função de remoção para ser usada no componente
+ return { editTServicoTipo };
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoReadHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoReadHook.ts
new file mode 100644
index 0000000..b827959
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoReadHook.ts
@@ -0,0 +1,35 @@
+import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
+import { useState } from 'react';
+
+// Serviço que busca a lista de tipos de serviço (TServicoTipoIndexService)
+import { TServicoTipoIndexService } from '../../_services/t_servico_tipo/TServicoTipoIndexService';
+
+// Interface tipada do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
+
+// Hook customizado para leitura de dados de tipos de serviço
+export const useTServicoTipoReadHook = () => {
+ // Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
+ const { setResponse } = useResponse();
+
+ // Estado local que armazena a lista de tipos de serviço retornada da API
+ const [tServicoTipo, setTServicoTipo] = useState([]);
+
+ // Função assíncrona que busca os dados dos tipos de serviço
+ const fetchTServicoTipo = async () => {
+ // Chama o serviço responsável por consultar a API
+ const response = await TServicoTipoIndexService();
+
+ // Atualiza o estado local com os dados retornados
+ setTServicoTipo(response.data);
+
+ // Atualiza o contexto global de resposta
+ setResponse(response);
+
+ // Retorna a resposta para quem chamou o hook
+ return response;
+ };
+
+ // Retorna os dados e a função de busca para serem usados no componente
+ return { tServicoTipo, fetchTServicoTipo };
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoRemoveHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoRemoveHook.ts
new file mode 100644
index 0000000..e0f8d5d
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoRemoveHook.ts
@@ -0,0 +1,25 @@
+import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
+
+// Interface tipada do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
+
+// Função que remove o tipo de serviço via API
+import { TServicoTipoRemoveData } from '../../_data/TServicoTipo/TServicoTipoRemoveData';
+
+// Hook customizado para remoção de tipos de serviço
+export const useTServicoTipoRemoveHook = () => {
+ // Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
+ const { setResponse } = useResponse();
+
+ // Função assíncrona que remove um tipo de serviço
+ const removeTServicoTipo = async (data: TServicoTipoInterface) => {
+ // Chama a função de remoção passando os dados do tipo de serviço
+ const response = await TServicoTipoRemoveData(data);
+
+ // Atualiza o contexto global com a resposta da API
+ setResponse(response);
+ };
+
+ // Retorna a função de remoção para ser usada no componente
+ return { removeTServicoTipo };
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoSaveHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoSaveHook.ts
new file mode 100644
index 0000000..964d127
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoSaveHook.ts
@@ -0,0 +1,33 @@
+import { useState } from 'react';
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Interface tipada do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
+
+// Serviço que salva os dados do tipo de serviço
+import { TServicoTipoSaveService } from '../../_services/t_servico_tipo/TServicoTipoSaveService';
+
+export const useTServicoTipoSaveHook = () => {
+ const { setResponse } = useResponse();
+
+ // Estado local para armazenar os dados do tipo de serviço salvos
+ const [tServicoTipo, setTServicoTipo] = useState(null);
+
+ /**
+ * Função que executa o salvamento de um tipo de serviço.
+ * @param data Os dados do tipo de serviço a serem salvos.
+ */
+ const saveTServicoTipo = async (data: TServicoTipoInterface) => {
+ // Chama o serviço de salvamento
+ const response = await TServicoTipoSaveService(data);
+
+ // Guardar os dados localizados
+ setTServicoTipo(response.data);
+
+ // Manda a resposta para o verificador de resposta global
+ setResponse(response);
+ };
+
+ // Retorna o estado e a função de salvamento para uso no componente
+ return { tServicoTipo, saveTServicoTipo };
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_hooks/t_tb_reconhecimentotipo/useTTBReconhecimentoTipoReadHook.ts b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_tb_reconhecimentotipo/useTTBReconhecimentoTipoReadHook.ts
new file mode 100644
index 0000000..c0f2697
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_hooks/t_tb_reconhecimentotipo/useTTBReconhecimentoTipoReadHook.ts
@@ -0,0 +1,41 @@
+// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
+import { useResponse } from '@/shared/components/response/ResponseContext';
+
+// Importa hooks do React para gerenciamento de estado e memorização de valores
+import { useMemo, useState } from 'react';
+
+// Importa a interface que define a estrutura dos dados de "TTBReconhecimentoTipo"
+import { TTBReconhecimentoTipoReadInterface } from '../../_interfaces/TTBReconhecimentoTipoReadInterface';
+import { TTBReconhecimentoTipoInterface } from '../../_interfaces/TTBReconhecimentoTipoInterface';
+
+// Importa o serviço responsável por buscar os dados de "TTBReconhecimentoTipo" na API
+import { TTBReconhecimentoTipoIndexService } from '../../_services/t_tb_reconhecimentotipo/TTBReconhecimentoTipoIndexService';
+
+// Hook personalizado para leitura (consulta) dos tipos de marcação
+export const useTTBReconhecimentoTipoReadHook = () => {
+ // Obtém a função que atualiza a resposta global do sistema
+ const { setResponse } = useResponse();
+
+ // Define o estado local que armazenará a lista de tipos de marcação
+ const [tTBReconhecimentoTipo, setTTBReconhecimentoTipo] = useState<
+ TTBReconhecimentoTipoInterface[]
+ >([]);
+
+ // Função responsável por buscar os dados da API e atualizar o estado
+ const fetchTTBReconhecimentoTipo = async (data: TTBReconhecimentoTipoReadInterface) => {
+ // Executa o serviço que faz a requisição à API
+ const response = await TTBReconhecimentoTipoIndexService(data);
+
+ // Atualiza o estado local com os dados retornados
+ setTTBReconhecimentoTipo(response.data);
+
+ // Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
+ setResponse(response);
+ };
+
+ // Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
+ return useMemo(
+ () => ({ tTBReconhecimentoTipo, fetchTTBReconhecimentoTipo }),
+ [tTBReconhecimentoTipo, fetchTTBReconhecimentoTipo],
+ );
+};
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoInterface.ts
new file mode 100644
index 0000000..c6595b6
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoInterface.ts
@@ -0,0 +1,17 @@
+// Interface que representa a tabela C_CAIXA_SERVICO
+export interface CCaixaServicoInterface {
+ interno_sistema?: string; // VARCHAR(1)
+ caixa_servico_id: number; // NUMERIC(10,2) NOT NULL - Chave primária
+ descricao?: string; // VARCHAR(60)
+ situacao?: string; // VARCHAR(1)
+ tipo_transacao?: string; // VARCHAR(1)
+ sistema_id?: number; // NUMERIC(14,3)
+ selo_grupo_id?: number; // NUMERIC(10,2)
+ emitir_relatorio?: string; // VARCHAR(1)
+ repasse?: string; // VARCHAR(1)
+ repetir_descricao?: string; // VARCHAR(1)
+ codigo_conta?: number; // NUMERIC(10,2)
+ tipo_conta_carneleao?: string; // VARCHAR(60)
+ centro_de_custa_id?: number; // NUMERIC(10,2) - Chave estrangeira
+ devolucao_juizo?: string; // VARCHAR(1)
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoReadInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoReadInterface.ts
new file mode 100644
index 0000000..52ed3ef
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoReadInterface.ts
@@ -0,0 +1,3 @@
+export interface CCaixaServicoReadInterface {
+ sistema_id?: number;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoInterface.ts
new file mode 100644
index 0000000..64c2518
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoInterface.ts
@@ -0,0 +1,20 @@
+// Interface que representa a tabela G_EMOLUMENTO
+export interface GEmolumentoInterface {
+ emolumento_id?: number; // NUMERIC(10,2) - Chave primária
+ descricao?: string; // VARCHAR(260)
+ tipo?: string; // VARCHAR(1)
+ sistema_id?: number; // NUMERIC(10,2)
+ selo_grupo_id?: number; // NUMERIC(10,2)
+ reg_averb?: string; // VARCHAR(1)
+ pre_definido?: string; // VARCHAR(1)
+ situacao?: string; // VARCHAR(1)
+ situacao_ri?: string; // VARCHAR(1)
+ com_reducao?: string; // VARCHAR(1)
+ motivo_reducao?: string; // VARCHAR(120)
+ valor_maximo_certidao?: number; // NUMERIC(14,3)
+ tipo_objetivo?: string; // VARCHAR(3)
+ modelo_tag?: string; // VARCHAR(3)
+ codigo_nota_id?: number; // NUMERIC(10,2)
+ convenio_codhab?: string; // VARCHAR(1)
+ item_df?: string; // VARCHAR(10)
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemInterface.ts
new file mode 100644
index 0000000..11b9857
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemInterface.ts
@@ -0,0 +1,32 @@
+// Interface que representa a tabela G_EMOLUMENTO_ITEM (inferido)
+export interface GEmolumentoItemInterface {
+ valor_emolumento?: number; // NUMERIC(14,3)
+ emolumento_item_id: number; // NUMERIC(10,2) NOT NULL - Chave primária (assumida)
+ emolumento_id?: number; // NUMERIC(10,2)
+ valor_inicio?: number; // NUMERIC(14,3)
+ valor_fim?: number; // NUMERIC(14,3)
+ valor_taxa_judiciaria?: number; // NUMERIC(14,3)
+ emolumento_periodo_id?: number; // NUMERIC(10,2)
+ codigo?: number; // NUMERIC(10,2)
+ pagina_extra?: number; // NUMERIC(10,2)
+ valor_pagina_extra?: number; // NUMERIC(14,3)
+ valor_outra_taxa1?: number; // NUMERIC(14,3)
+ codigo_selo?: string; // VARCHAR(30)
+ valor_fundo_ri?: number; // NUMERIC(14,3)
+ codigo_tabela?: string; // VARCHAR(30)
+ selo_grupo_id?: number; // NUMERIC(10,2)
+ codigo_km?: string; // VARCHAR(30)
+ emolumento_acresce?: number; // NUMERIC(14,3)
+ taxa_acresce?: number; // NUMERIC(14,3)
+ funcivil_acresce?: number; // NUMERIC(14,3)
+ valor_fracao?: number; // NUMERIC(14,3)
+ valor_por_excedente_emol?: number; // NUMERIC(14,3)
+ valor_por_excedente_tj?: number; // NUMERIC(14,3)
+ valor_por_excedente_fundo?: number; // NUMERIC(14,3)
+ valor_limite_excedente_emol?: number; // NUMERIC(14,3)
+ valor_limite_excedente_tj?: number; // NUMERIC(14,3)
+ valor_limite_excedente_fundo?: number; // NUMERIC(14,3)
+ fundo_selo?: number; // NUMERIC(14,3)
+ distribuicao?: number; // NUMERIC(14,3)
+ vrc_ext?: number; // NUMERIC(10,2) - Renomeado de VRCEXT para vrc_ext (convenção)
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemReadInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemReadInterface.ts
new file mode 100644
index 0000000..79144fc
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemReadInterface.ts
@@ -0,0 +1,4 @@
+export interface GEmolumentoItemReadInterface {
+ emolumento_id?: number;
+ valor?: number;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoReadInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoReadInterface.ts
new file mode 100644
index 0000000..111562f
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoReadInterface.ts
@@ -0,0 +1,3 @@
+export interface GEmolumentoReadInterface {
+ sistema_id?: number;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoInterface.ts
new file mode 100644
index 0000000..1127a0c
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoInterface.ts
@@ -0,0 +1,20 @@
+export interface GMarcacaoTipoInterface {
+ marcacao_tipo_id?: number;
+ descricao?: string;
+ texto?: string; // Mapeamento para BLOB SUB_TYPE BINARY
+ nome?: string;
+ grupo?: string;
+ situacao?: string;
+ sistema_id?: number;
+ grupo_tipo?: string;
+ tipo_qualificacao?: string;
+ condicao_sql?: string;
+ separador_1?: string;
+ separador_2?: string;
+ separador_3?: string;
+ tipo_valor?: string;
+ atualizar?: string;
+ protegida?: string;
+ ativar_separador?: string;
+ sql_completo?: string;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoReadInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoReadInterface.ts
new file mode 100644
index 0000000..ca49448
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoReadInterface.ts
@@ -0,0 +1,5 @@
+export interface GMarcacaoTipoReadInterface {
+ grupo?: string;
+ sistema_id?: number;
+ situacao?: string;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaInterface.ts
new file mode 100644
index 0000000..67c03aa
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaInterface.ts
@@ -0,0 +1,7 @@
+// Interface que representa a tabela T_TB_RECONHECIMENTOTIPO
+export interface TServicoEtiquetaInterface {
+ servico_etiqueta_id?: number; // NUMERIC(10,2) NOT NULL - Chave primária
+ etiqueta_modelo_id?: number; // NUMERIC(10,2)
+ servico_tipo_id?: number; // NUMERIC(10,2)
+ descricao?: string;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaServicoIdReadInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaServicoIdReadInterface.ts
new file mode 100644
index 0000000..4c5b92b
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaServicoIdReadInterface.ts
@@ -0,0 +1,3 @@
+export interface TServicoEtiquetaServicoIdReadInterface {
+ servico_tipo_id?: number;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoTipoInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoTipoInterface.ts
new file mode 100644
index 0000000..a7e6e7c
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoTipoInterface.ts
@@ -0,0 +1,27 @@
+export default interface TServicoTipoInterface {
+ servico_tipo_id?: number; // SERVICO_TIPO_ID NUMERIC(10,2) NOT NULL (PK)
+ descricao: string; // DESCRICAO VARCHAR(60)
+ valor?: number; // VALOR NUMERIC(14,3)
+ requer_autorizacao?: string; // REQUER_AUTORIZACAO VARCHAR(1)
+ requer_biometria?: string; // REQUER_BIOMETRIA VARCHAR(1)
+ tipo_pessoa?: string; // TIPO_PESSOA VARCHAR(1)
+ tb_reconhecimentotipo_id?: number; // TB_RECONHECIMENTOTIPO_ID NUMERIC(10,2) (FK)
+ requer_abonador?: string; // REQUER_ABONADOR VARCHAR(1)
+ situacao?: string; // SITUACAO VARCHAR(1)
+ requer_cpf?: string; // REQUER_CPF VARCHAR(1)
+ servico_padrao?: string; // SERVICO_PADRAO VARCHAR(1)
+ maximo_pessoa?: number; // MAXIMO_PESSOA NUMERIC(10,2)
+ alterar_valor?: string; // ALTERAR_VALOR VARCHAR(1)
+ servico_caixa_id?: number; // SERVICO_CAIXA_ID NUMERIC(10,2)
+ caixa_servico_id?: number; // LIBERAR_DESCONTO VARCHAR(1)
+ valor_fixo?: string; // VALOR_FIXO VARCHAR(1)
+ emolumento_id?: number; // EMOLUMENTO_ID NUMERIC(10,2) (FK)
+ emolumento_obrigatorio?: number; // EMOLUMENTO_OBRIGATORIO NUMERIC(10,2) (FK)
+ ato_praticado?: string; // ATO_PRATICADO VARCHAR(1)
+ selar?: string; // SELAR VARCHAR(1)
+ frenteverso?: string; // FRENTEVERSO VARCHAR(1)
+ etiqueta_unica?: string; // ETIQUETA_UNICA VARCHAR(1)
+ transferencia_veiculo?: string; // TRANSFERENCIA_VEICULO VARCHAR(1)
+ usar_a4?: string; // USAR_A4 VARCHAR(1)
+ averbacao?: string; // AVERBACAO VARCHAR(1)
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoInterface.ts
new file mode 100644
index 0000000..bbf207c
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoInterface.ts
@@ -0,0 +1,6 @@
+// Interface que representa a tabela T_TB_RECONHECIMENTOTIPO
+export interface TTbReconhecimentoTipoInterface {
+ tb_reconhecimentotipo_id: number; // NUMERIC(10,2) NOT NULL - Chave primária
+ descricao?: string; // VARCHAR(30)
+ situacao?: string; // VARCHAR(1)
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoReadInterface.ts b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoReadInterface.ts
new file mode 100644
index 0000000..c1732f6
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoReadInterface.ts
@@ -0,0 +1,4 @@
+export interface TTBReconhecimentoTipoReadInterface {
+ tb_reconhecimentotipo_id?: number;
+ descricao?: string;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoEtiquetaSchema.ts b/src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoEtiquetaSchema.ts
new file mode 100644
index 0000000..b7d3b06
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoEtiquetaSchema.ts
@@ -0,0 +1,14 @@
+/**
+ * Interface principal baseada na DDL
+ * Tabela: T_SERVICO_ETIQUETA
+ */
+export interface TServicoEtiquetaFormValues {
+ /** Identificador principal (PK) */
+ servico_etiqueta_id?: number;
+
+ /** Relacionamento com o modelo de etiqueta (FK) */
+ etiqueta_modelo_id?: number;
+
+ /** Relacionamento com o tipo de serviço (FK) */
+ servico_tipo_id?: number;
+}
diff --git a/src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoTipoSchema.ts b/src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoTipoSchema.ts
new file mode 100644
index 0000000..8fb4cb2
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoTipoSchema.ts
@@ -0,0 +1,78 @@
+import z from 'zod';
+
+/**
+ * Tipos utilitários para campos simples
+ */
+const SN = z.enum(['S', 'N']).default('N'); // Campos do tipo Sim/Não
+const AI = z.enum(['A', 'I']).default('A'); // Situação Ativo/Inativo
+const OneCharString = z.string().max(1, 'Deve ter no máximo 1 caractere').optional();
+const RequiredString = z.string().min(1, 'O campo é obrigatório');
+const OptionalNumber = z.number().optional();
+const RequiredNumber = z.number();
+
+/**
+ * Schema principal baseado na DDL e adaptado ao formulário React
+ */
+export const TServicoTipoSchema = z.object({
+ // Identificador
+ servico_tipo_id: RequiredNumber.describe('ID do Tipo de Serviço').optional(),
+
+ // Campos principais
+ descricao: z.string().max(60, 'A descrição deve ter no máximo 60 caracteres').optional(),
+ categoria: z.string().optional(),
+
+ // Controle de flags (S/N)
+ frenteverso: SN.optional(),
+ averbacao: SN.optional(),
+ transferencia_veiculo: SN.optional(),
+ usar_a4: SN.optional(),
+ etiqueta_unica: SN.optional(),
+ selar: SN.optional(),
+ servico_padrao: SN.optional(),
+ // lancar_taxa: SN.optional(),
+ // lancar_fundesp: SN.optional(),
+ // liberar_desconto: SN.optional(),
+ // fundesp_automatica: SN.optional(),
+ // lancar_valor_documento: SN.optional(),
+ valor_fixo: SN.optional(),
+ ato_praticado: SN.optional(),
+ // apresentante_selo: SN.optional(),
+ // renovacao_cartao: SN.optional(),
+
+ // Situação
+ situacao: AI,
+
+ // Campos numéricos
+ valor: OptionalNumber,
+ maximo_pessoa: OptionalNumber,
+ servico_caixa_id: OptionalNumber,
+ emolumento_id: z.number().nullable(),
+ emolumento_obrigatorio: z.number().nullable(),
+
+ // Relacionamentos e permissões
+ tipo_item: OneCharString,
+ requer_autorizacao: OneCharString,
+ requer_biometria: OneCharString,
+ tipo_pessoa: OneCharString,
+ tb_reconhecimentotipo_id: OptionalNumber,
+ // tipo_permissao_cpf: OneCharString,
+ requer_abonador: OneCharString,
+ // requer_representante: OneCharString,
+ requer_cpf: OneCharString,
+ // alterar_valor: OneCharString,
+ // pagina_acrescida: OneCharString,
+
+ // Campos auxiliares usados apenas no formulário (não persistidos)
+ valor_emolumento: z.number().optional(),
+ valor_taxa_judiciaria: z.number().optional(),
+ fundesp_valor: z.number().optional(),
+ valor_total: z.number().optional(),
+ etiquetas_carimbos: z.any().optional(),
+ emolumento: z.any().optional(),
+ emolumento_auxiliar: z.any().optional(),
+});
+
+/**
+ * Tipo inferido do schema — usado diretamente no useForm
+ */
+export type TServicoTipoFormValues = z.infer;
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/c_caixa_servico/CCaixaServicoIndexService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/c_caixa_servico/CCaixaServicoIndexService.ts
new file mode 100644
index 0000000..c9d11be
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/c_caixa_servico/CCaixaServicoIndexService.ts
@@ -0,0 +1,18 @@
+// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a função que realiza a requisição de listagem dos tipos de marcação
+import { CCaixaServicoIndexData } from '../../_data/CCaixaServico/CCaixaServicoIndexData';
+import { CCaixaServicoReadInterface } from '../../_interfaces/CCaixaServicoReadInterface';
+
+// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
+async function executeCCaixaServicoIndexService(data: CCaixaServicoReadInterface) {
+ // Chama a função que realiza a requisição à API e aguarda a resposta
+ const response = await CCaixaServicoIndexData(data);
+
+ // Retorna a resposta obtida da requisição
+ return response;
+}
+
+// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const CCaixaServicoIndexService = withClientErrorHandler(executeCCaixaServicoIndexService);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento/GEmolumentoIndexService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento/GEmolumentoIndexService.ts
new file mode 100644
index 0000000..4d46361
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento/GEmolumentoIndexService.ts
@@ -0,0 +1,18 @@
+// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a função que realiza a requisição de listagem dos tipos de marcação
+import { GEmolumentoIndexData } from '../../_data/GEmolumento/GEmolumentoIndexData';
+import { GEmolumentoReadInterface } from '../../_interfaces/GEmolumentoReadInterface';
+
+// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
+async function executeGEmolumentoIndexService(data: GEmolumentoReadInterface) {
+ // Chama a função que realiza a requisição à API e aguarda a resposta
+ const response = await GEmolumentoIndexData(data);
+
+ // Retorna a resposta obtida da requisição
+ return response;
+}
+
+// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const GEmolumentoIndexService = withClientErrorHandler(executeGEmolumentoIndexService);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento_item/GEmolumentoItemValorService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento_item/GEmolumentoItemValorService.ts
new file mode 100644
index 0000000..9c74b1f
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento_item/GEmolumentoItemValorService.ts
@@ -0,0 +1,20 @@
+// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a função que realiza a requisição de listagem dos tipos de marcação
+import { GEmolumentoItemValorData } from '../../_data/GEmolumentoItem/GEmolumentoItemValorData';
+import { GEmolumentoItemReadInterface } from '../../_interfaces/GEmolumentoItemReadInterface';
+
+// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
+async function executeGEmolumentoItemValorService(data: GEmolumentoItemReadInterface) {
+ // Chama a função que realiza a requisição à API e aguarda a resposta
+ const response = await GEmolumentoItemValorData(data);
+
+ // Retorna a resposta obtida da requisição
+ return response;
+}
+
+// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const GEmolumentoItemValorService = withClientErrorHandler(
+ executeGEmolumentoItemValorService,
+);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/g_marcacao_tipo/GMarcacaoTipoIndexService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/g_marcacao_tipo/GMarcacaoTipoIndexService.ts
new file mode 100644
index 0000000..7a058ee
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/g_marcacao_tipo/GMarcacaoTipoIndexService.ts
@@ -0,0 +1,18 @@
+// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a função que realiza a requisição de listagem dos tipos de marcação
+import { GMarcacaoTipoIndexData } from '../../_data/GMarcacaoTipo/GMarcacaoTipoIndexData';
+import { GMarcacaoTipoReadInterface } from '../../_interfaces/GMarcacaoTipoReadInterface';
+
+// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
+async function executeGMarcacaoTipoIndexService(data: GMarcacaoTipoReadInterface) {
+ // Chama a função que realiza a requisição à API e aguarda a resposta
+ const response = await GMarcacaoTipoIndexData(data);
+
+ // Retorna a resposta obtida da requisição
+ return response;
+}
+
+// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const GMarcacaoTipoIndexService = withClientErrorHandler(executeGMarcacaoTipoIndexService);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaSaveService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaSaveService.ts
new file mode 100644
index 0000000..ef0a70d
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaSaveService.ts
@@ -0,0 +1,22 @@
+// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Função que salva os dados do serviço etiqueta via API (ou mock)
+import { TServicoEtiquetaSaveData } from '../../_data/TServicoEtiqueta/TServicoEtiquetaSaveData';
+
+// Interface tipada do serviço etiqueta
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
+
+// Função assíncrona que executa o salvamento de um serviço etiqueta
+async function executeTServicoEtiquetaSaveService(data: TServicoEtiquetaInterface) {
+ // Chama a função que salva os dados do serviço etiqueta
+ const response = await TServicoEtiquetaSaveData(data);
+
+ // Retorna a resposta do salvamento
+ return response;
+}
+
+// Exporta o serviço de salvamento de serviço etiqueta já encapsulado com tratamento de erros
+export const TServicoEtiquetaSaveService = withClientErrorHandler(
+ executeTServicoEtiquetaSaveService,
+);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaServicoIdService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaServicoIdService.ts
new file mode 100644
index 0000000..702d7db
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaServicoIdService.ts
@@ -0,0 +1,21 @@
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
+
+import { TServicoEtiquetaReadData } from '../../_data/TServicoEtiqueta/TServicoEtiquetaReadData';
+
+import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
+// Interface tipada do tipo de serviço
+
+// Função assíncrona que executa a consulta de um tipo de serviço etiqueta
+async function executeTServicoEtiquetaServicoIdService(data: TServicoEtiquetaInterface) {
+ // Chama a função que consulta os dados do tipo de serviço etiqueta
+ const response = await TServicoEtiquetaReadData(data);
+
+ // Retorna a resposta da remoção
+ return response;
+}
+
+// Exporta o serviço de remoção de tipo de serviço já encapsulado com tratamento de erros
+export const TServicoEtiquetaServicoIdService = withClientErrorHandler(
+ executeTServicoEtiquetaServicoIdService,
+);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoEditService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoEditService.ts
new file mode 100644
index 0000000..9e0ab2e
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoEditService.ts
@@ -0,0 +1,20 @@
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
+
+import { TServicoTipoEditData } from '../../_data/TServicoTipo/TServicoTipoEditData';
+// Função que remove os dados do tipo de serviço via API
+
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
+// Interface tipada do tipo de serviço
+
+// Função assíncrona que executa a remoção de um tipo de serviço
+async function executeTServicoTipoEditService(data: TServicoTipoInterface) {
+ // Chama a função que remove os dados do tipo de serviço
+ const response = await TServicoTipoEditData(data);
+
+ // Retorna a resposta da remoção
+ return response;
+}
+
+// Exporta o serviço de remoção de tipo de serviço já encapsulado com tratamento de erros
+export const TServicoTipoEditService = withClientErrorHandler(executeTServicoTipoEditService);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoIndexService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoIndexService.ts
new file mode 100644
index 0000000..d8654ca
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoIndexService.ts
@@ -0,0 +1,17 @@
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
+
+import { TServicoTipoIndexData } from '../../_data/TServicoTipo/TServicoTipoIndexData';
+// Função que retorna os dados da lista de tipos de serviço (chamada à API ou mock)
+
+// Função assíncrona que executa a chamada para buscar os dados dos tipos de serviço
+async function executeTServicoTipoIndexService() {
+ // Chama a função que retorna os dados dos tipos de serviço
+ const response = await TServicoTipoIndexData();
+
+ // Retorna a resposta para o chamador
+ return response;
+}
+
+// Exporta o serviço de índice de tipos de serviço já encapsulado com tratamento de erros
+export const TServicoTipoIndexService = withClientErrorHandler(executeTServicoTipoIndexService);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoRemoveService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoRemoveService.ts
new file mode 100644
index 0000000..4376393
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoRemoveService.ts
@@ -0,0 +1,20 @@
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
+
+import { TServicoTipoRemoveData } from '../../_data/TServicoTipo/TServicoTipoRemoveData';
+// Função que remove os dados do tipo de serviço via API
+
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
+// Interface tipada do tipo de serviço
+
+// Função assíncrona que executa a remoção de um tipo de serviço
+async function executeTServicoTipoRemoveService(data: TServicoTipoInterface) {
+ // Chama a função que remove os dados do tipo de serviço
+ const response = await TServicoTipoRemoveData(data);
+
+ // Retorna a resposta da remoção
+ return response;
+}
+
+// Exporta o serviço de remoção de tipo de serviço já encapsulado com tratamento de erros
+export const TServicoTipoRemoveService = withClientErrorHandler(executeTServicoTipoRemoveService);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoSaveService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoSaveService.ts
new file mode 100644
index 0000000..770d824
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoSaveService.ts
@@ -0,0 +1,20 @@
+// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Função que salva os dados do tipo de serviço via API (ou mock)
+import { TServicoTipoSaveData } from '../../_data/TServicoTipo/TServicoTipoSaveData';
+
+// Interface tipada do tipo de serviço
+import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
+
+// Função assíncrona que executa o salvamento de um tipo de serviço
+async function executeTServicoTipoSaveService(data: TServicoTipoInterface) {
+ // Chama a função que salva os dados do tipo de serviço
+ const response = await TServicoTipoSaveData(data);
+
+ // Retorna a resposta do salvamento
+ return response;
+}
+
+// Exporta o serviço de salvamento de tipo de serviço já encapsulado com tratamento de erros
+export const TServicoTipoSaveService = withClientErrorHandler(executeTServicoTipoSaveService);
diff --git a/src/app/(protected)/(cadastros)/cadastros/_services/t_tb_reconhecimentotipo/TTBReconhecimentoTipoIndexService.ts b/src/app/(protected)/(cadastros)/cadastros/_services/t_tb_reconhecimentotipo/TTBReconhecimentoTipoIndexService.ts
new file mode 100644
index 0000000..f9fca02
--- /dev/null
+++ b/src/app/(protected)/(cadastros)/cadastros/_services/t_tb_reconhecimentotipo/TTBReconhecimentoTipoIndexService.ts
@@ -0,0 +1,20 @@
+// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
+import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
+
+// Importa a função que realiza a requisição de listagem dos tipos de marcação
+import { TTBReconhecimentoTipoIndexData } from '../../_data/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndexData';
+import { TTBReconhecimentoTipoReadInterface } from '../../_interfaces/TTBReconhecimentoTipoReadInterface';
+
+// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
+async function executeTTBReconhecimentoTipoIndexService(data: TTBReconhecimentoTipoReadInterface) {
+ // Chama a função que realiza a requisição à API e aguarda a resposta
+ const response = await TTBReconhecimentoTipoIndexData(data);
+
+ // Retorna a resposta obtida da requisição
+ return response;
+}
+
+// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
+export const TTBReconhecimentoTipoIndexService = withClientErrorHandler(
+ executeTTBReconhecimentoTipoIndexService,
+);
diff --git a/src/app/(protected)/layout.tsx b/src/app/(protected)/layout.tsx
index 0e86ae0..c6fea82 100644
--- a/src/app/(protected)/layout.tsx
+++ b/src/app/(protected)/layout.tsx
@@ -56,15 +56,11 @@ export default function RootLayout({
-
- Building Your Application
-
+ Building Your Application
-
- Data Fetching
-
+ Data Fetching
diff --git a/src/app/(protected)/page.tsx b/src/app/(protected)/page.tsx
index a1f4581..bf69e37 100644
--- a/src/app/(protected)/page.tsx
+++ b/src/app/(protected)/page.tsx
@@ -4,51 +4,47 @@ import useGUsuarioGetJWTHook from '@/shared/hooks/auth/useGUsuarioGetJWTHook';
import { useEffect, useState } from 'react';
export default function Page() {
- const { userAuthenticated } = useGUsuarioGetJWTHook();
+ const { userAuthenticated } = useGUsuarioGetJWTHook();
- // Inicializa time como null para renderizar só no cliente
- const [time, setTime] = useState(null);
+ // Inicializa time como null para renderizar só no cliente
+ const [time, setTime] = useState(null);
- useEffect(() => {
- setTime(new Date()); // define data inicial no cliente
- const interval = setInterval(() => setTime(new Date()), 1000);
- return () => clearInterval(interval);
- }, []);
+ useEffect(() => {
+ setTime(new Date()); // define data inicial no cliente
+ const interval = setInterval(() => setTime(new Date()), 1000);
+ return () => clearInterval(interval);
+ }, []);
- // Se ainda não temos a hora, renderiza nada para evitar mismatch
- if (!time || !userAuthenticated?.data) return null;
+ // Se ainda não temos a hora, renderiza nada para evitar mismatch
+ if (!time || !userAuthenticated?.data) return null;
- const hours = time.getHours();
- const greeting =
- hours < 12 ? 'Bom dia' : hours < 18 ? 'Boa tarde' : 'Boa noite';
+ const hours = time.getHours();
+ const greeting = hours < 12 ? 'Bom dia' : hours < 18 ? 'Boa tarde' : 'Boa noite';
- const formattedDate = time.toLocaleDateString('pt-BR', {
- weekday: 'long',
- day: '2-digit',
- month: 'long',
- });
- const formattedTime = time.toLocaleTimeString('pt-BR');
+ const formattedDate = time.toLocaleDateString('pt-BR', {
+ weekday: 'long',
+ day: '2-digit',
+ month: 'long',
+ });
+ const formattedTime = time.toLocaleTimeString('pt-BR');
- return (
-
-
-