560 changed files with 1329 additions and 26710 deletions
--- a/14
+++ b/14
@ -1,9 +1,13 @@
+# Usa a imagem oficial do Python
 FROM python:3.12-slim

+# Define diretório de trabalho no container
 WORKDIR /app

+# Copia o arquivo de dependências
 COPY requirements.txt .

+# Instala dependências no sistema e no Python
 RUN apt-get update && apt-get install -y \
    gcc libffi-dev libssl-dev python3-dev firebird-dev \
 && pip install --upgrade pip \
@ -12,13 +16,11 @@ RUN apt-get update && apt-get install -y \
 && apt-get autoremove -y \
 && rm -rf /var/lib/apt/lists/*

-# ===============================
-# CRIA DIRETÓRIOS NECESSÁRIOS
-# ===============================
-RUN mkdir -p storage/temp
-
+# Copia o restante do projeto para o container
 COPY . .

+# Expõe a porta padrão do Uvicorn/FastAPI
 EXPOSE 8000

-CMD ["gunicorn", "main:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000"]
+# Comando para iniciar o servidor
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port 8000"]
--- a/README.md
+++ b/README.md
@ -1,12 +1,12 @@
 # Configuração do Projeto Python

-Este guia descreve o passo a passo para configurar o ambiente de desenvolvimento e produção de um projeto Python, incluindo ambiente virtual, dependências, banco de dados, e ajuste de desempenho com múltiplos núcleos.
+Este guia descreve o passo a passo para configurar o ambiente de desenvolvimento de um projeto Python, incluindo a preparação do ambiente virtual, instalação de dependências e configuração do banco de dados.

 ---

 ## 1. Clonar o Projeto

-Clone o repositório do projeto a partir do Git:
+Primeiro, clone o repositório do projeto a partir do Git:

 ```bash
 git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git
@ -16,7 +16,7 @@ git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git

 ## 2. Criar o Ambiente Virtual

-Crie um **ambiente virtual** isolado para o projeto:
+O uso de um **ambiente virtual** garante que as bibliotecas instaladas para este projeto não afetem o Python global da sua máquina.

 ```bash
 python -m venv venv
@ -26,13 +26,14 @@ python -m venv venv

 ## 3. Ativar o Ambiente Virtual

-Ative o ambiente virtual antes de instalar as dependências:
+Ative o ambiente virtual antes de instalar as dependências ou executar a aplicação.

 ```bash
 venv\Scripts\activate
 ```

-> **Em sistemas Linux/Mac:**
+> **Observação:**
+> Em sistemas Unix (Linux/Mac), o comando pode ser:
 >
 > ```bash
 > source venv/bin/activate
@ -42,11 +43,9 @@ venv\Scripts\activate

 ## 4. Instalar Dependências do Sistema

-O projeto depende de compiladores nativos para algumas bibliotecas Python.
+A biblioteca de criptografia utilizada no projeto requer uma extensão da Microsoft para ser instalada.
+Baixe e instale o **Microsoft C++ Build Tools** através do link abaixo:

-### Windows
-
-Baixe e instale o **Microsoft C++ Build Tools**:
 [https://visualstudio.microsoft.com/pt-br/visual-cpp-build-tools/](https://visualstudio.microsoft.com/pt-br/visual-cpp-build-tools/)

 Durante a instalação, selecione o pacote:
@ -55,15 +54,6 @@ Durante a instalação, selecione o pacote:
 Desktop Development With C++
 ```

-### Linux
-
-Execute no terminal:
-
-```bash
-sudo apt update
-sudo apt install -y build-essential libpq-dev
-```
-
 ---

 ## 5. Instalar as Bibliotecas do Projeto
@ -76,21 +66,21 @@ pip install -r requirements.txt

 ---

-## 6. Configurar o Banco de Dados (Firebird)
+## 6. Configurar o Banco de Dados

-O projeto utiliza o banco **Firebird**.
-Edite o arquivo de configuração em:
+O projeto utiliza um banco **Firebird**.
+Edite o arquivo de configuração localizado em:

 ```
 api/config/database/firebird.json
 ```

-Exemplo:
+Exemplo do conteúdo padrão:

 ```json
 {
  "host": "localhost",
-  "name": "/data/base/CAIAPONIA.FDB",
+  "name": "D:/Orius/Base/CAIAPONIA.FDB",
  "port": 3050,
  "user": "SYSDBA",
  "password": "",
@ -103,179 +93,50 @@ Exemplo:
 }
 ```

-**Campos principais:**
+### Ajustes Necessários:

-| Campo               | Descrição                          |
-| ------------------- | ---------------------------------- |
-| `host`              | Endereço do servidor Firebird      |
-| `name`              | Caminho completo do arquivo `.FDB` |
-| `port`              | Porta padrão `3050`                |
-| `user`              | Usuário do banco                   |
-| `password`          | Senha do usuário                   |
-| `charset`           | Codificação (UTF8 recomendado)     |
-| `pool.size`         | Número de conexões fixas           |
-| `pool.max_overflow` | Conexões extras sob demanda        |
+* **host**: Endereço do servidor do banco de dados.
+* **name**: Caminho completo do arquivo `.FDB`.
+* **port**: Porta do Firebird (padrão: `3050`).
+* **user**: Usuário do banco de dados.
+* **password**: Senha do usuário configurado.

 ---

-## 7. Modo Desenvolvimento
+## 7. Iniciar a Aplicação

-Para ambiente local, execute:
+Com o ambiente virtual **ativado**, execute o comando abaixo para iniciar a aplicação:

 ```bash
 uvicorn main:app --reload
 ```

-> O parâmetro `--reload` reinicia automaticamente a aplicação ao detectar alterações no código.
+> **Dica:**
+> O parâmetro `--reload` reinicia automaticamente a aplicação sempre que houver alterações no código.

-Acesse:
+---

-```
+## 8. Testando a Aplicação
+
+Após iniciar a aplicação, abra o navegador e acesse o seguinte endereço:
+
+```http
 http://localhost:8000/docs
 ```

---
+Você deverá visualizar a interface do **Swagger**, onde estarão listados todos os endpoints disponíveis da API.

-## 8. Modo Produção
-
-A execução em produção varia conforme o sistema operacional.
+> **Observação:**
+> O Swagger permite testar os endpoints diretamente pelo navegador, sem necessidade de ferramentas externas como Postman ou Insomnia.

 ---

-### **Windows (modo produção simulado)**
+## Resumo dos Comandos

-O **Gunicorn** não é compatível com Windows, pois depende do módulo `fcntl` exclusivo de sistemas Unix.
-Portanto, em ambiente Windows, recomenda-se usar o **Uvicorn** diretamente com múltiplos *workers*:
-
-```bash
-uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
-```
-
-> O parâmetro `--workers` define quantos processos simultâneos serão utilizados.
-> Idealmente, use `(número_de_CPUs * 2) + 1`.
-
-#### Alternativa compatível (Windows)
-
-Instale e use o **Hypercorn**, uma alternativa semelhante ao Gunicorn:
-
-```bash
-pip install hypercorn
-hypercorn main:app --workers 4 --bind 0.0.0.0:8000
-```
-
---
-
-### **Linux (modo produção real)**
-
-Em ambientes Linux (ou Docker), utilize o **Gunicorn** com o **Uvicorn Worker** para obter o máximo desempenho.
-
-#### Instalar Gunicorn (caso ainda não instalado)
-
-```bash
-pip install gunicorn uvicorn
-```
-
-#### Executar com múltiplos núcleos
-
-```bash
-gunicorn main:app \
-  -k uvicorn.workers.UvicornWorker \
-  --workers 4 \
-  --bind 0.0.0.0:8000 \
-  --timeout 120 \
-  --log-level info
-```
-
-#### Parâmetros principais
-
-| Parâmetro                          | Função                                   |
-| ---------------------------------- | ---------------------------------------- |
-| `-k uvicorn.workers.UvicornWorker` | Usa o Uvicorn como worker ASGI           |
-| `--workers 4`                      | Define o número de núcleos usados        |
-| `--bind 0.0.0.0:8000`              | Expõe a aplicação em todas as interfaces |
-| `--timeout 120`                    | Tempo limite de resposta (em segundos)   |
-| `--log-level info`                 | Define o nível de logs                   |
-
-#### Dica de cálculo de workers
-
-```
-(número_de_CPUs * 2) + 1
-```
-
-Exemplo: servidor com 2 CPUs → `--workers 5`
-
---
-
-### **Execução em segundo plano (Linux)**
-
-Para rodar a aplicação continuamente:
-
-```bash
-nohup gunicorn main:app -k uvicorn.workers.UvicornWorker --workers 4 --bind 0.0.0.0:8000 &
-```
-
-Verifique se está rodando:
-
-```bash
-ps aux | grep gunicorn
-```
-
---
-
-## 9. Logs e Monitoramento
-
-É possível direcionar os logs de acesso e erro para arquivos dedicados:
-
-```bash
-gunicorn main:app \
-  -k uvicorn.workers.UvicornWorker \
-  --workers 4 \
-  --bind 0.0.0.0:8000 \
-  --access-logfile logs/access.log \
-  --error-logfile logs/error.log
-```
-
---
-
-## 10. Estrutura Recomendada de Deploy
-
-```
-/app
-├── main.py
-├── api/
-├── packages/
-├── requirements.txt
-├── logs/
-│   ├── access.log
-│   └── error.log
-└── systemd/
-    └── saas_api.service
-```
-
---
-
-## 11. Resumo dos Comandos
-
-| Etapa                       | Comando                                                                              |
-| --------------------------- | ------------------------------------------------------------------------------------ |
-| Clonar projeto              | `git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git`             |
-| Criar venv                  | `python -m venv venv`                                                                |
-| Ativar venv                 | `venv\Scripts\activate` *(Windows)*<br>`source venv/bin/activate` *(Linux/Mac)*      |
-| Instalar dependências       | `pip install -r requirements.txt`                                                    |
-| Rodar em desenvolvimento    | `uvicorn main:app --reload`                                                          |
-| Rodar em produção (Windows) | `uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4`                            |
-| Rodar em produção (Linux)   | `gunicorn main:app -k uvicorn.workers.UvicornWorker --workers 4 --bind 0.0.0.0:8000` |
-| Alternativa (Windows)       | `hypercorn main:app --workers 4 --bind 0.0.0.0:8000`                                 |
-
---
-
-## 12. Recomendações Finais
-
-* Em **Windows**, use Uvicorn ou Hypercorn apenas para testes e ambientes locais.
-* Para **produção real**, use **Linux** com Gunicorn + Uvicorn Worker, idealmente em container **Docker**.
-* Monitore o consumo de CPU/RAM e ajuste o número de *workers* conforme o ambiente.
-* Automatize o serviço em produção via **systemd** (ex: `/etc/systemd/system/saas_api.service`) para iniciar junto com o servidor.
-
---
-
-uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+| Etapa                   | Comando                                                                         |
+| ----------------------- | ------------------------------------------------------------------------------- |
+| Clonar o projeto        | `git clone https://git.oriustecnologia.com/OriusTecnologia/saas_api.git`        |
+| Criar ambiente virtual  | `python -m venv venv`                                                           |
+| Ativar ambiente virtual | `venv\Scripts\activate` *(Windows)*<br>`source venv/bin/activate` *(Linux/Mac)* |
+| Instalar dependências   | `pip install -r requirements.txt`                                               |
+| Iniciar a aplicação     | `uvicorn main:app --reload`                                                     |
--- a/abstracts/action.py
+++ b/abstracts/action.py
@ -1,4 +1,4 @@
-from abc import abstractmethod
+from abc import ABC, abstractmethod


 class BaseAction:
--- a/abstracts/repository.py
+++ b/abstracts/repository.py
@ -1,114 +1,50 @@
-# Importa tipos utilitários para anotações estáticas e sobrecarga de assinaturas.
-from typing import Any, Mapping, List, Optional, Literal, Union, overload
+from typing import Literal, Optional

-# Função `text` para construir SQL parametrizado de forma segura.
 from sqlalchemy import text
-
-# Tipo de retorno de execução bruta de SQL (cursor/result set) do SQLAlchemy.
-from sqlalchemy.engine import CursorResult
-
-# Exceção base do SQLAlchemy para capturar erros de banco.
 from sqlalchemy.exc import SQLAlchemyError

-# Provedor do engine de conexão com o Firebird, centralizado no projeto.
 from database.firebird import Firebird


-# Define a classe base de repositórios, concentrando operações comuns de acesso a dados.
 class BaseRepository:
-    # Sobrecarga 1: quando `fetch="all"`, o retorno é uma lista de mapeamentos (coluna->valor).
-    @overload
-    def _execute(
-        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["all"]
-    ) -> List[Mapping[str, Any]]: ...
-
-    # Sobrecarga 2: quando `fetch="one"`, o retorno é um único mapeamento ou None.
-    @overload
-    def _execute(
-        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["one"]
-    ) -> Optional[Mapping[str, Any]]: ...
-
-    # Sobrecarga 3: quando `fetch="none"`, não há retorno (operações DML sem leitura).
-    @overload
-    def _execute(
-        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["none"]
-    ) -> None: ...
-
-    # Sobrecarga 4: quando `fetch="result"`, retorna o objeto `CursorResult` bruto do SQLAlchemy.
-    @overload
-    def _execute(
-        self, sql: str, params: Optional[dict[str, Any]], fetch: Literal["result"]
-    ) -> CursorResult[Any]: ...
-
-    # Implementação concreta que atende às quatro sobrecargas por meio de um retorno em união.
-    def _execute(
-        self,
-        sql: str,  # Comando SQL (SELECT/INSERT/UPDATE/DELETE) em texto.
-        params: Optional[dict[str, Any]] = None,  # Parâmetros nomeados para o SQL.
-        fetch: Literal[
-            "all", "one", "none", "result"
-        ] = "result",  # Modo de leitura/retorno.
-    ) -> Union[
-        List[Mapping[str, Any]],  # Retorno quando `fetch="all"`.
-        Optional[Mapping[str, Any]],  # Retorno quando `fetch="one"`.
-        None,  # Retorno quando `fetch="none"`.
-        CursorResult[Any],  # Retorno quando `fetch="result"`.
-    ]:
-        """Método interno que executa o SQL conforme o modo de fetch especificado."""
-        # Obtém o engine de conexão com o Firebird a partir do provider central.
-        engine = Firebird.get_engine()
-        try:
-            # Inicia um contexto transacional; `begin()` garante commit/rollback automáticos.
-            with engine.begin() as conn:
-                # Executa o SQL com parâmetros (usa dict vazio quando `params` é None).
-                result = conn.execute(text(sql), params or {})
-                # Quando for solicitado "all", converte o resultado em lista de mapeamentos (coluna->valor).
-                if fetch == "all":
-                    # retorna Sequence[RowMapping], compatível com List[Mapping[str, Any]]
-                    return list(result.mappings().all())
-                # Quando for solicitado "one", retorna apenas o primeiro registro (ou None).
-                elif fetch == "one":
-                    return result.mappings().first()
-                # Quando for solicitado "none", não retorna dados (apenas executa o comando).
-                elif fetch == "none":
-                    return None
-                # Caso padrão: retorna o objeto Result bruto para manipulações específicas.
-                return result
-        except SQLAlchemyError as e:
-            # Log simples para facilitar diagnóstico em ambiente de desenvolvimento/produção.
-            print(f"[ERRO SQL]: {e}")
-            # Propaga a exceção para camadas superiores tratarem (ex.: FastAPI Exception Handler).
-            raise
-
-    # Executa uma consulta e retorna o objeto `CursorResult` bruto (uso avançado ou stream).
-    def query(
-        self, sql: str, params: Optional[dict[str, Any]] = None
-    ) -> CursorResult[Any]:
-        """Executa uma consulta SQL e retorna o resultado como objeto ResultProxy."""
+    def query(self, sql: str, params: Optional[dict] = None):
+        """Executa uma consulta SQL e retorna o resultado como objeto ResultProxy"""
        return self._execute(sql, params, fetch="result")

-    # Executa uma consulta e retorna todos os registros como lista de mapeamentos.
-    def fetch_all(
-        self, sql: str, params: Optional[dict[str, Any]] = None
-    ) -> List[Mapping[str, Any]]:
-        """Executa uma consulta SQL e retorna todos os registros com mapeamento de colunas."""
+    def fetch_all(self, sql: str, params: Optional[dict] = None):
+        """Executa uma consulta SQL e retorna todos os registros com mapeamento de colunas"""
        return self._execute(sql, params, fetch="all")

-    # Executa uma consulta e retorna apenas o primeiro registro ou None.
-    def fetch_one(
-        self, sql: str, params: Optional[dict[str, Any]] = None
-    ) -> Optional[Mapping[str, Any]]:
-        """Executa uma consulta SQL e retorna o primeiro registro com mapeamento de colunas."""
+    def fetch_one(self, sql: str, params: Optional[dict] = None):
+        """Executa uma consulta SQL e retorna o primeiro registro com mapeamento de colunas"""
        return self._execute(sql, params, fetch="one")

-    # Executa comandos DML (INSERT/UPDATE/DELETE) sem retorno de dados.
-    def run(self, sql: str, params: Optional[dict[str, Any]] = None) -> None:
-        """Executa um SQL sem retorno de dados (ex: INSERT, UPDATE, DELETE)."""
-        self._execute(sql, params, fetch="none")
-
-    # Executa comandos com cláusula RETURNING e devolve o registro retornado (ou None).
-    def run_and_return(
-        self, sql: str, params: Optional[dict[str, Any]] = None
-    ) -> Optional[Mapping[str, Any]]:
-        """Executa SQL com RETURNING e retorna o primeiro registro como dict."""
+    def run(self, sql: str, params: Optional[dict] = None):
+        """Executa um SQL sem retorno de dados (ex: INSERT, UPDATE, DELETE)"""
+        return self._execute(sql, params, fetch="none")
+    
+    def run_and_return(self, sql: str, params: Optional[dict] = None):
+        """Executa SQL com RETURNING e retorna o primeiro registro como dict"""
        return self._execute(sql, params, fetch="one")
+
+    def _execute(
+        self,
+        sql: str,
+        params: Optional[dict] = None,
+        fetch: Literal["all", "one", "result", "none"] = "result",
+    ):
+        engine = Firebird.get_engine()
+        try:
+            with engine.begin() as conn:
+                result = conn.execute(text(sql), params or {})
+                if fetch == "all":
+                    return result.mappings().all()
+                elif fetch == "one":
+                    return result.mappings().first()
+                elif fetch == "none":
+                    return None
+                return result  # Result object
+        except SQLAlchemyError as e:
+            print(f"[ERRO SQL]: {e}")
+            raise
+ 
--- a/actions/config/config.py
+++ b/actions/config/config.py
@ -11,10 +11,10 @@ class Config:
        base_dir = Path(__file__).resolve().parent

        # Caminho absoluto para o config.json (subindo dois níveis e entrando em config/)
-        config_path = base_dir.parent.parent / "config" / name
+        config_path = base_dir.parent.parent / 'config' / name

        # Carrega o JSON como objeto acessível por ponto
-        with open(config_path, "r") as f:
+        with open(config_path, 'r') as f:
            config = json.load(f, object_hook=lambda d: SimpleNamespace(**d))

-        return config
+        return config
--- a/actions/data/dict_to_namespace.py
+++ b/actions/data/dict_to_namespace.py
@ -1,31 +0,0 @@
-import json
-from types import SimpleNamespace
-
-
-def dict_to_namespace(d):
-    """
-    Converte dict (ou string JSON) recursivamente em SimpleNamespace.
-    """
-    # Caso venha uma string JSON
-    if isinstance(d, str):
-        try:
-            # tenta fazer parse do JSON interno
-            parsed = json.loads(d)
-            # se for mesmo JSON, converte recursivamente
-            return dict_to_namespace(parsed)
-        except (json.JSONDecodeError, TypeError):
-            # não era JSON, retorna string normal
-            return d
-
-    # Caso seja um dicionário
-    if isinstance(d, dict):
-        return SimpleNamespace(**{k: dict_to_namespace(v) for k, v in d.items()})
-
-    # Caso seja lista/tupla
-    if isinstance(d, list):
-        return [dict_to_namespace(i) for i in d]
-    if isinstance(d, tuple):
-        return tuple(dict_to_namespace(i) for i in d)
-
-    # Caso base (valor simples)
-    return d
--- a/actions/data/dict_to_obj.py
+++ b/actions/data/dict_to_obj.py
@ -1,82 +0,0 @@
-from typing import Any, Mapping, Iterable
-
-
-class DictToObj:
-    """
-    Converte dicts (aninhados) em objetos com acesso por ponto.
-    - d["x"] -> o.x
-    - Listas/tuplas são convertidas recursivamente.
-    - Mantém método parse() para voltar ao dict original.
-    """
-
-    __slots__ = ("__data__",)
-
-    def __init__(self, data: Mapping[str, Any] | None = None):
-        object.__setattr__(self, "__data__", {})
-        if data:
-            for k, v in data.items():
-                self.__data__[k] = self._convert(v)
-
-    # ===== Conversões =====
-    @classmethod
-    def _convert(cls, value: Any) -> Any:
-        if isinstance(value, Mapping):
-            return cls(value)
-        if isinstance(value, list):
-            return [cls._convert(v) for v in value]
-        if isinstance(value, tuple):
-            return tuple(cls._convert(v) for v in value)
-        return value
-
-    def parse(self) -> dict[str, Any]:
-        def back(v: Any) -> Any:
-            if isinstance(v, DictToObj):
-                return v.parse()
-            if isinstance(v, list):
-                return [back(i) for i in v]
-            if isinstance(v, tuple):
-                return tuple(back(i) for i in v)
-            return v
-
-        return {k: back(v) for k, v in self.__data__.items()}
-
-    # ===== Acesso por ponto / item =====
-    def __getattr__(self, name: str) -> Any:
-        try:
-            return self.__data__[name]
-        except KeyError as e:
-            raise AttributeError(name) from e
-
-    def __setattr__(self, name: str, value: Any) -> None:
-        # protege o atributo interno
-        if name == "__data__":
-            object.__setattr__(self, name, value)
-        else:
-            self.__data__[name] = self._convert(value)
-
-    def __getitem__(self, key: str) -> Any:
-        return self.__data__[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self.__data__[key] = self._convert(value)
-
-    def __contains__(self, key: str) -> bool:
-        return key in self.__data__
-
-    def keys(self) -> Iterable[str]:
-        return self.__data__.keys()
-
-    def items(self) -> Iterable[tuple[str, Any]]:
-        return self.__data__.items()
-
-    def values(self) -> Iterable[Any]:
-        return self.__data__.values()
-
-    def __iter__(self):
-        return iter(self.__data__)
-
-    def __len__(self) -> int:
-        return len(self.__data__)
-
-    def __repr__(self) -> str:
-        return f"DictToObj({self.__data__!r})"
--- a/actions/data/generate_insert_sql.py
+++ b/actions/data/generate_insert_sql.py
@ -1,51 +0,0 @@
-from pydantic import BaseModel
-from decimal import Decimal
-
-def generate_insert_sql(table_name: str, data: BaseModel | dict) -> str:
-    """
-    Gera um comando SQL INSERT seguro para Firebird.
-    - Aceita BaseModel (Pydantic) ou dict.
-    - Ignora *_ID None.
-    - Mantém colunas em MAIÚSCULAS e parâmetros em minúsculas (para bind funcionar).
-    """
-
-    # Converte o model em dict limpo
-    if isinstance(data, BaseModel):
-        data_dict = data.model_dump(exclude_unset=True)
-    elif isinstance(data, dict):
-        data_dict = data
-    else:
-        raise TypeError("O parâmetro 'data' deve ser um BaseModel ou dict.")
-
-    columns = []
-    params = []
-    returning_fields = []
-
-    for key, value in data_dict.items():
-        column_name = key.upper()
-
-        # Converte Decimal → float
-        if isinstance(value, Decimal):
-            data_dict[key] = float(value)
-
-        # Campos válidos para retorno
-        if value is not None:
-            returning_fields.append(column_name)
-
-        # Coluna em maiúsculo, parâmetro em minúsculo
-        columns.append(column_name)
-        params.append(f":{key}")
-
-    columns_str = ", ".join(columns)
-    params_str = ", ".join(params)
-    returning_str = ", ".join(returning_fields) if returning_fields else "*"
-
-    sql = (
-        f"INSERT INTO {table_name} (\n"
-        f"    {columns_str}\n"
-        f") VALUES (\n"
-        f"    {params_str}\n"
-        f") RETURNING {returning_str};"
-    )
-
-    return sql
--- a/actions/data/get_url_params.py
+++ b/actions/data/get_url_params.py
@ -1,5 +0,0 @@
-from fastapi import Request
-
-
-async def get_url_params(request: Request):
-    return dict(request.query_params)
--- a/actions/data/json_to_dict.py
+++ b/actions/data/json_to_dict.py
@ -1,37 +0,0 @@
-import json
-from pathlib import Path
-from typing import Any, Union
-
-
-class JsonToDict:
-    """
-    Converte conteúdo JSON (string, bytes ou arquivo) em dicionário Python.
-    """
-
-    @staticmethod
-    def parse(data: Union[str, bytes, Path]) -> dict[str, Any]:
-        """
-        Recebe uma string JSON, bytes ou caminho de arquivo .json
-        e retorna um dicionário Python.
-        """
-
-        try:
-            # Caso seja um caminho de arquivo
-            if isinstance(data, Path):
-                with open(data, "r", encoding="utf-8") as file:
-                    return json.load(file)
-
-            # Caso seja conteúdo JSON (str ou bytes)
-            if isinstance(data, bytes):
-                data = data.decode("utf-8")
-
-            # Garante que é string JSON
-            if isinstance(data, str):
-                return json.loads(data)
-
-            raise TypeError("Tipo de entrada inválido. Use str, bytes ou Path.")
-
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Erro ao decodificar JSON: {e}")
-        except Exception as e:
-            raise ValueError(f"Erro ao converter JSON para dict: {e}")
--- a/actions/data/microtime.py
+++ b/actions/data/microtime.py
@ -1,31 +0,0 @@
-import time
-
-
-class Microtime:
-    """
-    Utilitário para manipulação de tempo com alta precisão (microssegundos).
-    """
-
-    @staticmethod
-    def get() -> float:
-        """
-        Retorna o timestamp Unix atual com precisão de microssegundos.
-        Equivalente ao microtime(true) do PHP.
-        """
-        return time.time()
-
-    @staticmethod
-    def as_int() -> int:
-        """
-        Retorna o tempo atual puramente em microssegundos (Inteiro).
-        Útil para gerar IDs únicos ou ordenação precisa.
-        """
-        # Pega em nanosegundos e converte para microssegundos
-        return time.time_ns() // 1000
-
-    @staticmethod
-    def diff(start_time: float) -> float:
-        """
-        Calcula a diferença (duração) em segundos com precisão.
-        """
-        return time.time() - start_time
--- a/actions/data/prepare_update_data.py
+++ b/actions/data/prepare_update_data.py
@ -1,30 +0,0 @@
-from typing import Tuple, Dict, Any
-from pydantic import BaseModel
-
-
-def prepare_update_data(
-    schema: BaseModel, exclude_fields: list[str] = None, id_field: str = "id"
-) -> Tuple[Dict[str, Any], str]:
-    """
-    Gera dinamicamente os dados e SQL para update com base em um schema Pydantic.
-
-    Args:
-        schema: Instância do schema (ex: t_pessoa_save_schema)
-        exclude_fields: Lista de campos a serem ignorados no SET (ex: ['pessoa_id'])
-        id_field: Nome do campo identificador primário (ex: 'pessoa_id')
-
-    Returns:
-        Tuple contendo:
-        - data_dict: dicionário com apenas campos preenchidos (sem unset)
-        - update_sql: string SQL do tipo "campo1 = :campo1, campo2 = :campo2"
-    """
-    exclude_fields = exclude_fields or [id_field]
-
-    # Cria o dicionário apenas com os campos enviados
-    data_dict = schema.model_dump(exclude_unset=True)
-
-    # Monta lista dinâmica de campos para o SET
-    update_fields = [f"{k} = :{k}" for k in data_dict.keys() if k not in exclude_fields]
-
-    update_sql = ", ".join(update_fields)
-    return data_dict, update_sql
--- a/actions/data/text.py
+++ b/actions/data/text.py
@ -1,111 +0,0 @@
-# Importa a biblioteca nativa 'zlib' usada para compressão/descompressão de dados binários.
-import zlib
-
-# Importa a função 'rtf_to_text' da biblioteca 'striprtf',
-# responsável por converter documentos RTF em texto plano legível.
-from striprtf.striprtf import rtf_to_text
-
-
-# Define uma classe utilitária chamada 'Text', contendo apenas métodos estáticos.
-# Essa abordagem permite o uso direto sem necessidade de instanciar a classe.
-class Text:
-    @staticmethod
-    def decompress(vf_string):
-        """
-        Descomprime e decodifica texto de origem WPTools/Firebird.
-
-        Finalidade:
-            Converter o conteúdo de campos BLOB ou strings compactadas (como no Delphi)
-            em texto legível, detectando automaticamente se o conteúdo está:
-              - Compactado com zlib
-              - Codificado em ISO-8859-1 (padrão ANSI)
-              - Representado como bytes puros
-        """
-        # Verifica se o valor recebido é nulo, vazio ou None.
-        if not vf_string:
-            return ""
-
-        # Caso seja um objeto tipo stream (ex: campo BLOB do Firebird)
-        if hasattr(vf_string, "read"):
-            vf_string = vf_string.read()
-
-        # Garante que o valor trabalhado é uma sequência de bytes
-        if isinstance(vf_string, str):
-            vf_bytes = vf_string.encode("latin1", errors="ignore")
-        else:
-            vf_bytes = vf_string
-
-        # Detecta assinatura zlib (0x78 0x9C ou 0x78 0xDA)
-        is_zlib = (
-            len(vf_bytes) > 2 and vf_bytes[0] == 0x78 and vf_bytes[1] in (0x9C, 0xDA)
-        )
-
-        # Se for zlib, tenta descompactar
-        if is_zlib:
-            try:
-                return zlib.decompress(vf_bytes).decode("iso-8859-1", errors="ignore")
-            except Exception:
-                pass
-
-        # Caso não seja zlib, trata como texto puro
-        try:
-            return vf_bytes.decode("iso-8859-1", errors="ignore")
-        except Exception:
-            return str(vf_string)
-
-    @staticmethod
-    def compress(text, *, encoding: str = "iso-8859-1"):
-        """
-        Comprime texto/dados com zlib SEM Base64.
-
-        Parâmetros:
-            text: str | bytes | stream (com .read())
-            encoding: encoding usado quando 'text' for str (padrão: ISO-8859-1)
-
-        Retorno:
-            - bytes comprimidos (zlib)
-
-        Observações:
-            - Ideal para armazenamento direto em BLOB (Firebird, PostgreSQL, etc.)
-            - Evita overhead e custo do Base64
-            - Totalmente compatível com 'decompress'
-        """
-        if text is None or text == "":
-            return b""
-
-        # Se for stream (ex.: BLOB do Firebird)
-        if hasattr(text, "read"):
-            raw = text.read()
-        else:
-            raw = text
-
-        # Garante bytes
-        if isinstance(raw, str):
-            raw_bytes = raw.encode(encoding, errors="ignore")
-        else:
-            raw_bytes = bytes(raw)
-
-        # Comprime com zlib e retorna bytes
-        return zlib.compress(raw_bytes)
-
-    @staticmethod
-    def to_text(raw_text: str) -> str:
-        """
-        Converte o conteúdo RTF em texto simples e retorna como string.
-
-        Finalidade:
-            - Detectar automaticamente se o conteúdo está em formato RTF.
-            - Converter para texto plano usando a função 'rtf_to_text'.
-            - Retornar uma string limpa e pronta para uso.
-        """
-        if not raw_text:
-            return ""
-
-        # Detecta cabeçalho RTF
-        if raw_text.strip().startswith("{\\rtf"):
-            try:
-                return rtf_to_text(raw_text).strip()
-            except Exception:
-                return raw_text
-
-        return raw_text.strip()
--- a/actions/dynamic_import/dynamic_import.py
+++ b/actions/dynamic_import/dynamic_import.py
@ -1,23 +1,20 @@
 import importlib
 from actions.config.config import Config
-from typing import Optional, Any, Type


 class DynamicImport:

-    def __init__(self) -> None:
-        self.config: dict[str, Any] = Config.get("app.json")
-        self.base: str = "packages.v1"
-        self.package: Optional[str] = None
-        self.table: Optional[str] = None
+    def __init__(self):
+        self.config = Config.get('app.json')
+        self.base = 'packages.v1'

-    def set_package(self, name: str) -> None:
+    def set_package(self, name):
        self.package = name

-    def set_table(self, table: str):
+    def set_table(self, table):
        self.table = table

-    def service(self, name: str, class_name: str) -> Type[Any]:
+    def service(self, name: str, class_name : str):
        try:
            # Define o nome do Módulo
            module_file = f"{name}"
--- a/actions/dynamic_import/service_factory.py
+++ b/actions/dynamic_import/service_factory.py
@ -1,64 +0,0 @@
-import importlib
-import re
-from functools import lru_cache
-from typing import Type, TypeVar, Optional
-from actions.config.config import Config
-from actions.env.env_config_loader import EnvConfigLoader
-
-# Genérico para garantir que o retorno respeite o Protocolo
-T = TypeVar("T")
-
-
-class ServiceFactory:
-
-    def __init__(self, package: str, table: str):
-
-        # Instancia o loader com o prefixo correto
-        env = EnvConfigLoader(".env")
-
-        # Ex: "packages.v1"
-        self.base_root = "packages.v1"
-        self.package = package
-        self.table = table
-
-        # Carrega config apenas uma vez
-        self.app_config = Config.get("app.json")
-
-        # Define a UF da aplicação
-        self.current_state = env.ORIUS_CLIENT_STATE
-
-    @lru_cache(maxsize=32)
-    def make(self, class_name: str, interface: Type[T]) -> T:
-        """
-        Instancia um serviço dinamicamente com comportamento de Autoload.
-        """
-        # 1. Converte CamelCase para snake_case (Autoload style)
-        # Ex: TAtoIndexService -> t_ato_index_service
-        module_name = re.sub(r"(?<!^)(?=[A-Z])", "_", class_name).lower()
-
-        # 2. Monta o caminho completo
-        # Ex: packages.v1.servicos.balcao.services.t_ato.SP.t_ato_index_service
-        import_path = (
-            f"{self.base_root}.{self.package}.services."
-            f"{self.table}.{self.current_state}.{module_name}"
-        )
-
-        try:
-            # 3. Importação Dinâmica
-            module = importlib.import_module(import_path)
-
-            # 4. Pega a classe do módulo
-            clazz = getattr(module, class_name)
-
-            # 5. Retorna a INSTÂNCIA da classe (já com () )
-            # Se seus serviços precisam de argumentos no __init__, altere aqui.
-            return clazz()
-
-        except ImportError as e:
-            raise ImportError(
-                f"FATAL: Não foi possível carregar o serviço '{class_name}' para o estado '{self.current_state}'.\nCaminho tentado: {import_path}\nErro: {e}"
-            )
-        except AttributeError:
-            raise AttributeError(
-                f"FATAL: O arquivo '{module_name}.py' existe, mas a classe '{class_name}' não foi encontrada dentro dele."
-            )
--- a/actions/env/env_config_loader.py
+++ b/actions/env/env_config_loader.py
@ -1,36 +0,0 @@
-from dotenv import dotenv_values, load_dotenv
-import os
-
-
-class EnvConfigLoader:
-    """
-    Classe para carregar todas as variáveis de ambiente (.env)
-    e permitir acesso via atributo (settings.VAR).
-    """
-
-    def __init__(self, env_file: str = ".env"):
-
-        # Garante que o .env será carregado no ambiente do sistema
-        load_dotenv(env_file)
-
-        # Lê todas as variáveis (do arquivo + sistema)
-        self._values = {
-            **dotenv_values(env_file),  # Conteúdo do .env
-            **os.environ,  # Variáveis já existentes no ambiente
-        }
-
-    def __getattr__(self, name: str):
-        """Permite acessar como settings.VAR"""
-        # Normaliza o nome para maiúsculo
-        key = name.upper()
-        if key in self._values:
-            return self._values[key]
-        raise AttributeError(f"A variável '{name}' não existe no .env")
-
-    def __repr__(self):
-        """Exibe todas as variáveis carregadas"""
-        return f"<Settings {self._values}>"
-
-    def all(self) -> dict:
-        """Retorna todas as variáveis como dicionário"""
-        return dict(self._values)
--- a/actions/jwt/create_token.py
+++ b/actions/jwt/create_token.py
@ -5,30 +5,32 @@ from pytz import timezone
 from abstracts.action import BaseAction
 from actions.config.config import Config

-
 class CreateToken(BaseAction):
    def __init__(self):
-
        # Busca as configurações da aplicação
-        self.config = Config.get("app.json")
+        self.config = Config.get('app.json')

        # Cria o timedelta com base na config
        self.access_token_expire = timedelta(
            minutes=self.config.jwt.expire.minute,
            hours=self.config.jwt.expire.hours,
-            days=self.config.jwt.expire.days,
+            days=self.config.jwt.expire.days
        )

-    def execute(self, tipo_token: str, data: str) -> str:
-
-        sp = timezone("America/Sao_Paulo")
+    def execute(self, tipo_token: str, data : str) -> str:
+        
+        sp = timezone('America/Sao_Paulo')
        agora = datetime.now(tz=sp)
        expira = agora + self.access_token_expire

        # Define os dados do token
-        payload = {"type": tipo_token, "exp": expira, "iat": agora, "data": str(data)}
+        payload = {
+            'type' : tipo_token,
+            'exp' : expira,
+            'iat' : agora,
+            'data' : str(data)
+        }

        # Retorna os dados codificados
-        return jwt.encode(
-            payload, self.config.jwt.token, algorithm=self.config.jwt.algorithm
-        )
+        return jwt.encode(payload, self.config.jwt.token, algorithm=self.config.jwt.algorithm)
+        
--- a/actions/jwt/get_current_user.py
+++ b/actions/jwt/get_current_user.py
@ -1,11 +1,10 @@
-from fastapi import Depends, HTTPException, status
+from fastapi import Depends, HTTPException, status, Request
 from fastapi.security import OAuth2PasswordBearer

 from actions.jwt.verify_token import VerifyToken  # A classe que criamos anteriormente

 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")  # Apenas requerido pelo FastAPI

-
 def get_current_user(token: str = Depends(oauth2_scheme)):

    # Ação que válida o tokne
@ -14,12 +13,12 @@ def get_current_user(token: str = Depends(oauth2_scheme)):
    result = verify_token.execute(token)

    # Verifica se a resposta é diferente de inválida
-    if result["status"] != "valid":
+    if result['status'] != 'valid':
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=result.get("message", "Token inválido ou expirado"),
+            detail=result.get('message', 'Token inválido ou expirado'),
            headers={"WWW-Authenticate": "Bearer"},
        )

    # Retorna apenas os dados do token
-    return result["payload"]
+    return result['payload']
--- a/actions/jwt/verify_token.py
+++ b/actions/jwt/verify_token.py
@ -1,4 +1,6 @@
+from datetime import datetime
 from jose import jwt, JWTError, ExpiredSignatureError
+from pytz import timezone

 from actions.config.config import Config

--- a/actions/session/get_session.py
+++ b/actions/session/get_session.py
@ -1,11 +0,0 @@
-from fastapi import Request, HTTPException, status
-
-
-def get_session_user(request: Request) -> dict:
-    user = request.session.get("user")
-    if not user:
-        # ajuste conforme sua regra (pode só retornar None)
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED, detail="Sessão inválida"
-        )
-    return user
--- a/actions/session/session_services.py
+++ b/actions/session/session_services.py
@ -1,16 +0,0 @@
-# services/session_service.py
-from fastapi import Request
-
-
-class SessionService:
-    def __init__(self, request: Request):
-        self._session = request.session
-
-    def set(self, k, v):
-        self._session[k] = v
-
-    def get(self, k, d=None):
-        return self._session.get(k, d)
-
-    def clear(self):
-        self._session.clear()
--- a/actions/system/handlers.py
+++ b/actions/system/handlers.py
@ -1,4 +1,5 @@
 # handlers.py
+import json
 import traceback

 from fastapi import Request
@ -12,58 +13,74 @@ from actions.log.log import Log

 def register_exception_handlers(app):

-    def __init__(self):
+    def __init__ (self):
        log = Log()

    @app.exception_handler(BusinessRuleException)
-    async def business_rule_exception_handler(
-        request: Request, exc: BusinessRuleException
-    ):
-
-        response = {"status": "422", "error": "Regra de negócio", "detail": exc.message}
+    async def business_rule_exception_handler(request: Request, exc: BusinessRuleException):

+        response = {
+                "status": "422",
+                "error": "Regra de negócio", 
+                "detail": exc.message
+            }
+        
        # Salva o log em disco
-        Log.register(response, "storage/temp/business_rule_exception_handler.json")
+        Log.register(response, 'storage/temp/business_rule_exception_handler.json')

-        return JSONResponse(status_code=422, content=response)
+        return JSONResponse(
+            status_code=422,
+            content=response
+        )

    @app.exception_handler(StarletteHTTPException)
    async def http_exception_handler(request: Request, exc: StarletteHTTPException):
        response = {
-            "status": exc.status_code,
-            "error": "HTTP Error",
-            "detail": exc.detail,
-        }
+                "status": exc.status_code,
+                    "error": "HTTP Error", 
+                    "detail": exc.detail
+            }

        # Salva o log em disco
-        Log.register(response, "storage/temp/http_exception_handler.json")
+        Log.register(response, 'storage/temp/http_exception_handler.json')

-        return JSONResponse(status_code=exc.status_code, content=response)
+        return JSONResponse(
+            status_code=exc.status_code,
+            content=response
+        )

    @app.exception_handler(RequestValidationError)
-    async def validation_exception_handler(
-        request: Request, exc: RequestValidationError
-    ):
+    async def validation_exception_handler(request: Request, exc: RequestValidationError):

-        response = {"status": 400, "error": "Erro de validação", "detail": exc.errors()}
+        response = {
+                "status": 400,
+                "error": "Erro de validação", 
+                "detail": exc.errors()
+            }

        # Salva o log em disco
-        Log.register(response, "storage/temp/validation_exception_handler.json")
+        Log.register(response, 'storage/temp/validation_exception_handler.json')

-        return JSONResponse(status_code=400, content=response)
+        return JSONResponse(
+            status_code=400,
+            content=response
+        )

    @app.exception_handler(Exception)
    async def global_exception_handler(request: Request, exc: Exception):

        response = {
-            "status": 500,
-            "error": "Erro Interno do Servidor",
-            "type": type(exc).__name__,
-            "message": str(exc),
-            "trace": traceback.format_exc(),
-        }
+                "status": 500,
+                "error": "Erro Interno do Servidor",
+                "type": type(exc).__name__,
+                "message": str(exc),
+                "trace": traceback.format_exc()
+            }

        # Salva o log em disco
-        Log.register(response, "storage/temp/validation_exception_handler.json")
+        Log.register(response, 'storage/temp/validation_exception_handler.json')

-        return JSONResponse(status_code=500, content=response)
+        return JSONResponse(
+            status_code=500,
+            content=response
+        )
--- a/actions/validations/cep.py
+++ b/actions/validations/cep.py
@ -1,7 +1,8 @@
+
 class CEP:

    @staticmethod
    def validate(data: str) -> bool:

        # Valida e retorna a informação
-        return len(data) == 8
+        return len(data) == 8
--- a/actions/values/values.py
+++ b/actions/values/values.py
@ -1,14 +0,0 @@
-from decimal import ROUND_HALF_UP, Decimal
-
-
-class Values:
-
-    @staticmethod
-    def percent(value: Decimal, percent: Decimal) -> Decimal:
-
-        return value / percent
-
-    @staticmethod
-    def money(scale: str, value: Decimal) -> Decimal:
-
-        return value.quantize(scale, rounding=ROUND_HALF_UP)
--- a/api.code-workspace
+++ b/api.code-workspace
@ -1,186 +0,0 @@
-{
-  "folders": [
-    {
-      "path": "D:/IIS/Orius/api"
-    }
-  ],
-  "settings": {
-    // === ⚙️ GERAL ===
-    "editor.formatOnSave": true,
-    "editor.codeActionsOnSave": {
-      "source.fixAll": "explicit",
-      "source.organizeImports": "explicit"
-    },
-    "editor.formatOnPaste": false,
-    "editor.formatOnType": false,
-    "editor.minimap.enabled": false,
-    "files.trimTrailingWhitespace": true,
-    "files.autoSave": "onFocusChange",
-    "telemetry.telemetryLevel": "off",
-    "update.mode": "manual",
-    "workbench.startupEditor": "none",
-    "workbench.editor.enablePreview": false,
-    // === ⚡ PERFORMANCE ===
-    "files.watcherExclude": {
-      "**/__pycache__/**": true,
-      "**/.mypy_cache/**": true,
-      "**/.pytest_cache/**": true,
-      "**/.venv/**": true,
-      "**/venv/**": true,
-      "**/.git/**": true
-    },
-    "search.exclude": {
-      "**/__pycache__": true,
-      "**/.git": true,
-      "**/.mypy_cache": true,
-      "**/.pytest_cache": true
-    },
-    // === 🐍 PYTHON ===
-    "python.defaultInterpreterPath": "D:/IIS/Orius/api/venv/Scripts/python.exe",
-    "python.languageServer": "Pylance",
-    "python.analysis.autoImportCompletions": true,
-    "python.analysis.indexing": true,
-    "python.analysis.typeCheckingMode": "basic",
-    "python.analysis.useLibraryCodeForTypes": true,
-    "python.analysis.memory.keepLibraryAst": false,
-    // === 🧹 FORMATADOR ===
-    "python.formatting.provider": "black",
-    "python.formatting.blackArgs": [
-      "--line-length",
-      "100"
-    ],
-    // === ✅ LINTING ===
-    "python.linting.enabled": true,
-    "python.linting.pylintEnabled": false,
-    "python.linting.flake8Enabled": true,
-    "python.linting.flake8Args": [
-      "--max-line-length=100"
-    ],
-    // === 🧩 FORMATAÇÃO LOCAL ===
-    "[python]": {
-      "editor.defaultFormatter": "ms-python.black-formatter",
-      "editor.formatOnSave": true
-    },
-    // === 🧠 GIT ===
-    "git.enabled": true,
-    "git.autorefresh": true,
-    "git.confirmSync": false,
-    "git.fetchOnPull": true,
-    "git.countBadge": "tracked",
-    "git.pruneOnFetch": true,
-    "git.postCommitCommand": "sync",
-    "git.openDiffOnClick": true,
-    "git.decorations.enabled": true,
-    // === 🔍 GITLENS ===
-    "gitlens.advanced.messages": {
-      "suppressShowKeyBindingsNotice": true
-    },
-    "gitlens.codeLens.enabled": false,
-    "gitlens.currentLine.enabled": false,
-    "gitlens.hovers.enabled": true,
-    "gitlens.views.repositories.autoRefresh": true,
-    "gitlens.views.repositories.location": "scm",
-    "gitlens.defaultDateFormat": "DD/MM/YYYY HH:mm",
-    "gitlens.defaultDateShortFormat": "DD/MM HH:mm",
-    "gitlens.statusBar.enabled": true,
-    // === 💻 TERMINAIS INTEGRADOS ===
-    "terminal.integrated.profiles.windows": {
-      "FastAPI Dev": {
-        "path": "cmd.exe",
-        "args": [
-          "/k",
-          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate && uvicorn main:app --reload --log-level debug"
-        ]
-      },
-      "FastAPI Prod": {
-        "path": "cmd.exe",
-        "args": [
-          "/k",
-          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate && uvicorn main:app --host 0.0.0.0 --port 8000"
-        ]
-      },
-      "FastAPI Test": {
-        "path": "cmd.exe",
-        "args": [
-          "/k",
-          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate && pytest -v"
-        ]
-      },
-      "Python Shell": {
-        "path": "cmd.exe",
-        "args": [
-          "/k",
-          "cd D:\\IIS\\Orius\\api && venv\\Scripts\\activate"
-        ]
-      },
-      "Git Bash": {
-        "path": "C:\\Program Files\\Git\\bin\\bash.exe"
-      }
-    },
-    "terminal.integrated.defaultProfile.windows": "FastAPI Dev",
-    "terminal.integrated.scrollback": 10000,
-    "terminal.integrated.enablePersistentSessions": false,
-    // === 🧪 TESTES ===
-    "python.testing.pytestEnabled": true,
-    "python.testing.unittestEnabled": false,
-    "python.testing.autoTestDiscoverOnSaveEnabled": true,
-    // === 🗂️ ARQUIVOS ===
-    "files.exclude": {
-      "**/.DS_Store": true,
-      "**/*.log": true
-    }
-  },
-  "launch": {
-    "version": "0.2.0",
-    "configurations": [
-      {
-        "name": "Debug FastAPI",
-        "type": "python",
-        "request": "launch",
-        "module": "uvicorn",
-        "args": [
-          "main:app",
-          "--reload",
-          "--host",
-          "127.0.0.1",
-          "--port",
-          "8000"
-        ],
-        "jinja": true,
-        "justMyCode": true,
-        "cwd": "${workspaceFolder}",
-        "env": {
-          "PYTHONPATH": "${workspaceFolder}"
-        }
-      },
-      {
-        "name": "Pytest All",
-        "type": "python",
-        "request": "launch",
-        "program": "${workspaceFolder}/venv/Scripts/pytest.exe",
-        "args": [
-          "-v"
-        ],
-        "console": "integratedTerminal"
-      }
-    ]
-  },
-  "extensions": {
-    "recommendations": [
-      // === 🐍 PYTHON ===
-      "ms-python.python",
-      "ms-python.pylance",
-      "ms-python.black-formatter",
-      "ms-python.flake8",
-      "littlefoxteam.vscode-python-test-adapter",
-      // === 🔍 GIT ===
-      "eamodio.gitlens",
-      "mhutchie.git-graph",
-      "donjayamanne.githistory",
-      // === 🧰 UTILITÁRIOS ===
-      "formulahendry.code-runner",
-      "streetsidesoftware.code-spell-checker",
-      "tamasfe.even-better-toml"
-    ]
-  }
-}
--- a/config/database/firebird.json
+++ b/config/database/firebird.json
@ -1,13 +0,0 @@
-{
-  "host": "localhost",
-  "name": "/database/BASE.FDB",
-  "port": 3050,
-  "user": "SYSDBA",
-  "password": "302b3c",
-  "charset": "UTF8",
-  "pool" : {
-    "pre_ping" : true,
-    "size" : 5,
-    "max_overflow" :10
-  }
-}
--- a/database/firebird.py
+++ b/database/firebird.py
@ -1,7 +1,8 @@
 from typing import Optional
 from sqlalchemy import create_engine
 from sqlalchemy.engine import Engine
