// Gerado pelo gerador do TermoCore (`cargo run -p gerador`). Não edite à mão: a próxima geração sobrescreve.
use crate::base::servicos::TERMO_WEBHOOK as SERVICO_DESTA_API;
#[allow(unused_imports)]
use crate::base::{
codificar_parametro_de_caminho, multipart, CredencialDeAcesso, ErroAoChamarServico, Method,
RequisicaoAoServico,
};
use serde::{Deserialize, Serialize};
#[allow(unused_imports)]
use super::tipos;
#[doc = "Parâmetros de consulta e de cabeçalho de `/aplicativo`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorAplicativo {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/aplicativo/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteAplicativo {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/aplicativo/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroAplicativo {
#[serde(skip_serializing_if = "Option::is_none")]
pub nome: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ativo: Option<bool>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/assinatura`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorAssinatura {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/assinatura/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteAssinatura {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/assinatura/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroAssinatura {
#[serde(skip_serializing_if = "Option::is_none")]
pub aplicativo_assinante_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tipo_de_evento_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ativa: Option<bool>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/auth`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorAuth {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/auth/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteAuth {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub perfil: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/auth/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroAuth {
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub perfil: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ativo: Option<bool>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/colaborador`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorColaborador {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub nome: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setor: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cargo: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ativo: Option<bool>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/colaborador/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteColaborador {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/colaborador/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroColaborador {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub nome: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setor: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cargo: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ativo: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub perfil_acesso_id: Option<uuid::Uuid>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/entrega`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorEntrega {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub situacao: Option<String>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/entrega/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroEntrega {
#[serde(skip_serializing_if = "Option::is_none")]
pub situacao: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub assinatura_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub evento_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub aplicativo_assinante_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tipo_de_evento_id: Option<uuid::Uuid>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/evento`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorEvento {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/evento/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroEvento {
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tipo_de_evento_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub aplicativo_publicador_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub entidade_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub desde: Option<chrono::DateTime<chrono::Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ate: Option<chrono::DateTime<chrono::Utc>>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/evento_recusado`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorEventoRecusado {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/evento_recusado/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroEventoRecusado {
#[serde(skip_serializing_if = "Option::is_none")]
pub motivo: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub aplicativo_publicador_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub nome_do_tipo_informado: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub desde: Option<chrono::DateTime<chrono::Utc>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ate: Option<chrono::DateTime<chrono::Utc>>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/perfil_acesso`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorPerfilAcesso {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/perfil_acesso/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompletePerfilAcesso {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/perfil_acesso/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroPerfilAcesso {
#[serde(skip_serializing_if = "Option::is_none")]
pub nome: Option<String>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/solicitacao_de_reprocessamento`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorSolicitacaoDeReprocessamento {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/solicitacao_de_reprocessamento/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroSolicitacaoDeReprocessamento {
#[serde(skip_serializing_if = "Option::is_none")]
pub assinatura_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub alcance: Option<String>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/tipo_de_evento`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorTipoDeEvento {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/tipo_de_evento/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteTipoDeEvento {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/tipo_de_evento/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroTipoDeEvento {
#[serde(skip_serializing_if = "Option::is_none")]
pub nome: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub aplicativo_dono_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ativo: Option<bool>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/versao_de_esquema`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorVersaoDeEsquema {
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/versao_de_esquema/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteVersaoDeEsquema {
#[serde(skip_serializing_if = "Option::is_none")]
pub busca: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tipo_de_evento_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pagina: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tamanho: Option<i64>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/versao_de_esquema/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroVersaoDeEsquema {
#[serde(skip_serializing_if = "Option::is_none")]
pub tipo_de_evento_id: Option<uuid::Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
pub situacao: Option<String>,
}
#[doc = "Parâmetros de consulta e de cabeçalho de `/webhooks/termowebhook`."]
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct ParametrosDeWebhooksReceberEventoTermoWebhook {
#[doc = "Horário Unix em segundos da entrega; tolerância de 5 minutos"]
#[doc = "Enviado no cabeçalho `X-TermoWebhook-Data`."]
#[serde(skip)]
pub x_termo_webhook_data: i64,
#[doc = "`kid` da chave do hub que assinou"]
#[doc = "Enviado no cabeçalho `X-TermoWebhook-Chave`."]
#[serde(skip)]
pub x_termo_webhook_chave: String,
#[doc = "Id do aplicativo assinante"]
#[doc = "Enviado no cabeçalho `X-TermoWebhook-Destino`."]
#[serde(skip)]
pub x_termo_webhook_destino: uuid::Uuid,
#[doc = "`ed25519=<base64url>` sobre `<data>.<aplicativo_assinante_id>.<corpo>`"]
#[doc = "Enviado no cabeçalho `X-TermoWebhook-Assinatura`."]
#[serde(skip)]
pub x_termo_webhook_assinatura: String,
}
#[doc = "Versão do backend no ar\n\nPública, sem token. Devolve `sucesso: true` e a versão do backend que está publicada, no formato semver.\n\n`GET /`"]
pub async fn buscar_versao_test() -> Result<tipos::VersaoDoBackend, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/")
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Chaves públicas que conferem as entregas\n\nPública, sem token. Lista as chaves públicas Ed25519 (JWKS, `kty: OKP`, `crv: Ed25519`, `alg: EdDSA`) com que o hub assina cada entrega. O assinante confere `X-TermoWebhook-Assinatura: ed25519=<base64url>` sobre `<X-TermoWebhook-Data>.<id do próprio aplicativo>.<corpo>` com a chave do `kid` em `X-TermoWebhook-Chave`. Pode guardar em cache por 5 minutos e buscar de novo quando chegar um `kid` desconhecido.\n\n`GET /.well-known/jwks.json`"]
pub async fn buscar_paginador_chave_de_assinatura(
) -> Result<tipos::ConjuntoDeChaves, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/.well-known/jwks.json")
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista os aplicativos paginados\n\nLeitura liberada a quem tem a permissão `ler` em `aplicativos`, `contratos`, `assinaturas` ou `monitoramento`. Antes de listar, sincroniza com os apps do TermoAuth pelo `termo_core` (token de quem chama, se for master; senão o token de aplicativo do TermoWebhook, se o segredo do app estiver cadastrado): app novo entra ativo, nome e descrição seguem os do TermoAuth, e app que saiu do TermoAuth é excluído ou, se ainda é dono de tipos de evento ou tem assinaturas, fica inativo. Falha do TermoAuth não impede a listagem. Não existe criar, editar nem excluir aplicativo no TermoWebhook. Lista os aplicativos não excluídos em ordem alfabética do nome. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10, sem máximo; valores menores que 1 viram 1. `total` é a quantidade de aplicativos não excluídos.\n\n`GET /aplicativo`"]
pub async fn buscar_paginador_aplicativo(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorAplicativo,
) -> Result<tipos::PaginaAplicativo, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/aplicativo")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista básica de aplicativos para seleção\n\nLeitura liberada a quem tem a permissão `ler` em `aplicativos`, `contratos`, `assinaturas` ou `monitoramento`, para escolher o dono de um tipo de evento ou o assinante de uma assinatura. Devolve só id, nome e `ativo`, em ordem alfabética do nome, sem os excluídos. `busca` procura o trecho no nome, sem diferenciar maiúsculas. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10.\n\n`GET /aplicativo/autocomplete`"]
pub async fn buscar_auto_complete_aplicativo(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarAutoCompleteAplicativo,
) -> Result<tipos::PaginaAplicativoAutoComplete, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/aplicativo/autocomplete",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca aplicativos por filtro\n\nLeitura liberada a quem tem a permissão `ler` em `aplicativos`, `contratos`, `assinaturas` ou `monitoramento`. Devolve todos os aplicativos não excluídos que casam com o filtro, sem paginação, em ordem alfabética do nome. `nome` procura o trecho no nome e na descrição, sem diferenciar maiúsculas; `ativo` filtra pela situação. Sem filtro, devolve todos.\n\n`GET /aplicativo/filtro`"]
pub async fn buscar_pelo_filtro_aplicativo(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroAplicativo,
) -> Result<Vec<tipos::Aplicativo>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/aplicativo/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca um aplicativo pelo id\n\nLeitura liberada a quem tem a permissão `ler` em `aplicativos`, `contratos`, `assinaturas` ou `monitoramento`. Aplicativo excluído não é encontrado. Os aplicativos são do TermoAuth e aqui são só leitura: `identificador_no_termoauth` é o id do app no TermoAuth (o `sub` do token de aplicativo) e não muda. `quantidade_de_tipos_de_evento` conta os tipos de que o aplicativo é dono e `quantidade_de_assinaturas` as assinaturas em que ele é o assinante.\n\n`GET /aplicativo/{id}`"]
pub async fn buscar_pelo_id_aplicativo(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::Aplicativo, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/aplicativo/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista as assinaturas paginadas\n\nLeitura liberada a quem tem a permissão `ler` em `assinaturas` ou `monitoramento`. Lista as assinaturas não excluídas, ordenadas pelo nome do aplicativo assinante e depois pelo nome do tipo de evento. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10, sem máximo; valores menores que 1 viram 1. `total` é a quantidade de assinaturas não excluídas.\n\n`GET /assinatura`"]
pub async fn buscar_paginador_assinatura(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorAssinatura,
) -> Result<tipos::PaginaAssinatura, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/assinatura")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Cadastra uma assinatura\n\nExige a permissão `criar` na área `assinaturas`. Inscreve um aplicativo para receber os eventos de um tipo numa versão do esquema: cada evento aceito dali em diante nessa versão vira uma entrega para `url_de_destino`. O aplicativo assinante e o tipo de evento precisam existir, e a versão precisa existir para o tipo e não estar desligada. Cada aplicativo assina um tipo uma vez só; para mudar de versão, atualize a assinatura existente. `url_de_destino` tem até 500 caracteres e precisa ser `https` (`http` só para localhost). `maximo_de_tentativas` vai de 1 a 20 e `tempo_limite_em_segundos` de 1 a 30 (padrão 5 em ambos); `ativa` tem padrão `true`. Não há segredo por assinatura: o hub assina cada entrega com a chave dele (Ed25519, chaves públicas em `GET /.well-known/jwks.json`) e o assinante confere só com a URL do hub e o id do próprio aplicativo.\n\n`POST /assinatura`"]
pub async fn criar_assinatura(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::AssinaturaCriar,
) -> Result<tipos::Assinatura, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/assinatura")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista básica de assinaturas para seleção\n\nLeitura liberada a quem tem a permissão `ler` em `assinaturas` ou `monitoramento`, por exemplo para escolher a assinatura de um reprocessamento. Devolve só id, nomes do assinante e do tipo, versão e `ativa`, ordenados pelo nome do aplicativo assinante e depois pelo nome do tipo, sem as excluídas. `busca` procura o trecho no nome do aplicativo assinante ou do tipo de evento, sem diferenciar maiúsculas. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10.\n\n`GET /assinatura/autocomplete`"]
pub async fn buscar_auto_complete_assinatura(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarAutoCompleteAssinatura,
) -> Result<tipos::PaginaAssinaturaAutoComplete, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/assinatura/autocomplete",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca assinaturas por filtro\n\nLeitura liberada a quem tem a permissão `ler` em `assinaturas` ou `monitoramento`. Devolve todas as assinaturas não excluídas que casam com o filtro, sem paginação, ordenadas pelo nome do aplicativo assinante e depois pelo nome do tipo de evento. `aplicativo_assinante_id`, `tipo_de_evento_id` e `ativa` filtram pelo valor exato. Sem filtro, devolve todas.\n\n`GET /assinatura/filtro`"]
pub async fn buscar_pelo_filtro_assinatura(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroAssinatura,
) -> Result<Vec<tipos::Assinatura>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/assinatura/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca uma assinatura pelo id\n\nLeitura liberada a quem tem a permissão `ler` em `assinaturas` ou `monitoramento`. Assinatura excluída não é encontrada. Traz os nomes do aplicativo assinante e do tipo de evento, a situação da versão assinada, quantas entregas estão na fila de erro (tentativas esgotadas) e quando foi a última entrega bem-sucedida.\n\n`GET /assinatura/{id}`"]
pub async fn buscar_pelo_id_assinatura(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::Assinatura, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/assinatura/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Atualiza uma assinatura pelo id\n\nExige a permissão `editar` na área `assinaturas`. Atualização parcial: só os campos enviados mudam; o aplicativo assinante e o tipo de evento não mudam. `versao_do_esquema` troca a versão assinada e precisa existir para o tipo e não estar desligada (manter a versão atual é sempre aceito). `url_de_destino`, `maximo_de_tentativas` e `tempo_limite_em_segundos` seguem as regras do cadastro. Desativar a assinatura (`ativa: false`) faz ela deixar de receber eventos novos e cancela as entregas pendentes dela na mesma hora.\n\n`PATCH /assinatura/{id}`"]
pub async fn atualizar_pelo_id_assinatura(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
corpo_da_requisicao: &tipos::AssinaturaAtualizar,
) -> Result<tipos::Assinatura, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::PATCH,
&format!("/assinatura/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Exclui uma assinatura pelo id\n\nExige a permissão `deletar` na área `assinaturas`. A exclusão é lógica: a assinatura some das leituras, para de gerar entregas e o aplicativo pode assinar o mesmo tipo de novo, mas o registro não é apagado e não há como restaurar. As entregas pendentes dela são canceladas na mesma hora; o histórico de entregas continua até vencer a retenção.\n\n`DELETE /assinatura/{id}`"]
pub async fn deletar_pelo_id_assinatura(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<(), ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::DELETE,
&format!("/assinatura/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ignorar_corpo_da_resposta()
.await
}
#[doc = "Lista acessos com paginação\n\nExige qualquer permissão da área `colaboradores`. Ordena por perfil e depois por e-mail. `pagina` começa em 1 (padrão 1); `tamanho` tem padrão 10, sem máximo. Acessos excluídos não aparecem nem entram no `total`.\n\n`GET /auth`"]
pub async fn buscar_paginador_auth(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorAuth,
) -> Result<tipos::PaginaAuth, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/auth")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Cria um acesso\n\nExige a permissão `criar` da área `colaboradores`. Cadastra quem pode entrar no TermoWebhook: o e-mail é gravado em minúsculas, sem espaços nas pontas, com até 160 caracteres. O único perfil aceito é `colaborador`. O acesso nasce ativo e sem perfil de acesso. Para a pessoa conseguir entrar, o e-mail precisa ser `@termotubos.com.br` e existir no TermoAuth. O colaborador (nome, setor, cargo e função) não se cadastra aqui: vem só do TermoAuth, pelos eventos do TermoWebhook.\n\n`POST /auth`"]
pub async fn criar_auth(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::AuthCriar,
) -> Result<tipos::Auth, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/auth")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca o acesso de quem está logado\n\nLivre para qualquer usuário autenticado com cadastro ativo, mesmo sem nenhuma permissão liberada. Devolve o cadastro de quem chamou, o nome do perfil de acesso do colaborador em `perfil_acesso` (`null` quando ainda não tem) e as permissões que o perfil dá por área (`monitoramento`, `aplicativos`, `contratos`, `assinaturas` e `colaboradores`), cada uma com `ler`, `criar`, `editar` e `deletar`. Um master do TermoAuth recebe todas as permissões e, no primeiro acesso, ganha o cadastro automaticamente. `nome` vem do TermoAuth e, se estiver vazio, repete o e-mail. É a chamada que o painel faz antes de mostrar qualquer tela.\n\n`GET /auth/acesso`"]
pub async fn buscar_acesso_auth(
credencial_de_acesso: &CredencialDeAcesso,
) -> Result<tipos::AcessoAtual, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/auth/acesso")
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista básica de acessos para seleção\n\nExige qualquer permissão da área `colaboradores`. Devolve só id, e-mail e perfil, em ordem alfabética de e-mail, para escolher um acesso. `busca` procura por trecho do e-mail, sem diferenciar maiúsculas; `perfil` compara o valor exato. `pagina` começa em 1 (padrão 1); `tamanho` tem padrão 10, sem máximo.\n\n`GET /auth/autocomplete`"]
pub async fn buscar_auto_complete_auth(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarAutoCompleteAuth,
) -> Result<tipos::PaginaAuthAutoComplete, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/auth/autocomplete")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca acessos por filtro\n\nExige qualquer permissão da área `colaboradores`. Devolve todos os acessos que casam com o filtro, sem paginação, em ordem alfabética de e-mail. `email` procura por trecho, sem diferenciar maiúsculas; `perfil` compara o valor exato; `ativo` filtra pela situação. Sem filtro, devolve todos. Acessos excluídos não aparecem.\n\n`GET /auth/filtro`"]
pub async fn buscar_pelo_filtro_auth(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroAuth,
) -> Result<Vec<tipos::Auth>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/auth/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca um acesso pelo id\n\nExige qualquer permissão da área `colaboradores`. Acesso excluído responde `404`. `vinculado` diz se há um colaborador ligado ao acesso, e `nome` é o nome desse colaborador.\n\n`GET /auth/{id}`"]
pub async fn buscar_pelo_id_auth(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::Auth, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/auth/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Atualiza um acesso pelo id\n\nExige a permissão `editar` da área `colaboradores`. Só os campos enviados mudam: `email` (gravado em minúsculas, até 160 caracteres) e `ativo` (acesso inativo é barrado em todas as rotas). O acesso de um master do TermoAuth não pode ser alterado.\n\n`PATCH /auth/{id}`"]
pub async fn atualizar_pelo_id_auth(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
corpo_da_requisicao: &tipos::AuthAtualizar,
) -> Result<tipos::Auth, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::PATCH,
&format!("/auth/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Exclui um acesso pelo id\n\nExige a permissão `deletar` da área `colaboradores`. A exclusão é lógica: o acesso some das consultas e a pessoa deixa de entrar, mas o registro fica guardado e não há como restaurar. Acesso com colaborador vinculado não pode ser excluído: o colaborador pertence ao TermoAuth e só sai de lá. O acesso de um master do TermoAuth não pode ser excluído.\n\n`DELETE /auth/{id}`"]
pub async fn deletar_pelo_id_auth(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<(), ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::DELETE,
&format!("/auth/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ignorar_corpo_da_resposta()
.await
}
#[doc = "Lista colaboradores com paginação\n\nSó leitura: o colaborador é cadastrado, alterado e excluído no TermoAuth e chega aqui pelos eventos `colaborador.criado` e `colaborador.atualizado` do TermoWebhook; aqui só se escolhe o perfil de acesso dele (`PATCH /colaborador/{id}/perfil_acesso`). Exige qualquer permissão da área `colaboradores`. Ordena por nome. `nome`, `setor` e `cargo` filtram por trecho, sem diferenciar maiúsculas, e `ativo` pela situação. `pagina` começa em 1 (padrão 1; valores menores viram 1). A página tem sempre 50 itens: `tamanho` é aceito, mas ignorado. Colaboradores excluídos não aparecem nem entram no `total`, que conta os registros que casam com os filtros. Quando quem chama é master do TermoAuth, a lista antes traz do TermoAuth os colaboradores `@termotubos.com.br` que ainda não existem aqui, criando acesso e colaborador sem perfil de acesso; quem já existe não é alterado e ninguém é excluído. Se o TermoAuth falhar, a lista sai mesmo assim, só sem a sincronização.\n\n`GET /colaborador`"]
pub async fn buscar_paginador_colaborador(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorColaborador,
) -> Result<tipos::PaginaColaborador, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/colaborador")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista básica de colaboradores para seleção\n\nExige qualquer permissão da área `colaboradores`. Devolve só id, nome e e-mail, em ordem alfabética de nome, para escolher um colaborador. `busca` procura por trecho do nome ou do e-mail, sem diferenciar maiúsculas. `pagina` começa em 1 (padrão 1); `tamanho` tem padrão 10, sem máximo.\n\n`GET /colaborador/autocomplete`"]
pub async fn buscar_auto_complete_colaborador(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarAutoCompleteColaborador,
) -> Result<tipos::PaginaColaboradorAutoComplete, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/colaborador/autocomplete",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca colaboradores por filtro\n\nExige qualquer permissão da área `colaboradores`. Devolve todos os colaboradores que casam com o filtro, sem paginação, em ordem alfabética de nome. `busca` procura por trecho do nome ou do e-mail; `nome`, `email`, `setor` e `cargo` procuram por trecho, sem diferenciar maiúsculas; `ativo` filtra pela situação; `perfil_acesso_id` filtra pelo perfil de acesso. Sem filtro, devolve todos. Colaboradores excluídos não aparecem.\n\n`GET /colaborador/filtro`"]
pub async fn buscar_pelo_filtro_colaborador(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroColaborador,
) -> Result<Vec<tipos::Colaborador>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/colaborador/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca um colaborador pelo id\n\nExige qualquer permissão da área `colaboradores`. Colaborador excluído responde `404`. Traz junto o e-mail do acesso, se ele é master do TermoAuth e o perfil de acesso (`perfil_acesso_id` e o nome em `perfil_acesso`).\n\n`GET /colaborador/{id}`"]
pub async fn buscar_pelo_id_colaborador(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::Colaborador, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/colaborador/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Define o perfil de acesso de um colaborador\n\nExige a permissão `editar` da área `colaboradores`. É a única escrita do colaborador feita pelo TermoWebhook: `perfil_acesso_id` aponta para um perfil de `GET /perfil_acesso/filtro` e passa a definir o que a pessoa enxerga; `null` tira o perfil e deixa a pessoa sem nenhuma área. O colaborador de um master do TermoAuth não aceita perfil (ele já tem tudo). Vale em até 5 minutos (cache do acesso).\n\n`PATCH /colaborador/{id}/perfil_acesso`"]
pub async fn vincular_perfil_acesso_colaborador(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
corpo_da_requisicao: &tipos::ColaboradorVincularPerfilAcesso,
) -> Result<tipos::Colaborador, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::PATCH,
&format!(
"/colaborador/{}/perfil_acesso",
codificar_parametro_de_caminho(id)
),
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Mostra se o segredo do app está cadastrado\n\nSó o master do TermoAuth (os demais recebem `403`). Devolve a configuração única do TermoWebhook (tela `/painel/configuracoes/provedores`). O segredo do app gerado no TermoAuth nunca volta aberto: só `configurado` e o final mascarado (`final_visivel`). Fica cifrado no banco com AES-256-GCM e a chave derivada de `GLOBAL_SECRET_CRIPTOGRAFIA`; sem essa variável no servidor, ou se ela mudou, `configurado` vem `false`.\n\n`GET /configuracao`"]
pub async fn buscar_pelo_id_configuracao(
credencial_de_acesso: &CredencialDeAcesso,
) -> Result<tipos::Configuracao, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/configuracao")
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Grava ou limpa o segredo do app\n\nSó o master do TermoAuth (os demais recebem `403`). `segredo_do_app_gerado_no_termo_auth` ausente fica como está, string troca (até 2.000 caracteres, sem quebra de linha; vazia conta como limpar) e `null` limpa. O valor é cifrado com a `GLOBAL_SECRET_CRIPTOGRAFIA` e entregue na hora ao `termo_core`, sem deploy. A resposta é a mesma do `GET`.\n\n`PATCH /configuracao`"]
pub async fn atualizar_pelo_id_configuracao(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::ConfiguracaoAtualizar,
) -> Result<tipos::Configuracao, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::PATCH, "/configuracao")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista entregas com paginação\n\nExige a área `monitoramento`. As atualizadas mais recentemente vêm primeiro. `pagina` começa em 1 (padrão 1); `tamanho` tem padrão 10. `situacao` é opcional e aceita os mesmos valores do filtro: `pendente`, `aguardando_nova_tentativa`, `entregue`, `tentativas_esgotadas`, `cancelada` ou `na_fila`.\n\n`GET /entrega`"]
pub async fn buscar_paginador_entrega(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorEntrega,
) -> Result<tipos::PaginaEntrega, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/entrega")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca entregas por filtro\n\nExige a área `monitoramento`. Sem paginação: devolve no máximo 200 entregas, as criadas mais recentemente primeiro. Todos os filtros são opcionais e se somam. `situacao` é `pendente`, `aguardando_nova_tentativa`, `entregue`, `tentativas_esgotadas` (a fila de erro), `cancelada` ou `na_fila` (pendentes e aguardando nova tentativa juntas). Os demais filtram por assinatura, evento, aplicativo assinante e tipo de evento.\n\n`GET /entrega/filtro`"]
pub async fn buscar_pelo_filtro_entrega(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroEntrega,
) -> Result<Vec<tipos::Entrega>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/entrega/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca uma entrega pelo id, com o histórico de tentativas\n\nExige a área `monitoramento`. Devolve a entrega (evento, assinatura, assinante, URL de destino e situação) e a lista `tentativas`, da mais recente para a mais antiga, com status HTTP, duração, erro e trecho da resposta de cada chamada ao assinante. `quantidade_de_tentativas` é o total histórico; `tentativas_no_ciclo_atual` zera a cada reprocessamento.\n\n`GET /entrega/{id}`"]
pub async fn buscar_pelo_id_entrega(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::EntregaDetalhada, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/entrega/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Descarta uma entrega\n\nExige a área `monitoramento` com permissão de editar. O único valor aceito é `situacao = cancelada`: descarta a entrega, que deixa de ser reenviada. Só vale para entregas pendentes, aguardando nova tentativa ou na fila de erro; entrega já entregue ou já cancelada responde `409`. Para reenviar uma entrega, use o reprocessamento (`POST /solicitacao_de_reprocessamento`).\n\n`PATCH /entrega/{id}`"]
pub async fn atualizar_pelo_id_entrega(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
corpo_da_requisicao: &tipos::EntregaAtualizar,
) -> Result<tipos::EntregaDetalhada, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::PATCH,
&format!("/entrega/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Catálogo dos esquemas de evento vigentes\n\nPública, sem token. Lista todas as versões de esquema que não estão desligadas (ativas e descontinuadas), com o aplicativo dono, o tipo de evento e o JSON Schema dos dados, em ordem de aplicativo, tipo e versão. É a fonte de onde o gerador do TermoCore cria os contratos tipados do crate `termo_webhook`. Pode guardar em cache por 1 minuto.\n\n`GET /esquemas.json`"]
pub async fn buscar_paginador_esquema() -> Result<tipos::CatalogoDeEsquemas, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/esquemas.json")
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista os eventos recebidos, paginados\n\nExige a área `monitoramento` com permissão de ler. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10; valores menores que 1 viram 1. Ordena do recebido mais recente para o mais antigo e traz, por evento, os contadores das entregas (total, concluídas, na fila e na fila de erro), sem os `dados`. `total` é a quantidade de eventos guardados.\n\n`GET /evento`"]
pub async fn buscar_paginador_evento(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorEvento,
) -> Result<tipos::PaginaEvento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/evento")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Publica um evento de teste pelo painel\n\nExige a área `monitoramento` com permissão de criar. Publica um evento em nome do aplicativo dono do tipo, registra quem publicou e cria as entregas para todas as assinaturas ativas daquela versão. O id do evento é gerado pelo hub (UUIDv7). `entidade_id` é obrigatório, com no máximo 200 caracteres (os espaços nas pontas são removidos). `ocorrido_em` é opcional e, sem ele, vale o horário do recebimento. O tipo precisa estar ativo e a versão do esquema não pode estar desligada; `dados` é validado contra o JSON Schema da versão e os erros voltam no `422`, até 50 por resposta. Devolve o evento detalhado, já com as entregas criadas.\n\n`POST /evento`"]
pub async fn criar_evento(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::EventoCriar,
) -> Result<tipos::EventoDetalhado, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/evento")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca eventos por filtro\n\nExige a área `monitoramento` com permissão de ler. Todos os filtros são opcionais e se somam: `id` do evento, `tipo_de_evento_id`, `aplicativo_publicador_id`, `entidade_id` (igualdade exata, sem os espaços nas pontas) e o intervalo `desde`/`ate` sobre o horário de recebimento (RFC 3339, inclusivo). Devolve no máximo 200 eventos, do recebido mais recente para o mais antigo, sem paginação e sem os `dados`.\n\n`GET /evento/filtro`"]
pub async fn buscar_pelo_filtro_evento(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroEvento,
) -> Result<Vec<tipos::Evento>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/evento/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Visão geral do hub\n\nExige a área `monitoramento` com permissão de ler. Devolve os totais das últimas 24 horas (eventos recebidos, recusados, entregas concluídas e tentativas com falha, contando como falha toda resposta fora de 2xx ou sem resposta), a situação atual da fila (entregas pendentes, aguardando nova tentativa e na fila de erro), os cadastros ativos (aplicativos, tipos de evento e assinaturas) e `por_hora`: 24 faixas de uma hora, da mais antiga até a hora atual, com eventos, recusados e entregas com falha.\n\n`GET /evento/resumo`"]
pub async fn buscar_resumo_evento(
credencial_de_acesso: &CredencialDeAcesso,
) -> Result<tipos::ResumoDosEventos, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/evento/resumo")
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca um evento pelo id\n\nExige a área `monitoramento` com permissão de ler. Devolve o evento com os `dados` publicados, os contadores das entregas e a lista das entregas de cada assinante. Eventos mais velhos que a retenção do tipo são apagados de verdade e passam a responder `404`.\n\n`GET /evento/{id}`"]
pub async fn buscar_pelo_id_evento(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::EventoDetalhado, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/evento/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista eventos recusados com paginação\n\nExige a área `monitoramento`. Os mais recentes vêm primeiro. `pagina` começa em 1 (padrão 1); `tamanho` tem padrão 10. Recusados com mais de 30 dias são apagados pela limpeza diária.\n\n`GET /evento_recusado`"]
pub async fn buscar_paginador_evento_recusado(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorEventoRecusado,
) -> Result<tipos::PaginaEventoRecusado, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/evento_recusado")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca eventos recusados por filtro\n\nExige a área `monitoramento`. Sem paginação: devolve no máximo 200 recusados, os mais recentes primeiro. Todos os filtros são opcionais e se somam. `motivo` é `token_invalido`, `aplicativo_inativo`, `envelope_invalido`, `tipo_desconhecido`, `tipo_inativo`, `versao_inexistente`, `versao_desligada`, `publicador_nao_e_dono` ou `dados_fora_do_contrato`. `nome_do_tipo_informado` procura parte do nome, sem diferenciar maiúsculas. `desde` e `ate` (data e hora ISO 8601, inclusivos) limitam o momento da recusa.\n\n`GET /evento_recusado/filtro`"]
pub async fn buscar_pelo_filtro_evento_recusado(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroEventoRecusado,
) -> Result<Vec<tipos::EventoRecusado>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/evento_recusado/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca um evento recusado pelo id\n\nExige a área `monitoramento`. Devolve o que o publicador informou (aplicativo, id do evento, tipo e versão, quando foi possível ler), o `motivo` da recusa, os `erros_de_validacao` do JSON Schema (só em `dados_fora_do_contrato`) e um trecho do corpo recebido. Recusados ficam guardados por 30 dias.\n\n`GET /evento_recusado/{id}`"]
pub async fn buscar_pelo_id_evento_recusado(
credencial_de_acesso: &CredencialDeAcesso,
id: i64,
) -> Result<tipos::EventoRecusado, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/evento_recusado/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Publica um evento no hub\n\nExige o token de aplicativo do TermoAuth (`Authorization: Bearer <token>`, `tipo: aplicativo`): é aqui que cada aplicativo publica os eventos dos dados de que é dono. Token de usuário não publica.\n\n**Token.** O app troca o segredo dele (`SEGREDO_DO_APP_GERADO_NO_TERMO_AUTH`) por um JWT de 15 minutos em `POST /token_de_app` do TermoAuth; o `termo_core` faz isso sozinho. O hub valida o JWT offline pelo JWKS do TermoAuth. O publicador é o aplicativo cujo `identificador_no_termoauth` é o `sub` do token; se ele ainda não existir, é criado na hora com o `name` do token, ativo e sem tipos de evento.\n\n**Corpo.** JSON de até 1 MiB com o envelope `{ id, tipo, versao, entidade_id, ocorrido_em, dados }`: `id` é um UUID (de preferência UUIDv7) gerado pelo publicador e é a chave de idempotência; `tipo` é o nome do tipo de evento no catálogo; `versao` é o número da versão do esquema (maior que zero); `entidade_id` tem de 1 a 200 caracteres; `ocorrido_em` é RFC 3339; `dados` é validado contra o JSON Schema da versão.\n\n**Ordem das verificações.** Token, aplicativo ativo, envelope, tipo cadastrado e ativo, publicador dono do tipo, versão cadastrada e não desligada, e os `dados` contra o contrato. Toda recusa fica registrada nos eventos recusados do painel com o `motivo` devolvido: `token_invalido`, `aplicativo_inativo`, `envelope_invalido`, `tipo_desconhecido`, `tipo_inativo`, `publicador_nao_e_dono`, `versao_inexistente`, `versao_desligada` ou `dados_fora_do_contrato`.\n\n**Idempotência.** Um `id` já recebido responde `200` com `situacao: repetido` e não cria entregas de novo, então reenviar depois de uma falha de rede é seguro. Aceito, o evento é entregue a todas as assinaturas ativas da versão publicada, pelo menos uma vez cada. Publicar numa versão descontinuada é aceito, mas volta um `aviso` pedindo a migração.\n\n`POST /eventos`"]
pub async fn receber_evento_eventos(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::EnvelopeDoEvento,
) -> Result<tipos::PublicacaoRepetida, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/eventos")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista os perfis de acesso com paginação\n\nExige qualquer permissão da área `colaboradores` (qualquer ação liberada na área já libera a leitura). Ordena pelo nome. `pagina` começa em 1 (padrão 1; valores menores viram 1). A página tem sempre 50 itens: `tamanho` é aceito, mas ignorado. `total` conta todos os registros não excluídos.\n\n`GET /perfil_acesso`"]
pub async fn buscar_paginador_perfil_acesso(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorPerfilAcesso,
) -> Result<tipos::PaginaPerfilAcesso, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/perfil_acesso")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Cria um perfil de acesso\n\nExige a permissão `criar` da área `colaboradores`. O perfil de acesso é o conjunto de permissões que o TermoWebhook dá a um colaborador: cada colaborador aponta para um perfil (`PATCH /colaborador/{id}/perfil_acesso`) e enxerga o que o perfil libera. `nome` é obrigatório (até 80 caracteres, único sem diferenciar maiúsculas); `descricao` é opcional (até 200); `permissoes` traz, para cada área (`monitoramento`, `aplicativos`, `contratos`, `assinaturas` e `colaboradores`), as ações `ler`, `criar`, `editar` e `deletar` (o que não vier fica `false`). A resposta inclui `colaboradores`, quantas pessoas usam o perfil. O master do TermoAuth tem tudo liberado sem precisar de perfil.\n\n`POST /perfil_acesso`"]
pub async fn criar_perfil_acesso(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::PerfilAcessoCriar,
) -> Result<tipos::PerfilAcesso, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/perfil_acesso")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista básica de perfis de acesso para seleção\n\nExige qualquer permissão da área `colaboradores` (qualquer ação liberada na área já libera a leitura). Devolve só o id e o nome, em ordem alfabética. `busca` procura por trecho do nome, sem diferenciar maiúsculas. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10, sem máximo; valores menores que 1 viram 1. `total` conta os registros que casam com a busca.\n\n`GET /perfil_acesso/autocomplete`"]
pub async fn buscar_auto_complete_perfil_acesso(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarAutoCompletePerfilAcesso,
) -> Result<tipos::PaginaPerfilAcessoAutoComplete, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/perfil_acesso/autocomplete",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca perfis de acesso por filtro\n\nExige qualquer permissão da área `colaboradores` (qualquer ação liberada na área já libera a leitura). Devolve todos os perfis que casam com o filtro, sem paginação, em ordem alfabética de nome. `nome` procura por trecho, sem diferenciar maiúsculas. Sem filtro, devolve todos (é o que a tela usa para listar e para escolher o perfil de um colaborador).\n\n`GET /perfil_acesso/filtro`"]
pub async fn buscar_pelo_filtro_perfil_acesso(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroPerfilAcesso,
) -> Result<Vec<tipos::PerfilAcesso>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/perfil_acesso/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca um perfil de acesso pelo id\n\nExige qualquer permissão da área `colaboradores` (qualquer ação liberada na área já libera a leitura). Perfil excluído responde `404`.\n\n`GET /perfil_acesso/{id}`"]
pub async fn buscar_pelo_id_perfil_acesso(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::PerfilAcesso, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/perfil_acesso/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Atualiza um perfil de acesso pelo id\n\nExige a permissão `editar` da área `colaboradores`. Atualização parcial: só os campos enviados mudam. `nome` segue o limite do cadastro; `descricao` vazia apaga o valor; `permissoes`, quando enviado, substitui o conjunto inteiro (o que não vier fica `false`). Todo colaborador do perfil passa a valer com as novas permissões em até 5 minutos (cache do acesso).\n\n`PATCH /perfil_acesso/{id}`"]
pub async fn atualizar_pelo_id_perfil_acesso(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
corpo_da_requisicao: &tipos::PerfilAcessoAtualizar,
) -> Result<tipos::PerfilAcesso, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::PATCH,
&format!("/perfil_acesso/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Exclui um perfil de acesso pelo id\n\nExige a permissão `deletar` da área `colaboradores`. A exclusão é lógica e só é aceita quando nenhum colaborador usa o perfil: com gente vinculada responde `409`, e é preciso trocar o perfil dessas pessoas antes.\n\n`DELETE /perfil_acesso/{id}`"]
pub async fn deletar_pelo_id_perfil_acesso(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<(), ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::DELETE,
&format!("/perfil_acesso/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ignorar_corpo_da_resposta()
.await
}
#[doc = "Lista solicitações de reprocessamento com paginação\n\nExige a área `monitoramento`. As mais recentes vêm primeiro. `pagina` começa em 1 (padrão 1); `tamanho` tem padrão 10.\n\n`GET /solicitacao_de_reprocessamento`"]
pub async fn buscar_paginador_solicitacao_de_reprocessamento(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorSolicitacaoDeReprocessamento,
) -> Result<tipos::PaginaSolicitacaoDeReprocessamento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/solicitacao_de_reprocessamento",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Solicita o reprocessamento de entregas\n\nExige a área `monitoramento` com permissão de criar. `motivo` é obrigatório (até 500 caracteres) e fica no histórico junto com quem pediu. O `alcance` define o que é reenviado:\n\n- `entrega`: exige `entrega_id`. Reenvia aquela entrega agora, mesmo que já tenha sido entregue, cancelada ou esteja aguardando nova tentativa (se ela está pendente, nada muda). Para reenviar várias, faça uma solicitação por entrega.\n- `fila_de_erro`: exige `assinatura_id`. Reabre todas as entregas da assinatura que esgotaram as tentativas.\n- `periodo`: exige `assinatura_id` e `eventos_desde`; `eventos_ate` é opcional (sem ele, vai até agora) e não pode ser antes do início. Cria as entregas que faltam para os eventos recebidos no período e reabre as esgotadas e as canceladas; com `incluir_entregues = true`, reenvia também as já entregues.\n\nCampos que não pertencem ao alcance escolhido são ignorados. A assinatura precisa estar ativa. Cada entrega reaberta recomeça o ciclo de tentativas. A resposta traz quantas entregas foram reabertas e quantas foram criadas.\n\n`POST /solicitacao_de_reprocessamento`"]
pub async fn criar_solicitacao_de_reprocessamento(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::SolicitacaoDeReprocessamentoCriar,
) -> Result<tipos::SolicitacaoDeReprocessamento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::POST,
"/solicitacao_de_reprocessamento",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca solicitações de reprocessamento por filtro\n\nExige a área `monitoramento`. Sem paginação: devolve no máximo 200 solicitações, as mais recentes primeiro. Filtros opcionais e somados: `assinatura_id` e `alcance` (`entrega`, `fila_de_erro` ou `periodo`; outro valor não encontra nada).\n\n`GET /solicitacao_de_reprocessamento/filtro`"]
pub async fn buscar_pelo_filtro_solicitacao_de_reprocessamento(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroSolicitacaoDeReprocessamento,
) -> Result<Vec<tipos::SolicitacaoDeReprocessamento>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/solicitacao_de_reprocessamento/filtro",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca uma solicitação de reprocessamento pelo id\n\nExige a área `monitoramento`. Devolve quem pediu, o motivo, o alcance com seus parâmetros, a assinatura (assinante e tipo de evento) e quantas entregas foram reabertas e criadas.\n\n`GET /solicitacao_de_reprocessamento/{id}`"]
pub async fn buscar_pelo_id_solicitacao_de_reprocessamento(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::SolicitacaoDeReprocessamento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!(
"/solicitacao_de_reprocessamento/{}",
codificar_parametro_de_caminho(id)
),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Verifica se o backend está no ar\n\nPública, sem token. Responde `200` com `sucesso: true` e a versão do backend no ar (semver) sempre que o servidor está de pé; não consulta o banco nem o TermoAuth.\n\n`GET /test`"]
pub async fn verificar_saude_test() -> Result<tipos::SaudeDoBackend, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/test")
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista os tipos de evento paginados\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Lista os tipos não excluídos em ordem alfabética do nome. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10, sem máximo; valores menores que 1 viram 1. `total` é a quantidade de tipos não excluídos.\n\n`GET /tipo_de_evento`"]
pub async fn buscar_paginador_tipo_de_evento(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorTipoDeEvento,
) -> Result<tipos::PaginaTipoDeEvento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/tipo_de_evento")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Cadastra um tipo de evento\n\nExige a permissão `criar` na área `contratos`. `nome` segue o formato `dominio.acontecimento`, só com letras minúsculas, números e `_` (ex.: `pedido.faturado`), tem até 120 caracteres, é único entre os tipos não excluídos e não muda depois. `descricao` é obrigatória (até 500 caracteres). `aplicativo_dono_id` é o aplicativo que publica o tipo: só ele pode publicar eventos desse tipo. `dias_de_retencao` vai de 1 a 3650 (padrão 30): eventos mais velhos que isso são apagados de vez pela limpeza diária. `ativo` tem padrão `true`; tipo inativo tem as publicações recusadas. O tipo nasce sem versões: cadastre o esquema em `POST /versao_de_esquema`.\n\n`POST /tipo_de_evento`"]
pub async fn criar_tipo_de_evento(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::TipoDeEventoCriar,
) -> Result<tipos::TipoDeEvento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/tipo_de_evento")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista básica de tipos de evento para seleção\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Devolve só id, nome, descrição e o id do aplicativo dono, em ordem alfabética do nome, sem os excluídos. `busca` procura o trecho no nome e na descrição, sem diferenciar maiúsculas. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10.\n\n`GET /tipo_de_evento/autocomplete`"]
pub async fn buscar_auto_complete_tipo_de_evento(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarAutoCompleteTipoDeEvento,
) -> Result<tipos::PaginaTipoDeEventoAutoComplete, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/tipo_de_evento/autocomplete",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca tipos de evento por filtro\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Devolve todos os tipos não excluídos que casam com o filtro, sem paginação, em ordem alfabética do nome. `nome` procura o trecho no nome e na descrição, sem diferenciar maiúsculas; `aplicativo_dono_id` e `ativo` filtram pelo valor exato. Sem filtro, devolve todos.\n\n`GET /tipo_de_evento/filtro`"]
pub async fn buscar_pelo_filtro_tipo_de_evento(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroTipoDeEvento,
) -> Result<Vec<tipos::TipoDeEvento>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/tipo_de_evento/filtro")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca um tipo de evento pelo id\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Tipo excluído não é encontrado. Traz o nome do aplicativo dono, as versões do esquema não excluídas (número e situação, em ordem crescente), a quantidade de assinaturas e a data do último evento recebido.\n\n`GET /tipo_de_evento/{id}`"]
pub async fn buscar_pelo_id_tipo_de_evento(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::TipoDeEvento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/tipo_de_evento/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Atualiza um tipo de evento pelo id\n\nExige a permissão `editar` na área `contratos`. Atualização parcial: só os campos enviados mudam; o `nome` não pode ser alterado. `descricao` não pode ficar vazia (até 500 caracteres), `dias_de_retencao` vai de 1 a 3650 e `aplicativo_dono_id` precisa ser um aplicativo existente. O dono não pode mudar enquanto houver eventos publicados pelo dono atual ainda dentro da retenção. Desativar o tipo faz as próximas publicações dele serem recusadas.\n\n`PATCH /tipo_de_evento/{id}`"]
pub async fn atualizar_pelo_id_tipo_de_evento(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
corpo_da_requisicao: &tipos::TipoDeEventoAtualizar,
) -> Result<tipos::TipoDeEvento, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::PATCH,
&format!("/tipo_de_evento/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Exclui um tipo de evento pelo id\n\nExige a permissão `deletar` na área `contratos`. A exclusão é lógica: o tipo e todas as versões do esquema dele somem das leituras e o nome fica livre para um novo cadastro, mas nada é apagado e não há como restaurar. Só exclui tipo sem assinaturas; exclua-as antes. Os eventos já recebidos continuam até vencer a retenção.\n\n`DELETE /tipo_de_evento/{id}`"]
pub async fn deletar_pelo_id_tipo_de_evento(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<(), ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::DELETE,
&format!("/tipo_de_evento/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ignorar_corpo_da_resposta()
.await
}
#[doc = "Lista as versões do esquema paginadas\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Lista as versões não excluídas, ordenadas pelo nome do tipo e da versão mais nova para a mais velha. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10, sem máximo; valores menores que 1 viram 1. `total` é a quantidade de versões não excluídas.\n\n`GET /versao_de_esquema`"]
pub async fn buscar_paginador_versao_de_esquema(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPaginadorVersaoDeEsquema,
) -> Result<tipos::PaginaVersaoDeEsquema, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/versao_de_esquema")
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Cadastra uma versão do esquema de um tipo de evento\n\nExige a permissão `criar` na área `contratos`. `esquema_dos_dados` é o JSON Schema (um objeto, até 256 KB) contra o qual o campo `dados` de cada evento publicado nessa versão é validado; um esquema que não compila é recusado. `versao` é opcional e maior que zero: sem ela, o backend usa a próxima depois da maior já cadastrada para o tipo, contando as excluídas, porque número de versão excluída não volta. `situacao` é `ativa` (padrão), `descontinuada` (ainda aceita publicações) ou `desligada` (recusa publicações e novas assinaturas). `versao_do_pacote_de_contratos` vai até 100 caracteres; sem ela, fica registrado que veio do cadastro manual no painel.\n\n`POST /versao_de_esquema`"]
pub async fn criar_versao_de_esquema(
credencial_de_acesso: &CredencialDeAcesso,
corpo_da_requisicao: &tipos::VersaoDeEsquemaCriar,
) -> Result<tipos::VersaoDeEsquema, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/versao_de_esquema")
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Lista básica de versões do esquema para seleção\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Devolve só id, tipo de evento, número e situação, sem o JSON Schema, ordenados pelo nome do tipo e pelo número da versão, sem as excluídas. `busca` procura o trecho no nome do tipo de evento, sem diferenciar maiúsculas; `tipo_de_evento_id` restringe a um tipo. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10.\n\n`GET /versao_de_esquema/autocomplete`"]
pub async fn buscar_auto_complete_versao_de_esquema(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarAutoCompleteVersaoDeEsquema,
) -> Result<tipos::PaginaVersaoDeEsquemaAutoComplete, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/versao_de_esquema/autocomplete",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca versões do esquema por filtro\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Devolve todas as versões não excluídas que casam com o filtro, sem paginação, ordenadas pelo nome do tipo e da versão mais nova para a mais velha. `tipo_de_evento_id` filtra pelo tipo; `situacao` é `ativa`, `descontinuada` ou `desligada`. Sem filtro, devolve todas.\n\n`GET /versao_de_esquema/filtro`"]
pub async fn buscar_pelo_filtro_versao_de_esquema(
credencial_de_acesso: &CredencialDeAcesso,
parametros: &ParametrosDeBuscarPeloFiltroVersaoDeEsquema,
) -> Result<Vec<tipos::VersaoDeEsquema>, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
"/versao_de_esquema/filtro",
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_parametros_de_consulta(parametros)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Busca uma versão do esquema pelo id\n\nLeitura liberada a quem tem a permissão `ler` em `contratos`, `assinaturas` ou `monitoramento`. Versão excluída não é encontrada. Traz o JSON Schema completo, o nome do tipo de evento, a situação, quando deixou de ser ativa (`descontinuada_em`) e quantas assinaturas usam a versão.\n\n`GET /versao_de_esquema/{id}`"]
pub async fn buscar_pelo_id_versao_de_esquema(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<tipos::VersaoDeEsquema, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::GET,
&format!("/versao_de_esquema/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Atualiza uma versão do esquema pelo id\n\nExige a permissão `editar` na área `contratos`. Atualização parcial: só os campos enviados mudam; o tipo de evento e o número da versão não mudam. `esquema_dos_dados` segue as mesmas regras do cadastro (objeto JSON Schema válido, até 256 KB) e passa a valer para as próximas publicações. `situacao` é `ativa`, `descontinuada` ou `desligada`: ao sair de `ativa` a data de `descontinuada_em` é registrada, e ao voltar para `ativa` ela é limpa; `desligada` recusa novas publicações nessa versão. `versao_do_pacote_de_contratos` vai até 100 caracteres; texto vazio mantém o valor atual.\n\n`PATCH /versao_de_esquema/{id}`"]
pub async fn atualizar_pelo_id_versao_de_esquema(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
corpo_da_requisicao: &tipos::VersaoDeEsquemaAtualizar,
) -> Result<tipos::VersaoDeEsquema, ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::PATCH,
&format!("/versao_de_esquema/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ler_resposta_json()
.await
}
#[doc = "Exclui uma versão do esquema pelo id\n\nExige a permissão `deletar` na área `contratos`. A exclusão é lógica: a versão some das leituras e passa a recusar publicações, mas o registro não é apagado e não há como restaurar; o número dela não pode ser reaproveitado. Só exclui versão sem assinaturas; migre-as para outra versão ou exclua-as antes.\n\n`DELETE /versao_de_esquema/{id}`"]
pub async fn deletar_pelo_id_versao_de_esquema(
credencial_de_acesso: &CredencialDeAcesso,
id: uuid::Uuid,
) -> Result<(), ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(
&SERVICO_DESTA_API,
Method::DELETE,
&format!("/versao_de_esquema/{}", codificar_parametro_de_caminho(id)),
)
.com_credencial_de_acesso(credencial_de_acesso)
.enviar_e_ignorar_corpo_da_resposta()
.await
}
#[doc = "Recebe as entregas do hub como assinante\n\nPública, sem token do usuário: é onde o próprio TermoWebhook, como assinante, recebe as entregas do hub. A assinatura é conferida pelo crate `termo_core` (feature `webhook_receber`) com a chave pública do hub (endereço do hub pelo `AMBIENTE` + `/.well-known/jwks.json`) e o id do aplicativo em `TERMOWEBHOOK_APLICATIVO_ID`.\n\n**Eventos assinados.** `colaborador.criado` v1 cria o acesso e o colaborador de quem ainda não existe aqui, sem perfil de acesso. `colaborador.atualizado` v1 grava e-mail e master, o nome só quando `nome` está em `campos_alterados`, e a troca de perfil liga ou desliga o acesso (virou cliente desliga, voltou a colaborador religa); quem é colaborador e ainda não existe é criado.\n\n**Ordem e repetição.** A entrega é pelo menos uma vez e sem ordem garantida: a alteração só é aplicada quando o `ocorrido_em` é mais novo que o do último evento aplicado àquele acesso; o repetido ou atrasado responde `200` sem mudar nada. Tipo que o app não assina responde `200`.\n\n`POST /webhooks/termowebhook`"]
pub async fn webhooks_receber_evento_termo_webhook(
parametros: &ParametrosDeWebhooksReceberEventoTermoWebhook,
corpo_da_requisicao: &tipos::EntregaRecebida,
) -> Result<(), ErroAoChamarServico> {
RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/webhooks/termowebhook")
.com_cabecalho_opcional(
"X-TermoWebhook-Data",
Some(¶metros.x_termo_webhook_data),
)
.com_cabecalho_opcional(
"X-TermoWebhook-Chave",
Some(¶metros.x_termo_webhook_chave),
)
.com_cabecalho_opcional(
"X-TermoWebhook-Destino",
Some(¶metros.x_termo_webhook_destino),
)
.com_cabecalho_opcional(
"X-TermoWebhook-Assinatura",
Some(¶metros.x_termo_webhook_assinatura),
)
.com_corpo_json(corpo_da_requisicao)
.enviar_e_ignorar_corpo_da_resposta()
.await
}