Skip to main content

inttegro/
resources.rs

1//! Typed API resources.
2
3use crate::generated::*;
4use crate::{
5    BalanceSnapshot, Client, CountrySpecifications, CreateFileRequest, FileDownload,
6    FulfillUploadRequest, OpenFileLinkRequest, RequestOptions, RequestSpec, Result,
7};
8
9/// Operations for Inttegro apps.
10#[derive(Clone)]
11pub struct Apps {
12    client: Client,
13}
14
15impl Apps {
16    pub(crate) fn new(client: Client) -> Self {
17        Self { client }
18    }
19
20    /// Create an application
21    pub async fn create(&self, request: &CreateApplicationRequest) -> Result<Application> {
22        self.create_with_options(request, RequestOptions::default())
23            .await
24    }
25    /// Create an application with per-request options.
26    pub async fn create_with_options(
27        &self,
28        request: &CreateApplicationRequest,
29        options: RequestOptions,
30    ) -> Result<Application> {
31        self.client
32            .request_resource(
33                RequestSpec {
34                    method: "POST",
35                    path: "/apps/create",
36                    operation: "apps.create",
37                    field: Some("app"),
38                    authenticated: true,
39                },
40                Some(request),
41                options,
42            )
43            .await
44    }
45
46    /// Retrieve the authenticated application
47    pub async fn lookup(&self) -> Result<Application> {
48        self.lookup_with_options(RequestOptions::default()).await
49    }
50    /// Retrieve the authenticated application with per-request options.
51    pub async fn lookup_with_options(&self, options: RequestOptions) -> Result<Application> {
52        let body = serde_json::json!({});
53        self.client
54            .request_resource(
55                RequestSpec {
56                    method: "POST",
57                    path: "/apps/lookup",
58                    operation: "apps.lookup",
59                    field: Some("app"),
60                    authenticated: true,
61                },
62                Some(&body),
63                options,
64            )
65            .await
66    }
67
68    /// Update the authenticated application
69    pub async fn update(&self, request: &UpdateApplicationRequest) -> Result<Application> {
70        self.update_with_options(request, RequestOptions::default())
71            .await
72    }
73    /// Update the authenticated application with per-request options.
74    pub async fn update_with_options(
75        &self,
76        request: &UpdateApplicationRequest,
77        options: RequestOptions,
78    ) -> Result<Application> {
79        self.client
80            .request_resource(
81                RequestSpec {
82                    method: "POST",
83                    path: "/apps/update",
84                    operation: "apps.update",
85                    field: Some("app"),
86                    authenticated: true,
87                },
88                Some(request),
89                options,
90            )
91            .await
92    }
93}
94
95/// Operations for Inttegro balance transactions.
96#[derive(Clone)]
97pub struct BalanceTransactions {
98    client: Client,
99}
100
101impl BalanceTransactions {
102    pub(crate) fn new(client: Client) -> Self {
103        Self { client }
104    }
105
106    /// Look up a balance transaction
107    pub async fn lookup(
108        &self,
109        request: &LookupBalanceTransactionRequest,
110    ) -> Result<BalanceTransaction> {
111        self.lookup_with_options(request, RequestOptions::default())
112            .await
113    }
114    /// Look up a balance transaction with per-request options.
115    pub async fn lookup_with_options(
116        &self,
117        request: &LookupBalanceTransactionRequest,
118        options: RequestOptions,
119    ) -> Result<BalanceTransaction> {
120        self.client
121            .request_resource(
122                RequestSpec {
123                    method: "POST",
124                    path: "/balance_transactions/lookup",
125                    operation: "balance_transactions.lookup",
126                    field: Some("transaction"),
127                    authenticated: true,
128                },
129                Some(request),
130                options,
131            )
132            .await
133    }
134
135    /// Page through balance transactions
136    pub async fn page(
137        &self,
138        request: &PageBalanceTransactionsRequest,
139    ) -> Result<BalanceTransactionPage> {
140        self.page_with_options(request, RequestOptions::default())
141            .await
142    }
143    /// Page through balance transactions with per-request options.
144    pub async fn page_with_options(
145        &self,
146        request: &PageBalanceTransactionsRequest,
147        options: RequestOptions,
148    ) -> Result<BalanceTransactionPage> {
149        self.client
150            .request_resource(
151                RequestSpec {
152                    method: "POST",
153                    path: "/balance_transactions/page",
154                    operation: "balance_transactions.page",
155                    field: Some("page"),
156                    authenticated: true,
157                },
158                Some(request),
159                options,
160            )
161            .await
162    }
163}
164
165/// Operations for Inttegro balances.
166#[derive(Clone)]
167pub struct Balances {
168    client: Client,
169}
170
171impl Balances {
172    pub(crate) fn new(client: Client) -> Self {
173        Self { client }
174    }
175
176    /// Retrieve your balance
177    pub async fn get(&self) -> Result<BalanceSnapshot> {
178        self.get_with_options(RequestOptions::default()).await
179    }
180    /// Retrieve your balance with per-request options.
181    pub async fn get_with_options(&self, options: RequestOptions) -> Result<BalanceSnapshot> {
182        let body = serde_json::json!({});
183        self.client
184            .request_resource(
185                RequestSpec {
186                    method: "POST",
187                    path: "/balances",
188                    operation: "balances.get",
189                    field: Some("balances"),
190                    authenticated: true,
191                },
192                Some(&body),
193                options,
194            )
195            .await
196    }
197}
198
199/// Operations for Inttegro broadcasts.
200#[derive(Clone)]
201pub struct Broadcasts {
202    client: Client,
203}
204
205impl Broadcasts {
206    pub(crate) fn new(client: Client) -> Self {
207        Self { client }
208    }
209
210    /// Look up a broadcast
211    pub async fn lookup(&self, request: &LookupBroadcastRequest) -> Result<BroadcastDetail> {
212        self.lookup_with_options(request, RequestOptions::default())
213            .await
214    }
215    /// Look up a broadcast with per-request options.
216    pub async fn lookup_with_options(
217        &self,
218        request: &LookupBroadcastRequest,
219        options: RequestOptions,
220    ) -> Result<BroadcastDetail> {
221        self.client
222            .request_resource(
223                RequestSpec {
224                    method: "POST",
225                    path: "/broadcasts/lookup",
226                    operation: "broadcasts.lookup",
227                    field: Some("broadcast"),
228                    authenticated: true,
229                },
230                Some(request),
231                options,
232            )
233            .await
234    }
235
236    /// Cancel a broadcast
237    pub async fn cancel(&self, request: &CancelBroadcastRequest) -> Result<BroadcastDetail> {
238        self.cancel_with_options(request, RequestOptions::default())
239            .await
240    }
241    /// Cancel a broadcast with per-request options.
242    pub async fn cancel_with_options(
243        &self,
244        request: &CancelBroadcastRequest,
245        options: RequestOptions,
246    ) -> Result<BroadcastDetail> {
247        self.client
248            .request_resource(
249                RequestSpec {
250                    method: "POST",
251                    path: "/broadcasts/cancel",
252                    operation: "broadcasts.cancel",
253                    field: Some("broadcast"),
254                    authenticated: true,
255                },
256                Some(request),
257                options,
258            )
259            .await
260    }
261}
262
263/// Operations for Inttegro chimes.
264#[derive(Clone)]
265pub struct Chimes {
266    client: Client,
267}
268
269impl Chimes {
270    pub(crate) fn new(client: Client) -> Self {
271        Self { client }
272    }
273
274    /// Send a Chime
275    pub async fn send(&self, request: &SendChimeRequest) -> Result<Chime> {
276        self.send_with_options(request, RequestOptions::default())
277            .await
278    }
279    /// Send a Chime with per-request options.
280    pub async fn send_with_options(
281        &self,
282        request: &SendChimeRequest,
283        options: RequestOptions,
284    ) -> Result<Chime> {
285        self.client
286            .request_resource(
287                RequestSpec {
288                    method: "POST",
289                    path: "/chimes/send",
290                    operation: "chimes.send",
291                    field: Some("chime"),
292                    authenticated: true,
293                },
294                Some(request),
295                options,
296            )
297            .await
298    }
299
300    /// Look up a Chime
301    pub async fn lookup(&self, request: &LookupChimeRequest) -> Result<Chime> {
302        self.lookup_with_options(request, RequestOptions::default())
303            .await
304    }
305    /// Look up a Chime with per-request options.
306    pub async fn lookup_with_options(
307        &self,
308        request: &LookupChimeRequest,
309        options: RequestOptions,
310    ) -> Result<Chime> {
311        self.client
312            .request_resource(
313                RequestSpec {
314                    method: "POST",
315                    path: "/chimes/lookup",
316                    operation: "chimes.lookup",
317                    field: Some("chime"),
318                    authenticated: true,
319                },
320                Some(request),
321                options,
322            )
323            .await
324    }
325
326    /// Page through Chimes
327    pub async fn page(&self, request: &PageChimesRequest) -> Result<ChimePage> {
328        self.page_with_options(request, RequestOptions::default())
329            .await
330    }
331    /// Page through Chimes with per-request options.
332    pub async fn page_with_options(
333        &self,
334        request: &PageChimesRequest,
335        options: RequestOptions,
336    ) -> Result<ChimePage> {
337        self.client
338            .request_resource(
339                RequestSpec {
340                    method: "POST",
341                    path: "/chimes/page",
342                    operation: "chimes.page",
343                    field: Some("page"),
344                    authenticated: true,
345                },
346                Some(request),
347                options,
348            )
349            .await
350    }
351
352    /// Schedule Chimes
353    pub async fn schedule(&self, request: &ScheduleChimeRequest) -> Result<ScheduleCreationDetail> {
354        self.schedule_with_options(request, RequestOptions::default())
355            .await
356    }
357    /// Schedule Chimes with per-request options.
358    pub async fn schedule_with_options(
359        &self,
360        request: &ScheduleChimeRequest,
361        options: RequestOptions,
362    ) -> Result<ScheduleCreationDetail> {
363        self.client
364            .request_resource(
365                RequestSpec {
366                    method: "POST",
367                    path: "/chimes/schedule",
368                    operation: "chimes.schedule",
369                    field: Some("scheduled_chime"),
370                    authenticated: true,
371                },
372                Some(request),
373                options,
374            )
375            .await
376    }
377
378    /// Broadcast Chimes
379    pub async fn broadcast(&self, request: &BroadcastRequest) -> Result<BroadcastCreationDetail> {
380        self.broadcast_with_options(request, RequestOptions::default())
381            .await
382    }
383    /// Broadcast Chimes with per-request options.
384    pub async fn broadcast_with_options(
385        &self,
386        request: &BroadcastRequest,
387        options: RequestOptions,
388    ) -> Result<BroadcastCreationDetail> {
389        self.client
390            .request_resource(
391                RequestSpec {
392                    method: "POST",
393                    path: "/chimes/broadcast",
394                    operation: "chimes.broadcast",
395                    field: Some("broadcast"),
396                    authenticated: true,
397                },
398                Some(request),
399                options,
400            )
401            .await
402    }
403}
404
405/// Operations for Inttegro customers.
406#[derive(Clone)]
407pub struct Customers {
408    client: Client,
409}
410
411impl Customers {
412    pub(crate) fn new(client: Client) -> Self {
413        Self { client }
414    }
415
416    /// Create a customer
417    pub async fn create(&self, request: &CreateCustomerRequest) -> Result<Customer> {
418        self.create_with_options(request, RequestOptions::default())
419            .await
420    }
421    /// Create a customer with per-request options.
422    pub async fn create_with_options(
423        &self,
424        request: &CreateCustomerRequest,
425        options: RequestOptions,
426    ) -> Result<Customer> {
427        self.client
428            .request_resource(
429                RequestSpec {
430                    method: "POST",
431                    path: "/customers/create",
432                    operation: "customers.create",
433                    field: Some("customer"),
434                    authenticated: true,
435                },
436                Some(request),
437                options,
438            )
439            .await
440    }
441
442    /// Look up a customer
443    pub async fn lookup(&self, request: &LookupCustomerRequest) -> Result<Customer> {
444        self.lookup_with_options(request, RequestOptions::default())
445            .await
446    }
447    /// Look up a customer with per-request options.
448    pub async fn lookup_with_options(
449        &self,
450        request: &LookupCustomerRequest,
451        options: RequestOptions,
452    ) -> Result<Customer> {
453        self.client
454            .request_resource(
455                RequestSpec {
456                    method: "POST",
457                    path: "/customers/lookup",
458                    operation: "customers.lookup",
459                    field: Some("customer"),
460                    authenticated: true,
461                },
462                Some(request),
463                options,
464            )
465            .await
466    }
467
468    /// Update a customer
469    pub async fn update(&self, request: &UpdateCustomerRequest) -> Result<Customer> {
470        self.update_with_options(request, RequestOptions::default())
471            .await
472    }
473    /// Update a customer with per-request options.
474    pub async fn update_with_options(
475        &self,
476        request: &UpdateCustomerRequest,
477        options: RequestOptions,
478    ) -> Result<Customer> {
479        self.client
480            .request_resource(
481                RequestSpec {
482                    method: "POST",
483                    path: "/customers/update",
484                    operation: "customers.update",
485                    field: Some("customer"),
486                    authenticated: true,
487                },
488                Some(request),
489                options,
490            )
491            .await
492    }
493
494    /// Page through customers
495    pub async fn page(&self, request: &PageCustomersRequest) -> Result<CustomerPage> {
496        self.page_with_options(request, RequestOptions::default())
497            .await
498    }
499    /// Page through customers with per-request options.
500    pub async fn page_with_options(
501        &self,
502        request: &PageCustomersRequest,
503        options: RequestOptions,
504    ) -> Result<CustomerPage> {
505        self.client
506            .request_resource(
507                RequestSpec {
508                    method: "POST",
509                    path: "/customers/page",
510                    operation: "customers.page",
511                    field: Some("page"),
512                    authenticated: true,
513                },
514                Some(request),
515                options,
516            )
517            .await
518    }
519}
520
521/// Operations for Inttegro file links.
522#[derive(Clone)]
523pub struct FileLinks {
524    client: Client,
525}
526
527impl FileLinks {
528    pub(crate) fn new(client: Client) -> Self {
529        Self { client }
530    }
531
532    /// Create a file link
533    pub async fn create(&self, request: &CreateFileLinkRequest) -> Result<FileLinkCreation> {
534        self.create_with_options(request, RequestOptions::default())
535            .await
536    }
537    /// Create a file link with per-request options.
538    pub async fn create_with_options(
539        &self,
540        request: &CreateFileLinkRequest,
541        options: RequestOptions,
542    ) -> Result<FileLinkCreation> {
543        self.client
544            .request_resource(
545                RequestSpec {
546                    method: "POST",
547                    path: "/file_links/create",
548                    operation: "file_links.create",
549                    field: None,
550                    authenticated: true,
551                },
552                Some(request),
553                options,
554            )
555            .await
556    }
557
558    /// Lookup a file link
559    pub async fn lookup(&self, request: &LookupFileLinkRequest) -> Result<FileLink> {
560        self.lookup_with_options(request, RequestOptions::default())
561            .await
562    }
563    /// Lookup a file link with per-request options.
564    pub async fn lookup_with_options(
565        &self,
566        request: &LookupFileLinkRequest,
567        options: RequestOptions,
568    ) -> Result<FileLink> {
569        self.client
570            .request_resource(
571                RequestSpec {
572                    method: "POST",
573                    path: "/file_links/lookup",
574                    operation: "file_links.lookup",
575                    field: Some("file_link"),
576                    authenticated: true,
577                },
578                Some(request),
579                options,
580            )
581            .await
582    }
583
584    /// Page file links
585    pub async fn page(&self, request: &PageFileLinksRequest) -> Result<FileLinkPage> {
586        self.page_with_options(request, RequestOptions::default())
587            .await
588    }
589    /// Page file links with per-request options.
590    pub async fn page_with_options(
591        &self,
592        request: &PageFileLinksRequest,
593        options: RequestOptions,
594    ) -> Result<FileLinkPage> {
595        self.client
596            .request_resource(
597                RequestSpec {
598                    method: "POST",
599                    path: "/file_links/page",
600                    operation: "file_links.page",
601                    field: Some("page"),
602                    authenticated: true,
603                },
604                Some(request),
605                options,
606            )
607            .await
608    }
609
610    /// Revoke a file link
611    pub async fn revoke(&self, request: &RevokeFileLinkRequest) -> Result<FileLink> {
612        self.revoke_with_options(request, RequestOptions::default())
613            .await
614    }
615    /// Revoke a file link with per-request options.
616    pub async fn revoke_with_options(
617        &self,
618        request: &RevokeFileLinkRequest,
619        options: RequestOptions,
620    ) -> Result<FileLink> {
621        self.client
622            .request_resource(
623                RequestSpec {
624                    method: "POST",
625                    path: "/file_links/revoke",
626                    operation: "file_links.revoke",
627                    field: Some("file_link"),
628                    authenticated: true,
629                },
630                Some(request),
631                options,
632            )
633            .await
634    }
635
636    /// Open a public file link
637    pub async fn open(&self, request: OpenFileLinkRequest) -> Result<FileDownload> {
638        self.client
639            .open_file_link("/file_links/open", request, "file_links.open")
640            .await
641    }
642}
643
644/// Operations for Inttegro file references.
645#[derive(Clone)]
646pub struct FileReferences {
647    client: Client,
648}
649
650impl FileReferences {
651    pub(crate) fn new(client: Client) -> Self {
652        Self { client }
653    }
654
655    /// Reconcile file references
656    pub async fn reconcile(
657        &self,
658        request: &FileReferenceReconcileRequest,
659    ) -> Result<FileReferenceReconciliation> {
660        self.reconcile_with_options(request, RequestOptions::default())
661            .await
662    }
663    /// Reconcile file references with per-request options.
664    pub async fn reconcile_with_options(
665        &self,
666        request: &FileReferenceReconcileRequest,
667        options: RequestOptions,
668    ) -> Result<FileReferenceReconciliation> {
669        self.client
670            .request_resource(
671                RequestSpec {
672                    method: "POST",
673                    path: "/file_references/reconcile",
674                    operation: "file_references.reconcile",
675                    field: None,
676                    authenticated: true,
677                },
678                Some(request),
679                options,
680            )
681            .await
682    }
683}
684
685/// Operations for Inttegro files.
686#[derive(Clone)]
687pub struct Files {
688    client: Client,
689}
690
691impl Files {
692    pub(crate) fn new(client: Client) -> Self {
693        Self { client }
694    }
695
696    /// Create a file
697    pub async fn create(&self, request: CreateFileRequest) -> Result<File> {
698        self.create_with_options(request, RequestOptions::default())
699            .await
700    }
701    /// Create a file with per-request options.
702    pub async fn create_with_options(
703        &self,
704        request: CreateFileRequest,
705        options: RequestOptions,
706    ) -> Result<File> {
707        self.client
708            .upload_file(
709                "/files/create",
710                request,
711                options,
712                "files.create",
713                Some("file"),
714                true,
715            )
716            .await
717    }
718
719    /// Lookup a file
720    pub async fn lookup(&self, request: &LookupFileRequest) -> Result<File> {
721        self.lookup_with_options(request, RequestOptions::default())
722            .await
723    }
724    /// Lookup a file with per-request options.
725    pub async fn lookup_with_options(
726        &self,
727        request: &LookupFileRequest,
728        options: RequestOptions,
729    ) -> Result<File> {
730        self.client
731            .request_resource(
732                RequestSpec {
733                    method: "POST",
734                    path: "/files/lookup",
735                    operation: "files.lookup",
736                    field: Some("file"),
737                    authenticated: true,
738                },
739                Some(request),
740                options,
741            )
742            .await
743    }
744
745    /// Page files
746    pub async fn page(&self, request: &PageFilesRequest) -> Result<FilePage> {
747        self.page_with_options(request, RequestOptions::default())
748            .await
749    }
750    /// Page files with per-request options.
751    pub async fn page_with_options(
752        &self,
753        request: &PageFilesRequest,
754        options: RequestOptions,
755    ) -> Result<FilePage> {
756        self.client
757            .request_resource(
758                RequestSpec {
759                    method: "POST",
760                    path: "/files/page",
761                    operation: "files.page",
762                    field: Some("page"),
763                    authenticated: true,
764                },
765                Some(request),
766                options,
767            )
768            .await
769    }
770
771    /// Deliver file contents
772    pub async fn contents(&self, request: &FileContentsRequest) -> Result<FileDownload> {
773        self.contents_with_options(request, RequestOptions::default())
774            .await
775    }
776    /// Deliver file contents with per-request options.
777    pub async fn contents_with_options(
778        &self,
779        request: &FileContentsRequest,
780        options: RequestOptions,
781    ) -> Result<FileDownload> {
782        self.client
783            .download(
784                "POST",
785                "/files/contents",
786                Some(request),
787                options,
788                "files.contents",
789                true,
790            )
791            .await
792    }
793
794    /// Delete a file
795    pub async fn delete(&self, request: &DeleteFileRequest) -> Result<File> {
796        self.delete_with_options(request, RequestOptions::default())
797            .await
798    }
799    /// Delete a file with per-request options.
800    pub async fn delete_with_options(
801        &self,
802        request: &DeleteFileRequest,
803        options: RequestOptions,
804    ) -> Result<File> {
805        self.client
806            .request_resource(
807                RequestSpec {
808                    method: "POST",
809                    path: "/files/delete",
810                    operation: "files.delete",
811                    field: Some("file"),
812                    authenticated: true,
813                },
814                Some(request),
815                options,
816            )
817            .await
818    }
819}
820
821/// Operations for Inttegro financial accounts.
822#[derive(Clone)]
823pub struct FinancialAccounts {
824    client: Client,
825}
826
827impl FinancialAccounts {
828    pub(crate) fn new(client: Client) -> Self {
829        Self { client }
830    }
831
832    /// Create a financial account
833    pub async fn create(
834        &self,
835        request: &FinancialAccountCreateRequest,
836    ) -> Result<FinancialAccount> {
837        self.create_with_options(request, RequestOptions::default())
838            .await
839    }
840    /// Create a financial account with per-request options.
841    pub async fn create_with_options(
842        &self,
843        request: &FinancialAccountCreateRequest,
844        options: RequestOptions,
845    ) -> Result<FinancialAccount> {
846        self.client
847            .request_resource(
848                RequestSpec {
849                    method: "POST",
850                    path: "/financial_accounts/create",
851                    operation: "financial_accounts.create",
852                    field: Some("account"),
853                    authenticated: true,
854                },
855                Some(request),
856                options,
857            )
858            .await
859    }
860
861    /// Lookup a financial account
862    pub async fn lookup(&self, request: &FinancialAccountIDRequest) -> Result<FinancialAccount> {
863        self.lookup_with_options(request, RequestOptions::default())
864            .await
865    }
866    /// Lookup a financial account with per-request options.
867    pub async fn lookup_with_options(
868        &self,
869        request: &FinancialAccountIDRequest,
870        options: RequestOptions,
871    ) -> Result<FinancialAccount> {
872        self.client
873            .request_resource(
874                RequestSpec {
875                    method: "POST",
876                    path: "/financial_accounts/lookup",
877                    operation: "financial_accounts.lookup",
878                    field: Some("account"),
879                    authenticated: true,
880                },
881                Some(request),
882                options,
883            )
884            .await
885    }
886
887    /// Page through financial accounts
888    pub async fn page(
889        &self,
890        request: &FinancialAccountPageRequest,
891    ) -> Result<FinancialAccountPage> {
892        self.page_with_options(request, RequestOptions::default())
893            .await
894    }
895    /// Page through financial accounts with per-request options.
896    pub async fn page_with_options(
897        &self,
898        request: &FinancialAccountPageRequest,
899        options: RequestOptions,
900    ) -> Result<FinancialAccountPage> {
901        self.client
902            .request_resource(
903                RequestSpec {
904                    method: "POST",
905                    path: "/financial_accounts/page",
906                    operation: "financial_accounts.page",
907                    field: Some("page"),
908                    authenticated: true,
909                },
910                Some(request),
911                options,
912            )
913            .await
914    }
915
916    /// Connect a financial account
917    pub async fn connect(
918        &self,
919        request: &FinancialAccountCreateRequest,
920    ) -> Result<FinancialAccount> {
921        self.connect_with_options(request, RequestOptions::default())
922            .await
923    }
924    /// Connect a financial account with per-request options.
925    pub async fn connect_with_options(
926        &self,
927        request: &FinancialAccountCreateRequest,
928        options: RequestOptions,
929    ) -> Result<FinancialAccount> {
930        self.client
931            .request_resource(
932                RequestSpec {
933                    method: "POST",
934                    path: "/financial_accounts/connect",
935                    operation: "financial_accounts.connect",
936                    field: Some("account"),
937                    authenticated: true,
938                },
939                Some(request),
940                options,
941            )
942            .await
943    }
944
945    /// Update a financial account
946    pub async fn update(
947        &self,
948        request: &FinancialAccountUpdateRequest,
949    ) -> Result<FinancialAccount> {
950        self.update_with_options(request, RequestOptions::default())
951            .await
952    }
953    /// Update a financial account with per-request options.
954    pub async fn update_with_options(
955        &self,
956        request: &FinancialAccountUpdateRequest,
957        options: RequestOptions,
958    ) -> Result<FinancialAccount> {
959        self.client
960            .request_resource(
961                RequestSpec {
962                    method: "POST",
963                    path: "/financial_accounts/update",
964                    operation: "financial_accounts.update",
965                    field: Some("account"),
966                    authenticated: true,
967                },
968                Some(request),
969                options,
970            )
971            .await
972    }
973
974    /// Enable push capability
975    pub async fn enable_push(
976        &self,
977        request: &FinancialAccountIDRequest,
978    ) -> Result<FinancialAccount> {
979        self.enable_push_with_options(request, RequestOptions::default())
980            .await
981    }
982    /// Enable push capability with per-request options.
983    pub async fn enable_push_with_options(
984        &self,
985        request: &FinancialAccountIDRequest,
986        options: RequestOptions,
987    ) -> Result<FinancialAccount> {
988        self.client
989            .request_resource(
990                RequestSpec {
991                    method: "POST",
992                    path: "/financial_accounts/enable_push",
993                    operation: "financial_accounts.enable_push",
994                    field: Some("account"),
995                    authenticated: true,
996                },
997                Some(request),
998                options,
999            )
1000            .await
1001    }
1002
1003    /// Disable push capability
1004    pub async fn disable_push(
1005        &self,
1006        request: &FinancialAccountDisableRequest,
1007    ) -> Result<FinancialAccount> {
1008        self.disable_push_with_options(request, RequestOptions::default())
1009            .await
1010    }
1011    /// Disable push capability with per-request options.
1012    pub async fn disable_push_with_options(
1013        &self,
1014        request: &FinancialAccountDisableRequest,
1015        options: RequestOptions,
1016    ) -> Result<FinancialAccount> {
1017        self.client
1018            .request_resource(
1019                RequestSpec {
1020                    method: "POST",
1021                    path: "/financial_accounts/disable_push",
1022                    operation: "financial_accounts.disable_push",
1023                    field: Some("account"),
1024                    authenticated: true,
1025                },
1026                Some(request),
1027                options,
1028            )
1029            .await
1030    }
1031
1032    /// Disconnect a financial account
1033    pub async fn disconnect(
1034        &self,
1035        request: &FinancialAccountDisableRequest,
1036    ) -> Result<FinancialAccount> {
1037        self.disconnect_with_options(request, RequestOptions::default())
1038            .await
1039    }
1040    /// Disconnect a financial account with per-request options.
1041    pub async fn disconnect_with_options(
1042        &self,
1043        request: &FinancialAccountDisableRequest,
1044        options: RequestOptions,
1045    ) -> Result<FinancialAccount> {
1046        self.client
1047            .request_resource(
1048                RequestSpec {
1049                    method: "POST",
1050                    path: "/financial_accounts/disconnect",
1051                    operation: "financial_accounts.disconnect",
1052                    field: Some("account"),
1053                    authenticated: true,
1054                },
1055                Some(request),
1056                options,
1057            )
1058            .await
1059    }
1060
1061    /// Reconnect a financial account
1062    pub async fn reconnect(&self, request: &FinancialAccountIDRequest) -> Result<FinancialAccount> {
1063        self.reconnect_with_options(request, RequestOptions::default())
1064            .await
1065    }
1066    /// Reconnect a financial account with per-request options.
1067    pub async fn reconnect_with_options(
1068        &self,
1069        request: &FinancialAccountIDRequest,
1070        options: RequestOptions,
1071    ) -> Result<FinancialAccount> {
1072        self.client
1073            .request_resource(
1074                RequestSpec {
1075                    method: "POST",
1076                    path: "/financial_accounts/reconnect",
1077                    operation: "financial_accounts.reconnect",
1078                    field: Some("account"),
1079                    authenticated: true,
1080                },
1081                Some(request),
1082                options,
1083            )
1084            .await
1085    }
1086
1087    /// Enable pull capability
1088    pub async fn enable_pull(
1089        &self,
1090        request: &FinancialAccountEnablePullRequest,
1091    ) -> Result<FinancialAccount> {
1092        self.enable_pull_with_options(request, RequestOptions::default())
1093            .await
1094    }
1095    /// Enable pull capability with per-request options.
1096    pub async fn enable_pull_with_options(
1097        &self,
1098        request: &FinancialAccountEnablePullRequest,
1099        options: RequestOptions,
1100    ) -> Result<FinancialAccount> {
1101        self.client
1102            .request_resource(
1103                RequestSpec {
1104                    method: "POST",
1105                    path: "/financial_accounts/enable_pull",
1106                    operation: "financial_accounts.enable_pull",
1107                    field: Some("account"),
1108                    authenticated: true,
1109                },
1110                Some(request),
1111                options,
1112            )
1113            .await
1114    }
1115
1116    /// Disable pull capability
1117    pub async fn disable_pull(
1118        &self,
1119        request: &FinancialAccountIDRequest,
1120    ) -> Result<FinancialAccount> {
1121        self.disable_pull_with_options(request, RequestOptions::default())
1122            .await
1123    }
1124    /// Disable pull capability with per-request options.
1125    pub async fn disable_pull_with_options(
1126        &self,
1127        request: &FinancialAccountIDRequest,
1128        options: RequestOptions,
1129    ) -> Result<FinancialAccount> {
1130        self.client
1131            .request_resource(
1132                RequestSpec {
1133                    method: "POST",
1134                    path: "/financial_accounts/disable_pull",
1135                    operation: "financial_accounts.disable_pull",
1136                    field: Some("account"),
1137                    authenticated: true,
1138                },
1139                Some(request),
1140                options,
1141            )
1142            .await
1143    }
1144}
1145
1146/// Operations for Inttegro keys.
1147#[derive(Clone)]
1148pub struct Keys {
1149    client: Client,
1150}
1151
1152impl Keys {
1153    pub(crate) fn new(client: Client) -> Self {
1154        Self { client }
1155    }
1156
1157    /// Generate a secret key
1158    pub async fn generate(&self, request: &GenerateSecretKeyRequest) -> Result<GeneratedSecretKey> {
1159        self.generate_with_options(request, RequestOptions::default())
1160            .await
1161    }
1162    /// Generate a secret key with per-request options.
1163    pub async fn generate_with_options(
1164        &self,
1165        request: &GenerateSecretKeyRequest,
1166        options: RequestOptions,
1167    ) -> Result<GeneratedSecretKey> {
1168        self.client
1169            .request_resource(
1170                RequestSpec {
1171                    method: "POST",
1172                    path: "/keys/generate",
1173                    operation: "keys.generate",
1174                    field: Some("key"),
1175                    authenticated: true,
1176                },
1177                Some(request),
1178                options,
1179            )
1180            .await
1181    }
1182
1183    /// Page secret keys
1184    pub async fn page(&self, request: &PageSecretKeysRequest) -> Result<SecretKeyPage> {
1185        self.page_with_options(request, RequestOptions::default())
1186            .await
1187    }
1188    /// Page secret keys with per-request options.
1189    pub async fn page_with_options(
1190        &self,
1191        request: &PageSecretKeysRequest,
1192        options: RequestOptions,
1193    ) -> Result<SecretKeyPage> {
1194        self.client
1195            .request_resource(
1196                RequestSpec {
1197                    method: "POST",
1198                    path: "/keys/page",
1199                    operation: "keys.page",
1200                    field: Some("page"),
1201                    authenticated: true,
1202                },
1203                Some(request),
1204                options,
1205            )
1206            .await
1207    }
1208
1209    /// Retrieve a secret key
1210    pub async fn lookup(&self, request: &LookupSecretKeyRequest) -> Result<SecretKey> {
1211        self.lookup_with_options(request, RequestOptions::default())
1212            .await
1213    }
1214    /// Retrieve a secret key with per-request options.
1215    pub async fn lookup_with_options(
1216        &self,
1217        request: &LookupSecretKeyRequest,
1218        options: RequestOptions,
1219    ) -> Result<SecretKey> {
1220        self.client
1221            .request_resource(
1222                RequestSpec {
1223                    method: "POST",
1224                    path: "/keys/lookup",
1225                    operation: "keys.lookup",
1226                    field: Some("key"),
1227                    authenticated: true,
1228                },
1229                Some(request),
1230                options,
1231            )
1232            .await
1233    }
1234
1235    /// Update a secret key
1236    pub async fn update(&self, request: &UpdateSecretKeyRequest) -> Result<SecretKey> {
1237        self.update_with_options(request, RequestOptions::default())
1238            .await
1239    }
1240    /// Update a secret key with per-request options.
1241    pub async fn update_with_options(
1242        &self,
1243        request: &UpdateSecretKeyRequest,
1244        options: RequestOptions,
1245    ) -> Result<SecretKey> {
1246        self.client
1247            .request_resource(
1248                RequestSpec {
1249                    method: "POST",
1250                    path: "/keys/update",
1251                    operation: "keys.update",
1252                    field: Some("key"),
1253                    authenticated: true,
1254                },
1255                Some(request),
1256                options,
1257            )
1258            .await
1259    }
1260
1261    /// Revoke a secret key
1262    pub async fn destroy(&self, request: &DestroySecretKeyRequest) -> Result<SecretKey> {
1263        self.destroy_with_options(request, RequestOptions::default())
1264            .await
1265    }
1266    /// Revoke a secret key with per-request options.
1267    pub async fn destroy_with_options(
1268        &self,
1269        request: &DestroySecretKeyRequest,
1270        options: RequestOptions,
1271    ) -> Result<SecretKey> {
1272        self.client
1273            .request_resource(
1274                RequestSpec {
1275                    method: "POST",
1276                    path: "/keys/destroy",
1277                    operation: "keys.destroy",
1278                    field: Some("key"),
1279                    authenticated: true,
1280                },
1281                Some(request),
1282                options,
1283            )
1284            .await
1285    }
1286
1287    /// Retrieve secret key usage
1288    pub async fn usage(&self, request: &SecretKeyUsageRequest) -> Result<SecretKeyUsage> {
1289        self.usage_with_options(request, RequestOptions::default())
1290            .await
1291    }
1292    /// Retrieve secret key usage with per-request options.
1293    pub async fn usage_with_options(
1294        &self,
1295        request: &SecretKeyUsageRequest,
1296        options: RequestOptions,
1297    ) -> Result<SecretKeyUsage> {
1298        self.client
1299            .request_resource(
1300                RequestSpec {
1301                    method: "POST",
1302                    path: "/keys/usage",
1303                    operation: "keys.usage",
1304                    field: None,
1305                    authenticated: true,
1306                },
1307                Some(request),
1308                options,
1309            )
1310            .await
1311    }
1312}
1313
1314/// Operations for Inttegro message templates.
1315#[derive(Clone)]
1316pub struct MessageTemplates {
1317    client: Client,
1318}
1319
1320impl MessageTemplates {
1321    pub(crate) fn new(client: Client) -> Self {
1322        Self { client }
1323    }
1324
1325    /// Create a message template
1326    pub async fn create(&self, request: &CreateMessageTemplateRequest) -> Result<MessageTemplate> {
1327        self.create_with_options(request, RequestOptions::default())
1328            .await
1329    }
1330    /// Create a message template with per-request options.
1331    pub async fn create_with_options(
1332        &self,
1333        request: &CreateMessageTemplateRequest,
1334        options: RequestOptions,
1335    ) -> Result<MessageTemplate> {
1336        self.client
1337            .request_resource(
1338                RequestSpec {
1339                    method: "POST",
1340                    path: "/message_templates/create",
1341                    operation: "message_templates.create",
1342                    field: Some("message_template"),
1343                    authenticated: true,
1344                },
1345                Some(request),
1346                options,
1347            )
1348            .await
1349    }
1350
1351    /// Update a message template
1352    pub async fn update(&self, request: &UpdateMessageTemplateRequest) -> Result<MessageTemplate> {
1353        self.update_with_options(request, RequestOptions::default())
1354            .await
1355    }
1356    /// Update a message template with per-request options.
1357    pub async fn update_with_options(
1358        &self,
1359        request: &UpdateMessageTemplateRequest,
1360        options: RequestOptions,
1361    ) -> Result<MessageTemplate> {
1362        self.client
1363            .request_resource(
1364                RequestSpec {
1365                    method: "POST",
1366                    path: "/message_templates/update",
1367                    operation: "message_templates.update",
1368                    field: Some("message_template"),
1369                    authenticated: true,
1370                },
1371                Some(request),
1372                options,
1373            )
1374            .await
1375    }
1376
1377    /// Publish a message template
1378    pub async fn publish(&self, request: &MessageTemplateIDRequest) -> Result<MessageTemplate> {
1379        self.publish_with_options(request, RequestOptions::default())
1380            .await
1381    }
1382    /// Publish a message template with per-request options.
1383    pub async fn publish_with_options(
1384        &self,
1385        request: &MessageTemplateIDRequest,
1386        options: RequestOptions,
1387    ) -> Result<MessageTemplate> {
1388        self.client
1389            .request_resource(
1390                RequestSpec {
1391                    method: "POST",
1392                    path: "/message_templates/publish",
1393                    operation: "message_templates.publish",
1394                    field: Some("message_template"),
1395                    authenticated: true,
1396                },
1397                Some(request),
1398                options,
1399            )
1400            .await
1401    }
1402
1403    /// Archive a message template
1404    pub async fn archive(&self, request: &MessageTemplateIDRequest) -> Result<MessageTemplate> {
1405        self.archive_with_options(request, RequestOptions::default())
1406            .await
1407    }
1408    /// Archive a message template with per-request options.
1409    pub async fn archive_with_options(
1410        &self,
1411        request: &MessageTemplateIDRequest,
1412        options: RequestOptions,
1413    ) -> Result<MessageTemplate> {
1414        self.client
1415            .request_resource(
1416                RequestSpec {
1417                    method: "POST",
1418                    path: "/message_templates/archive",
1419                    operation: "message_templates.archive",
1420                    field: Some("message_template"),
1421                    authenticated: true,
1422                },
1423                Some(request),
1424                options,
1425            )
1426            .await
1427    }
1428
1429    /// Look up a message template
1430    pub async fn lookup(&self, request: &MessageTemplateIDRequest) -> Result<MessageTemplate> {
1431        self.lookup_with_options(request, RequestOptions::default())
1432            .await
1433    }
1434    /// Look up a message template with per-request options.
1435    pub async fn lookup_with_options(
1436        &self,
1437        request: &MessageTemplateIDRequest,
1438        options: RequestOptions,
1439    ) -> Result<MessageTemplate> {
1440        self.client
1441            .request_resource(
1442                RequestSpec {
1443                    method: "POST",
1444                    path: "/message_templates/lookup",
1445                    operation: "message_templates.lookup",
1446                    field: Some("message_template"),
1447                    authenticated: true,
1448                },
1449                Some(request),
1450                options,
1451            )
1452            .await
1453    }
1454
1455    /// Page message templates
1456    pub async fn page(
1457        &self,
1458        request: &PageMessageTemplatesRequest,
1459    ) -> Result<MessageTemplatesPage> {
1460        self.page_with_options(request, RequestOptions::default())
1461            .await
1462    }
1463    /// Page message templates with per-request options.
1464    pub async fn page_with_options(
1465        &self,
1466        request: &PageMessageTemplatesRequest,
1467        options: RequestOptions,
1468    ) -> Result<MessageTemplatesPage> {
1469        self.client
1470            .request_resource(
1471                RequestSpec {
1472                    method: "POST",
1473                    path: "/message_templates/page",
1474                    operation: "message_templates.page",
1475                    field: Some("page"),
1476                    authenticated: true,
1477                },
1478                Some(request),
1479                options,
1480            )
1481            .await
1482    }
1483
1484    /// Render a message template preview
1485    pub async fn render_preview(
1486        &self,
1487        request: &RenderMessageTemplatePreviewRequest,
1488    ) -> Result<MessageTemplatePreview> {
1489        self.render_preview_with_options(request, RequestOptions::default())
1490            .await
1491    }
1492    /// Render a message template preview with per-request options.
1493    pub async fn render_preview_with_options(
1494        &self,
1495        request: &RenderMessageTemplatePreviewRequest,
1496        options: RequestOptions,
1497    ) -> Result<MessageTemplatePreview> {
1498        self.client
1499            .request_resource(
1500                RequestSpec {
1501                    method: "POST",
1502                    path: "/message_templates/render_preview",
1503                    operation: "message_templates.render_preview",
1504                    field: None,
1505                    authenticated: true,
1506                },
1507                Some(request),
1508                options,
1509            )
1510            .await
1511    }
1512}
1513
1514/// Operations for Inttegro orders.
1515#[derive(Clone)]
1516pub struct Orders {
1517    client: Client,
1518}
1519
1520impl Orders {
1521    pub(crate) fn new(client: Client) -> Self {
1522        Self { client }
1523    }
1524
1525    /// Create a new order
1526    pub async fn create(&self, request: &CreateOrderRequest) -> Result<Order> {
1527        self.create_with_options(request, RequestOptions::default())
1528            .await
1529    }
1530    /// Create a new order with per-request options.
1531    pub async fn create_with_options(
1532        &self,
1533        request: &CreateOrderRequest,
1534        options: RequestOptions,
1535    ) -> Result<Order> {
1536        self.client
1537            .request_resource(
1538                RequestSpec {
1539                    method: "POST",
1540                    path: "/orders/create",
1541                    operation: "orders.create",
1542                    field: Some("order"),
1543                    authenticated: true,
1544                },
1545                Some(request),
1546                options,
1547            )
1548            .await
1549    }
1550
1551    /// Lookup an order
1552    pub async fn lookup(&self, request: &LookupOrderRequest) -> Result<Order> {
1553        self.lookup_with_options(request, RequestOptions::default())
1554            .await
1555    }
1556    /// Lookup an order with per-request options.
1557    pub async fn lookup_with_options(
1558        &self,
1559        request: &LookupOrderRequest,
1560        options: RequestOptions,
1561    ) -> Result<Order> {
1562        self.client
1563            .request_resource(
1564                RequestSpec {
1565                    method: "POST",
1566                    path: "/orders/lookup",
1567                    operation: "orders.lookup",
1568                    field: Some("order"),
1569                    authenticated: true,
1570                },
1571                Some(request),
1572                options,
1573            )
1574            .await
1575    }
1576
1577    /// Update an order
1578    pub async fn update(&self, request: &UpdateOrderRequest) -> Result<Order> {
1579        self.update_with_options(request, RequestOptions::default())
1580            .await
1581    }
1582    /// Update an order with per-request options.
1583    pub async fn update_with_options(
1584        &self,
1585        request: &UpdateOrderRequest,
1586        options: RequestOptions,
1587    ) -> Result<Order> {
1588        self.client
1589            .request_resource(
1590                RequestSpec {
1591                    method: "POST",
1592                    path: "/orders/update",
1593                    operation: "orders.update",
1594                    field: Some("order"),
1595                    authenticated: true,
1596                },
1597                Some(request),
1598                options,
1599            )
1600            .await
1601    }
1602
1603    /// Pay for an order
1604    pub async fn pay(&self, request: &PayOrderRequest) -> Result<Order> {
1605        self.pay_with_options(request, RequestOptions::default())
1606            .await
1607    }
1608    /// Pay for an order with per-request options.
1609    pub async fn pay_with_options(
1610        &self,
1611        request: &PayOrderRequest,
1612        options: RequestOptions,
1613    ) -> Result<Order> {
1614        self.client
1615            .request_resource(
1616                RequestSpec {
1617                    method: "POST",
1618                    path: "/orders/pay",
1619                    operation: "orders.pay",
1620                    field: Some("order"),
1621                    authenticated: true,
1622                },
1623                Some(request),
1624                options,
1625            )
1626            .await
1627    }
1628
1629    /// Confirm payment with token
1630    pub async fn confirm_payment(&self, request: &ConfirmPaymentRequest) -> Result<Order> {
1631        self.confirm_payment_with_options(request, RequestOptions::default())
1632            .await
1633    }
1634    /// Confirm payment with token with per-request options.
1635    pub async fn confirm_payment_with_options(
1636        &self,
1637        request: &ConfirmPaymentRequest,
1638        options: RequestOptions,
1639    ) -> Result<Order> {
1640        self.client
1641            .request_resource(
1642                RequestSpec {
1643                    method: "POST",
1644                    path: "/orders/confirm_payment",
1645                    operation: "orders.confirm_payment",
1646                    field: Some("order"),
1647                    authenticated: true,
1648                },
1649                Some(request),
1650                options,
1651            )
1652            .await
1653    }
1654
1655    /// Request payment confirmation
1656    pub async fn request_confirmation(
1657        &self,
1658        request: &RequestConfirmationRequest,
1659    ) -> Result<Order> {
1660        self.request_confirmation_with_options(request, RequestOptions::default())
1661            .await
1662    }
1663    /// Request payment confirmation with per-request options.
1664    pub async fn request_confirmation_with_options(
1665        &self,
1666        request: &RequestConfirmationRequest,
1667        options: RequestOptions,
1668    ) -> Result<Order> {
1669        self.client
1670            .request_resource(
1671                RequestSpec {
1672                    method: "POST",
1673                    path: "/orders/request_confirmation",
1674                    operation: "orders.request_confirmation",
1675                    field: Some("order"),
1676                    authenticated: true,
1677                },
1678                Some(request),
1679                options,
1680            )
1681            .await
1682    }
1683
1684    /// Cancel an order
1685    pub async fn cancel(&self, request: &CancelOrderRequest) -> Result<Order> {
1686        self.cancel_with_options(request, RequestOptions::default())
1687            .await
1688    }
1689    /// Cancel an order with per-request options.
1690    pub async fn cancel_with_options(
1691        &self,
1692        request: &CancelOrderRequest,
1693        options: RequestOptions,
1694    ) -> Result<Order> {
1695        self.client
1696            .request_resource(
1697                RequestSpec {
1698                    method: "POST",
1699                    path: "/orders/cancel",
1700                    operation: "orders.cancel",
1701                    field: Some("order"),
1702                    authenticated: true,
1703                },
1704                Some(request),
1705                options,
1706            )
1707            .await
1708    }
1709
1710    /// Finalize an order
1711    pub async fn finalize(&self, request: &FinalizeOrderRequest) -> Result<Order> {
1712        self.finalize_with_options(request, RequestOptions::default())
1713            .await
1714    }
1715    /// Finalize an order with per-request options.
1716    pub async fn finalize_with_options(
1717        &self,
1718        request: &FinalizeOrderRequest,
1719        options: RequestOptions,
1720    ) -> Result<Order> {
1721        self.client
1722            .request_resource(
1723                RequestSpec {
1724                    method: "POST",
1725                    path: "/orders/finalize",
1726                    operation: "orders.finalize",
1727                    field: Some("order"),
1728                    authenticated: true,
1729                },
1730                Some(request),
1731                options,
1732            )
1733            .await
1734    }
1735
1736    /// Complete an order
1737    pub async fn complete(&self, request: &CompleteOrderRequest) -> Result<Order> {
1738        self.complete_with_options(request, RequestOptions::default())
1739            .await
1740    }
1741    /// Complete an order with per-request options.
1742    pub async fn complete_with_options(
1743        &self,
1744        request: &CompleteOrderRequest,
1745        options: RequestOptions,
1746    ) -> Result<Order> {
1747        self.client
1748            .request_resource(
1749                RequestSpec {
1750                    method: "POST",
1751                    path: "/orders/complete",
1752                    operation: "orders.complete",
1753                    field: Some("order"),
1754                    authenticated: true,
1755                },
1756                Some(request),
1757                options,
1758            )
1759            .await
1760    }
1761
1762    /// Send an order invoice
1763    pub async fn send_invoice(
1764        &self,
1765        request: &OrderDocumentDeliveryRequest,
1766    ) -> Result<OrderDocumentDeliveryResult> {
1767        self.send_invoice_with_options(request, RequestOptions::default())
1768            .await
1769    }
1770    /// Send an order invoice with per-request options.
1771    pub async fn send_invoice_with_options(
1772        &self,
1773        request: &OrderDocumentDeliveryRequest,
1774        options: RequestOptions,
1775    ) -> Result<OrderDocumentDeliveryResult> {
1776        self.client
1777            .request_resource(
1778                RequestSpec {
1779                    method: "POST",
1780                    path: "/orders/send_invoice",
1781                    operation: "orders.send_invoice",
1782                    field: None,
1783                    authenticated: true,
1784                },
1785                Some(request),
1786                options,
1787            )
1788            .await
1789    }
1790
1791    /// Send an order receipt
1792    pub async fn send_receipt(
1793        &self,
1794        request: &OrderDocumentDeliveryRequest,
1795    ) -> Result<OrderDocumentDeliveryResult> {
1796        self.send_receipt_with_options(request, RequestOptions::default())
1797            .await
1798    }
1799    /// Send an order receipt with per-request options.
1800    pub async fn send_receipt_with_options(
1801        &self,
1802        request: &OrderDocumentDeliveryRequest,
1803        options: RequestOptions,
1804    ) -> Result<OrderDocumentDeliveryResult> {
1805        self.client
1806            .request_resource(
1807                RequestSpec {
1808                    method: "POST",
1809                    path: "/orders/send_receipt",
1810                    operation: "orders.send_receipt",
1811                    field: None,
1812                    authenticated: true,
1813                },
1814                Some(request),
1815                options,
1816            )
1817            .await
1818    }
1819
1820    /// Page through orders
1821    pub async fn page(&self, request: &PageOrdersRequest) -> Result<OrderPage> {
1822        self.page_with_options(request, RequestOptions::default())
1823            .await
1824    }
1825    /// Page through orders with per-request options.
1826    pub async fn page_with_options(
1827        &self,
1828        request: &PageOrdersRequest,
1829        options: RequestOptions,
1830    ) -> Result<OrderPage> {
1831        self.client
1832            .request_resource(
1833                RequestSpec {
1834                    method: "POST",
1835                    path: "/orders/page",
1836                    operation: "orders.page",
1837                    field: Some("page"),
1838                    authenticated: true,
1839                },
1840                Some(request),
1841                options,
1842            )
1843            .await
1844    }
1845
1846    /// Create a refund using the compatibility URL
1847    pub async fn refund(&self, request: &CreateRefundRequest) -> Result<Refund> {
1848        self.refund_with_options(request, RequestOptions::default())
1849            .await
1850    }
1851    /// Create a refund using the compatibility URL with per-request options.
1852    pub async fn refund_with_options(
1853        &self,
1854        request: &CreateRefundRequest,
1855        options: RequestOptions,
1856    ) -> Result<Refund> {
1857        self.client
1858            .request_resource(
1859                RequestSpec {
1860                    method: "POST",
1861                    path: "/orders/refund",
1862                    operation: "orders.refund",
1863                    field: Some("refund"),
1864                    authenticated: true,
1865                },
1866                Some(request),
1867                options,
1868            )
1869            .await
1870    }
1871}
1872
1873/// Operations for Inttegro otp.
1874#[derive(Clone)]
1875pub struct Otp {
1876    client: Client,
1877}
1878
1879impl Otp {
1880    pub(crate) fn new(client: Client) -> Self {
1881        Self { client }
1882    }
1883
1884    /// Initiate OTP transaction
1885    pub async fn initiate(&self, request: &InitiateOTPRequest) -> Result<OTPTransaction> {
1886        self.initiate_with_options(request, RequestOptions::default())
1887            .await
1888    }
1889    /// Initiate OTP transaction with per-request options.
1890    pub async fn initiate_with_options(
1891        &self,
1892        request: &InitiateOTPRequest,
1893        options: RequestOptions,
1894    ) -> Result<OTPTransaction> {
1895        self.client
1896            .request_resource(
1897                RequestSpec {
1898                    method: "POST",
1899                    path: "/otp/initiate",
1900                    operation: "otp.initiate",
1901                    field: Some("transaction"),
1902                    authenticated: true,
1903                },
1904                Some(request),
1905                options,
1906            )
1907            .await
1908    }
1909
1910    /// Verify OTP token
1911    pub async fn verify(&self, request: &VerifyOTPRequest) -> Result<OTPVerification> {
1912        self.verify_with_options(request, RequestOptions::default())
1913            .await
1914    }
1915    /// Verify OTP token with per-request options.
1916    pub async fn verify_with_options(
1917        &self,
1918        request: &VerifyOTPRequest,
1919        options: RequestOptions,
1920    ) -> Result<OTPVerification> {
1921        self.client
1922            .request_resource(
1923                RequestSpec {
1924                    method: "POST",
1925                    path: "/otp/verify",
1926                    operation: "otp.verify",
1927                    field: None,
1928                    authenticated: true,
1929                },
1930                Some(request),
1931                options,
1932            )
1933            .await
1934    }
1935
1936    /// Lookup OTP transaction
1937    pub async fn lookup(&self, request: &LookupOTPRequest) -> Result<OTPTransaction> {
1938        self.lookup_with_options(request, RequestOptions::default())
1939            .await
1940    }
1941    /// Lookup OTP transaction with per-request options.
1942    pub async fn lookup_with_options(
1943        &self,
1944        request: &LookupOTPRequest,
1945        options: RequestOptions,
1946    ) -> Result<OTPTransaction> {
1947        self.client
1948            .request_resource(
1949                RequestSpec {
1950                    method: "POST",
1951                    path: "/otp/lookup",
1952                    operation: "otp.lookup",
1953                    field: Some("transaction"),
1954                    authenticated: true,
1955                },
1956                Some(request),
1957                options,
1958            )
1959            .await
1960    }
1961}
1962
1963/// Operations for Inttegro payment methods.
1964#[derive(Clone)]
1965pub struct PaymentMethods {
1966    client: Client,
1967}
1968
1969impl PaymentMethods {
1970    pub(crate) fn new(client: Client) -> Self {
1971        Self { client }
1972    }
1973
1974    /// Tokenize a payment method
1975    pub async fn tokenize(
1976        &self,
1977        request: &TokenizeMobileMoneyPaymentMethodRequest,
1978    ) -> Result<PaymentMethod> {
1979        self.tokenize_with_options(request, RequestOptions::default())
1980            .await
1981    }
1982    /// Tokenize a payment method with per-request options.
1983    pub async fn tokenize_with_options(
1984        &self,
1985        request: &TokenizeMobileMoneyPaymentMethodRequest,
1986        options: RequestOptions,
1987    ) -> Result<PaymentMethod> {
1988        self.client
1989            .request_resource(
1990                RequestSpec {
1991                    method: "POST",
1992                    path: "/payment_methods/tokenize",
1993                    operation: "payment_methods.tokenize",
1994                    field: Some("payment_method"),
1995                    authenticated: true,
1996                },
1997                Some(request),
1998                options,
1999            )
2000            .await
2001    }
2002
2003    /// Lookup a payment method
2004    pub async fn lookup(&self, request: &LookupPaymentMethodRequest) -> Result<PaymentMethod> {
2005        self.lookup_with_options(request, RequestOptions::default())
2006            .await
2007    }
2008    /// Lookup a payment method with per-request options.
2009    pub async fn lookup_with_options(
2010        &self,
2011        request: &LookupPaymentMethodRequest,
2012        options: RequestOptions,
2013    ) -> Result<PaymentMethod> {
2014        self.client
2015            .request_resource(
2016                RequestSpec {
2017                    method: "POST",
2018                    path: "/payment_methods/lookup",
2019                    operation: "payment_methods.lookup",
2020                    field: Some("payment_method"),
2021                    authenticated: true,
2022                },
2023                Some(request),
2024                options,
2025            )
2026            .await
2027    }
2028
2029    /// Page payment methods
2030    pub async fn page(&self, request: &PaymentMethodPageRequest) -> Result<PaymentMethodPage> {
2031        self.page_with_options(request, RequestOptions::default())
2032            .await
2033    }
2034    /// Page payment methods with per-request options.
2035    pub async fn page_with_options(
2036        &self,
2037        request: &PaymentMethodPageRequest,
2038        options: RequestOptions,
2039    ) -> Result<PaymentMethodPage> {
2040        self.client
2041            .request_resource(
2042                RequestSpec {
2043                    method: "POST",
2044                    path: "/payment_methods/page",
2045                    operation: "payment_methods.page",
2046                    field: Some("page"),
2047                    authenticated: true,
2048                },
2049                Some(request),
2050                options,
2051            )
2052            .await
2053    }
2054
2055    /// Update a payment method
2056    pub async fn update(&self, request: &UpdatePaymentMethodRequest) -> Result<PaymentMethod> {
2057        self.update_with_options(request, RequestOptions::default())
2058            .await
2059    }
2060    /// Update a payment method with per-request options.
2061    pub async fn update_with_options(
2062        &self,
2063        request: &UpdatePaymentMethodRequest,
2064        options: RequestOptions,
2065    ) -> Result<PaymentMethod> {
2066        self.client
2067            .request_resource(
2068                RequestSpec {
2069                    method: "POST",
2070                    path: "/payment_methods/update",
2071                    operation: "payment_methods.update",
2072                    field: Some("payment_method"),
2073                    authenticated: true,
2074                },
2075                Some(request),
2076                options,
2077            )
2078            .await
2079    }
2080
2081    /// Activate a payment method
2082    pub async fn activate(&self, request: &ActivatePaymentMethodRequest) -> Result<PaymentMethod> {
2083        self.activate_with_options(request, RequestOptions::default())
2084            .await
2085    }
2086    /// Activate a payment method with per-request options.
2087    pub async fn activate_with_options(
2088        &self,
2089        request: &ActivatePaymentMethodRequest,
2090        options: RequestOptions,
2091    ) -> Result<PaymentMethod> {
2092        self.client
2093            .request_resource(
2094                RequestSpec {
2095                    method: "POST",
2096                    path: "/payment_methods/activate",
2097                    operation: "payment_methods.activate",
2098                    field: Some("payment_method"),
2099                    authenticated: true,
2100                },
2101                Some(request),
2102                options,
2103            )
2104            .await
2105    }
2106
2107    /// Deactivate a payment method
2108    pub async fn deactivate(
2109        &self,
2110        request: &DisactivatePaymentMethodRequest,
2111    ) -> Result<PaymentMethod> {
2112        self.deactivate_with_options(request, RequestOptions::default())
2113            .await
2114    }
2115    /// Deactivate a payment method with per-request options.
2116    pub async fn deactivate_with_options(
2117        &self,
2118        request: &DisactivatePaymentMethodRequest,
2119        options: RequestOptions,
2120    ) -> Result<PaymentMethod> {
2121        self.client
2122            .request_resource(
2123                RequestSpec {
2124                    method: "POST",
2125                    path: "/payment_methods/disactivate",
2126                    operation: "payment_methods.deactivate",
2127                    field: Some("payment_method"),
2128                    authenticated: true,
2129                },
2130                Some(request),
2131                options,
2132            )
2133            .await
2134    }
2135
2136    /// Archive a payment method
2137    pub async fn archive(&self, request: &ArchivePaymentMethodRequest) -> Result<PaymentMethod> {
2138        self.archive_with_options(request, RequestOptions::default())
2139            .await
2140    }
2141    /// Archive a payment method with per-request options.
2142    pub async fn archive_with_options(
2143        &self,
2144        request: &ArchivePaymentMethodRequest,
2145        options: RequestOptions,
2146    ) -> Result<PaymentMethod> {
2147        self.client
2148            .request_resource(
2149                RequestSpec {
2150                    method: "POST",
2151                    path: "/payment_methods/archive",
2152                    operation: "payment_methods.archive",
2153                    field: Some("payment_method"),
2154                    authenticated: true,
2155                },
2156                Some(request),
2157                options,
2158            )
2159            .await
2160    }
2161
2162    /// Unarchive a payment method
2163    pub async fn unarchive(
2164        &self,
2165        request: &UnarchivePaymentMethodRequest,
2166    ) -> Result<PaymentMethod> {
2167        self.unarchive_with_options(request, RequestOptions::default())
2168            .await
2169    }
2170    /// Unarchive a payment method with per-request options.
2171    pub async fn unarchive_with_options(
2172        &self,
2173        request: &UnarchivePaymentMethodRequest,
2174        options: RequestOptions,
2175    ) -> Result<PaymentMethod> {
2176        self.client
2177            .request_resource(
2178                RequestSpec {
2179                    method: "POST",
2180                    path: "/payment_methods/unarchive",
2181                    operation: "payment_methods.unarchive",
2182                    field: Some("payment_method"),
2183                    authenticated: true,
2184                },
2185                Some(request),
2186                options,
2187            )
2188            .await
2189    }
2190
2191    /// Get payment method settings
2192    pub async fn settings(&self) -> Result<PaymentMethodSettings> {
2193        self.settings_with_options(RequestOptions::default()).await
2194    }
2195    /// Get payment method settings with per-request options.
2196    pub async fn settings_with_options(
2197        &self,
2198        options: RequestOptions,
2199    ) -> Result<PaymentMethodSettings> {
2200        let body = serde_json::json!({});
2201        self.client
2202            .request_resource(
2203                RequestSpec {
2204                    method: "POST",
2205                    path: "/payment_methods/settings",
2206                    operation: "payment_methods.settings",
2207                    field: Some("settings"),
2208                    authenticated: true,
2209                },
2210                Some(&body),
2211                options,
2212            )
2213            .await
2214    }
2215}
2216
2217/// Operations for Inttegro payouts.
2218#[derive(Clone)]
2219pub struct Payouts {
2220    client: Client,
2221}
2222
2223impl Payouts {
2224    pub(crate) fn new(client: Client) -> Self {
2225        Self { client }
2226    }
2227
2228    /// Schedule a payout
2229    pub async fn schedule(&self, request: &SchedulePayoutRequest) -> Result<Payout> {
2230        self.schedule_with_options(request, RequestOptions::default())
2231            .await
2232    }
2233    /// Schedule a payout with per-request options.
2234    pub async fn schedule_with_options(
2235        &self,
2236        request: &SchedulePayoutRequest,
2237        options: RequestOptions,
2238    ) -> Result<Payout> {
2239        self.client
2240            .request_resource(
2241                RequestSpec {
2242                    method: "POST",
2243                    path: "/payouts/schedule",
2244                    operation: "payouts.schedule",
2245                    field: Some("payout"),
2246                    authenticated: true,
2247                },
2248                Some(request),
2249                options,
2250            )
2251            .await
2252    }
2253
2254    /// Lookup a payout
2255    pub async fn lookup(&self, request: &LookupPayoutRequest) -> Result<Payout> {
2256        self.lookup_with_options(request, RequestOptions::default())
2257            .await
2258    }
2259    /// Lookup a payout with per-request options.
2260    pub async fn lookup_with_options(
2261        &self,
2262        request: &LookupPayoutRequest,
2263        options: RequestOptions,
2264    ) -> Result<Payout> {
2265        self.client
2266            .request_resource(
2267                RequestSpec {
2268                    method: "POST",
2269                    path: "/payouts/lookup",
2270                    operation: "payouts.lookup",
2271                    field: Some("payout"),
2272                    authenticated: true,
2273                },
2274                Some(request),
2275                options,
2276            )
2277            .await
2278    }
2279
2280    /// Set payout destinations
2281    pub async fn set_destinations(
2282        &self,
2283        request: &SetPayoutDestinationsRequest,
2284    ) -> Result<PayoutSettingsMutation> {
2285        self.set_destinations_with_options(request, RequestOptions::default())
2286            .await
2287    }
2288    /// Set payout destinations with per-request options.
2289    pub async fn set_destinations_with_options(
2290        &self,
2291        request: &SetPayoutDestinationsRequest,
2292        options: RequestOptions,
2293    ) -> Result<PayoutSettingsMutation> {
2294        self.client
2295            .request_resource(
2296                RequestSpec {
2297                    method: "POST",
2298                    path: "/payouts/set_destinations",
2299                    operation: "payouts.set_destinations",
2300                    field: Some("settings"),
2301                    authenticated: true,
2302                },
2303                Some(request),
2304                options,
2305            )
2306            .await
2307    }
2308
2309    /// Get payout settings
2310    pub async fn settings(&self) -> Result<PayoutSettingsLookup> {
2311        self.settings_with_options(RequestOptions::default()).await
2312    }
2313    /// Get payout settings with per-request options.
2314    pub async fn settings_with_options(
2315        &self,
2316        options: RequestOptions,
2317    ) -> Result<PayoutSettingsLookup> {
2318        let body = serde_json::json!({});
2319        self.client
2320            .request_resource(
2321                RequestSpec {
2322                    method: "POST",
2323                    path: "/payouts/settings",
2324                    operation: "payouts.settings",
2325                    field: Some("settings"),
2326                    authenticated: true,
2327                },
2328                Some(&body),
2329                options,
2330            )
2331            .await
2332    }
2333
2334    /// Disable automatic payouts
2335    pub async fn disable(&self) -> Result<PayoutSettingsMutation> {
2336        self.disable_with_options(RequestOptions::default()).await
2337    }
2338    /// Disable automatic payouts with per-request options.
2339    pub async fn disable_with_options(
2340        &self,
2341        options: RequestOptions,
2342    ) -> Result<PayoutSettingsMutation> {
2343        let body = serde_json::json!({});
2344        self.client
2345            .request_resource(
2346                RequestSpec {
2347                    method: "POST",
2348                    path: "/payouts/disable",
2349                    operation: "payouts.disable",
2350                    field: Some("settings"),
2351                    authenticated: true,
2352                },
2353                Some(&body),
2354                options,
2355            )
2356            .await
2357    }
2358
2359    /// Enable automatic payouts
2360    pub async fn enable(&self) -> Result<PayoutSettingsMutation> {
2361        self.enable_with_options(RequestOptions::default()).await
2362    }
2363    /// Enable automatic payouts with per-request options.
2364    pub async fn enable_with_options(
2365        &self,
2366        options: RequestOptions,
2367    ) -> Result<PayoutSettingsMutation> {
2368        let body = serde_json::json!({});
2369        self.client
2370            .request_resource(
2371                RequestSpec {
2372                    method: "POST",
2373                    path: "/payouts/enable",
2374                    operation: "payouts.enable",
2375                    field: Some("settings"),
2376                    authenticated: true,
2377                },
2378                Some(&body),
2379                options,
2380            )
2381            .await
2382    }
2383
2384    /// Page through payouts
2385    pub async fn page(&self, request: &PagePayoutsRequest) -> Result<PayoutPage> {
2386        self.page_with_options(request, RequestOptions::default())
2387            .await
2388    }
2389    /// Page through payouts with per-request options.
2390    pub async fn page_with_options(
2391        &self,
2392        request: &PagePayoutsRequest,
2393        options: RequestOptions,
2394    ) -> Result<PayoutPage> {
2395        self.client
2396            .request_resource(
2397                RequestSpec {
2398                    method: "POST",
2399                    path: "/payouts/page",
2400                    operation: "payouts.page",
2401                    field: Some("page"),
2402                    authenticated: true,
2403                },
2404                Some(request),
2405                options,
2406            )
2407            .await
2408    }
2409
2410    /// Cancel a scheduled payout
2411    pub async fn cancel(&self, request: &CancelPayoutRequest) -> Result<Payout> {
2412        self.cancel_with_options(request, RequestOptions::default())
2413            .await
2414    }
2415    /// Cancel a scheduled payout with per-request options.
2416    pub async fn cancel_with_options(
2417        &self,
2418        request: &CancelPayoutRequest,
2419        options: RequestOptions,
2420    ) -> Result<Payout> {
2421        self.client
2422            .request_resource(
2423                RequestSpec {
2424                    method: "POST",
2425                    path: "/payouts/cancel",
2426                    operation: "payouts.cancel",
2427                    field: Some("payout"),
2428                    authenticated: true,
2429                },
2430                Some(request),
2431                options,
2432            )
2433            .await
2434    }
2435}
2436
2437/// Operations for Inttegro prices.
2438#[derive(Clone)]
2439pub struct Prices {
2440    client: Client,
2441}
2442
2443impl Prices {
2444    pub(crate) fn new(client: Client) -> Self {
2445        Self { client }
2446    }
2447
2448    /// Create a price
2449    pub async fn create(&self, request: &CatalogPriceParams) -> Result<CatalogPrice> {
2450        self.create_with_options(request, RequestOptions::default())
2451            .await
2452    }
2453    /// Create a price with per-request options.
2454    pub async fn create_with_options(
2455        &self,
2456        request: &CatalogPriceParams,
2457        options: RequestOptions,
2458    ) -> Result<CatalogPrice> {
2459        self.client
2460            .request_resource(
2461                RequestSpec {
2462                    method: "POST",
2463                    path: "/prices/create",
2464                    operation: "prices.create",
2465                    field: Some("price"),
2466                    authenticated: true,
2467                },
2468                Some(request),
2469                options,
2470            )
2471            .await
2472    }
2473
2474    /// Lookup a price
2475    pub async fn lookup(&self, request: &LookupPriceRequest) -> Result<CatalogPrice> {
2476        self.lookup_with_options(request, RequestOptions::default())
2477            .await
2478    }
2479    /// Lookup a price with per-request options.
2480    pub async fn lookup_with_options(
2481        &self,
2482        request: &LookupPriceRequest,
2483        options: RequestOptions,
2484    ) -> Result<CatalogPrice> {
2485        self.client
2486            .request_resource(
2487                RequestSpec {
2488                    method: "POST",
2489                    path: "/prices/lookup",
2490                    operation: "prices.lookup",
2491                    field: Some("price"),
2492                    authenticated: true,
2493                },
2494                Some(request),
2495                options,
2496            )
2497            .await
2498    }
2499
2500    /// Page through prices
2501    pub async fn page(&self, request: &PricePageRequest) -> Result<PricePage> {
2502        self.page_with_options(request, RequestOptions::default())
2503            .await
2504    }
2505    /// Page through prices with per-request options.
2506    pub async fn page_with_options(
2507        &self,
2508        request: &PricePageRequest,
2509        options: RequestOptions,
2510    ) -> Result<PricePage> {
2511        self.client
2512            .request_resource(
2513                RequestSpec {
2514                    method: "POST",
2515                    path: "/prices/page",
2516                    operation: "prices.page",
2517                    field: Some("page"),
2518                    authenticated: true,
2519                },
2520                Some(request),
2521                options,
2522            )
2523            .await
2524    }
2525
2526    /// Update a price
2527    pub async fn update(&self, request: &UpdatePriceRequest) -> Result<CatalogPrice> {
2528        self.update_with_options(request, RequestOptions::default())
2529            .await
2530    }
2531    /// Update a price with per-request options.
2532    pub async fn update_with_options(
2533        &self,
2534        request: &UpdatePriceRequest,
2535        options: RequestOptions,
2536    ) -> Result<CatalogPrice> {
2537        self.client
2538            .request_resource(
2539                RequestSpec {
2540                    method: "POST",
2541                    path: "/prices/update",
2542                    operation: "prices.update",
2543                    field: Some("price"),
2544                    authenticated: true,
2545                },
2546                Some(request),
2547                options,
2548            )
2549            .await
2550    }
2551
2552    /// Activate a price
2553    pub async fn activate(&self, request: &PriceActionRequest) -> Result<CatalogPrice> {
2554        self.activate_with_options(request, RequestOptions::default())
2555            .await
2556    }
2557    /// Activate a price with per-request options.
2558    pub async fn activate_with_options(
2559        &self,
2560        request: &PriceActionRequest,
2561        options: RequestOptions,
2562    ) -> Result<CatalogPrice> {
2563        self.client
2564            .request_resource(
2565                RequestSpec {
2566                    method: "POST",
2567                    path: "/prices/activate",
2568                    operation: "prices.activate",
2569                    field: Some("price"),
2570                    authenticated: true,
2571                },
2572                Some(request),
2573                options,
2574            )
2575            .await
2576    }
2577
2578    /// Deactivate a price
2579    pub async fn deactivate(&self, request: &PriceActionRequest) -> Result<CatalogPrice> {
2580        self.deactivate_with_options(request, RequestOptions::default())
2581            .await
2582    }
2583    /// Deactivate a price with per-request options.
2584    pub async fn deactivate_with_options(
2585        &self,
2586        request: &PriceActionRequest,
2587        options: RequestOptions,
2588    ) -> Result<CatalogPrice> {
2589        self.client
2590            .request_resource(
2591                RequestSpec {
2592                    method: "POST",
2593                    path: "/prices/deactivate",
2594                    operation: "prices.deactivate",
2595                    field: Some("price"),
2596                    authenticated: true,
2597                },
2598                Some(request),
2599                options,
2600            )
2601            .await
2602    }
2603
2604    /// Archive a price
2605    pub async fn archive(&self, request: &PriceActionRequest) -> Result<CatalogPrice> {
2606        self.archive_with_options(request, RequestOptions::default())
2607            .await
2608    }
2609    /// Archive a price with per-request options.
2610    pub async fn archive_with_options(
2611        &self,
2612        request: &PriceActionRequest,
2613        options: RequestOptions,
2614    ) -> Result<CatalogPrice> {
2615        self.client
2616            .request_resource(
2617                RequestSpec {
2618                    method: "POST",
2619                    path: "/prices/archive",
2620                    operation: "prices.archive",
2621                    field: Some("price"),
2622                    authenticated: true,
2623                },
2624                Some(request),
2625                options,
2626            )
2627            .await
2628    }
2629}
2630
2631/// Operations for Inttegro products.
2632#[derive(Clone)]
2633pub struct Products {
2634    client: Client,
2635}
2636
2637impl Products {
2638    pub(crate) fn new(client: Client) -> Self {
2639        Self { client }
2640    }
2641
2642    /// Create a product
2643    pub async fn create(&self, request: &CreateProductRequest) -> Result<Product> {
2644        self.create_with_options(request, RequestOptions::default())
2645            .await
2646    }
2647    /// Create a product with per-request options.
2648    pub async fn create_with_options(
2649        &self,
2650        request: &CreateProductRequest,
2651        options: RequestOptions,
2652    ) -> Result<Product> {
2653        self.client
2654            .request_resource(
2655                RequestSpec {
2656                    method: "POST",
2657                    path: "/products/create",
2658                    operation: "products.create",
2659                    field: Some("product"),
2660                    authenticated: true,
2661                },
2662                Some(request),
2663                options,
2664            )
2665            .await
2666    }
2667
2668    /// Add a price to a product
2669    pub async fn add_price(&self, request: &AddProductPriceRequest) -> Result<CatalogPrice> {
2670        self.add_price_with_options(request, RequestOptions::default())
2671            .await
2672    }
2673    /// Add a price to a product with per-request options.
2674    pub async fn add_price_with_options(
2675        &self,
2676        request: &AddProductPriceRequest,
2677        options: RequestOptions,
2678    ) -> Result<CatalogPrice> {
2679        self.client
2680            .request_resource(
2681                RequestSpec {
2682                    method: "POST",
2683                    path: "/products/add_price",
2684                    operation: "products.add_price",
2685                    field: Some("price"),
2686                    authenticated: true,
2687                },
2688                Some(request),
2689                options,
2690            )
2691            .await
2692    }
2693
2694    /// Lookup a product
2695    pub async fn lookup(&self, request: &LookupProductRequest) -> Result<Product> {
2696        self.lookup_with_options(request, RequestOptions::default())
2697            .await
2698    }
2699    /// Lookup a product with per-request options.
2700    pub async fn lookup_with_options(
2701        &self,
2702        request: &LookupProductRequest,
2703        options: RequestOptions,
2704    ) -> Result<Product> {
2705        self.client
2706            .request_resource(
2707                RequestSpec {
2708                    method: "POST",
2709                    path: "/products/lookup",
2710                    operation: "products.lookup",
2711                    field: Some("product"),
2712                    authenticated: true,
2713                },
2714                Some(request),
2715                options,
2716            )
2717            .await
2718    }
2719
2720    /// Update a product
2721    pub async fn update(&self, request: &UpdateProductRequest) -> Result<Product> {
2722        self.update_with_options(request, RequestOptions::default())
2723            .await
2724    }
2725    /// Update a product with per-request options.
2726    pub async fn update_with_options(
2727        &self,
2728        request: &UpdateProductRequest,
2729        options: RequestOptions,
2730    ) -> Result<Product> {
2731        self.client
2732            .request_resource(
2733                RequestSpec {
2734                    method: "POST",
2735                    path: "/products/update",
2736                    operation: "products.update",
2737                    field: Some("product"),
2738                    authenticated: true,
2739                },
2740                Some(request),
2741                options,
2742            )
2743            .await
2744    }
2745
2746    /// Publish a product
2747    pub async fn publish(&self, request: &ProductActionRequest) -> Result<Product> {
2748        self.publish_with_options(request, RequestOptions::default())
2749            .await
2750    }
2751    /// Publish a product with per-request options.
2752    pub async fn publish_with_options(
2753        &self,
2754        request: &ProductActionRequest,
2755        options: RequestOptions,
2756    ) -> Result<Product> {
2757        self.client
2758            .request_resource(
2759                RequestSpec {
2760                    method: "POST",
2761                    path: "/products/publish",
2762                    operation: "products.publish",
2763                    field: Some("product"),
2764                    authenticated: true,
2765                },
2766                Some(request),
2767                options,
2768            )
2769            .await
2770    }
2771
2772    /// Unpublish a product
2773    pub async fn unpublish(&self, request: &ProductActionRequest) -> Result<Product> {
2774        self.unpublish_with_options(request, RequestOptions::default())
2775            .await
2776    }
2777    /// Unpublish a product with per-request options.
2778    pub async fn unpublish_with_options(
2779        &self,
2780        request: &ProductActionRequest,
2781        options: RequestOptions,
2782    ) -> Result<Product> {
2783        self.client
2784            .request_resource(
2785                RequestSpec {
2786                    method: "POST",
2787                    path: "/products/unpublish",
2788                    operation: "products.unpublish",
2789                    field: Some("product"),
2790                    authenticated: true,
2791                },
2792                Some(request),
2793                options,
2794            )
2795            .await
2796    }
2797
2798    /// Archive a product
2799    pub async fn archive(&self, request: &ProductActionRequest) -> Result<Product> {
2800        self.archive_with_options(request, RequestOptions::default())
2801            .await
2802    }
2803    /// Archive a product with per-request options.
2804    pub async fn archive_with_options(
2805        &self,
2806        request: &ProductActionRequest,
2807        options: RequestOptions,
2808    ) -> Result<Product> {
2809        self.client
2810            .request_resource(
2811                RequestSpec {
2812                    method: "POST",
2813                    path: "/products/archive",
2814                    operation: "products.archive",
2815                    field: Some("product"),
2816                    authenticated: true,
2817                },
2818                Some(request),
2819                options,
2820            )
2821            .await
2822    }
2823
2824    /// Page through products
2825    pub async fn page(&self, request: &PageProductsRequest) -> Result<ProductPage> {
2826        self.page_with_options(request, RequestOptions::default())
2827            .await
2828    }
2829    /// Page through products with per-request options.
2830    pub async fn page_with_options(
2831        &self,
2832        request: &PageProductsRequest,
2833        options: RequestOptions,
2834    ) -> Result<ProductPage> {
2835        self.client
2836            .request_resource(
2837                RequestSpec {
2838                    method: "POST",
2839                    path: "/products/page",
2840                    operation: "products.page",
2841                    field: Some("page"),
2842                    authenticated: true,
2843                },
2844                Some(request),
2845                options,
2846            )
2847            .await
2848    }
2849}
2850
2851/// Operations for Inttegro purchase intents.
2852#[derive(Clone)]
2853pub struct PurchaseIntents {
2854    client: Client,
2855}
2856
2857impl PurchaseIntents {
2858    pub(crate) fn new(client: Client) -> Self {
2859        Self { client }
2860    }
2861
2862    /// Create a purchase intent
2863    pub async fn create(&self, request: &CreatePurchaseIntentRequest) -> Result<PurchaseIntent> {
2864        self.create_with_options(request, RequestOptions::default())
2865            .await
2866    }
2867    /// Create a purchase intent with per-request options.
2868    pub async fn create_with_options(
2869        &self,
2870        request: &CreatePurchaseIntentRequest,
2871        options: RequestOptions,
2872    ) -> Result<PurchaseIntent> {
2873        self.client
2874            .request_resource(
2875                RequestSpec {
2876                    method: "POST",
2877                    path: "/purchase_intents/create",
2878                    operation: "purchase_intents.create",
2879                    field: Some("purchase_intent"),
2880                    authenticated: true,
2881                },
2882                Some(request),
2883                options,
2884            )
2885            .await
2886    }
2887
2888    /// Update a purchase intent
2889    pub async fn update(&self, request: &UpdatePurchaseIntentRequest) -> Result<PurchaseIntent> {
2890        self.update_with_options(request, RequestOptions::default())
2891            .await
2892    }
2893    /// Update a purchase intent with per-request options.
2894    pub async fn update_with_options(
2895        &self,
2896        request: &UpdatePurchaseIntentRequest,
2897        options: RequestOptions,
2898    ) -> Result<PurchaseIntent> {
2899        self.client
2900            .request_resource(
2901                RequestSpec {
2902                    method: "POST",
2903                    path: "/purchase_intents/update",
2904                    operation: "purchase_intents.update",
2905                    field: Some("purchase_intent"),
2906                    authenticated: true,
2907                },
2908                Some(request),
2909                options,
2910            )
2911            .await
2912    }
2913
2914    /// Cancel a purchase intent
2915    pub async fn cancel(&self, request: &CancelPurchaseIntentRequest) -> Result<PurchaseIntent> {
2916        self.cancel_with_options(request, RequestOptions::default())
2917            .await
2918    }
2919    /// Cancel a purchase intent with per-request options.
2920    pub async fn cancel_with_options(
2921        &self,
2922        request: &CancelPurchaseIntentRequest,
2923        options: RequestOptions,
2924    ) -> Result<PurchaseIntent> {
2925        self.client
2926            .request_resource(
2927                RequestSpec {
2928                    method: "POST",
2929                    path: "/purchase_intents/cancel",
2930                    operation: "purchase_intents.cancel",
2931                    field: Some("purchase_intent"),
2932                    authenticated: true,
2933                },
2934                Some(request),
2935                options,
2936            )
2937            .await
2938    }
2939
2940    /// Lookup a purchase intent
2941    pub async fn lookup(&self, request: &LookupPurchaseIntentRequest) -> Result<PurchaseIntent> {
2942        self.lookup_with_options(request, RequestOptions::default())
2943            .await
2944    }
2945    /// Lookup a purchase intent with per-request options.
2946    pub async fn lookup_with_options(
2947        &self,
2948        request: &LookupPurchaseIntentRequest,
2949        options: RequestOptions,
2950    ) -> Result<PurchaseIntent> {
2951        self.client
2952            .request_resource(
2953                RequestSpec {
2954                    method: "POST",
2955                    path: "/purchase_intents/lookup",
2956                    operation: "purchase_intents.lookup",
2957                    field: Some("purchase_intent"),
2958                    authenticated: true,
2959                },
2960                Some(request),
2961                options,
2962            )
2963            .await
2964    }
2965
2966    /// List purchase intents
2967    pub async fn page(&self, request: &PagePurchaseIntentsRequest) -> Result<PurchaseIntentPage> {
2968        self.page_with_options(request, RequestOptions::default())
2969            .await
2970    }
2971    /// List purchase intents with per-request options.
2972    pub async fn page_with_options(
2973        &self,
2974        request: &PagePurchaseIntentsRequest,
2975        options: RequestOptions,
2976    ) -> Result<PurchaseIntentPage> {
2977        self.client
2978            .request_resource(
2979                RequestSpec {
2980                    method: "POST",
2981                    path: "/purchase_intents/page",
2982                    operation: "purchase_intents.page",
2983                    field: Some("page"),
2984                    authenticated: true,
2985                },
2986                Some(request),
2987                options,
2988            )
2989            .await
2990    }
2991}
2992
2993/// Operations for Inttegro refunds.
2994#[derive(Clone)]
2995pub struct Refunds {
2996    client: Client,
2997}
2998
2999impl Refunds {
3000    pub(crate) fn new(client: Client) -> Self {
3001        Self { client }
3002    }
3003
3004    /// Create a refund
3005    pub async fn create(&self, request: &CreateRefundRequest) -> Result<Refund> {
3006        self.create_with_options(request, RequestOptions::default())
3007            .await
3008    }
3009    /// Create a refund with per-request options.
3010    pub async fn create_with_options(
3011        &self,
3012        request: &CreateRefundRequest,
3013        options: RequestOptions,
3014    ) -> Result<Refund> {
3015        self.client
3016            .request_resource(
3017                RequestSpec {
3018                    method: "POST",
3019                    path: "/refunds/create",
3020                    operation: "refunds.create",
3021                    field: Some("refund"),
3022                    authenticated: true,
3023                },
3024                Some(request),
3025                options,
3026            )
3027            .await
3028    }
3029
3030    /// Cancel a refund
3031    pub async fn cancel(&self, request: &CancelRefundRequest) -> Result<Refund> {
3032        self.cancel_with_options(request, RequestOptions::default())
3033            .await
3034    }
3035    /// Cancel a refund with per-request options.
3036    pub async fn cancel_with_options(
3037        &self,
3038        request: &CancelRefundRequest,
3039        options: RequestOptions,
3040    ) -> Result<Refund> {
3041        self.client
3042            .request_resource(
3043                RequestSpec {
3044                    method: "POST",
3045                    path: "/refunds/cancel",
3046                    operation: "refunds.cancel",
3047                    field: Some("refund"),
3048                    authenticated: true,
3049                },
3050                Some(request),
3051                options,
3052            )
3053            .await
3054    }
3055
3056    /// Look up a refund
3057    pub async fn lookup(&self, request: &LookupRefundRequest) -> Result<Refund> {
3058        self.lookup_with_options(request, RequestOptions::default())
3059            .await
3060    }
3061    /// Look up a refund with per-request options.
3062    pub async fn lookup_with_options(
3063        &self,
3064        request: &LookupRefundRequest,
3065        options: RequestOptions,
3066    ) -> Result<Refund> {
3067        self.client
3068            .request_resource(
3069                RequestSpec {
3070                    method: "POST",
3071                    path: "/refunds/lookup",
3072                    operation: "refunds.lookup",
3073                    field: Some("refund"),
3074                    authenticated: true,
3075                },
3076                Some(request),
3077                options,
3078            )
3079            .await
3080    }
3081
3082    /// Page through refunds
3083    pub async fn page(&self, request: &PageRefundsRequest) -> Result<RefundPage> {
3084        self.page_with_options(request, RequestOptions::default())
3085            .await
3086    }
3087    /// Page through refunds with per-request options.
3088    pub async fn page_with_options(
3089        &self,
3090        request: &PageRefundsRequest,
3091        options: RequestOptions,
3092    ) -> Result<RefundPage> {
3093        self.client
3094            .request_resource(
3095                RequestSpec {
3096                    method: "POST",
3097                    path: "/refunds/page",
3098                    operation: "refunds.page",
3099                    field: Some("page"),
3100                    authenticated: true,
3101                },
3102                Some(request),
3103                options,
3104            )
3105            .await
3106    }
3107}
3108
3109/// Operations for Inttegro schedules.
3110#[derive(Clone)]
3111pub struct Schedules {
3112    client: Client,
3113}
3114
3115impl Schedules {
3116    pub(crate) fn new(client: Client) -> Self {
3117        Self { client }
3118    }
3119
3120    /// Look up a scheduled Chime
3121    pub async fn lookup(&self, request: &LookupScheduleRequest) -> Result<ScheduleDetail> {
3122        self.lookup_with_options(request, RequestOptions::default())
3123            .await
3124    }
3125    /// Look up a scheduled Chime with per-request options.
3126    pub async fn lookup_with_options(
3127        &self,
3128        request: &LookupScheduleRequest,
3129        options: RequestOptions,
3130    ) -> Result<ScheduleDetail> {
3131        self.client
3132            .request_resource(
3133                RequestSpec {
3134                    method: "POST",
3135                    path: "/schedules/lookup",
3136                    operation: "schedules.lookup",
3137                    field: Some("scheduled_chime"),
3138                    authenticated: true,
3139                },
3140                Some(request),
3141                options,
3142            )
3143            .await
3144    }
3145
3146    /// Cancel a scheduled Chime
3147    pub async fn cancel(&self, request: &CancelScheduleRequest) -> Result<ScheduleCancelDetail> {
3148        self.cancel_with_options(request, RequestOptions::default())
3149            .await
3150    }
3151    /// Cancel a scheduled Chime with per-request options.
3152    pub async fn cancel_with_options(
3153        &self,
3154        request: &CancelScheduleRequest,
3155        options: RequestOptions,
3156    ) -> Result<ScheduleCancelDetail> {
3157        self.client
3158            .request_resource(
3159                RequestSpec {
3160                    method: "POST",
3161                    path: "/schedules/cancel",
3162                    operation: "schedules.cancel",
3163                    field: Some("scheduled_chime"),
3164                    authenticated: true,
3165                },
3166                Some(request),
3167                options,
3168            )
3169            .await
3170    }
3171}
3172
3173/// Operations for Inttegro specifications.
3174#[derive(Clone)]
3175pub struct Specifications {
3176    client: Client,
3177}
3178
3179impl Specifications {
3180    pub(crate) fn new(client: Client) -> Self {
3181        Self { client }
3182    }
3183
3184    /// Get country specifications
3185    pub async fn countries(&self) -> Result<CountrySpecifications> {
3186        self.countries_with_options(RequestOptions::default()).await
3187    }
3188    /// Get country specifications with per-request options.
3189    pub async fn countries_with_options(
3190        &self,
3191        options: RequestOptions,
3192    ) -> Result<CountrySpecifications> {
3193        let body = serde_json::json!({});
3194        self.client
3195            .request_resource(
3196                RequestSpec {
3197                    method: "POST",
3198                    path: "/spec/countries",
3199                    operation: "specifications.countries",
3200                    field: Some("countries"),
3201                    authenticated: false,
3202                },
3203                Some(&body),
3204                options,
3205            )
3206            .await
3207    }
3208}
3209
3210/// Operations for Inttegro upload requests.
3211#[derive(Clone)]
3212pub struct UploadRequests {
3213    client: Client,
3214}
3215
3216impl UploadRequests {
3217    pub(crate) fn new(client: Client) -> Self {
3218        Self { client }
3219    }
3220
3221    /// Create an upload request
3222    pub async fn create(&self, request: &CreateUploadRequestRequest) -> Result<UploadRequest> {
3223        self.create_with_options(request, RequestOptions::default())
3224            .await
3225    }
3226    /// Create an upload request with per-request options.
3227    pub async fn create_with_options(
3228        &self,
3229        request: &CreateUploadRequestRequest,
3230        options: RequestOptions,
3231    ) -> Result<UploadRequest> {
3232        self.client
3233            .request_resource(
3234                RequestSpec {
3235                    method: "POST",
3236                    path: "/upload_requests/create",
3237                    operation: "upload_requests.create",
3238                    field: Some("upload_request"),
3239                    authenticated: true,
3240                },
3241                Some(request),
3242                options,
3243            )
3244            .await
3245    }
3246
3247    /// Lookup an upload request
3248    pub async fn lookup(&self, request: &LookupUploadRequestRequest) -> Result<UploadRequest> {
3249        self.lookup_with_options(request, RequestOptions::default())
3250            .await
3251    }
3252    /// Lookup an upload request with per-request options.
3253    pub async fn lookup_with_options(
3254        &self,
3255        request: &LookupUploadRequestRequest,
3256        options: RequestOptions,
3257    ) -> Result<UploadRequest> {
3258        self.client
3259            .request_resource(
3260                RequestSpec {
3261                    method: "POST",
3262                    path: "/upload_requests/lookup",
3263                    operation: "upload_requests.lookup",
3264                    field: Some("upload_request"),
3265                    authenticated: true,
3266                },
3267                Some(request),
3268                options,
3269            )
3270            .await
3271    }
3272
3273    /// Page upload requests
3274    pub async fn page(&self, request: &PageUploadRequestsRequest) -> Result<UploadRequestPage> {
3275        self.page_with_options(request, RequestOptions::default())
3276            .await
3277    }
3278    /// Page upload requests with per-request options.
3279    pub async fn page_with_options(
3280        &self,
3281        request: &PageUploadRequestsRequest,
3282        options: RequestOptions,
3283    ) -> Result<UploadRequestPage> {
3284        self.client
3285            .request_resource(
3286                RequestSpec {
3287                    method: "POST",
3288                    path: "/upload_requests/page",
3289                    operation: "upload_requests.page",
3290                    field: Some("page"),
3291                    authenticated: true,
3292                },
3293                Some(request),
3294                options,
3295            )
3296            .await
3297    }
3298
3299    /// Cancel an upload request
3300    pub async fn cancel(&self, request: &CancelUploadRequestRequest) -> Result<UploadRequest> {
3301        self.cancel_with_options(request, RequestOptions::default())
3302            .await
3303    }
3304    /// Cancel an upload request with per-request options.
3305    pub async fn cancel_with_options(
3306        &self,
3307        request: &CancelUploadRequestRequest,
3308        options: RequestOptions,
3309    ) -> Result<UploadRequest> {
3310        self.client
3311            .request_resource(
3312                RequestSpec {
3313                    method: "POST",
3314                    path: "/upload_requests/cancel",
3315                    operation: "upload_requests.cancel",
3316                    field: Some("upload_request"),
3317                    authenticated: true,
3318                },
3319                Some(request),
3320                options,
3321            )
3322            .await
3323    }
3324
3325    /// Review an upload request attempt
3326    pub async fn review(
3327        &self,
3328        request: &ReviewUploadRequestAttemptRequest,
3329    ) -> Result<UploadRequest> {
3330        self.review_with_options(request, RequestOptions::default())
3331            .await
3332    }
3333    /// Review an upload request attempt with per-request options.
3334    pub async fn review_with_options(
3335        &self,
3336        request: &ReviewUploadRequestAttemptRequest,
3337        options: RequestOptions,
3338    ) -> Result<UploadRequest> {
3339        self.client
3340            .request_resource(
3341                RequestSpec {
3342                    method: "POST",
3343                    path: "/upload_requests/review",
3344                    operation: "upload_requests.review",
3345                    field: Some("upload_request"),
3346                    authenticated: true,
3347                },
3348                Some(request),
3349                options,
3350            )
3351            .await
3352    }
3353
3354    /// Fulfill an upload request
3355    pub async fn fulfill(&self, request: FulfillUploadRequest) -> Result<UploadFulfillment> {
3356        self.fulfill_with_options(request, RequestOptions::default())
3357            .await
3358    }
3359    /// Fulfill an upload request with per-request options.
3360    pub async fn fulfill_with_options(
3361        &self,
3362        request: FulfillUploadRequest,
3363        options: RequestOptions,
3364    ) -> Result<UploadFulfillment> {
3365        self.client
3366            .fulfill_upload(
3367                "/upload_requests/upload",
3368                request,
3369                options,
3370                "upload_requests.fulfill",
3371            )
3372            .await
3373    }
3374}