-from actions.env.env_config_loader import EnvConfigLoader
+
+from actions.config.config import Config


 class Firebird:
@ -9,29 +10,28 @@ class Firebird:

    @classmethod
    def get_engine(cls) -> Engine:
-
-        # Instancia o loader com o prefixo correto
-        env_database = EnvConfigLoader(".env")
+        # Obtem as configurações do arquivo JSON
+        database = Config.get('database/firebird.json')

        # Cria a engine apenas uma vez
        if cls._engine is None:

            # DSN para o SQLAlchemy usando firebird-driver
            dsn = (
-                f"firebird+firebird://{env_database.ORIUS_API_FDB_USER}:"
-                f"{env_database.ORIUS_API_FDB_PASSWORD}@"
-                f"{env_database.ORIUS_API_FDB_HOST}:"
-                f"{env_database.ORIUS_API_FDB_PORT}/"
-                f"{env_database.ORIUS_API_FDB_NAME}"
+                f"firebird+firebird://{database.user}:"
+                f"{database.password}@"
+                f"{database.host}:"
+                f"{database.port}/"
+                f"{database.name}"
            )

            # Criação da engine SQLAlchemy
            cls._engine = create_engine(
                dsn,
-                connect_args={"charset": env_database.ORIUS_API_FDB_CHARSET},
-                pool_pre_ping=bool(env_database.ORIUS_API_FDB_POOL_PRE_PING),
-                pool_size=int(env_database.ORIUS_API_FDB_POOL_SIZE),
-                max_overflow=int(env_database.ORIUS_API_FDB_POOL_MAX_OVERFLOW),
+                connect_args={"charset": database.charset},
+                pool_pre_ping=bool(database.pool.pre_ping),
+                pool_size=database.pool.size,
+                max_overflow=database.pool.max_overflow,
            )

        return cls._engine
