termo_core 0.1.87

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
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
// 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_FLOW 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 `/cadencia`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorCadencia {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub busca: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativo: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub robo_id: Option<uuid::Uuid>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/cadencia/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteCadencia {
    #[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>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativo: Option<bool>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/cadencia/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroCadencia {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nome: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub robo_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativo: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contato_novo: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub com_segmento: Option<bool>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/cliente_configuracao`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorClienteConfiguracao {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativo: Option<bool>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/cliente_configuracao/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteClienteConfiguracao {
    #[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 `/cliente_configuracao/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroClienteConfiguracao {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cliente_ids: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativo: Option<bool>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BuscarPaginadorContatoOrdenar {
    #[serde(rename = "nome")]
    Nome,
    #[serde(rename = "telefone")]
    Telefone,
    #[serde(rename = "email")]
    Email,
    #[serde(rename = "empresa")]
    Empresa,
    #[serde(rename = "conta")]
    Conta,
    #[serde(rename = "ultima_atividade_em")]
    UltimaAtividadeEm,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BuscarPaginadorContatoDirecao {
    #[serde(rename = "crescente")]
    Crescente,
    #[serde(rename = "decrescente")]
    Decrescente,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BuscarPaginadorContatoTelefone {
    #[serde(rename = "com")]
    Com,
    #[serde(rename = "sem")]
    Sem,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BuscarPaginadorContatoEmail {
    #[serde(rename = "com")]
    Com,
    #[serde(rename = "sem")]
    Sem,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum BuscarPaginadorContatoEmpresa {
    #[serde(rename = "com")]
    Com,
    #[serde(rename = "sem")]
    Sem,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/contato`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorContato {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub busca: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config_system_chatwoot_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ordenar: Option<BuscarPaginadorContatoOrdenar>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direcao: Option<BuscarPaginadorContatoDirecao>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telefone: Option<BuscarPaginadorContatoTelefone>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<BuscarPaginadorContatoEmail>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub empresa: Option<BuscarPaginadorContatoEmpresa>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub atividade_desde: Option<chrono::DateTime<chrono::Utc>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sem_atividade_desde: Option<chrono::DateTime<chrono::Utc>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/contato/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteContato {
    #[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 `/contato/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroContato {
    #[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 telefone: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config_system_chatwoot_id: Option<uuid::Uuid>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/contato/origem-regra`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeOrigemRegraBuscarPaginadorContato {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/contato/origem-regra/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeOrigemRegraBuscarAutoCompleteContato {
    #[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 `/contato/origem-regra/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeOrigemRegraBuscarPeloFiltroContato {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub frase: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativa: Option<bool>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/contato/{id}/origens`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeOrigemBuscarPaginadorContato {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/conversa`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorConversa {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config_system_whatsapp_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sincronizacao: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nao_lidas: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fora_do_chatwoot: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contato: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub texto: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fila: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub equipe_chatwoot_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vendedor_email: Option<String>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/conversa/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteConversa {
    #[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 `/conversa/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroConversa {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cliente_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub robo_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config_system_z_api_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chatwoot_conversa_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config_system_chatwoot_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chatwoot_contato_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contato: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub texto: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sincronizacao: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nao_lidas: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub config_system_whatsapp_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fora_do_chatwoot: Option<bool>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/robo`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorRobo {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub busca: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativo: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub com_numero: Option<bool>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/robo/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteRobo {
    #[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 `/robo/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroRobo {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nome: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modelo: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ativo: Option<bool>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/sessao`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPaginadorSessao {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagina: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub robo_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contato: Option<String>,
}

#[doc = "Parâmetros de consulta e de cabeçalho de `/sessao/autocomplete`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarAutoCompleteSessao {
    #[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 `/sessao/filtro`."]
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParametrosDeBuscarPeloFiltroSessao {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub robo_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conversa_id: Option<uuid::Uuid>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chatwoot_conversa_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contato: Option<String>,
}

#[doc = "Lista as cadências com paginação\n\nExige qualquer permissão da área `cadencias`, `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Ordena por nome. `pagina` começa em 1 (padrão 1; valores menores viram 1) e a página tem sempre 50 itens. `busca` (opcional) procura no nome e na descrição; `ativo` (opcional) traz só as ativas ou só as desativadas; `robo_id` (opcional) traz só as do robô. `total` conta as cadências não excluídas que casam com os filtros.\n\n`GET /cadencia`"]
pub async fn buscar_paginador_cadencia(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPaginadorCadencia,
) -> Result<tipos::PaginaCadencia, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/cadencia")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Cadastra uma cadência de contatos\n\nExige a permissão `criar` da área `cadencias`. `nome` é obrigatório (até 80 caracteres, único entre as cadências), `descricao` vai até 200 e `robo_id` é o robô de prompt e IA que escreve as mensagens por IA (de `GET /robo/autocomplete`; robô inexistente dá `400`). Envia por **um** número: `config_system_whatsapp_oficial_id` (WhatsApp oficial da Meta) **ou** `config_system_whatsapp_id` (número do QR Code); os dois juntos dão `400`, e o número precisa existir e estar ativo. A cadência nasce desativada, na versão 1, com o fluxo só com o `inicio`, prioridade 5, `ao_conflitar = ignorar` e os padrões de `entradas`, `horario` e `limites`; o resto se monta depois pelo `PATCH`, com estes campos: `entradas` diz quem entra sozinho: `contato_novo` (booleano; o contato novo entra na cadência de maior prioridade do robô que tem essa entrada ligada) e `segmento` (opcional; `null` desliga) com `operador` `e` (todas as regras valem) ou `ou` (basta uma) e `regras` (1 a 10, cada uma com `id` único, `tipo` e `valor`): `sem_pedido_ha_dias`, `sem_conversa_ha_dias`, `sem_resposta_ha_dias`, `conversa_resolvida_ha_dias`, `sem_mensagem_do_contato_ha_dias`, `parou_de_comprar_ha_dias` e `contato_cadastrado_ha_dias` pedem em `valor` um número de dias de 0 a 3650; `estado` pede a sigla com 2 letras; `cidade` pede o nome, até 80 caracteres; `cliente_do_portal`, `contato_novo`, `nunca_respondeu`, `nunca_comprou` e `fora_de_cadencia` não usam `valor`. `horario` é a janela de envio no horário de Brasília: `hora_inicio` (0 a 23, padrão 8), `hora_fim` (até 24 e maior que `hora_inicio`, padrão 18) e `dias_da_semana` (pelo menos um, de 1 = segunda a 7 = domingo; padrão 1 a 5). `limites`: `maximo_mensagens` por contato (1 a 30, padrão 5), `intervalo_minimo_horas` entre mensagens (0 a 336, padrão 20), `dias_de_carencia` antes de inscrever o mesmo contato de novo (0 a 365, padrão 30), `pausar_com_atendente` (padrão `true`: pausa a inscrição quando um atendente assume a conversa) e `palavras_de_saida` (até 20, cada uma com texto e até 40 caracteres; a resposta com uma delas tira o contato da cadência). `prioridade` vai de 1 a 10 (padrão 5) e `ao_conflitar` (padrão `ignorar`) decide o que fazer com o contato que já está em outra cadência: `ignorar` (não inscreve), `enfileirar` (entra na fila) ou `substituir` (troca quando a prioridade desta é maior ou igual). `fluxo` é o caminho da cadência: `nos` (até 40 passos, exatamente um do tipo `inicio`, com id `inicio`; os outros tipos são `mensagem`, `esperar`, `decidir`, `encaminhar` e `encerrar`; todo passo tem `id` único, `tipo` e `posicao` {`x`, `y`}) e `ligacoes` (`id`, `origem`, `destino` e `origem_saida`, que é `sim` ou `nao` nas ligações que saem do `decidir` e `null` nos outros). Cada passo fora o início precisa de `nome` (até 60 caracteres). `mensagem`: texto fixo em `mensagem` (até 1000 caracteres, com marcadores como `{{contato.nome}}`, `{{cliente.nome}}`, `{{cliente.razao_social}}`, `{{cliente.nome_fantasia}}`, `{{cliente.cnpj}}`, `{{cliente.email}}`, `{{cliente.telefone}}`, `{{cliente.cidade}}` e `{{cliente.estado}}`; marcador inexistente dá `400`) ou, com `mensagem_por_ia = true`, a `instrucao` (até 2000) para a IA do robô escrever; `objetivo` vai até 200 e `ferramentas` lista até 128 ids de ferramentas do robô. `ao_responder` diz quem trata a resposta do contato: `cadencia` (padrão; a cadência registra a resposta e segue o fluxo), `robo` (a mensagem sai como novo atendimento e, na resposta, o robô da caixa do Chatwoot do número recomeça o fluxo dele do início) ou `vendedor` (entrega a conversa à equipe `equipe_id` e/ou ao vendedor `vendedor_id` do Chatwoot; exige pelo menos um dos dois). `esperar`: `quantidade` (maior que zero) na `unidade` `minutos`, `horas` ou `dias` (padrão `dias`; no máximo 90 dias), `dias_uteis` (com `dias`, pula sábado e domingo) e `interromper_ao_responder` (padrão `true`: a resposta do contato encerra a espera na hora). `decidir`: `condicao` `respondeu`, `atendente_assumiu`, `conversa_resolvida` ou `cliente_do_portal`, com uma ligação `sim` e uma `nao`. `encaminhar`: passa a conversa à equipe `equipe_id` e/ou ao vendedor `vendedor_id` do Chatwoot (opcionais, maiores que zero), enviando a `mensagem` (até 1000; em branco, um aviso padrão); termina a cadência. `encerrar`: `resultado` `convertido`, `sem_resposta`, `sem_interesse` ou `outro`; termina a cadência. `encaminhar` e `encerrar` não têm próximo passo, os outros passos têm uma saída só; nenhuma ligação volta ao início nem liga o passo nele mesmo, e cada saída tem no máximo um próximo passo. Para ligar a cadência ao gatilho de cliente sem resposta do robô, use o `id` dela no `cadencia_id` do gatilho.\n\n`POST /cadencia`"]
pub async fn criar_cadencia(
    credencial_de_acesso: &CredencialDeAcesso,
    corpo_da_requisicao: &tipos::CadenciaCriar,
) -> Result<tipos::Cadencia, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/cadencia")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_corpo_json(corpo_da_requisicao)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista básica de cadências para seleção\n\nExige qualquer permissão da área `cadencias`, `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve só id, nome e `ativo`, em ordem alfabética de nome, para achar o id de uma cadência (o mesmo do `cadencia_id` do gatilho do robô). `busca` procura por trecho do nome, sem diferenciar maiúsculas; `ativo` (opcional) traz só as ativas ou só as desativadas. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10; valores menores que 1 viram 1. `total` conta as cadências que casam com a busca.\n\n`GET /cadencia/autocomplete`"]
pub async fn buscar_auto_complete_cadencia(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarAutoCompleteCadencia,
) -> Result<tipos::PaginaDeCadenciaAutoComplete, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/cadencia/autocomplete")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca cadências por filtro\n\nExige qualquer permissão da área `cadencias`, `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve todas as cadências que casam com o filtro, com o fluxo, sem paginação, em ordem alfabética de nome. `nome` procura por trecho, sem diferenciar maiúsculas; `robo_id` e `ativo` comparam igual; `contato_novo` filtra pela entrada de contato novo e `com_segmento = true` traz só as que têm segmento (`false`, só as sem). Sem filtro, devolve todas.\n\n`GET /cadencia/filtro`"]
pub async fn buscar_pelo_filtro_cadencia(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPeloFiltroCadencia,
) -> Result<Vec<tipos::Cadencia>, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/cadencia/filtro")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca uma cadência pelo id\n\nExige qualquer permissão da área `cadencias`, `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve a cadência com as entradas, o horário, os limites e o fluxo completo (passos e ligações), no mesmo formato aceito pelo `PATCH`, além do nome do robô, do número que envia e de `inscricoes_em_andamento`. Cadência excluída responde `404`.\n\n`GET /cadencia/{id}`"]
pub async fn buscar_pelo_id_cadencia(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<tipos::Cadencia, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!("/cadencia/{}", codificar_parametro_de_caminho(id)),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Atualiza uma cadência pelo id\n\nExige a permissão `editar` da área `cadencias`. Atualização parcial: só os campos enviados mudam, com os mesmos limites do cadastro (`nome` até 80 e único, `descricao` até 200, `robo_id` de robô existente). Envia por **um** número: `config_system_whatsapp_oficial_id` (WhatsApp oficial da Meta) **ou** `config_system_whatsapp_id` (número do QR Code); os dois juntos dão `400`, e o número precisa existir e estar ativo. Escolher um número limpa o outro. `ativo = true` exige o início ligado ao primeiro passo e um número pronto para enviar (conectado); `ativo = false` pausa as inscrições em andamento e voltar a ativar as retoma. Enviar `fluxo`, `entradas`, `horario` ou `limites` sobe a `versao` em 1 e substitui o objeto inteiro (`fluxo` troca o fluxo inteiro: leia antes com `GET /cadencia/{id}`). `entradas` diz quem entra sozinho: `contato_novo` (booleano; o contato novo entra na cadência de maior prioridade do robô que tem essa entrada ligada) e `segmento` (opcional; `null` desliga) com `operador` `e` (todas as regras valem) ou `ou` (basta uma) e `regras` (1 a 10, cada uma com `id` único, `tipo` e `valor`): `sem_pedido_ha_dias`, `sem_conversa_ha_dias`, `sem_resposta_ha_dias`, `conversa_resolvida_ha_dias`, `sem_mensagem_do_contato_ha_dias`, `parou_de_comprar_ha_dias` e `contato_cadastrado_ha_dias` pedem em `valor` um número de dias de 0 a 3650; `estado` pede a sigla com 2 letras; `cidade` pede o nome, até 80 caracteres; `cliente_do_portal`, `contato_novo`, `nunca_respondeu`, `nunca_comprou` e `fora_de_cadencia` não usam `valor`. `horario` é a janela de envio no horário de Brasília: `hora_inicio` (0 a 23, padrão 8), `hora_fim` (até 24 e maior que `hora_inicio`, padrão 18) e `dias_da_semana` (pelo menos um, de 1 = segunda a 7 = domingo; padrão 1 a 5). `limites`: `maximo_mensagens` por contato (1 a 30, padrão 5), `intervalo_minimo_horas` entre mensagens (0 a 336, padrão 20), `dias_de_carencia` antes de inscrever o mesmo contato de novo (0 a 365, padrão 30), `pausar_com_atendente` (padrão `true`: pausa a inscrição quando um atendente assume a conversa) e `palavras_de_saida` (até 20, cada uma com texto e até 40 caracteres; a resposta com uma delas tira o contato da cadência). `prioridade` vai de 1 a 10 (padrão 5) e `ao_conflitar` (padrão `ignorar`) decide o que fazer com o contato que já está em outra cadência: `ignorar` (não inscreve), `enfileirar` (entra na fila) ou `substituir` (troca quando a prioridade desta é maior ou igual). `fluxo` é o caminho da cadência: `nos` (até 40 passos, exatamente um do tipo `inicio`, com id `inicio`; os outros tipos são `mensagem`, `esperar`, `decidir`, `encaminhar` e `encerrar`; todo passo tem `id` único, `tipo` e `posicao` {`x`, `y`}) e `ligacoes` (`id`, `origem`, `destino` e `origem_saida`, que é `sim` ou `nao` nas ligações que saem do `decidir` e `null` nos outros). Cada passo fora o início precisa de `nome` (até 60 caracteres). `mensagem`: texto fixo em `mensagem` (até 1000 caracteres, com marcadores como `{{contato.nome}}`, `{{cliente.nome}}`, `{{cliente.razao_social}}`, `{{cliente.nome_fantasia}}`, `{{cliente.cnpj}}`, `{{cliente.email}}`, `{{cliente.telefone}}`, `{{cliente.cidade}}` e `{{cliente.estado}}`; marcador inexistente dá `400`) ou, com `mensagem_por_ia = true`, a `instrucao` (até 2000) para a IA do robô escrever; `objetivo` vai até 200 e `ferramentas` lista até 128 ids de ferramentas do robô. `ao_responder` diz quem trata a resposta do contato: `cadencia` (padrão; a cadência registra a resposta e segue o fluxo), `robo` (a mensagem sai como novo atendimento e, na resposta, o robô da caixa do Chatwoot do número recomeça o fluxo dele do início) ou `vendedor` (entrega a conversa à equipe `equipe_id` e/ou ao vendedor `vendedor_id` do Chatwoot; exige pelo menos um dos dois). `esperar`: `quantidade` (maior que zero) na `unidade` `minutos`, `horas` ou `dias` (padrão `dias`; no máximo 90 dias), `dias_uteis` (com `dias`, pula sábado e domingo) e `interromper_ao_responder` (padrão `true`: a resposta do contato encerra a espera na hora). `decidir`: `condicao` `respondeu`, `atendente_assumiu`, `conversa_resolvida` ou `cliente_do_portal`, com uma ligação `sim` e uma `nao`. `encaminhar`: passa a conversa à equipe `equipe_id` e/ou ao vendedor `vendedor_id` do Chatwoot (opcionais, maiores que zero), enviando a `mensagem` (até 1000; em branco, um aviso padrão); termina a cadência. `encerrar`: `resultado` `convertido`, `sem_resposta`, `sem_interesse` ou `outro`; termina a cadência. `encaminhar` e `encerrar` não têm próximo passo, os outros passos têm uma saída só; nenhuma ligação volta ao início nem liga o passo nele mesmo, e cada saída tem no máximo um próximo passo.\n\n`PATCH /cadencia/{id}`"]
pub async fn atualizar_pelo_id_cadencia(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
    corpo_da_requisicao: &tipos::CadenciaAtualizar,
) -> Result<tipos::Cadencia, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::PATCH,
        &format!("/cadencia/{}", 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 = "Lista as configurações de clientes com paginação\n\nExige qualquer permissão da área `clientes` (qualquer ação liberada na área já libera a leitura). Ordena da atualização mais recente para a mais antiga. `pagina` começa em 1 (padrão 1; valores menores viram 1) e a página tem sempre 50 itens. `ativo` (opcional) filtra pela situação. `total` conta as configurações não excluídas que casam com o filtro.\n\n`GET /cliente_configuracao`"]
pub async fn buscar_paginador_cliente_configuracao(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPaginadorClienteConfiguracao,
) -> Result<tipos::PaginaDeClienteConfiguracao, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/cliente_configuracao")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista básica de configurações de clientes para seleção\n\nExige qualquer permissão da área `clientes` (qualquer ação liberada na área já libera a leitura). Devolve só o id da configuração e o `cliente_id` do TermoPortal, ordenados por `cliente_id`. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10; valores menores que 1 viram 1. `total` conta as configurações não excluídas.\n\n`GET /cliente_configuracao/autocomplete`"]
pub async fn buscar_auto_complete_cliente_configuracao(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarAutoCompleteClienteConfiguracao,
) -> Result<tipos::PaginaDeClienteConfiguracaoAutoComplete, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        "/cliente_configuracao/autocomplete",
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .com_parametros_de_consulta(parametros)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Busca configurações de clientes por filtro\n\nExige qualquer permissão da área `clientes` (qualquer ação liberada na área já libera a leitura). Devolve todas as configurações que casam com o filtro, sem paginação, ordenadas por `cliente_id`. `cliente_ids` é uma lista de ids de clientes do TermoPortal separados por vírgula (até 200); `ativo` filtra pela situação. Cliente da lista sem configuração não aparece (vale o padrão `ativo = true`). Sem filtro, devolve todas.\n\n`GET /cliente_configuracao/filtro`"]
pub async fn buscar_pelo_filtro_cliente_configuracao(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPeloFiltroClienteConfiguracao,
) -> Result<Vec<tipos::ClienteConfiguracao>, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        "/cliente_configuracao/filtro",
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .com_parametros_de_consulta(parametros)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Busca a configuração de um cliente pelo id\n\nExige qualquer permissão da área `clientes` (qualquer ação liberada na área já libera a leitura). A configuração guarda o que é do TermoFlow para um cliente do TermoPortal (`cliente_id` é o id do cliente no portal): o robô atende as conversas de todo cliente, menos as do cliente com `ativo = false`, que vão para a equipe. Cliente sem configuração vale `ativo = true`. Configuração excluída responde `404`.\n\n`GET /cliente_configuracao/{id}`"]
pub async fn buscar_pelo_id_cliente_configuracao(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<tipos::ClienteConfiguracao, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!(
            "/cliente_configuracao/{}",
            codificar_parametro_de_caminho(id)
        ),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Lista os contatos com paginação\n\nExige qualquer permissão da área `contatos` (qualquer ação liberada na área já libera a leitura). `ordenar` (opcional: `nome`, `telefone`, `email`, `empresa`, `conta` ou `ultima_atividade_em`; padrão `nome`) e `direcao` (opcional: `crescente` ou `decrescente`; padrão `crescente`) ordenam a base inteira antes da paginação; contato sem valor no campo fica no fim nas duas direções. `pagina` começa em 1 (padrão 1; valores menores viram 1). A página tem sempre 50 itens: `tamanho` é aceito, mas ignorado. `busca` (opcional) procura por trecho no nome, no e-mail, no identificador e na empresa, e pelos dígitos no telefone; `config_system_chatwoot_id` (opcional) traz só os contatos de uma conta do Chatwoot. `telefone`, `email` e `empresa` (opcionais: `com` ou `sem`) trazem só quem tem ou só quem não tem o campo preenchido; `atividade_desde` (opcional, data e hora ISO 8601) traz quem teve atividade a partir do instante; `sem_atividade_desde` (opcional, data e hora ISO 8601) traz quem não teve atividade a partir do instante, inclusive quem nunca teve; `tag` (opcional) traz só os contatos com pelo menos uma origem registrada com essa tag. `total` conta os contatos não excluídos que casam com a busca e os filtros.\n\n`GET /contato`"]
pub async fn buscar_paginador_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPaginadorContato,
) -> Result<tipos::PaginaDeContato, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/contato")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista básica de contatos para seleção\n\nExige qualquer permissão da área `contatos` (qualquer ação liberada na área já libera a leitura). Devolve só id, nome e telefone, em ordem alfabética de nome, para achar o id de um contato. `busca` procura por trecho no nome, no e-mail, no identificador e na empresa, e pelos dígitos no telefone. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10; valores menores que 1 viram 1. `total` conta os contatos que casam com a busca.\n\n`GET /contato/autocomplete`"]
pub async fn buscar_auto_complete_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarAutoCompleteContato,
) -> Result<tipos::PaginaDeContatoAutoComplete, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/contato/autocomplete")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca contatos por filtro\n\nExige qualquer permissão da área `contatos` (qualquer ação liberada na área já libera a leitura). Devolve todos os contatos que casam com o filtro, sem paginação, em ordem alfabética de nome. `nome` e `email` procuram por trecho, sem diferenciar maiúsculas; `telefone` procura pelos dígitos na ordem, ignorando espaços, traços e parênteses; `config_system_chatwoot_id` traz só os contatos de uma conta do Chatwoot. Sem filtro, devolve todos.\n\n`GET /contato/filtro`"]
pub async fn buscar_pelo_filtro_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPeloFiltroContato,
) -> Result<Vec<tipos::Contato>, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/contato/filtro")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista as regras de origem com paginação\n\nExige qualquer permissão da área `contatos`.\n\n`GET /contato/origem-regra`"]
pub async fn origem_regra_buscar_paginador_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeOrigemRegraBuscarPaginadorContato,
) -> Result<tipos::PaginaDeContatoOrigemRegra, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/contato/origem-regra")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Cria uma regra de origem\n\nExige `criar` na área `contatos`. Quando a mensagem do contato contém a `frase` (sem diferenciar maiúsculas, acentos, pontuação e espaços), a entrada é registrada com a `tag`. A frase precisa de 10 letras ou números; a tag aceita `[a-z0-9-]`, até 40 caracteres. Grava histórico.\n\n`POST /contato/origem-regra`"]
pub async fn origem_regra_criar_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    corpo_da_requisicao: &tipos::ContatoOrigemRegraCriar,
) -> Result<tipos::ContatoOrigemRegra, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/contato/origem-regra")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_corpo_json(corpo_da_requisicao)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista básica de regras de origem\n\nExige qualquer permissão da área `contatos`.\n\n`GET /contato/origem-regra/autocomplete`"]
pub async fn origem_regra_buscar_auto_complete_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeOrigemRegraBuscarAutoCompleteContato,
) -> Result<tipos::PaginaDeContatoOrigemRegraAutoComplete, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        "/contato/origem-regra/autocomplete",
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .com_parametros_de_consulta(parametros)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Busca regras de origem por filtro\n\nExige qualquer permissão da área `contatos`.\n\n`GET /contato/origem-regra/filtro`"]
pub async fn origem_regra_buscar_pelo_filtro_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeOrigemRegraBuscarPeloFiltroContato,
) -> Result<Vec<tipos::ContatoOrigemRegra>, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        "/contato/origem-regra/filtro",
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .com_parametros_de_consulta(parametros)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Busca uma regra de origem pelo id\n\nExige qualquer permissão da área `contatos`.\n\n`GET /contato/origem-regra/{id}`"]
pub async fn origem_regra_buscar_pelo_id_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<tipos::ContatoOrigemRegra, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!(
            "/contato/origem-regra/{}",
            codificar_parametro_de_caminho(id)
        ),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Atualiza uma regra de origem\n\nExige `editar` na área `contatos`. Grava histórico.\n\n`PATCH /contato/origem-regra/{id}`"]
