termo_core 0.1.21

Todos os clientes da Termotubos num crate só: um módulo por serviço e cada rota da API como uma função de uma linha, com o endereço resolvido pelo ambiente atual.
Documentation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
// 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<String>,
    #[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 `/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<String>,
    #[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<String>,
    #[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<String>,
    #[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 `/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<String>,
    #[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 = "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: &str,
) -> 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 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 = "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 = "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
}