--- a/env.bat
+++ b/env.bat
@ -1,17 +0,0 @@
-@echo off
-echo === Registrando variáveis de ambiente ORIUS_API ===
-
-setx ORIUS_API_FDB_HOST "localhost"
-setx ORIUS_API_FDB_NAME "S:\Bases\SANTARITA.FDB"
-setx ORIUS_API_FDB_PORT "3050"
-setx ORIUS_API_FDB_USER "SYSDBA"
-setx ORIUS_API_FDB_PASSWORD "302b3c"
-setx ORIUS_API_FDB_CHARSET "UTF8"
-setx ORIUS_API_FDB_POOL_PRE_PING "true"
-setx ORIUS_API_FDB_POOL_SIZE "5"
-setx ORIUS_API_FDB_POOL_MAX_OVERFLOW "10"
-
-echo.
-echo Variáveis ORIUS_API registradas com sucesso!
-echo Reinicie o terminal ou o computador para aplicar as alterações.
-pause
--- a/interfaces/service_protocols.py
+++ b/interfaces/service_protocols.py
@ -1,10 +0,0 @@
-from typing import Protocol, Any, runtime_checkable
-
-
-@runtime_checkable
-class ServiceProtocolsInterface(Protocol):
-    """
-    Contrato que garante que todo serviço tenha um método execute.
-    """
-
-    def execute(self, schema: Any) -> Any: ...
--- a/main.py
+++ b/main.py
@ -1,46 +1,32 @@
 # Ajuste para garantir que o diretório base do projeto seja incluído no PYTHONPATH
 import os