pub async fn origem_regra_atualizar_pelo_id_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
    corpo_da_requisicao: &tipos::ContatoOrigemRegraAtualizar,
) -> Result<tipos::ContatoOrigemRegra, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::PATCH,
        &format!(
            "/contato/origem-regra/{}",
            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 regra de origem\n\nExige `deletar` na área `contatos`. Exclusão lógica; as origens já gravadas continuam. Grava histórico.\n\n`DELETE /contato/origem-regra/{id}`"]
pub async fn origem_regra_deletar_pelo_id_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<(), ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::DELETE,
        &format!(
            "/contato/origem-regra/{}",
            codificar_parametro_de_caminho(id)
        ),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ignorar_corpo_da_resposta()
    .await
}

#[doc = "Busca um contato pelo id\n\nExige qualquer permissão da área `contatos` (qualquer ação liberada na área já libera a leitura). Os contatos são uma cópia dos contatos do Chatwoot, trazida toda noite ou quando um master pede a sincronização; `conta` é o nome da conta do Chatwoot de onde o contato veio. Contato excluído responde `404`.\n\n`GET /contato/{id}`"]
pub async fn buscar_pelo_id_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<tipos::Contato, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!("/contato/{}", codificar_parametro_de_caminho(id)),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Lista as origens de um contato\n\nExige qualquer permissão da área `contatos`. Cada linha é uma entrada do contato identificada pela frase fixa de uma regra de origem (ex.: `anuncio-meta`), da mais recente para a mais antiga, 50 por página. Casa pela conta do Chatwoot e pelo id do contato no Chatwoot, então entradas gravadas antes da sincronização dos contatos também aparecem.\n\n`GET /contato/{id}/origens`"]
pub async fn origem_buscar_paginador_contato(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
    parametros: &ParametrosDeOrigemBuscarPaginadorContato,
) -> Result<tipos::PaginaDeContatoOrigem, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!("/contato/{}/origens", codificar_parametro_de_caminho(id)),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .com_parametros_de_consulta(parametros)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Lista as conversas com paginação\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Ordena da mensagem mais recente para a mais antiga. `pagina` começa em 1 (padrão 1; valores menores viram 1). A página tem sempre 50 itens: `tamanho` é aceito, mas ignorado. Filtros opcionais: `status` (igual), `config_system_whatsapp_id` (número do QR Code), `contato` (trecho do nome do contato, do telefone ou da razão social do cliente), `texto` (trecho no conteúdo das mensagens), `nao_lidas = true`, `fora_do_chatwoot = true` e `sincronizacao` (`solicitada`, `recuperou`, `nada_faltava`, `sem_resposta` ou `nunca`). `total` conta as conversas não excluídas que casam com os filtros e que a pessoa pode ver. As conversas de número restrito ficam de fora para quem não está vinculado a ele (só o master principal vê todas).\n\n`GET /conversa`"]
pub async fn buscar_paginador_conversa(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPaginadorConversa,
) -> Result<tipos::PaginaDeConversa, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/conversa")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista básica de conversas para seleção\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve só id, id da conversa no Chatwoot, nome e telefone do contato, em ordem alfabética do nome do contato (e, no mesmo nome, da conversa mais nova do Chatwoot para a mais antiga), para achar o id de uma conversa. `busca` procura por trecho no nome ou no telefone do contato, sem diferenciar maiúsculas. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10; valores menores que 1 viram 1. `total` conta as conversas que casam com a busca.\n\n`GET /conversa/autocomplete`"]
pub async fn buscar_auto_complete_conversa(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarAutoCompleteConversa,
) -> Result<tipos::PaginaDeConversaAutoComplete, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/conversa/autocomplete")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca conversas por filtro\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve até 500 conversas que casam com o filtro, sem paginação, da mensagem mais recente para a mais antiga. `cliente_id` (cliente do TermoPortal), `robo_id`, `config_system_z_api_id`, `config_system_whatsapp_id`, `chatwoot_conversa_id`, `config_system_chatwoot_id` (conta do Chatwoot), `chatwoot_contato_id` (id do contato no Chatwoot; junto com a conta traz as conversas de um contato) e `status` comparam igual; `contato` procura por trecho no nome do contato, no telefone e na razão social do cliente; `texto` procura por trecho no conteúdo das mensagens; `nao_lidas = true` traz só as com mensagem não lida; `fora_do_chatwoot = true` traz só as que ainda não existem no Chatwoot; `sincronizacao` filtra pela situação da busca do histórico (`solicitada`, `recuperou`, `nada_faltava`, `sem_resposta` ou `nunca`). As conversas de número restrito ficam de fora para quem não está vinculado a ele (só o master principal vê todas).\n\n`GET /conversa/filtro`"]
pub async fn buscar_pelo_filtro_conversa(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPeloFiltroConversa,
) -> Result<Vec<tipos::Conversa>, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/conversa/filtro")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca uma conversa pelo id\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve a conversa do WhatsApp com o contato, o cliente do TermoPortal vinculado, o robô, o número (Z-API ou QR Code), a última mensagem, a quantidade de mensagens e o endereço da conversa no Chatwoot. `status` é o do Chatwoot (`pending` com o robô, `open`, `resolved`, `snoozed`) ou `so_no_whatsapp` (conversa que ainda não existe no Chatwoot). Conversa de número restrito a quem está vinculado responde `404` para quem não está vinculado (só o master principal vê todas), como a conversa excluída.\n\n`GET /conversa/{id}`"]
pub async fn buscar_pelo_id_conversa(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<tipos::Conversa, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!("/conversa/{}", codificar_parametro_de_caminho(id)),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Lista os robôs com paginação\n\nExige qualquer permissão da área `robos`, `whatsapp` ou `chatwoot` (qualquer ação liberada na área já libera a leitura). Ordena por nome. `pagina` começa em 1 (padrão 1; valores menores viram 1). A página tem sempre 50 itens: `tamanho` é aceito, mas ignorado. `busca` (opcional) procura no nome, na descrição e no modelo; `ativo` (opcional) traz só os ativos ou só os inativos. `total` conta os robôs não excluídos que casam com a busca.\n\n`GET /robo`"]
pub async fn buscar_paginador_robo(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPaginadorRobo,
) -> Result<tipos::PaginaRobo, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/robo")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Cadastra um robô de atendimento\n\nExige a permissão `criar` da área `robos`. `nome` é obrigatório (até 80 caracteres, único entre os robôs); `modelo` é a IA preferida do gateway do TermoAI, um `provedor` de `GET /robo/modelos` (opcional, até 80; vazio deixa o TermoAI escolher); `descricao` vai até 200 e `prompt_base` até 4000 (padrão vazio). `configuracao` (opcional; sem ela valem os padrões) é o ritmo e o resumo do robô: `segundos_de_espera_antes_de_responder` (0 a 120, padrão 7) depois da última mensagem do cliente, `segundos_digitando` (0 a 15, padrão 4; zero desliga), `quantidade_de_tentativas` (0 a 10, padrão 3) e `minutos_entre_tentativas` (1 a 60, padrão 5) quando o gateway do TermoAI falha, `prompt_do_resumo` (até 4000; vazio desliga a nota de resumo ao passar a conversa) e `modelo_do_resumo` (`provedor` de `GET /robo/modelos`, até 80; vazio deixa o TermoAI escolher); campo omitido dentro dela volta ao padrão. Sem `fluxo`, o robô nasce só com a etapa de início. O robô nasce ativo, na versão 1. `fluxo` é o caminho do atendimento: `nos` (até 40 etapas, exatamente uma do tipo `inicio`; os outros tipos são `inicio_contato_novo`, `instrucao`, `mensagem`, `botoes`, `lista`, `botao_link`, `botao_ligar`, `botao_copiar`, `pedir_localizacao`, `atendimento`, `vendedor`, `finalizar`, `sales_analyser`, `gatilho` e `logar_cliente`) e `ligacoes` (`origem`, `destino` e `origem_saida`, que é o id do botão ou da regra de onde a ligação sai, `logado` ou `nao_encontrado` na `logar_cliente` e `null` no início e na mensagem). Cada etapa fora o início precisa de `nome` (até 60 caracteres); `objetivo` vai até 200, `instrucao` até 2000 e `mensagem` até 1000; `ferramentas` lista até 20 ids de ferramentas do robô. `modelo` (opcional, até 80 caracteres) é a IA da etapa, `provedor` ou `provedor/modelo` de `GET /robo/modelos`; vazio usa o `modelo` do robô. `enviar_catalogo` (booleano, padrão `false`) oferece à IA da etapa a ferramenta `enviar_catalogo`, que monta na hora um PDF com fotos dos produtos pedidos (catálogo do Portal B2B, até 30) e o envia na conversa, sem guardar o arquivo. `enviar_foto_do_produto` (booleano, padrão `false`) oferece à IA da etapa a ferramenta `enviar_foto_do_produto`, que busca o produto pedido no catálogo do Portal B2B e envia a foto principal na conversa com o nome na legenda (com mais de um produto, a IA pergunta qual pelo SKU; sem foto, avisa o cliente), sem guardar a imagem. `enviar_boleto` (booleano, padrão `false`) oferece à IA da etapa a ferramenta `enviar_boleto`, que baixa no Portal B2B o PDF do boleto de uma conta a pagar do cliente (`conta_id` de `listar_contas_a_pagar`, só em aberto ou paga em parte) e o envia na conversa, com a unidade sempre da empresa logada; a etapa com ela só pode vir depois da saída `logado` de uma `logar_cliente`. A `instrucao` precisa de 1 a 10 `regras` de saída (`condicao` até 200 caracteres); `botoes` precisa de 1 a 10 botões (`rotulo` até 20 caracteres) e de texto fixo em `mensagem` ou, com `mensagem_por_ia`, da `instrucao` para a IA escrever; `mensagem` também exige texto fixo ou `mensagem_por_ia`; `lista` segue as regras de `botoes` e sempre abre a lista de opções; `botao_link`, `botao_ligar` e `botao_copiar` se comportam como `mensagem` e levam exatamente um botão com `rotulo` e `valor` (link começando por `https://`, telefone com código do país e DDD, ou o texto copiado, até 500 caracteres); `pedir_localizacao` se comporta como `mensagem` e pede a localização do cliente; esses quatro só saem como botão no número por QR Code e, nos outros canais, em texto; `atendimento`, `vendedor` e `sales_analyser` enviam na passagem a `mensagem` fixa (opcional; em branco, o aviso padrão) ou, com `mensagem_por_ia`, a mensagem que a IA escreve pela `instrucao` (obrigatória nesse caso); fora do horário de atendimento (cadastrado em `config_system_horario_atendimento`; sem cadastro, nada muda), essas três etapas e o `gatilho` enviam uma mensagem só, a `mensagem_fora_do_horario` (opcional, até 1000 caracteres, só nesses tipos; em branco, a mensagem global de `config_system_horario_atendimento` e, sem ela, o aviso padrão com `{{atendimento.resumo}}` e `{{atendimento.proximo}}`) no lugar da mensagem normal, e a passagem para a equipe ou o vendedor segue igual; com `mensagem_por_ia`, a IA recebe o horário e escreve o retorno; `atendimento` encerra o robô, passa a conversa para a equipe do Chatwoot em `equipe_id` (opcional, de `GET /robo/equipes`) e, se vier `vendedor_id` (opcional, de `GET /robo/vendedores?equipe_id=`), para esse vendedor da equipe, e não tem saída; `vendedor` encerra o robô do mesmo jeito, mas passa a conversa só para o vendedor do Chatwoot em `vendedor_id` (obrigatório, de `GET /robo/vendedores`), sem equipe; `finalizar` encerra o robô sem passar para ninguém: envia a despedida (texto fixo em `mensagem` ou, com `mensagem_por_ia`, escrita pela IA pela `instrucao`), marca a conversa como resolvida no Chatwoot (a sessão termina como `resolvida`) e não tem saída; com `finalizar_sem_mensagem` (booleano, padrão `false`, só no `finalizar`) encerra sem enviar despedida, e `mensagem` e `instrucao` deixam de ser obrigatórias; se o cliente voltar a falar, o fluxo recomeça do início; `sales_analyser` encerra o robô como o `atendimento`, mas a equipe e o vendedor vêm do Sales Analyser, consultado pelo CNPJ da empresa logada: a equipe do Chatwoot com o nome de `destino.time` e o vendedor `destino.pessoa.chatwoot_id`; `equipe_id` (opcional) é a equipe padrão quando a consulta falha ou o time não existe no Chatwoot, não aceita `vendedor_id`, não tem saída e só pode ser alcançada depois da saída `logado` de uma `logar_cliente`, salvo com `usar_cnpj_digitado`, que consulta, sem empresa logada, o último CNPJ válido que o contato mandou na sessão (só para rotear, sem abrir sessão no portal); `logar_cliente` busca as empresas do telefone do contato no Portal B2B, pergunta qual quando há mais de uma e abre a sessão do portal da escolhida; sai por `logado` ou por `nao_encontrado` (telefone sem empresa liberada ou portal fora do ar) e, antes dela, a conversa não tem sessão do portal; `gatilho` (no máximo um, sem ligação de entrada nem de saída) é o gatilho de cliente sem resposta: `minutos_sem_resposta` (1 a 1440), `equipe_id` e `vendedor_id` opcionais (um, os dois ou nenhum; com `atribuir_pelo_sales_analyser` a equipe e o vendedor vêm do Sales Analyser pelo CNPJ da empresa logada na conversa, `equipe_id` vira a equipe padrão quando a consulta falha e `vendedor_id` não é aceito), e uma varredura a cada minuto passa para essa equipe e esse vendedor toda conversa com o robô em que o cliente ficou esse tempo sem responder. Ids de etapas, botões e regras são únicos; nenhuma ligação volta ao início nem liga a etapa nela mesma, e cada saída tem no máximo uma próxima etapa. `inicio_contato_novo` (no máximo um, sem ligação de entrada) é o início de quem não está na lista de clientes: com ele no fluxo o robô atende contatos novos (sem ele, o contato novo vai para a equipe) e, sem ligação, o contato novo sai pelo `inicio`. O texto fixo aceita marcadores como `{{cliente.nome}}`, `{{ultimo_pedido.itens}}`, `{{atendimento.proximo}}` (quando o atendimento volta, ex.: \"amanhã às 08:00\") e `{{atendimento.resumo}}` (o horário de atendimento).\n\n`POST /robo`"]
pub async fn criar_robo(
    credencial_de_acesso: &CredencialDeAcesso,
    corpo_da_requisicao: &tipos::RoboCriar,
) -> Result<tipos::Robo, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::POST, "/robo")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_corpo_json(corpo_da_requisicao)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista básica de robôs para seleção\n\nExige qualquer permissão da área `robos`, `whatsapp` ou `chatwoot` (qualquer ação liberada na área já libera a leitura). Devolve só id, nome e modelo, em ordem alfabética de nome, para achar o id de um robô. `busca` procura por trecho do nome, sem diferenciar maiúsculas. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10; valores menores que 1 viram 1. `total` conta os robôs que casam com a busca.\n\n`GET /robo/autocomplete`"]
pub async fn buscar_auto_complete_robo(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarAutoCompleteRobo,
) -> Result<tipos::PaginaDeRoboAutoComplete, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/robo/autocomplete")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca robôs por filtro\n\nExige qualquer permissão da área `robos`, `whatsapp` ou `chatwoot` (qualquer ação liberada na área já libera a leitura). Devolve todos os robôs que casam com o filtro, com o fluxo, sem paginação, em ordem alfabética de nome. `nome` e `modelo` procuram por trecho, sem diferenciar maiúsculas; `ativo` filtra pela situação. Sem filtro, devolve todos.\n\n`GET /robo/filtro`"]
pub async fn buscar_pelo_filtro_robo(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPeloFiltroRobo,
) -> Result<Vec<tipos::Robo>, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/robo/filtro")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca um robô pelo id\n\nExige qualquer permissão da área `robos`, `whatsapp` ou `chatwoot` (qualquer ação liberada na área já libera a leitura). Devolve o robô com o prompt e o fluxo completo (etapas e ligações), no mesmo formato aceito pelo `PATCH`. Robô excluído responde `404`.\n\n`GET /robo/{id}`"]
pub async fn buscar_pelo_id_robo(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<tipos::Robo, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!("/robo/{}", codificar_parametro_de_caminho(id)),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ler_resposta_json()
    .await
}

#[doc = "Atualiza um robô pelo id\n\nExige a permissão `editar` da área `robos`. Atualização parcial: só os campos enviados mudam, com os mesmos limites do cadastro; `descricao` vazia apaga o valor `ativo` liga ou desliga o robô. `fluxo`, quando enviado, substitui o fluxo inteiro. Enviar `prompt_base` ou `fluxo` sobe a `versao` em 1. `configuracao` (opcional), quando enviada, substitui a configuração inteira e traz o ritmo e o resumo do robô: `segundos_de_espera_antes_de_responder` (0 a 120, padrão 7) depois da última mensagem do cliente, `segundos_digitando` (0 a 15, padrão 4; zero desliga), `quantidade_de_tentativas` (0 a 10, padrão 3) e `minutos_entre_tentativas` (1 a 60, padrão 5) quando o gateway do TermoAI falha, `prompt_do_resumo` (até 4000; vazio desliga a nota de resumo ao passar a conversa) e `modelo_do_resumo` (`provedor` de `GET /robo/modelos`, até 80; vazio deixa o TermoAI escolher); campo omitido dentro dela volta ao padrão. `fluxo` é o caminho do atendimento: `nos` (até 40 etapas, exatamente uma do tipo `inicio`; os outros tipos são `inicio_contato_novo`, `instrucao`, `mensagem`, `botoes`, `lista`, `botao_link`, `botao_ligar`, `botao_copiar`, `pedir_localizacao`, `atendimento`, `vendedor`, `finalizar`, `sales_analyser`, `gatilho` e `logar_cliente`) e `ligacoes` (`origem`, `destino` e `origem_saida`, que é o id do botão ou da regra de onde a ligação sai, `logado` ou `nao_encontrado` na `logar_cliente` e `null` no início e na mensagem). Cada etapa fora o início precisa de `nome` (até 60 caracteres); `objetivo` vai até 200, `instrucao` até 2000 e `mensagem` até 1000; `ferramentas` lista até 20 ids de ferramentas do robô. `modelo` (opcional, até 80 caracteres) é a IA da etapa, `provedor` ou `provedor/modelo` de `GET /robo/modelos`; vazio usa o `modelo` do robô. `enviar_catalogo` (booleano, padrão `false`) oferece à IA da etapa a ferramenta `enviar_catalogo`, que monta na hora um PDF com fotos dos produtos pedidos (catálogo do Portal B2B, até 30) e o envia na conversa, sem guardar o arquivo. `enviar_foto_do_produto` (booleano, padrão `false`) oferece à IA da etapa a ferramenta `enviar_foto_do_produto`, que busca o produto pedido no catálogo do Portal B2B e envia a foto principal na conversa com o nome na legenda (com mais de um produto, a IA pergunta qual pelo SKU; sem foto, avisa o cliente), sem guardar a imagem. `enviar_boleto` (booleano, padrão `false`) oferece à IA da etapa a ferramenta `enviar_boleto`, que baixa no Portal B2B o PDF do boleto de uma conta a pagar do cliente (`conta_id` de `listar_contas_a_pagar`, só em aberto ou paga em parte) e o envia na conversa, com a unidade sempre da empresa logada; a etapa com ela só pode vir depois da saída `logado` de uma `logar_cliente`. A `instrucao` precisa de 1 a 10 `regras` de saída (`condicao` até 200 caracteres); `botoes` precisa de 1 a 10 botões (`rotulo` até 20 caracteres) e de texto fixo em `mensagem` ou, com `mensagem_por_ia`, da `instrucao` para a IA escrever; `mensagem` também exige texto fixo ou `mensagem_por_ia`; `lista` segue as regras de `botoes` e sempre abre a lista de opções; `botao_link`, `botao_ligar` e `botao_copiar` se comportam como `mensagem` e levam exatamente um botão com `rotulo` e `valor` (link começando por `https://`, telefone com código do país e DDD, ou o texto copiado, até 500 caracteres); `pedir_localizacao` se comporta como `mensagem` e pede a localização do cliente; esses quatro só saem como botão no número por QR Code e, nos outros canais, em texto; `atendimento`, `vendedor` e `sales_analyser` enviam na passagem a `mensagem` fixa (opcional; em branco, o aviso padrão) ou, com `mensagem_por_ia`, a mensagem que a IA escreve pela `instrucao` (obrigatória nesse caso); fora do horário de atendimento (cadastrado em `config_system_horario_atendimento`; sem cadastro, nada muda), essas três etapas e o `gatilho` enviam uma mensagem só, a `mensagem_fora_do_horario` (opcional, até 1000 caracteres, só nesses tipos; em branco, a mensagem global de `config_system_horario_atendimento` e, sem ela, o aviso padrão com `{{atendimento.resumo}}` e `{{atendimento.proximo}}`) no lugar da mensagem normal, e a passagem para a equipe ou o vendedor segue igual; com `mensagem_por_ia`, a IA recebe o horário e escreve o retorno; `atendimento` encerra o robô, passa a conversa para a equipe do Chatwoot em `equipe_id` (opcional, de `GET /robo/equipes`) e, se vier `vendedor_id` (opcional, de `GET /robo/vendedores?equipe_id=`), para esse vendedor da equipe, e não tem saída; `vendedor` encerra o robô do mesmo jeito, mas passa a conversa só para o vendedor do Chatwoot em `vendedor_id` (obrigatório, de `GET /robo/vendedores`), sem equipe; `finalizar` encerra o robô sem passar para ninguém: envia a despedida (texto fixo em `mensagem` ou, com `mensagem_por_ia`, escrita pela IA pela `instrucao`), marca a conversa como resolvida no Chatwoot (a sessão termina como `resolvida`) e não tem saída; com `finalizar_sem_mensagem` (booleano, padrão `false`, só no `finalizar`) encerra sem enviar despedida, e `mensagem` e `instrucao` deixam de ser obrigatórias; se o cliente voltar a falar, o fluxo recomeça do início; `sales_analyser` encerra o robô como o `atendimento`, mas a equipe e o vendedor vêm do Sales Analyser, consultado pelo CNPJ da empresa logada: a equipe do Chatwoot com o nome de `destino.time` e o vendedor `destino.pessoa.chatwoot_id`; `equipe_id` (opcional) é a equipe padrão quando a consulta falha ou o time não existe no Chatwoot, não aceita `vendedor_id`, não tem saída e só pode ser alcançada depois da saída `logado` de uma `logar_cliente`, salvo com `usar_cnpj_digitado`, que consulta, sem empresa logada, o último CNPJ válido que o contato mandou na sessão (só para rotear, sem abrir sessão no portal); `logar_cliente` busca as empresas do telefone do contato no Portal B2B, pergunta qual quando há mais de uma e abre a sessão do portal da escolhida; sai por `logado` ou por `nao_encontrado` (telefone sem empresa liberada ou portal fora do ar) e, antes dela, a conversa não tem sessão do portal; `gatilho` (no máximo um, sem ligação de entrada nem de saída) é o gatilho de cliente sem resposta: `minutos_sem_resposta` (1 a 1440), `equipe_id` e `vendedor_id` opcionais (um, os dois ou nenhum; com `atribuir_pelo_sales_analyser` a equipe e o vendedor vêm do Sales Analyser pelo CNPJ da empresa logada na conversa, `equipe_id` vira a equipe padrão quando a consulta falha e `vendedor_id` não é aceito), e uma varredura a cada minuto passa para essa equipe e esse vendedor toda conversa com o robô em que o cliente ficou esse tempo sem responder. Ids de etapas, botões e regras são únicos; nenhuma ligação volta ao início nem liga a etapa nela mesma, e cada saída tem no máximo uma próxima etapa. `inicio_contato_novo` (no máximo um, sem ligação de entrada) é o início de quem não está na lista de clientes: com ele no fluxo o robô atende contatos novos (sem ele, o contato novo vai para a equipe) e, sem ligação, o contato novo sai pelo `inicio`. O texto fixo aceita marcadores como `{{cliente.nome}}`, `{{ultimo_pedido.itens}}`, `{{atendimento.proximo}}` (quando o atendimento volta, ex.: \"amanhã às 08:00\") e `{{atendimento.resumo}}` (o horário de atendimento).\n\n`PATCH /robo/{id}`"]
pub async fn atualizar_pelo_id_robo(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
    corpo_da_requisicao: &tipos::RoboAtualizar,
) -> Result<tipos::Robo, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::PATCH,
        &format!("/robo/{}", 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 = "Lista as sessões do robô com paginação\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Ordena da atividade mais recente para a mais antiga, sem o `fluxo`. `pagina` começa em 1 (padrão 1; valores menores viram 1) e a página tem sempre 50 itens. Filtros opcionais: `status` (`ao_vivo` ou `finalizada`), `robo_id` e `contato` (trecho do nome do contato, da razão social do cliente ou dos dígitos do telefone). `total` conta as sessões não excluídas que casam com os filtros.\n\n`GET /sessao`"]