-import platform
 import sys

-from starlette.middleware.sessions import SessionMiddleware
-
 # Adiciona o diretório atual (onde está o main.py) ao sys.path
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-from firebird.driver import driver_config
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))

 # Importa a classe principal do FastAPI
 from fastapi import FastAPI, Request
 from pathlib import Path
-
 # Importa o middleware de CORS
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
+from fastapi.responses import Response
+from starlette.middleware.base import BaseHTTPMiddleware

 # Importa o roteador principal da API versão 1
 from packages.v1.api import api_router
-from packages.v1.system.service.startup_check_service import StartupCheckService
+from packages.v1.system.service.startup_check_service import \
+    StartupCheckService

 # Importa as configurações globais da aplicação
 from actions.log.log import Log
 from actions.config.config import Config
 from actions.system.handlers import register_exception_handlers

-if platform.system() == "Windows":
-
-    # Ajuste o caminho abaixo para onde o Firebird está instalado:
-    FB_DIR = r"C:\Program Files\Firebird\Firebird_4_0"
-    os.add_dll_directory(FB_DIR)
-
-    driver_config.fb_client_library.value = (
-        r"C:\Program Files\Firebird\Firebird_4_0\fbclient.dll"
-    )
-
-config = Config.get("app.json")
+config = Config.get('app.json')

 # Instancia o app FastAPI com um título personalizado