pub async fn buscar_paginador_sessao(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPaginadorSessao,
) -> Result<tipos::PaginaDeSessao, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/sessao")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Lista básica de sessões do robô para seleção\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve só id, nome e telefone do contato e o `status` (`ao_vivo` ou `finalizada`), em ordem alfabética do nome do contato, para achar o id de uma sessão. `busca` procura por trecho no nome do contato, na razão social do cliente e nos dígitos do telefone. `pagina` começa em 1 (padrão 1) e `tamanho` tem padrão 10; valores menores que 1 viram 1. `total` conta as sessões que casam com a busca.\n\n`GET /sessao/autocomplete`"]
pub async fn buscar_auto_complete_sessao(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarAutoCompleteSessao,
) -> Result<tipos::PaginaDeSessaoAutoComplete, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/sessao/autocomplete")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca sessões do robô por filtro\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Devolve até 500 sessões que casam com o filtro, sem paginação e sem o `fluxo`, da atividade mais recente para a mais antiga. `status` é `ao_vivo` ou `finalizada`; `robo_id`, `conversa_id` e `chatwoot_conversa_id` comparam igual; `contato` procura por trecho no nome do contato, na razão social do cliente e nos dígitos do telefone. Sem filtro, devolve as 500 mais recentes.\n\n`GET /sessao/filtro`"]
pub async fn buscar_pelo_filtro_sessao(
    credencial_de_acesso: &CredencialDeAcesso,
    parametros: &ParametrosDeBuscarPeloFiltroSessao,
) -> Result<Vec<tipos::Sessao>, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(&SERVICO_DESTA_API, Method::GET, "/sessao/filtro")
        .com_credencial_de_acesso(credencial_de_acesso)
        .com_parametros_de_consulta(parametros)
        .enviar_e_ler_resposta_json()
        .await
}

#[doc = "Busca uma sessão do robô pelo id\n\nExige qualquer permissão da área `conversas` ou `clientes` (qualquer ação liberada na área já libera a leitura). Uma sessão é a passagem de uma conversa do Chatwoot pelo robô: nasce na primeira etapa que o robô marca e fica `ao_vivo` até a conversa sair do robô, quando vira `finalizada`. `percurso` lista as etapas do fluxo por onde o contato passou, com a hora de entrada; `etapa_atual_*` é a etapa em que está agora; `motivo_do_fim` é `vendedor`, `atendimento`, `sem_resposta`, `equipe`, `resolvida` ou `encerrada_na_tela`. Só aqui vem o `fluxo`: a cópia do fluxo do robô da hora em que a sessão começou (instrução e mensagem cortadas em 280 caracteres). Sessão excluída responde `404`.\n\n`GET /sessao/{id}`"]
pub async fn buscar_pelo_id_sessao(
    credencial_de_acesso: &CredencialDeAcesso,
    id: uuid::Uuid,
) -> Result<tipos::Sessao, ErroAoChamarServico> {
    RequisicaoAoServico::nova_requisicao(
        &SERVICO_DESTA_API,
        Method::GET,
        &format!("/sessao/{}", codificar_parametro_de_caminho(id)),
    )
    .com_credencial_de_acesso(credencial_de_acesso)
    .enviar_e_ler_resposta_json()
    .await
}