-app = FastAPI(title="SAAS Orius")
+app = FastAPI(title='SAAS Orius')

 # Controle de erros personalizados
 register_exception_handlers(app)
@ -48,24 +34,12 @@ register_exception_handlers(app)
 # Adiciona o middleware de CORS
 app.add_middleware(
    CORSMiddleware,
-    allow_origins=["*"],  # Domínio do frontend
+    allow_origins=["http://localhost:3000"],  # Domínio do frontend
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
 )

-app.add_middleware(
-    SessionMiddleware,
-    secret_key="coloque-uma-secret-bem-grande-e-aleatoria",
-    session_cookie="sid",
-    same_site="lax",
-    https_only=True,
-    max_age=60 * 60 * 8,
-)
-
-app.mount(path="/temp", app=StaticFiles(directory="./storage/temp"), name="temp")
-
-
@app.on_event("startup")
 async def on_startup():

@ -75,21 +49,20 @@ async def on_startup():
    # Exibe o amarzenamento do servidor
    print(startupCheckService.execute())

-
@app.middleware("http")
 async def log_tempo_requisicao(request: Request, call_next):

-    # Ação responsavel por registrar o log de requisição
+    # Ação responsavel por registrar o log de requisição 
    log = Log()
-    config = Config.get("app.json")
+    config = Config.get('app.json')

    # Obtem os dados da requisição
    log_data = {
        "method": request.method,
        "url": str(request.url),
-        "headers": dict(request.headers),
+        "headers": dict(request.headers)
    }
-
+    
    # Gera o nome do arquivo
    file = Path(config.log.request.path) / config.log.request.name

@ -101,18 +74,16 @@ async def log_tempo_requisicao(request: Request, call_next):

    return response

-
 # Inclui as rotas da versão 1 da API com prefixo definido em settings (ex: /api/v1)
 app.include_router(api_router, prefix=config.url)

 # Executa o servidor com Uvicorn se este arquivo for executado diretamente
-if __name__ == "__main__":
+if __name__ == '__main__':
    import uvicorn
-
    uvicorn.run(
-        "main:app",  # Caminho do app para execução
-        host="0.0.0.0",  # Disponibiliza a aplicação externamente
-        port=8000,  # Porta padrão
-        log_level="info",  # Define o nível de log para desenvolvimento
-        reload=True,  # Ativa auto-reload durante desenvolvimento
+        "main:app",           # Caminho do app para execução
+        host="0.0.0.0",       # Disponibiliza a aplicação externamente
+        port=8000,            # Porta padrão
+        log_level='info',     # Define o nível de log para desenvolvimento
+        reload=True           # Ativa auto-reload durante desenvolvimento
    )
--- a/packages/v1/administrativo/actions/c_caixa_item/c_caixa_item_index_action.py
+++ b/packages/v1/administrativo/actions/c_caixa_item/c_caixa_item_index_action.py
@ -1,5 +1,7 @@
 from packages.v1.administrativo.repositories.c_caixa_item.c_caixa_item_index import \
    Index
+from packages.v1.administrativo.schemas.c_caixa_item_schema import \
+    CaixaItemSearchSchema
 from abstracts.action import BaseAction


--- a/packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_index_action.py
+++ b/packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_index_action.py
@ -1,8 +1,5 @@
 from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_index_repository import (
-    IndexRepository,
-)
-
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_index_repository import IndexRepository

 class IndexAction(BaseAction):

@ -15,4 +12,4 @@ class IndexAction(BaseAction):
        response = index_repository.execute()

        # Retorno da informação
-        return response
+        return response
--- a/packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_save_action.py
+++ b/packages/v1/administrativo/actions/c_caixa_servico/c_caixa_servico_save_action.py
@ -1,15 +1,11 @@
-from packages.v1.administrativo.schemas.c_caixa_servico_schema import (
-    CCaixaServicoSaveSchema,
-)
-from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_save_repository import (
-    SaveRepository,
-)
+from packages.v1.administrativo.schemas.c_caixa_servico_schema import CCaixaServicoSaveSchema
+from packages.v1.administrativo.repositories.c_caixa_servico.c_caixa_servico_save_repository import SaveRepository


 class SaveAction:

-    def execute(self, usuario_schema: CCaixaServicoSaveSchema):
+    def execute(self, usuario_schema : CCaixaServicoSaveSchema):

        save_repository = SaveRepository()

-        return save_repository.execute(usuario_schema)
+        return save_repository.execute(usuario_schema)
--- a/packages/v1/administrativo/actions/g_cartorio/g_cartorio_delete_action.py
+++ b/packages/v1/administrativo/actions/g_cartorio/g_cartorio_delete_action.py
@ -1,35 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_delete_repository import (
-    GCartorioDeleteRepository,
-)
-from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioIdSchema
-
-
-class GCartorioDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela G_CARTORIO.
-    """
-
-    def execute(self, g_cartorio_id_schema: GCartorioIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            g_cartorio_id_schema (GCartorioIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_cartorio_delete_repository = GCartorioDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = g_cartorio_delete_repository.execute(g_cartorio_id_schema)
-
-        return response
--- a/packages/v1/administrativo/actions/g_cartorio/g_cartorio_index_action.py
+++ b/packages/v1/administrativo/actions/g_cartorio/g_cartorio_index_action.py
@ -1,37 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_index_repository import (
-    GCartorioIndexRepository,
-)
-
-
-class GCartorioIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Args:
-            g_cartorio_index_schema (GCartorioIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
-
-        Returns:
-            A lista de registros encontrados.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_cartorio_index_repository = GCartorioIndexRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_cartorio_index_repository.execute()
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # --------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_cartorio/g_cartorio_save_action.py
+++ b/packages/v1/administrativo/actions/g_cartorio/g_cartorio_save_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_save_repository import (
-    GCartorioSaveRepository,
-)
-from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioSaveSchema
-
-
-class GCartorioSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela G_GRAMATICA.
-    """
-
-    def execute(self, g_cartorio_save_schema: GCartorioSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            g_cartorio_schema (GCartorioSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_cartorio_save_repository = GCartorioSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_cartorio_save_repository.execute(g_cartorio_save_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_cartorio/g_cartorio_show_action.py
+++ b/packages/v1/administrativo/actions/g_cartorio/g_cartorio_show_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_show_repository import (
-    GCartorioShowRepository,
-)
-from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioIdSchema
-
-
-class GCartorioShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_cartorio_id_schema: GCartorioIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_cartorio_id_schema (GCartorioIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_cartorio_show_repository = GCartorioShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_cartorio_show_repository.execute(g_cartorio_id_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_cartorio/g_cartorio_update_action.py
+++ b/packages/v1/administrativo/actions/g_cartorio/g_cartorio_update_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_cartorio.g_cartorio_update_repository import (
-    GCartorioUpdateRepository,
-)
-from packages.v1.administrativo.schemas.g_cartorio_schema import GCartorioUpdateSchema
-
-
-class GCartorioUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_cartorio_update_schema: GCartorioUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            g_cartorio_update_schema (GCartorioUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        g_cartorio_update_repository = GCartorioUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_cartorio_update_repository.execute(g_cartorio_update_schema)
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento/g_emolumento_delete_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento/g_emolumento_delete_action.py
@ -1,35 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_delete_repository import (
-    GEmolumentoDeleteRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_schema import GEmolumentoIdSchema
-
-
-class GEmolumentoDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela G_EMOLUMENTO.
-    """
-
-    def execute(self, g_emolumento_id_schema: GEmolumentoIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            g_emolumento_id_schema (GEmolumentoIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_delete_repository = GEmolumentoDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = g_emolumento_delete_repository.execute(g_emolumento_id_schema)
-
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento/g_emolumento_index_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento/g_emolumento_index_action.py
@ -0,0 +1,27 @@
+from abstracts.action import BaseAction
+from packages.v1.administrativo.schemas.g_emolumento_schema import GEmolumentoSistemaIdSchema
+
+# O repositório IndexRepository deve ser substituído pelo GEmolumentoIndexRepository.
+from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_index_repository import IndexRepository
+
+class IndexAction(BaseAction):
+    """
+    Serviço responsável por encapsular a lógica de negócio para a operação
+    de listagem de todos os registros na tabela G_EMOLUMENTO.
+    """
+
+    def execute(self, emolumento_schema: GEmolumentoSistemaIdSchema):
+        """
+        Executa a operação de listagem no banco de dados.
+
+        Returns:
+            A lista de todos os registros.
+        """
+        # Instanciamento do repositório
+        index_repository = IndexRepository()
+
+        # Execução do repositório
+        response = index_repository.execute(emolumento_schema)
+
+        # Retorno da informação
+        return response
--- a/packages/v1/administrativo/actions/g_emolumento/g_emolumento_index_by_sistema_id_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento/g_emolumento_index_by_sistema_id_action.py
@ -1,44 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_index_by_sistema_id_repository import (
-    GEmolumentoIndexBySistemaIdRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_schema import (
-    GEmolumentoSistemaIdSchema,
-)
-
-
-class GEmolumentoIndexBySistemaIdAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_emolumento_sistema_id_schema: GEmolumentoSistemaIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_emolumento_id_schema (GEmolumentoIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_index_by_sistema_id_repository = (
-            GEmolumentoIndexBySistemaIdRepository()
-        )
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_index_by_sistema_id_repository.execute(
-            g_emolumento_sistema_id_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento/g_emolumento_save_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento/g_emolumento_save_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_save_repository import (
-    GEmolumentoSaveRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_schema import GEmolumentoSaveSchema
-
-
-class GEmolumentoSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela G_EMOLUMENTO.
-    """
-
-    def execute(self, g_emolumento_save_schema: GEmolumentoSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            g_emolumento_schema (GEmolumentoSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_save_repository = GEmolumentoSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_save_repository.execute(g_emolumento_save_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento/g_emolumento_show_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento/g_emolumento_show_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_show_repository import (
-    GEmolumentoShowRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_schema import GEmolumentoIdSchema
-
-
-class GEmolumentoShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_emolumento_id_schema: GEmolumentoIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_emolumento_id_schema (GEmolumentoIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_show_repository = GEmolumentoShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_show_repository.execute(g_emolumento_id_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento/g_emolumento_update_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento/g_emolumento_update_action.py
@ -1,40 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento.g_emolumento_update_repository import (
-    GEmolumentoUpdateRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_schema import (
-    GEmolumentoUpdateSchema,
-)
-
-
-class GEmolumentoUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_emolumento_update_schema: GEmolumentoUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            g_emolumento_update_schema (GEmolumentoUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        g_emolumento_update_repository = GEmolumentoUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_update_repository.execute(g_emolumento_update_schema)
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_delete_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_delete_action.py
@ -1,39 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_delete_repository import (
-    GEmolumentoItemDeleteRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
-    GEmolumentoItemIdSchema,
-)
-
-
-class GEmolumentoItemDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela G_EMOLUMENTO_ITEM.
-    """
-
-    def execute(self, g_emolumento_item_id_schema: GEmolumentoItemIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            g_emolumento_item_id_schema (GEmolumentoItemIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_item_delete_repository = GEmolumentoItemDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = g_emolumento_item_delete_repository.execute(
-            g_emolumento_item_id_schema
-        )
-
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_get_faixa_valor_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_get_faixa_valor_action.py
@ -1,74 +0,0 @@
-from __future__ import annotations
-
-from decimal import Decimal
-from typing import Iterable, Optional, Protocol, Any
-
-
-class EmolumentoItemLike(Protocol):
-    """Protocolo mínimo esperado para um item de emolumento."""
-
-    valor_inicio: Optional[Decimal]
-    valor_fim: Optional[Decimal]
-
-
-class GEmolumentoItemGetFaixaValorAction:
-    """
-    Responsável por escolher, dentre uma coleção de itens de emolumento,
-    aquele cuja faixa [valor_inicio, valor_fim] contem o valor_documento.
-    - Se houver mais de um candidato, prioriza o de maior valor_inicio (faixa mais específica).
-    - Se não houver faixa que contenha o valor_documento, tenta a faixa 'aberta' (valor_fim nulo).
-    - Persistindo a ausência, retorna o item cujo valor_inicio é o mais próximo abaixo do valor_documento.
-    """
-
-    @staticmethod
-    def _para_decimal(valor: Any, padrao: str = "0") -> Decimal:
-        return valor if isinstance(valor, Decimal) else Decimal(str(valor or padrao))
-
-    def execute(
-        self,
-        itens: Iterable[EmolumentoItemLike],
-        valor_documento: Decimal,
-    ) -> EmolumentoItemLike:
-        lista = list(itens)
-        if not lista:
-            raise ValueError("Nenhum item de emolumento foi informado.")
-
-        valor_doc = self._para_decimal(valor_documento)
-
-        candidatos: list[tuple[Decimal, Decimal, EmolumentoItemLike]] = []
-        abertos: list[tuple[Decimal, EmolumentoItemLike]] = []
-        abaixo: list[tuple[Decimal, EmolumentoItemLike]] = []
-
-        for item in lista:
-            ini = self._para_decimal(getattr(item, "valor_inicio", None))
-            fim_raw = getattr(item, "valor_fim", None)
-            fim = (
-                self._para_decimal(fim_raw, padrao="Infinity")
-                if fim_raw is not None
-                else Decimal("Infinity")
-            )
-
-            if ini <= valor_doc <= fim:
-                candidatos.append((ini, fim, item))
-            elif fim == Decimal("Infinity") and ini <= valor_doc:
-                abertos.append((ini, item))
-            elif ini <= valor_doc:
-                abaixo.append((ini, item))
-
-        if candidatos:
-            candidatos.sort(key=lambda t: (t[0], t[1]))  # maior ini e menor fim
-            return candidatos[-1][2]
-
-        if abertos:
-            abertos.sort(key=lambda t: t[0])  # maior ini
-            return abertos[-1][1]
-
-        if abaixo:
-            abaixo.sort(key=lambda t: t[0])  # maior ini
-            return abaixo[-1][1]
-
-        # Fallback: não há faixa adequada nem valores abaixo; devolve o de menor valor_inicio
-        lista_ordenada = sorted(
-            lista, key=lambda it: self._para_decimal(getattr(it, "valor_inicio", None))
-        )
-        return lista_ordenada[0]
--- a/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_index_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_index_action.py
@ -1,44 +1,44 @@
 from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_index_repository import (
-    GEmolumentoItemIndexRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
-    GEmolumentoItemIndexSchema,
-)
+# O Schema precisa ser adaptado para GEmolumentoItem, talvez recebendo um ID de Emolumento
+# ou um ID do próprio Item, dependendo da necessidade de listagem.
+# Vamos sugerir um Schema específico para a listagem (Index) que pode receber um Emolumento ID
+# para listar todos os seus itens, mantendo o padrão do arquivo original que usava um 'SistemaIdSchema'.
+# Para simplificar, vamos assumir um schema de filtro ou um schema base para Index.
+# Sugerimos a criação de:
+# from packages.v1.administrativo.schemas.g_emolumento_item_schema import GEmolumentoItemIndexSchema 
+# (ou GEmolumentoItemEmolumentoIdSchema se for o padrão da aplicação)
+from packages.v1.administrativo.schemas.g_emolumento_item_schema import GEmolumentoItemEmolumentoIdSchema 

+# O repositório IndexRepository deve ser substituído pelo GEmolumentoItemIndexRepository.
+from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_index_repository import IndexRepository

-class GEmolumentoItemIndexAction(BaseAction):
+class IndexAction(BaseAction):
    """
    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
+    de listagem de todos os registros na tabela G_EMOLUMENTO_ITEM,
+    utilizando a DDL fornecida.
    """

-    def execute(
-        self, g_emolumento_item_emolumento_index_schema: GEmolumentoItemIndexSchema
-    ):
+    # Mantendo o padrão de nome de método do arquivo original
+    def execute(self, emolumento_item_schema: GEmolumentoItemEmolumentoIdSchema):
        """
-        Executa a operação de listagem no banco de dados.
+        Executa a operação de listagem de G_EMOLUMENTO_ITEM no banco de dados.

        Args:
-            g_emolumento_item_index_schema (GEmolumentoItemIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
+            emolumento_item_schema: Esquema com parâmetros de filtro/listagem
+                                    (por exemplo, ID do Emolumento pai, se a listagem for
+                                    filtrada por ele, ou parâmetros de paginação).

        Returns:
-            A lista de registros encontrados.
+            A lista de todos os registros de G_EMOLUMENTO_ITEM que satisfazem o filtro.
        """
-        # ----------------------------------------------------
        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_item_index_repository = GEmolumentoItemIndexRepository()
+        # O nome do repositório foi adaptado com o prefixo 'GEmolumentoItem'
+        index_repository = IndexRepository()

-        # ----------------------------------------------------
        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_item_index_repository.execute(
-            g_emolumento_item_emolumento_index_schema
-        )
+        # O nome do parâmetro foi adaptado para 'emolumento_item_schema'
+        response = index_repository.execute(emolumento_item_schema)

-        # ----------------------------------------------------
        # Retorno da informação
-        # --------------------------------
-        return response
+        return response
--- a/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_save_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_save_action.py
@ -1,36 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_save_repository import GEmolumentoItemSaveRepository
-from packages.v1.administrativo.schemas.g_emolumento_item_schema import GEmolumentoItemSaveSchema
-
-
-class GEmolumentoItemSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela G_EMOLUMENTO_ITEM.
-    """
-
-    def execute(self, g_emolumento_item_save_schema: GEmolumentoItemSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            g_emolumento_item_schema (GEmolumentoItemSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_item_save_repository = GEmolumentoItemSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_item_save_repository.execute(g_emolumento_item_save_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_show_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_show_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_show_repository import (
-    GEmolumentoItemShowRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
-    GEmolumentoItemIdSchema,
-)
-
-
-class GEmolumentoItemShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_emolumento_item_id_schema: GEmolumentoItemIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_emolumento_item_id_schema (GEmolumentoItemIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_item_show_repository = GEmolumentoItemShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_item_show_repository.execute(
-            g_emolumento_item_id_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_update_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_item/g_emolumento_item_update_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_item.g_emolumento_item_update_repository import (
-    GEmolumentoItemUpdateRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_item_schema import (
-    GEmolumentoItemUpdateSchema,
-)
-
-
-class GEmolumentoItemUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_emolumento_item_update_schema: GEmolumentoItemUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            g_emolumento_item_update_schema (GEmolumentoItemUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        g_emolumento_item_update_repository = GEmolumentoItemUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_item_update_repository.execute(
-            g_emolumento_item_update_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_delete_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_delete_action.py
@ -1,39 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_delete_repository import (
-    GEmolumentoPeriodoDeleteRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
-    GEmolumentoPeriodoIdSchema,
-)
-
-
-class GEmolumentoPeriodoDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela G_EMOLUMENTO_PERIODO.
-    """
-
-    def execute(self, g_emolumento_periodo_id_schema: GEmolumentoPeriodoIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            g_emolumento_periodo_id_schema (GEmolumentoPeriodoIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_periodo_delete_repository = GEmolumentoPeriodoDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = g_emolumento_periodo_delete_repository.execute(
-            g_emolumento_periodo_id_schema
-        )
-
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_index_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_index_action.py
@ -1,37 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_index_repository import (
-    GEmolumentoPeriodoIndexRepository,
-)
-
-
-class GEmolumentoPeriodoIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Args:
-            g_emolumento_periodo_index_schema (GEmolumentoPeriodoIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
-
-        Returns:
-            A lista de registros encontrados.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_periodo_index_repository = GEmolumentoPeriodoIndexRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_periodo_index_repository.execute()
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # --------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_save_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_save_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_save_repository import (
-    GEmolumentoPeriodoSaveRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
-    GEmolumentoPeriodoSaveSchema,
-)
-
-
-class GEmolumentoPeriodoSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela G_GRAMATICA.
-    """
-
-    def execute(self, g_emolumento_periodo_save_schema: GEmolumentoPeriodoSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            g_emolumento_periodo_schema (GEmolumentoPeriodoSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_periodo_save_repository = GEmolumentoPeriodoSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_periodo_save_repository.execute(
-            g_emolumento_periodo_save_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_show_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_show_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_show_repository import (
-    GEmolumentoPeriodoShowRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
-    GEmolumentoPeriodoIdSchema,
-)
-
-
-class GEmolumentoPeriodoShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_emolumento_periodo_id_schema: GEmolumentoPeriodoIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_emolumento_periodo_id_schema (GEmolumentoPeriodoIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_emolumento_periodo_show_repository = GEmolumentoPeriodoShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_periodo_show_repository.execute(
-            g_emolumento_periodo_id_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_update_action.py
+++ b/packages/v1/administrativo/actions/g_emolumento_periodo/g_emolumento_periodo_update_action.py
@ -1,44 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_emolumento_periodo.g_emolumento_periodo_update_repository import (
-    GEmolumentoPeriodoUpdateRepository,
-)
-from packages.v1.administrativo.schemas.g_emolumento_periodo_schema import (
-    GEmolumentoPeriodoUpdateSchema,
-)
-
-
-class GEmolumentoPeriodoUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(
-        self, g_emolumento_periodo_update_schema: GEmolumentoPeriodoUpdateSchema
-    ):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            g_emolumento_periodo_update_schema (GEmolumentoPeriodoUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        g_emolumento_periodo_update_repository = GEmolumentoPeriodoUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_emolumento_periodo_update_repository.execute(
-            g_emolumento_periodo_update_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_gramatica/g_gramatica_delete_action.py
+++ b/packages/v1/administrativo/actions/g_gramatica/g_gramatica_delete_action.py
@ -1,35 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_delete_repository import (
-    GGramaticaDeleteRepository,
-)
-from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaIdSchema
-
-
-class GGramaticaDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela G_GRAMATICA.
-    """
-
-    def execute(self, g_gramatica_id_schema: GGramaticaIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            g_gramatica_id_schema (GGramaticaIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_gramatica_delete_repository = GGramaticaDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = g_gramatica_delete_repository.execute(g_gramatica_id_schema)
-
-        return response
--- a/packages/v1/administrativo/actions/g_gramatica/g_gramatica_index_action.py
+++ b/packages/v1/administrativo/actions/g_gramatica/g_gramatica_index_action.py
@ -1,37 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_index_repository import (
-    GGramaticaIndexRepository,
-)
-
-
-class GGramaticaIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Args:
-            g_gramatica_index_schema (GGramaticaIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
-
-        Returns:
-            A lista de registros encontrados.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_gramatica_index_repository = GGramaticaIndexRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_gramatica_index_repository.execute()
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # --------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_gramatica/g_gramatica_save_action.py
+++ b/packages/v1/administrativo/actions/g_gramatica/g_gramatica_save_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_save_repository import (
-    GGramaticaSaveRepository,
-)
-from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaSaveSchema
-
-
-class GGramaticaSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela G_GRAMATICA.
-    """
-
-    def execute(self, g_gramatica_save_schema: GGramaticaSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            g_gramatica_schema (GGramaticaSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_gramatica_save_repository = GGramaticaSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_gramatica_save_repository.execute(g_gramatica_save_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_gramatica/g_gramatica_show_action.py
+++ b/packages/v1/administrativo/actions/g_gramatica/g_gramatica_show_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_show_repository import (
-    GGramaticaShowRepository,
-)
-from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaIdSchema
-
-
-class GGramaticaShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_gramatica_id_schema: GGramaticaIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_gramatica_id_schema (GGramaticaIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_gramatica_show_repository = GGramaticaShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_gramatica_show_repository.execute(g_gramatica_id_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_gramatica/g_gramatica_update_action.py
+++ b/packages/v1/administrativo/actions/g_gramatica/g_gramatica_update_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_gramatica.g_gramatica_update_repository import (
-    GGramaticaUpdateRepository,
-)
-from packages.v1.administrativo.schemas.g_gramatica_schema import GGramaticaUpdateSchema
-
-
-class GGramaticaUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_gramatica_update_schema: GGramaticaUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            g_gramatica_update_schema (GGramaticaUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        g_gramatica_update_repository = GGramaticaUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_gramatica_update_repository.execute(g_gramatica_update_schema)
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_natureza/g_natureza_delete_action.py
+++ b/packages/v1/administrativo/actions/g_natureza/g_natureza_delete_action.py
@ -1,26 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaIdSchema
-from packages.v1.administrativo.repositories.g_natureza.g_natureza_delete_repository import DeleteRepository
-
-
-class DeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela g_natureza.
-    """
-
-    def execute(self, natureza_schema: GNaturezaIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            natureza_schema (GNaturezaIdSchema): O esquema com o ID a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # Instanciamento do repositório
-        delete_repository = DeleteRepository()
-
-        # Execução do repositório
-        return delete_repository.execute(natureza_schema)
--- a/packages/v1/administrativo/actions/g_natureza/g_natureza_get_by_descricao_action.py
+++ b/packages/v1/administrativo/actions/g_natureza/g_natureza_get_by_descricao_action.py
@ -1,29 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaDescricaoSchema
-from packages.v1.administrativo.repositories.g_natureza.g_natureza_get_by_descricao_repository import GetByDescricaoRepository
-
-
-class GetByDescricaoAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de busca de um registro na tabela g_natureza por descrição.
-    """
-
-    def execute(self, natureza_schema: GNaturezaDescricaoSchema):
-        """
-        Executa a operação de busca no banco de dados.
-
-        Args:
-            natureza_schema (GNaturezaDescricaoSchema): O esquema com a descrição a ser buscada.
-
-        Returns:
-            O registro encontrado ou None.
-        """
-        # Instanciamento do repositório
-        show_repository = GetByDescricaoRepository()
-
-        # Execução do repositório
-        response = show_repository.execute(natureza_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_natureza/g_natureza_index_action.py
+++ b/packages/v1/administrativo/actions/g_natureza/g_natureza_index_action.py
@ -1,24 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_natureza.g_natureza_index_repository import IndexRepository
-
-class IndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela g_natureza.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Returns:
-            A lista de todos os registros.
-        """
-        # Instanciamento do repositório
-        index_repository = IndexRepository()
-
-        # Execução do repositório
-        response = index_repository.execute()
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_natureza/g_natureza_index_by_sistema_id_action.py
+++ b/packages/v1/administrativo/actions/g_natureza/g_natureza_index_by_sistema_id_action.py
@ -1,30 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_natureza.g_natureza_index_by_sistema_id_repository import (
-    IndexBySistemaIdRepository,
-)
-from packages.v1.administrativo.schemas.g_natureza_schema import (
-    GNaturezaSistemaIdSchema,
-)
-
-
-class IndexActionBySistemaId(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela g_natureza.
-    """
-
-    def execute(self, g_natureza_sistema_id_schema: GNaturezaSistemaIdSchema):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Returns:
-            A lista de todos os registros.
-        """
-        # Instanciamento do repositório
-        index_repository = IndexBySistemaIdRepository()
-
-        # Execução do repositório
-        response = index_repository.execute(g_natureza_sistema_id_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_natureza/g_natureza_save_action.py
+++ b/packages/v1/administrativo/actions/g_natureza/g_natureza_save_action.py
@ -1,28 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaSaveSchema
-from packages.v1.administrativo.repositories.g_natureza.g_natureza_save_repository import SaveRepository
-
-class SaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvar um novo registro na tabela g_natureza.
-    """
-
-    def execute(self, natureza_schema: GNaturezaSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            natureza_schema (GNaturezaSaveSchema): O esquema com os dados a serem salvos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # Instanciamento do repositório
-        save_repository = SaveRepository()
-
-        # Execução do repositório
-        response = save_repository.execute(natureza_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_natureza/g_natureza_show_action.py
+++ b/packages/v1/administrativo/actions/g_natureza/g_natureza_show_action.py
@ -1,28 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaIdSchema
-from packages.v1.administrativo.repositories.g_natureza.g_natureza_show_repository import ShowRepository
-
-class ShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela g_natureza.
-    """
-
-    def execute(self, natureza_schema: GNaturezaIdSchema):
-        """
-        Executa a operação de exibição.
-        
-        Args:
-            natureza_schema (GNaturezaIdSchema): O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # Instânciamento do repositório
-        show_repository = ShowRepository()
-
-        # Execução do repositório
-        response = show_repository.execute(natureza_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_natureza/g_natureza_update_action.py
+++ b/packages/v1/administrativo/actions/g_natureza/g_natureza_update_action.py
@ -1,26 +0,0 @@
-from packages.v1.administrativo.schemas.g_natureza_schema import GNaturezaUpdateSchema
-from packages.v1.administrativo.repositories.g_natureza.g_natureza_update_repository import UpdateRepository
-
-
-class UpdateAction:
-    """
-        Service responsável por encapsular a lógica de negócio para a atualização
-        de um registro na tabela g_natureza.
-    """
-
-    def execute(self, natureza_id: int, natureza_schema: GNaturezaUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            natureza_id (int): O ID do registro a ser atualizado.
-            natureza_schema (GNaturezaUpdateSchema): O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # Instância o repositório de atualização
-        update_repository = UpdateRepository()
-
-        # Chama o método de execução do repositório para realizar a atualização
-        return update_repository.execute(natureza_id, natureza_schema)
--- a/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_delete_action.py
+++ b/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_delete_action.py
@ -1,39 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_delete_repository import (
-    GNaturezaTituloDeleteRepository,
-)
-from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
-    GNaturezaTituloIdSchema,
-)
-
-
-class GNaturezaTituloDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_natureza_titulo_id_schema: GNaturezaTituloIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            g_natureza_titulo_id_schema (GNaturezaTituloIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_natureza_titulo_delete_repository = GNaturezaTituloDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = g_natureza_titulo_delete_repository.execute(
-            g_natureza_titulo_id_schema
-        )
-
-        return response
--- a/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_index_action.py
+++ b/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_index_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_index_repository import (
-    GNaturezaTituloIndexRepository,
-)
-from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
-    GNaturezaTituloIndexSchema,
-)
-
-
-class GNaturezaTituloIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_natureza_titulo_index_schema: GNaturezaTituloIndexSchema):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Args:
-            g_natureza_titulo_index_schema (GNaturezaTituloIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
-
-        Returns:
-            A lista de registros encontrados.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_natureza_titulo_index_repository = GNaturezaTituloIndexRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_natureza_titulo_index_repository.execute(
-            g_natureza_titulo_index_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # --------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_save_action.py
+++ b/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_save_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_save_repository import (
-    GNaturezaTituloSaveRepository,
-)
-from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
-    GNaturezaTituloSaveSchema,
-)
-
-
-class GNaturezaTituloSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_natureza_titulo_save_schema: GNaturezaTituloSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            g_natureza_titulo_schema (GNaturezaTituloSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_natureza_titulo_save_repository = GNaturezaTituloSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_natureza_titulo_save_repository.execute(
-            g_natureza_titulo_save_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_show_action.py
+++ b/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_show_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_show_repository import (
-    GNaturezaTituloShowRepository,
-)
-from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
-    GNaturezaTituloIdSchema,
-)
-
-
-class GNaturezaTituloShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_natureza_titulo_id_schema: GNaturezaTituloIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_natureza_titulo_id_schema (GNaturezaTituloIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_natureza_titulo_show_repository = GNaturezaTituloShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_natureza_titulo_show_repository.execute(
-            g_natureza_titulo_id_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_update_action.py
+++ b/packages/v1/administrativo/actions/g_natureza_titulo/g_natureza_titulo_update_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_natureza_titulo.g_natureza_titulo_update_repository import (
-    GNaturezaTituloUpdateRepository,
-)
-from packages.v1.administrativo.schemas.g_natureza_titulo_schema import (
-    GNaturezaTituloUpdateSchema,
-)
-
-
-class GNaturezaTituloUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_natureza_titulo_update_schema: GNaturezaTituloUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            g_natureza_titulo_update_schema (GNaturezaTituloUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        g_natureza_titulo_update_repository = GNaturezaTituloUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_natureza_titulo_update_repository.execute(
-            g_natureza_titulo_update_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_delete_action.py
+++ b/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_delete_action.py
@ -1,35 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_delete_repository import (
-    GSeloGrupoDeleteRepository,
-)
-from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoIdSchema
-
-
-class GSeloGrupoDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela G_SELO_GRUPO.
-    """
-
-    def execute(self, g_selo_grupo_id_schema: GSeloGrupoIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            g_selo_grupo_id_schema (GSeloGrupoIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_selo_grupo_delete_repository = GSeloGrupoDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = g_selo_grupo_delete_repository.execute(g_selo_grupo_id_schema)
-
-        return response
--- a/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_index_action.py
+++ b/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_index_action.py
@ -1,37 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_index_repository import (
-    GSeloGrupoIndexRepository,
-)
-
-
-class GSeloGrupoIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Args:
-            g_selo_grupo_index_schema (GSeloGrupoIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
-
-        Returns:
-            A lista de registros encontrados.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_selo_grupo_index_repository = GSeloGrupoIndexRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_selo_grupo_index_repository.execute()
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # --------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_save_action.py
+++ b/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_save_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_save_repository import (
-    GSeloGrupoSaveRepository,
-)
-from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoSaveSchema
-
-
-class GSeloGrupoSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela G_GRAMATICA.
-    """
-
-    def execute(self, g_selo_grupo_save_schema: GSeloGrupoSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            g_selo_grupo_schema (GSeloGrupoSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_selo_grupo_save_repository = GSeloGrupoSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_selo_grupo_save_repository.execute(g_selo_grupo_save_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_show_action.py
+++ b/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_show_action.py
@ -1,38 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_show_repository import (
-    GSeloGrupoShowRepository,
-)
-from packages.v1.administrativo.schemas.g_selo_grupo_schema import GSeloGrupoIdSchema
-
-
-class GSeloGrupoShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_selo_grupo_id_schema: GSeloGrupoIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            g_selo_grupo_id_schema (GSeloGrupoIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        g_selo_grupo_show_repository = GSeloGrupoShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_selo_grupo_show_repository.execute(g_selo_grupo_id_schema)
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_update_action.py
+++ b/packages/v1/administrativo/actions/g_selo_grupo/g_selo_grupo_update_action.py
@ -1,40 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_selo_grupo.g_selo_grupo_update_repository import (
-    GSeloGrupoUpdateRepository,
-)
-from packages.v1.administrativo.schemas.g_selo_grupo_schema import (
-    GSeloGrupoUpdateSchema,
-)
-
-
-class GSeloGrupoUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, g_selo_grupo_update_schema: GSeloGrupoUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            g_selo_grupo_update_schema (GSeloGrupoUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        g_selo_grupo_update_repository = GSeloGrupoUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = g_selo_grupo_update_repository.execute(g_selo_grupo_update_schema)
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_delete_action.py
+++ b/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_delete_action.py
@ -1,26 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoIdSchema
-from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_delete_repository import DeleteRepository
-
-
-class DeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela g_tb_documentotipo.
-    """
-
-    def execute(self, documento_tipo_schema: GTbDocumentoTipoIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            documento_tipo_schema (GTbDocumentoTipoIdSchema): O esquema com o ID a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # Instanciamento do repositório
-        delete_repository = DeleteRepository()
-
-        # Execução do repositório
-        return delete_repository.execute(documento_tipo_schema)
--- a/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_get_by_descricao_action.py
+++ b/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_get_by_descricao_action.py
@ -1,29 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoDescricaoSchema
-from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_get_by_descricao_repository import GetByDescricaoRepository
-
-
-class GetByDescricaoAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de busca de um registro na tabela g_tb_documentotipo por descrição.
-    """
-
-    def execute(self, documento_tipo_schema: GTbDocumentoTipoDescricaoSchema):
-        """
-        Executa a operação de busca no banco de dados.
-
-        Args:
-            documento_tipo_schema (GTbDocumentoTipoDescricaoSchema): O esquema com a descrição a ser buscada.
-
-        Returns:
-            O registro encontrado ou None.
-        """
-        # Instanciamento do repositório
-        show_repository = GetByDescricaoRepository()
-
-        # Execução do repositório
-        response = show_repository.execute(documento_tipo_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_index_action.py
+++ b/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_index_action.py
@ -1,24 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_index_repository import IndexRepository
-
-class IndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela g_tb_documentotipo.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Returns:
-            A lista de todos os registros.
-        """
-        # Instanciamento do repositório
-        index_repository = IndexRepository()
-
-        # Execução do repositório
-        response = index_repository.execute()
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_save_action.py
+++ b/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_save_action.py
@ -1,28 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoSaveSchema
-from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_save_repository import SaveRepository
-
-class SaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvar um novo registro na tabela g_tb_documentotipo.
-    """
-
-    def execute(self, documento_tipo_schema: GTbDocumentoTipoSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            documento_tipo_schema (GTbDocumentoTipoSaveSchema): O esquema com os dados a serem salvos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # Instanciamento do repositório
-        save_repository = SaveRepository()
-
-        # Execução do repositório
-        response = save_repository.execute(documento_tipo_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_show_action.py
+++ b/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_show_action.py
@ -1,28 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoIdSchema
-from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_show_repository import ShowRepository
-
-class ShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela g_tb_documentotipo.
-    """
-
-    def execute(self, documento_tipo_schema: GTbDocumentoTipoIdSchema):
-        """
-        Executa a operação de exibição.
-        
-        Args:
-            documento_tipo_schema (GTbDocumentoTipoIdSchema): O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # Instanciamento do repositório
-        show_repository = ShowRepository()
-
-        # Execução do repositório
-        response = show_repository.execute(documento_tipo_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_update_action.py
+++ b/packages/v1/administrativo/actions/g_tb_documentotipo/g_tb_documentotipo_update_action.py
@ -1,26 +0,0 @@
-from packages.v1.administrativo.schemas.g_tb_documentotipo_schema import GTbDocumentoTipoUpdateSchema
-from packages.v1.administrativo.repositories.g_tb_documentotipo.g_tb_documentotipo_update_repository import UpdateRepository
-
-
-class UpdateAction:
-    """
-        Service responsável por encapsular a lógica de negócio para a atualização
-        de um registro na tabela g_tb_documentotipo.
-    """
-
-    def execute(self, documento_tipo_id: int, documento_tipo_schema: GTbDocumentoTipoUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            documento_tipo_id (int): O ID do registro a ser atualizado.
-            documento_tipo_schema (GTbDocumentoTipoUpdateSchema): O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # Instância o repositório de atualização
-        update_repository = UpdateRepository()
-
-        # Chama o método de execução do repositório para realizar a atualização
-        return update_repository.execute(documento_tipo_id, documento_tipo_schema)
--- a/packages/v1/administrativo/actions/g_usuario/g_usuario_get_by_authenticate_action.py
+++ b/packages/v1/administrativo/actions/g_usuario/g_usuario_get_by_authenticate_action.py
@ -1,15 +1,11 @@
 from abstracts.action import BaseAction
-from packages.v1.administrativo.schemas.g_usuario_schema import (
-    GUsuarioAuthenticateSchema,
-)
-from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_authenticate_repository import (
-    GetByAuthenticateRepository,
-)
+from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioAuthenticateSchema
+from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_authenticate_repository import GetByAuthenticateRepository


 class GetByAuthenticateAction(BaseAction):

-    def execute(self, g_usuario_authenticate_schema: GUsuarioAuthenticateSchema):
+    def execute(self, g_usuario_authenticate_schema : GUsuarioAuthenticateSchema):

        # Instânciamento do repositório de busca pelo authenticate
        get_by_authenticate_repository = GetByAuthenticateRepository()
--- a/packages/v1/administrativo/actions/g_usuario/g_usuario_get_by_login_action.py
+++ b/packages/v1/administrativo/actions/g_usuario/g_usuario_get_by_login_action.py
@ -1,13 +1,10 @@
 from abstracts.action import BaseAction
 from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioLoginSchema
-from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_login_repository import (
-    GetByUsuarioLoginRepository,
-)
-
+from packages.v1.administrativo.repositories.g_usuario.g_usuario_get_by_login_repository import GetByUsuarioLoginRepository

 class GetByUsuarioLoginAction(BaseAction):

-    def execute(self, g_usuario_schema=GUsuarioLoginSchema):
+    def execute(self, g_usuario_schema = GUsuarioLoginSchema):

        # Importação do repositório
        get_by_login_repository = GetByUsuarioLoginRepository()
--- a/packages/v1/administrativo/actions/g_usuario/g_usuario_index_action.py
+++ b/packages/v1/administrativo/actions/g_usuario/g_usuario_index_action.py
@ -1,19 +1,15 @@
 from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.g_usuario.g_usuario_index_repository import (
-    IndexRepository,
-)
-from packages.v1.administrativo.schemas.g_usuario_schema import GUsuarioIndexSchema
-
+from packages.v1.administrativo.repositories.g_usuario.g_usuario_index_repository import IndexRepository

 class IndexAction(BaseAction):

-    def execute(self, g_usuario_index_schema: GUsuarioIndexSchema):
+    def execute(self):

        # Instânciamento do repositório sql
        index_repository = IndexRepository()

        # Execução do sql
-        response = index_repository.execute(g_usuario_index_schema)
+        response = index_repository.execute()

        # Retorno da informação
-        return response
+        return response
--- a/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_delete_action.py
+++ b/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_delete_action.py
@ -1,32 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_delete_repository import (
-    TAtoParteTipoDeleteRepository,
-)
-from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
-    TAtoParteTipoIdSchema,
-)
-
-
-class TAtoParteTipoDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela t_t_ato_partetipo_id.
-    """
-
-    def execute(self, t_ato_partetipo_id_schema: TAtoParteTipoIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            t_ato_partetipo_id_schema (TAtoParteTipoSchema): O esquema com o ID a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # Instanciamento do repositório
-        t_ato_partetipo_delete_repository = TAtoParteTipoDeleteRepository()
-
-        # Execução do repositório
-        response = t_ato_partetipo_delete_repository.execute(t_ato_partetipo_id_schema)
-
-        return response
--- a/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_index_action.py
+++ b/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_index_action.py
@ -1,27 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_index_repository import (
-    TAtoParteTipoIndexRepository,
-)
-
-
-class TAtoParteTipoIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela t_censec_qualidade.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Returns:
-            A lista de todos os registros.
-        """
-        # Instanciamento do repositório
-        t_ato_partetipo_index_repositoy = TAtoParteTipoIndexRepository()
-
-        # Execução do repositório
-        response = t_ato_partetipo_index_repositoy.execute()
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_save_action.py
+++ b/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_save_action.py
@ -1,33 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_save_repository import (
-    TAtoParteTipoSaveRepository,
-)
-from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
-    TAtoParteTipoSaveSchema,
-)
-
-
-class TAtoParteTipoSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvar um novo registro na tabela t_censec_qualidade.
-    """
-
-    def execute(self, t_ato_partetipo_save_schema: TAtoParteTipoSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            t_ato_partetipo_schema (TCensecQualidadeSaveSchema): O esquema com os dados a serem salvos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # Instanciamento do repositório
-        t_ato_partetipo_save_repository = TAtoParteTipoSaveRepository()
-
-        # Execução do repositório
-        response = t_ato_partetipo_save_repository.execute(t_ato_partetipo_save_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_show_action.py
+++ b/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_show_action.py
@ -1,33 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_show_repository import (
-    TAtoParteTipoShowRepository,
-)
-from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
-    TAtoParteTipoIdSchema,
-)
-
-
-class TAtoParteTipoShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela t_censec_qualidade.
-    """
-
-    def execute(self, t_ato_partetipo_id_schema: TAtoParteTipoIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            t_ato_partetipo_schema (TCensecQualidadeIdSchema): O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # Instânciamento do repositório
-        t_ato_partetipo_show_repository = TAtoParteTipoShowRepository()
-
-        # Execução do repositório
-        response = t_ato_partetipo_show_repository.execute(t_ato_partetipo_id_schema)
-
-        # Retorno da informação
-        return response
--- a/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_update_action.py
+++ b/packages/v1/administrativo/actions/t_ato_partetipo/t_ato_partetipo_update_action.py
@ -1,31 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_ato_partetipo.t_ato_partetipo_update_repository import (
-    TAtoParteTipoUpdateRepository,
-)
-from packages.v1.administrativo.schemas.t_ato_partetipo_schema import (
-    TAtoParteTipoUpdateSchema,
-)
-
-
-class TAtoParteTipoUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela t_censec_qualidade.
-    """
-
-    def execute(self, t_ato_partetipo_update_schema: TAtoParteTipoUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            t_ato_partetipo_unidade_id (int): O ID do registro a ser atualizado.
-            t_ato_partetipo_update_schema (TCensecQualidadeUpdateSchema): O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # Instância o repositório de atualização
-        t_ato_partetipo_update_repository = TAtoParteTipoUpdateRepository()
-
-        # Chama o método de execução do repositório para realizar a atualização
-        return t_ato_partetipo_update_repository.execute(t_ato_partetipo_update_schema)
--- a/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_delete_action.py
+++ b/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_delete_action.py
@ -1,39 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_delete_repository import (
-    TBiometriaPessoaDeleteRepository,
-)
-from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
-    TBiometriaPessoaIdSchema,
-)
-
-
-class TBiometriaPessoaDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela T_BIOMETRIA_PESSOA.
-    """
-
-    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_biometria_pessoa_delete_repository = TBiometriaPessoaDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = t_biometria_pessoa_delete_repository.execute(
-            t_biometria_pessoa_id_schema
-        )
-
-        return response
--- a/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_index_action.py
+++ b/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_index_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_index_repository import (
-    TBiometriaPessoaIndexRepository,
-)
-from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
-    TBiometriaPessoaIndexSchema,
-)
-
-
-class TBiometriaPessoaIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, biometria_pessoa_index_schema: TBiometriaPessoaIndexSchema):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Args:
-            t_biometria_pessoa_index_schema (TBiometriaPessoaIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
-
-        Returns:
-            A lista de registros encontrados.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_biometria_pessoa_index_repository = TBiometriaPessoaIndexRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = t_biometria_pessoa_index_repository.execute(
-            biometria_pessoa_index_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # --------------------------------
-        return response
--- a/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_save_action.py
+++ b/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_save_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_save_repository import (
-    TBiometriaPessoaSaveRepository,
-)
-from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
-    TBiometriaPessoaSaveSchema,
-)
-
-
-class TBiometriaPessoaSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela T_BIOMETRIA_PESSOA.
-    """
-
-    def execute(self, t_biometria_pessoa_save_schema: TBiometriaPessoaSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            t_biometria_pessoa_schema (TBiometriaPessoaSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_biometria_pessoa_save_repository = TBiometriaPessoaSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = t_biometria_pessoa_save_repository.execute(
-            t_biometria_pessoa_save_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_show_action.py
+++ b/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_show_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_show_repository import (
-    TBiometriaPessoaShowRepository,
-)
-from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
-    TBiometriaPessoaIdSchema,
-)
-
-
-class TBiometriaPessoaShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, t_biometria_pessoa_id_schema: TBiometriaPessoaIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            t_biometria_pessoa_id_schema (TBiometriaPessoaIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_biometria_pessoa_show_repository = TBiometriaPessoaShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = t_biometria_pessoa_show_repository.execute(
-            t_biometria_pessoa_id_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_update_action.py
+++ b/packages/v1/administrativo/actions/t_biometria_pessoa/t_biometria_pessoa_update_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_biometria_pessoa.t_biometria_pessoa_update_repository import (
-    TBiometriaPessoaUpdateRepository,
-)
-from packages.v1.administrativo.schemas.t_biometria_pessoa_schema import (
-    TBiometriaPessoaUpdateSchema,
-)
-
-
-class TBiometriaPessoaUpdateAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a atualização
-    de um registro na tabela G_NATUREZA_TITULO.
-    """
-
-    def execute(self, t_biometria_pessoa_update_schema: TBiometriaPessoaUpdateSchema):
-        """
-        Executa a operação de atualização.
-
-        Args:
-            t_biometria_pessoa_update_schema (TBiometriaPessoaUpdateSchema):
-                O esquema com os dados a serem atualizados.
-
-        Returns:
-            O resultado da operação de atualização.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório de atualização
-        # ----------------------------------------------------
-        t_biometria_pessoa_update_repository = TBiometriaPessoaUpdateRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = t_biometria_pessoa_update_repository.execute(
-            t_biometria_pessoa_update_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno do resultado
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_delete_action.py
+++ b/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_delete_action.py
@ -1,39 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_delete_repository import (
-    TCensecTipoNaturezaDeleteRepository,
-)
-from packages.v1.administrativo.schemas.t_censec_tiponatureza_schema import (
-    TCensecTipoNaturezaIdSchema,
-)
-
-
-class TCensecTipoNaturezaDeleteAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de exclusão de um registro na tabela T_CENSEC_TIPOATO.
-    """
-
-    def execute(self, t_censec_tiponatureza_id_schema: TCensecTipoNaturezaIdSchema):
-        """
-        Executa a operação de exclusão no banco de dados.
-
-        Args:
-            t_censec_tiponatureza_id_schema (TCensecTipoNaturezaIdSchema):
-                O esquema contendo o ID do registro a ser excluído.
-
-        Returns:
-            O resultado da operação de exclusão.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_censec_tiponatureza_delete_repository = TCensecTipoNaturezaDeleteRepository()
-
-        # ----------------------------------------------------
-        # Execução da exclusão
-        # ----------------------------------------------------
-        response = t_censec_tiponatureza_delete_repository.execute(
-            t_censec_tiponatureza_id_schema
-        )
-
-        return response
--- a/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_index_action.py
+++ b/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_index_action.py
@ -1,37 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_index_repository import (
-    TCensecTipoNaturezaIndexRepository,
-)
-
-
-class TCensecTipoNaturezaIndexAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de listagem de todos os registros na tabela T_CENSEC_TIPOATO.
-    """
-
-    def execute(self):
-        """
-        Executa a operação de listagem no banco de dados.
-
-        Args:
-            t_censec_tiponatureza_index_schema (TCensecTipoNaturezaIndexSchema):
-                Esquema contendo parâmetros opcionais de filtro.
-
-        Returns:
-            A lista de registros encontrados.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_censec_tiponatureza_index_repository = TCensecTipoNaturezaIndexRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = t_censec_tiponatureza_index_repository.execute()
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # --------------------------------
-        return response
--- a/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_save_action.py
+++ b/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_save_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_save_repository import (
-    TCensecTipoNaturezaSaveRepository,
-)
-from packages.v1.administrativo.schemas.t_censec_tiponatureza_schema import (
-    TCensecTipoNaturezaSaveSchema,
-)
-
-
-class TCensecTipoNaturezaSaveAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a operação
-    de salvamento de um novo registro na tabela T_CENSEC_TIPOATO.
-    """
-
-    def execute(self, t_censec_tiponatureza_save_schema: TCensecTipoNaturezaSaveSchema):
-        """
-        Executa a operação de salvamento.
-
-        Args:
-            t_censec_tiponatureza_schema (TCensecTipoNaturezaSchema):
-                O esquema com os dados a serem persistidos.
-
-        Returns:
-            O resultado da operação de salvamento.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_censec_tiponatureza_save_repository = TCensecTipoNaturezaSaveRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = t_censec_tiponatureza_save_repository.execute(
-            t_censec_tiponatureza_save_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_show_action.py
+++ b/packages/v1/administrativo/actions/t_censec_naturezatipo/t_censec_tiponatureza_show_action.py
@ -1,42 +0,0 @@
-from abstracts.action import BaseAction
-from packages.v1.administrativo.repositories.t_censec_tiponatureza.t_censec_tiponatureza_show_repository import (
-    TCensecTipoNaturezaShowRepository,
-)
-from packages.v1.administrativo.schemas.t_censec_tiponatureza_schema import (
-    TCensecTipoNaturezaIdSchema,
-)
-
-
-class TCensecTipoNaturezaShowAction(BaseAction):
-    """
-    Serviço responsável por encapsular a lógica de negócio para a exibição
-    de um registro na tabela T_CENSEC_TIPOATO.
-    """
-
-    def execute(self, t_censec_tiponatureza_id_schema: TCensecTipoNaturezaIdSchema):
-        """
-        Executa a operação de exibição.
-
-        Args:
-            t_censec_tiponatureza_id_schema (TCensecTipoNaturezaIdSchema):
-                O esquema com o ID do registro a ser exibido.
-
-        Returns:
-            O resultado da operação de exibição.
-        """
-        # ----------------------------------------------------
-        # Instanciamento do repositório
-        # ----------------------------------------------------
-        t_censec_tiponatureza_show_repository = TCensecTipoNaturezaShowRepository()
-
-        # ----------------------------------------------------
-        # Execução do repositório
-        # ----------------------------------------------------
-        response = t_censec_tiponatureza_show_repository.execute(
-            t_censec_tiponatureza_id_schema
-        )
-
-        # ----------------------------------------------------
-        # Retorno da informação
-        # ----------------------------------------------------
-        return response
--- a/Show more
+++ b/Show more