1use reqwest::Method;
5use serde::Serialize;
6use serde_json::Value;
7
8use crate::{NubisClient, NubisError};
9
10impl NubisClient {
11 pub async fn delete_api_v1_api_keys_by_key_id<B: Serialize + ?Sized>(
13 &self,
14 key_id: &str,
15 body: Option<&B>,
16 query: Option<&[(&str, &str)]>,
17 ) -> Result<Value, NubisError> {
18 self.request_value(
19 Method::DELETE,
20 "/api/v1/api-keys/:key_id",
21 &[("key_id", key_id)],
22 query,
23 body,
24 )
25 .await
26 }
27
28 pub async fn delete_api_v1_orgs_by_org_id<B: Serialize + ?Sized>(
30 &self,
31 org_id: &str,
32 body: Option<&B>,
33 query: Option<&[(&str, &str)]>,
34 ) -> Result<Value, NubisError> {
35 self.request_value(
36 Method::DELETE,
37 "/api/v1/orgs/:org_id",
38 &[("org_id", org_id)],
39 query,
40 body,
41 )
42 .await
43 }
44
45 pub async fn delete_api_v1_orgs_by_org_id_billing_payment_method<B: Serialize + ?Sized>(
47 &self,
48 org_id: &str,
49 body: Option<&B>,
50 query: Option<&[(&str, &str)]>,
51 ) -> Result<Value, NubisError> {
52 self.request_value(
53 Method::DELETE,
54 "/api/v1/orgs/:org_id/billing/payment-method",
55 &[("org_id", org_id)],
56 query,
57 body,
58 )
59 .await
60 }
61
62 pub async fn delete_api_v1_orgs_by_org_id_billing_payment_methods_by_method_id<
64 B: Serialize + ?Sized,
65 >(
66 &self,
67 org_id: &str,
68 method_id: &str,
69 body: Option<&B>,
70 query: Option<&[(&str, &str)]>,
71 ) -> Result<Value, NubisError> {
72 self.request_value(
73 Method::DELETE,
74 "/api/v1/orgs/:org_id/billing/payment-methods/:method_id",
75 &[("org_id", org_id), ("method_id", method_id)],
76 query,
77 body,
78 )
79 .await
80 }
81
82 pub async fn delete_api_v1_orgs_by_org_id_iac_webhooks_by_webhook_id<B: Serialize + ?Sized>(
84 &self,
85 org_id: &str,
86 webhook_id: &str,
87 body: Option<&B>,
88 query: Option<&[(&str, &str)]>,
89 ) -> Result<Value, NubisError> {
90 self.request_value(
91 Method::DELETE,
92 "/api/v1/orgs/:org_id/iac/webhooks/:webhook_id",
93 &[("org_id", org_id), ("webhook_id", webhook_id)],
94 query,
95 body,
96 )
97 .await
98 }
99
100 pub async fn delete_api_v1_orgs_by_org_id_iam_service_accounts_by_sa_id<
102 B: Serialize + ?Sized,
103 >(
104 &self,
105 org_id: &str,
106 sa_id: &str,
107 body: Option<&B>,
108 query: Option<&[(&str, &str)]>,
109 ) -> Result<Value, NubisError> {
110 self.request_value(
111 Method::DELETE,
112 "/api/v1/orgs/:org_id/iam/service-accounts/:sa_id",
113 &[("org_id", org_id), ("sa_id", sa_id)],
114 query,
115 body,
116 )
117 .await
118 }
119
120 pub async fn delete_api_v1_orgs_by_org_id_invitations_by_invite_id<B: Serialize + ?Sized>(
122 &self,
123 org_id: &str,
124 invite_id: &str,
125 body: Option<&B>,
126 query: Option<&[(&str, &str)]>,
127 ) -> Result<Value, NubisError> {
128 self.request_value(
129 Method::DELETE,
130 "/api/v1/orgs/:org_id/invitations/:invite_id",
131 &[("org_id", org_id), ("invite_id", invite_id)],
132 query,
133 body,
134 )
135 .await
136 }
137
138 pub async fn delete_api_v1_orgs_by_org_id_launch_github_connection<B: Serialize + ?Sized>(
140 &self,
141 org_id: &str,
142 body: Option<&B>,
143 query: Option<&[(&str, &str)]>,
144 ) -> Result<Value, NubisError> {
145 self.request_value(
146 Method::DELETE,
147 "/api/v1/orgs/:org_id/launch/github/connection",
148 &[("org_id", org_id)],
149 query,
150 body,
151 )
152 .await
153 }
154
155 pub async fn delete_api_v1_orgs_by_org_id_members_by_member_id<B: Serialize + ?Sized>(
157 &self,
158 org_id: &str,
159 member_id: &str,
160 body: Option<&B>,
161 query: Option<&[(&str, &str)]>,
162 ) -> Result<Value, NubisError> {
163 self.request_value(
164 Method::DELETE,
165 "/api/v1/orgs/:org_id/members/:member_id",
166 &[("org_id", org_id), ("member_id", member_id)],
167 query,
168 body,
169 )
170 .await
171 }
172
173 pub async fn delete_api_v1_orgs_by_org_id_observability_alerts_by_policy_id<
175 B: Serialize + ?Sized,
176 >(
177 &self,
178 org_id: &str,
179 policy_id: &str,
180 body: Option<&B>,
181 query: Option<&[(&str, &str)]>,
182 ) -> Result<Value, NubisError> {
183 self.request_value(
184 Method::DELETE,
185 "/api/v1/orgs/:org_id/observability/alerts/:policy_id",
186 &[("org_id", org_id), ("policy_id", policy_id)],
187 query,
188 body,
189 )
190 .await
191 }
192
193 pub async fn delete_api_v1_orgs_by_org_id_observability_destinations_by_destination_id<
195 B: Serialize + ?Sized,
196 >(
197 &self,
198 org_id: &str,
199 destination_id: &str,
200 body: Option<&B>,
201 query: Option<&[(&str, &str)]>,
202 ) -> Result<Value, NubisError> {
203 self.request_value(
204 Method::DELETE,
205 "/api/v1/orgs/:org_id/observability/destinations/:destination_id",
206 &[("org_id", org_id), ("destination_id", destination_id)],
207 query,
208 body,
209 )
210 .await
211 }
212
213 pub async fn delete_api_v1_orgs_by_org_id_projects_by_project_id<B: Serialize + ?Sized>(
215 &self,
216 org_id: &str,
217 project_id: &str,
218 body: Option<&B>,
219 query: Option<&[(&str, &str)]>,
220 ) -> Result<Value, NubisError> {
221 self.request_value(
222 Method::DELETE,
223 "/api/v1/orgs/:org_id/projects/:project_id",
224 &[("org_id", org_id), ("project_id", project_id)],
225 query,
226 body,
227 )
228 .await
229 }
230
231 pub async fn delete_api_v1_projects_by_project_id_backups_policies_by_policy_id<
233 B: Serialize + ?Sized,
234 >(
235 &self,
236 project_id: &str,
237 policy_id: &str,
238 body: Option<&B>,
239 query: Option<&[(&str, &str)]>,
240 ) -> Result<Value, NubisError> {
241 self.request_value(
242 Method::DELETE,
243 "/api/v1/projects/:project_id/backups/policies/:policy_id",
244 &[("project_id", project_id), ("policy_id", policy_id)],
245 query,
246 body,
247 )
248 .await
249 }
250
251 pub async fn delete_api_v1_projects_by_project_id_certificates_by_cert_id<
253 B: Serialize + ?Sized,
254 >(
255 &self,
256 project_id: &str,
257 cert_id: &str,
258 body: Option<&B>,
259 query: Option<&[(&str, &str)]>,
260 ) -> Result<Value, NubisError> {
261 self.request_value(
262 Method::DELETE,
263 "/api/v1/projects/:project_id/certificates/:cert_id",
264 &[("project_id", project_id), ("cert_id", cert_id)],
265 query,
266 body,
267 )
268 .await
269 }
270
271 pub async fn delete_api_v1_projects_by_project_id_databases_by_database_id<
273 B: Serialize + ?Sized,
274 >(
275 &self,
276 project_id: &str,
277 database_id: &str,
278 body: Option<&B>,
279 query: Option<&[(&str, &str)]>,
280 ) -> Result<Value, NubisError> {
281 self.request_value(
282 Method::DELETE,
283 "/api/v1/projects/:project_id/databases/:database_id",
284 &[("project_id", project_id), ("database_id", database_id)],
285 query,
286 body,
287 )
288 .await
289 }
290
291 pub async fn delete_api_v1_projects_by_project_id_databases_by_database_id_dbs_by_db_name<
293 B: Serialize + ?Sized,
294 >(
295 &self,
296 project_id: &str,
297 database_id: &str,
298 db_name: &str,
299 body: Option<&B>,
300 query: Option<&[(&str, &str)]>,
301 ) -> Result<Value, NubisError> {
302 self.request_value(
303 Method::DELETE,
304 "/api/v1/projects/:project_id/databases/:database_id/dbs/:db_name",
305 &[
306 ("project_id", project_id),
307 ("database_id", database_id),
308 ("db_name", db_name),
309 ],
310 query,
311 body,
312 )
313 .await
314 }
315
316 pub async fn delete_api_v1_projects_by_project_id_databases_by_database_id_pools_by_pool_name<
318 B: Serialize + ?Sized,
319 >(
320 &self,
321 project_id: &str,
322 database_id: &str,
323 pool_name: &str,
324 body: Option<&B>,
325 query: Option<&[(&str, &str)]>,
326 ) -> Result<Value, NubisError> {
327 self.request_value(
328 Method::DELETE,
329 "/api/v1/projects/:project_id/databases/:database_id/pools/:pool_name",
330 &[
331 ("project_id", project_id),
332 ("database_id", database_id),
333 ("pool_name", pool_name),
334 ],
335 query,
336 body,
337 )
338 .await
339 }
340
341 pub async fn delete_api_v1_projects_by_project_id_databases_by_database_id_replicas_by_replica_name<
343 B: Serialize + ?Sized,
344 >(
345 &self,
346 project_id: &str,
347 database_id: &str,
348 replica_name: &str,
349 body: Option<&B>,
350 query: Option<&[(&str, &str)]>,
351 ) -> Result<Value, NubisError> {
352 self.request_value(
353 Method::DELETE,
354 "/api/v1/projects/:project_id/databases/:database_id/replicas/:replica_name",
355 &[
356 ("project_id", project_id),
357 ("database_id", database_id),
358 ("replica_name", replica_name),
359 ],
360 query,
361 body,
362 )
363 .await
364 }
365
366 pub async fn delete_api_v1_projects_by_project_id_databases_by_database_id_users_by_username<
368 B: Serialize + ?Sized,
369 >(
370 &self,
371 project_id: &str,
372 database_id: &str,
373 username: &str,
374 body: Option<&B>,
375 query: Option<&[(&str, &str)]>,
376 ) -> Result<Value, NubisError> {
377 self.request_value(
378 Method::DELETE,
379 "/api/v1/projects/:project_id/databases/:database_id/users/:username",
380 &[
381 ("project_id", project_id),
382 ("database_id", database_id),
383 ("username", username),
384 ],
385 query,
386 body,
387 )
388 .await
389 }
390
391 pub async fn delete_api_v1_projects_by_project_id_firewalls_by_firewall_id<
393 B: Serialize + ?Sized,
394 >(
395 &self,
396 project_id: &str,
397 firewall_id: &str,
398 body: Option<&B>,
399 query: Option<&[(&str, &str)]>,
400 ) -> Result<Value, NubisError> {
401 self.request_value(
402 Method::DELETE,
403 "/api/v1/projects/:project_id/firewalls/:firewall_id",
404 &[("project_id", project_id), ("firewall_id", firewall_id)],
405 query,
406 body,
407 )
408 .await
409 }
410
411 pub async fn delete_api_v1_projects_by_project_id_firewalls_by_firewall_id_rules_by_rule_id<
413 B: Serialize + ?Sized,
414 >(
415 &self,
416 project_id: &str,
417 firewall_id: &str,
418 rule_id: &str,
419 body: Option<&B>,
420 query: Option<&[(&str, &str)]>,
421 ) -> Result<Value, NubisError> {
422 self.request_value(
423 Method::DELETE,
424 "/api/v1/projects/:project_id/firewalls/:firewall_id/rules/:rule_id",
425 &[
426 ("project_id", project_id),
427 ("firewall_id", firewall_id),
428 ("rule_id", rule_id),
429 ],
430 query,
431 body,
432 )
433 .await
434 }
435
436 pub async fn delete_api_v1_projects_by_project_id_floating_ips_by_eip_id<
438 B: Serialize + ?Sized,
439 >(
440 &self,
441 project_id: &str,
442 eip_id: &str,
443 body: Option<&B>,
444 query: Option<&[(&str, &str)]>,
445 ) -> Result<Value, NubisError> {
446 self.request_value(
447 Method::DELETE,
448 "/api/v1/projects/:project_id/floating-ips/:eip_id",
449 &[("project_id", project_id), ("eip_id", eip_id)],
450 query,
451 body,
452 )
453 .await
454 }
455
456 pub async fn delete_api_v1_projects_by_project_id_images_by_image_id<B: Serialize + ?Sized>(
458 &self,
459 project_id: &str,
460 image_id: &str,
461 body: Option<&B>,
462 query: Option<&[(&str, &str)]>,
463 ) -> Result<Value, NubisError> {
464 self.request_value(
465 Method::DELETE,
466 "/api/v1/projects/:project_id/images/:image_id",
467 &[("project_id", project_id), ("image_id", image_id)],
468 query,
469 body,
470 )
471 .await
472 }
473
474 pub async fn delete_api_v1_projects_by_project_id_k8s_by_cluster_id<B: Serialize + ?Sized>(
476 &self,
477 project_id: &str,
478 cluster_id: &str,
479 body: Option<&B>,
480 query: Option<&[(&str, &str)]>,
481 ) -> Result<Value, NubisError> {
482 self.request_value(
483 Method::DELETE,
484 "/api/v1/projects/:project_id/k8s/:cluster_id",
485 &[("project_id", project_id), ("cluster_id", cluster_id)],
486 query,
487 body,
488 )
489 .await
490 }
491
492 pub async fn delete_api_v1_projects_by_project_id_k8s_by_cluster_id_node_pools_by_pool_id<
494 B: Serialize + ?Sized,
495 >(
496 &self,
497 project_id: &str,
498 cluster_id: &str,
499 pool_id: &str,
500 body: Option<&B>,
501 query: Option<&[(&str, &str)]>,
502 ) -> Result<Value, NubisError> {
503 self.request_value(
504 Method::DELETE,
505 "/api/v1/projects/:project_id/k8s/:cluster_id/node_pools/:pool_id",
506 &[
507 ("project_id", project_id),
508 ("cluster_id", cluster_id),
509 ("pool_id", pool_id),
510 ],
511 query,
512 body,
513 )
514 .await
515 }
516
517 pub async fn delete_api_v1_projects_by_project_id_load_balancers_by_lb_id<
519 B: Serialize + ?Sized,
520 >(
521 &self,
522 project_id: &str,
523 lb_id: &str,
524 body: Option<&B>,
525 query: Option<&[(&str, &str)]>,
526 ) -> Result<Value, NubisError> {
527 self.request_value(
528 Method::DELETE,
529 "/api/v1/projects/:project_id/load-balancers/:lb_id",
530 &[("project_id", project_id), ("lb_id", lb_id)],
531 query,
532 body,
533 )
534 .await
535 }
536
537 pub async fn delete_api_v1_projects_by_project_id_load_balancers_by_lb_id_target_groups_by_tg_id_targets<
539 B: Serialize + ?Sized,
540 >(
541 &self,
542 project_id: &str,
543 lb_id: &str,
544 tg_id: &str,
545 body: Option<&B>,
546 query: Option<&[(&str, &str)]>,
547 ) -> Result<Value, NubisError> {
548 self.request_value(
549 Method::DELETE,
550 "/api/v1/projects/:project_id/load-balancers/:lb_id/target-groups/:tg_id/targets",
551 &[
552 ("project_id", project_id),
553 ("lb_id", lb_id),
554 ("tg_id", tg_id),
555 ],
556 query,
557 body,
558 )
559 .await
560 }
561
562 pub async fn delete_api_v1_projects_by_project_id_load_balancers_by_lb_id_targets_by_target_id<
564 B: Serialize + ?Sized,
565 >(
566 &self,
567 project_id: &str,
568 lb_id: &str,
569 target_id: &str,
570 body: Option<&B>,
571 query: Option<&[(&str, &str)]>,
572 ) -> Result<Value, NubisError> {
573 self.request_value(
574 Method::DELETE,
575 "/api/v1/projects/:project_id/load-balancers/:lb_id/targets/:target_id",
576 &[
577 ("project_id", project_id),
578 ("lb_id", lb_id),
579 ("target_id", target_id),
580 ],
581 query,
582 body,
583 )
584 .await
585 }
586
587 pub async fn delete_api_v1_projects_by_project_id_nat_gateways_by_nat_id<
589 B: Serialize + ?Sized,
590 >(
591 &self,
592 project_id: &str,
593 nat_id: &str,
594 body: Option<&B>,
595 query: Option<&[(&str, &str)]>,
596 ) -> Result<Value, NubisError> {
597 self.request_value(
598 Method::DELETE,
599 "/api/v1/projects/:project_id/nat-gateways/:nat_id",
600 &[("project_id", project_id), ("nat_id", nat_id)],
601 query,
602 body,
603 )
604 .await
605 }
606
607 pub async fn delete_api_v1_projects_by_project_id_networks_by_network_id<
609 B: Serialize + ?Sized,
610 >(
611 &self,
612 project_id: &str,
613 network_id: &str,
614 body: Option<&B>,
615 query: Option<&[(&str, &str)]>,
616 ) -> Result<Value, NubisError> {
617 self.request_value(
618 Method::DELETE,
619 "/api/v1/projects/:project_id/networks/:network_id",
620 &[("project_id", project_id), ("network_id", network_id)],
621 query,
622 body,
623 )
624 .await
625 }
626
627 pub async fn delete_api_v1_projects_by_project_id_networks_by_network_id_subnets_by_subnet_id<
629 B: Serialize + ?Sized,
630 >(
631 &self,
632 project_id: &str,
633 network_id: &str,
634 subnet_id: &str,
635 body: Option<&B>,
636 query: Option<&[(&str, &str)]>,
637 ) -> Result<Value, NubisError> {
638 self.request_value(
639 Method::DELETE,
640 "/api/v1/projects/:project_id/networks/:network_id/subnets/:subnet_id",
641 &[
642 ("project_id", project_id),
643 ("network_id", network_id),
644 ("subnet_id", subnet_id),
645 ],
646 query,
647 body,
648 )
649 .await
650 }
651
652 pub async fn delete_api_v1_projects_by_project_id_scaling_groups_by_group_id<
654 B: Serialize + ?Sized,
655 >(
656 &self,
657 project_id: &str,
658 group_id: &str,
659 body: Option<&B>,
660 query: Option<&[(&str, &str)]>,
661 ) -> Result<Value, NubisError> {
662 self.request_value(
663 Method::DELETE,
664 "/api/v1/projects/:project_id/scaling-groups/:group_id",
665 &[("project_id", project_id), ("group_id", group_id)],
666 query,
667 body,
668 )
669 .await
670 }
671
672 pub async fn delete_api_v1_projects_by_project_id_security_groups_by_sg_id<
674 B: Serialize + ?Sized,
675 >(
676 &self,
677 project_id: &str,
678 sg_id: &str,
679 body: Option<&B>,
680 query: Option<&[(&str, &str)]>,
681 ) -> Result<Value, NubisError> {
682 self.request_value(
683 Method::DELETE,
684 "/api/v1/projects/:project_id/security-groups/:sg_id",
685 &[("project_id", project_id), ("sg_id", sg_id)],
686 query,
687 body,
688 )
689 .await
690 }
691
692 pub async fn delete_api_v1_projects_by_project_id_security_groups_by_sg_id_rules_by_rule_id<
694 B: Serialize + ?Sized,
695 >(
696 &self,
697 project_id: &str,
698 sg_id: &str,
699 rule_id: &str,
700 body: Option<&B>,
701 query: Option<&[(&str, &str)]>,
702 ) -> Result<Value, NubisError> {
703 self.request_value(
704 Method::DELETE,
705 "/api/v1/projects/:project_id/security-groups/:sg_id/rules/:rule_id",
706 &[
707 ("project_id", project_id),
708 ("sg_id", sg_id),
709 ("rule_id", rule_id),
710 ],
711 query,
712 body,
713 )
714 .await
715 }
716
717 pub async fn delete_api_v1_projects_by_project_id_snapshots_by_snapshot_id<
719 B: Serialize + ?Sized,
720 >(
721 &self,
722 project_id: &str,
723 snapshot_id: &str,
724 body: Option<&B>,
725 query: Option<&[(&str, &str)]>,
726 ) -> Result<Value, NubisError> {
727 self.request_value(
728 Method::DELETE,
729 "/api/v1/projects/:project_id/snapshots/:snapshot_id",
730 &[("project_id", project_id), ("snapshot_id", snapshot_id)],
731 query,
732 body,
733 )
734 .await
735 }
736
737 pub async fn delete_api_v1_projects_by_project_id_ssh_keys_by_key_id<B: Serialize + ?Sized>(
739 &self,
740 project_id: &str,
741 key_id: &str,
742 body: Option<&B>,
743 query: Option<&[(&str, &str)]>,
744 ) -> Result<Value, NubisError> {
745 self.request_value(
746 Method::DELETE,
747 "/api/v1/projects/:project_id/ssh_keys/:key_id",
748 &[("project_id", project_id), ("key_id", key_id)],
749 query,
750 body,
751 )
752 .await
753 }
754
755 pub async fn delete_api_v1_projects_by_project_id_storage_access_keys_by_key_id<
757 B: Serialize + ?Sized,
758 >(
759 &self,
760 project_id: &str,
761 key_id: &str,
762 body: Option<&B>,
763 query: Option<&[(&str, &str)]>,
764 ) -> Result<Value, NubisError> {
765 self.request_value(
766 Method::DELETE,
767 "/api/v1/projects/:project_id/storage/access-keys/:key_id",
768 &[("project_id", project_id), ("key_id", key_id)],
769 query,
770 body,
771 )
772 .await
773 }
774
775 pub async fn delete_api_v1_projects_by_project_id_storage_buckets_by_bucket_id<
777 B: Serialize + ?Sized,
778 >(
779 &self,
780 project_id: &str,
781 bucket_id: &str,
782 body: Option<&B>,
783 query: Option<&[(&str, &str)]>,
784 ) -> Result<Value, NubisError> {
785 self.request_value(
786 Method::DELETE,
787 "/api/v1/projects/:project_id/storage/buckets/:bucket_id",
788 &[("project_id", project_id), ("bucket_id", bucket_id)],
789 query,
790 body,
791 )
792 .await
793 }
794
795 pub async fn delete_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_cors_by_rule_id<
797 B: Serialize + ?Sized,
798 >(
799 &self,
800 project_id: &str,
801 bucket_id: &str,
802 rule_id: &str,
803 body: Option<&B>,
804 query: Option<&[(&str, &str)]>,
805 ) -> Result<Value, NubisError> {
806 self.request_value(
807 Method::DELETE,
808 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/cors/:rule_id",
809 &[
810 ("project_id", project_id),
811 ("bucket_id", bucket_id),
812 ("rule_id", rule_id),
813 ],
814 query,
815 body,
816 )
817 .await
818 }
819
820 pub async fn delete_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_lifecycle_by_rule_id<
822 B: Serialize + ?Sized,
823 >(
824 &self,
825 project_id: &str,
826 bucket_id: &str,
827 rule_id: &str,
828 body: Option<&B>,
829 query: Option<&[(&str, &str)]>,
830 ) -> Result<Value, NubisError> {
831 self.request_value(
832 Method::DELETE,
833 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/lifecycle/:rule_id",
834 &[
835 ("project_id", project_id),
836 ("bucket_id", bucket_id),
837 ("rule_id", rule_id),
838 ],
839 query,
840 body,
841 )
842 .await
843 }
844
845 pub async fn delete_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_objects_key<
847 B: Serialize + ?Sized,
848 >(
849 &self,
850 project_id: &str,
851 bucket_id: &str,
852 body: Option<&B>,
853 query: Option<&[(&str, &str)]>,
854 ) -> Result<Value, NubisError> {
855 self.request_value(
856 Method::DELETE,
857 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/objects/*key",
858 &[("project_id", project_id), ("bucket_id", bucket_id)],
859 query,
860 body,
861 )
862 .await
863 }
864
865 pub async fn delete_api_v1_projects_by_project_id_templates_by_template_id<
867 B: Serialize + ?Sized,
868 >(
869 &self,
870 project_id: &str,
871 template_id: &str,
872 body: Option<&B>,
873 query: Option<&[(&str, &str)]>,
874 ) -> Result<Value, NubisError> {
875 self.request_value(
876 Method::DELETE,
877 "/api/v1/projects/:project_id/templates/:template_id",
878 &[("project_id", project_id), ("template_id", template_id)],
879 query,
880 body,
881 )
882 .await
883 }
884
885 pub async fn delete_api_v1_projects_by_project_id_vms_by_vm_id<B: Serialize + ?Sized>(
887 &self,
888 project_id: &str,
889 vm_id: &str,
890 body: Option<&B>,
891 query: Option<&[(&str, &str)]>,
892 ) -> Result<Value, NubisError> {
893 self.request_value(
894 Method::DELETE,
895 "/api/v1/projects/:project_id/vms/:vm_id",
896 &[("project_id", project_id), ("vm_id", vm_id)],
897 query,
898 body,
899 )
900 .await
901 }
902
903 pub async fn delete_api_v1_projects_by_project_id_vms_by_vm_id_disks_by_disk_id<
905 B: Serialize + ?Sized,
906 >(
907 &self,
908 project_id: &str,
909 vm_id: &str,
910 disk_id: &str,
911 body: Option<&B>,
912 query: Option<&[(&str, &str)]>,
913 ) -> Result<Value, NubisError> {
914 self.request_value(
915 Method::DELETE,
916 "/api/v1/projects/:project_id/vms/:vm_id/disks/:disk_id",
917 &[
918 ("project_id", project_id),
919 ("vm_id", vm_id),
920 ("disk_id", disk_id),
921 ],
922 query,
923 body,
924 )
925 .await
926 }
927
928 pub async fn delete_api_v1_projects_by_project_id_volumes_by_volume_id<
930 B: Serialize + ?Sized,
931 >(
932 &self,
933 project_id: &str,
934 volume_id: &str,
935 body: Option<&B>,
936 query: Option<&[(&str, &str)]>,
937 ) -> Result<Value, NubisError> {
938 self.request_value(
939 Method::DELETE,
940 "/api/v1/projects/:project_id/volumes/:volume_id",
941 &[("project_id", project_id), ("volume_id", volume_id)],
942 query,
943 body,
944 )
945 .await
946 }
947
948 pub async fn delete_api_v1_projects_by_project_id_zones_by_zone_id<B: Serialize + ?Sized>(
950 &self,
951 project_id: &str,
952 zone_id: &str,
953 body: Option<&B>,
954 query: Option<&[(&str, &str)]>,
955 ) -> Result<Value, NubisError> {
956 self.request_value(
957 Method::DELETE,
958 "/api/v1/projects/:project_id/zones/:zone_id",
959 &[("project_id", project_id), ("zone_id", zone_id)],
960 query,
961 body,
962 )
963 .await
964 }
965
966 pub async fn delete_api_v1_projects_by_project_id_zones_by_zone_id_records_by_record_id<
968 B: Serialize + ?Sized,
969 >(
970 &self,
971 project_id: &str,
972 zone_id: &str,
973 record_id: &str,
974 body: Option<&B>,
975 query: Option<&[(&str, &str)]>,
976 ) -> Result<Value, NubisError> {
977 self.request_value(
978 Method::DELETE,
979 "/api/v1/projects/:project_id/zones/:zone_id/records/:record_id",
980 &[
981 ("project_id", project_id),
982 ("zone_id", zone_id),
983 ("record_id", record_id),
984 ],
985 query,
986 body,
987 )
988 .await
989 }
990
991 pub async fn get_api_v1_account(
993 &self,
994 query: Option<&[(&str, &str)]>,
995 ) -> Result<Value, NubisError> {
996 self.request_value(
997 Method::GET,
998 "/api/v1/account",
999 &[],
1000 query,
1001 Option::<&Value>::None,
1002 )
1003 .await
1004 }
1005
1006 pub async fn get_api_v1_api_keys(
1008 &self,
1009 query: Option<&[(&str, &str)]>,
1010 ) -> Result<Value, NubisError> {
1011 self.request_value(
1012 Method::GET,
1013 "/api/v1/api-keys",
1014 &[],
1015 query,
1016 Option::<&Value>::None,
1017 )
1018 .await
1019 }
1020
1021 pub async fn get_api_v1_audit_logs(
1023 &self,
1024 query: Option<&[(&str, &str)]>,
1025 ) -> Result<Value, NubisError> {
1026 self.request_value(
1027 Method::GET,
1028 "/api/v1/audit-logs",
1029 &[],
1030 query,
1031 Option::<&Value>::None,
1032 )
1033 .await
1034 }
1035
1036 pub async fn get_api_v1_audit_logs_export(
1038 &self,
1039 query: Option<&[(&str, &str)]>,
1040 ) -> Result<Value, NubisError> {
1041 self.request_value(
1042 Method::GET,
1043 "/api/v1/audit-logs/export",
1044 &[],
1045 query,
1046 Option::<&Value>::None,
1047 )
1048 .await
1049 }
1050
1051 pub async fn get_api_v1_catalog_databases_options(
1053 &self,
1054 query: Option<&[(&str, &str)]>,
1055 ) -> Result<Value, NubisError> {
1056 self.request_value(
1057 Method::GET,
1058 "/api/v1/catalog/databases/options",
1059 &[],
1060 query,
1061 Option::<&Value>::None,
1062 )
1063 .await
1064 }
1065
1066 pub async fn get_api_v1_catalog_images(
1068 &self,
1069 query: Option<&[(&str, &str)]>,
1070 ) -> Result<Value, NubisError> {
1071 self.request_value(
1072 Method::GET,
1073 "/api/v1/catalog/images",
1074 &[],
1075 query,
1076 Option::<&Value>::None,
1077 )
1078 .await
1079 }
1080
1081 pub async fn get_api_v1_catalog_k8s_node_sizes(
1083 &self,
1084 query: Option<&[(&str, &str)]>,
1085 ) -> Result<Value, NubisError> {
1086 self.request_value(
1087 Method::GET,
1088 "/api/v1/catalog/k8s-node-sizes",
1089 &[],
1090 query,
1091 Option::<&Value>::None,
1092 )
1093 .await
1094 }
1095
1096 pub async fn get_api_v1_catalog_k8s_versions(
1098 &self,
1099 query: Option<&[(&str, &str)]>,
1100 ) -> Result<Value, NubisError> {
1101 self.request_value(
1102 Method::GET,
1103 "/api/v1/catalog/k8s-versions",
1104 &[],
1105 query,
1106 Option::<&Value>::None,
1107 )
1108 .await
1109 }
1110
1111 pub async fn get_api_v1_catalog_regions(
1113 &self,
1114 query: Option<&[(&str, &str)]>,
1115 ) -> Result<Value, NubisError> {
1116 self.request_value(
1117 Method::GET,
1118 "/api/v1/catalog/regions",
1119 &[],
1120 query,
1121 Option::<&Value>::None,
1122 )
1123 .await
1124 }
1125
1126 pub async fn get_api_v1_catalog_sizes(
1128 &self,
1129 query: Option<&[(&str, &str)]>,
1130 ) -> Result<Value, NubisError> {
1131 self.request_value(
1132 Method::GET,
1133 "/api/v1/catalog/sizes",
1134 &[],
1135 query,
1136 Option::<&Value>::None,
1137 )
1138 .await
1139 }
1140
1141 pub async fn get_api_v1_domains_verify_renewal(
1143 &self,
1144 query: Option<&[(&str, &str)]>,
1145 ) -> Result<Value, NubisError> {
1146 self.request_value(
1147 Method::GET,
1148 "/api/v1/domains/verify-renewal",
1149 &[],
1150 query,
1151 Option::<&Value>::None,
1152 )
1153 .await
1154 }
1155
1156 pub async fn get_api_v1_exchange_rates(
1158 &self,
1159 query: Option<&[(&str, &str)]>,
1160 ) -> Result<Value, NubisError> {
1161 self.request_value(
1162 Method::GET,
1163 "/api/v1/exchange-rates",
1164 &[],
1165 query,
1166 Option::<&Value>::None,
1167 )
1168 .await
1169 }
1170
1171 pub async fn get_api_v1_iam_roles(
1173 &self,
1174 query: Option<&[(&str, &str)]>,
1175 ) -> Result<Value, NubisError> {
1176 self.request_value(
1177 Method::GET,
1178 "/api/v1/iam/roles",
1179 &[],
1180 query,
1181 Option::<&Value>::None,
1182 )
1183 .await
1184 }
1185
1186 pub async fn get_api_v1_images(
1188 &self,
1189 query: Option<&[(&str, &str)]>,
1190 ) -> Result<Value, NubisError> {
1191 self.request_value(
1192 Method::GET,
1193 "/api/v1/images",
1194 &[],
1195 query,
1196 Option::<&Value>::None,
1197 )
1198 .await
1199 }
1200
1201 pub async fn get_api_v1_images_by_image_id(
1203 &self,
1204 image_id: &str,
1205 query: Option<&[(&str, &str)]>,
1206 ) -> Result<Value, NubisError> {
1207 self.request_value(
1208 Method::GET,
1209 "/api/v1/images/:image_id",
1210 &[("image_id", image_id)],
1211 query,
1212 Option::<&Value>::None,
1213 )
1214 .await
1215 }
1216
1217 pub async fn get_api_v1_incidents(
1219 &self,
1220 query: Option<&[(&str, &str)]>,
1221 ) -> Result<Value, NubisError> {
1222 self.request_value(
1223 Method::GET,
1224 "/api/v1/incidents",
1225 &[],
1226 query,
1227 Option::<&Value>::None,
1228 )
1229 .await
1230 }
1231
1232 pub async fn get_api_v1_incidents_by_id(
1234 &self,
1235 id: &str,
1236 query: Option<&[(&str, &str)]>,
1237 ) -> Result<Value, NubisError> {
1238 self.request_value(
1239 Method::GET,
1240 "/api/v1/incidents/:id",
1241 &[("id", id)],
1242 query,
1243 Option::<&Value>::None,
1244 )
1245 .await
1246 }
1247
1248 pub async fn get_api_v1_invitations_preview(
1250 &self,
1251 query: Option<&[(&str, &str)]>,
1252 ) -> Result<Value, NubisError> {
1253 self.request_value(
1254 Method::GET,
1255 "/api/v1/invitations/preview",
1256 &[],
1257 query,
1258 Option::<&Value>::None,
1259 )
1260 .await
1261 }
1262
1263 pub async fn get_api_v1_kyc_status(
1265 &self,
1266 query: Option<&[(&str, &str)]>,
1267 ) -> Result<Value, NubisError> {
1268 self.request_value(
1269 Method::GET,
1270 "/api/v1/kyc/status",
1271 &[],
1272 query,
1273 Option::<&Value>::None,
1274 )
1275 .await
1276 }
1277
1278 pub async fn get_api_v1_launch_github_callback(
1280 &self,
1281 query: Option<&[(&str, &str)]>,
1282 ) -> Result<Value, NubisError> {
1283 self.request_value(
1284 Method::GET,
1285 "/api/v1/launch/github/callback",
1286 &[],
1287 query,
1288 Option::<&Value>::None,
1289 )
1290 .await
1291 }
1292
1293 pub async fn get_api_v1_orgs(
1295 &self,
1296 query: Option<&[(&str, &str)]>,
1297 ) -> Result<Value, NubisError> {
1298 self.request_value(
1299 Method::GET,
1300 "/api/v1/orgs",
1301 &[],
1302 query,
1303 Option::<&Value>::None,
1304 )
1305 .await
1306 }
1307
1308 pub async fn get_api_v1_orgs_by_org_id(
1310 &self,
1311 org_id: &str,
1312 query: Option<&[(&str, &str)]>,
1313 ) -> Result<Value, NubisError> {
1314 self.request_value(
1315 Method::GET,
1316 "/api/v1/orgs/:org_id",
1317 &[("org_id", org_id)],
1318 query,
1319 Option::<&Value>::None,
1320 )
1321 .await
1322 }
1323
1324 pub async fn get_api_v1_orgs_by_org_id_billing_account_status(
1326 &self,
1327 org_id: &str,
1328 query: Option<&[(&str, &str)]>,
1329 ) -> Result<Value, NubisError> {
1330 self.request_value(
1331 Method::GET,
1332 "/api/v1/orgs/:org_id/billing/account-status",
1333 &[("org_id", org_id)],
1334 query,
1335 Option::<&Value>::None,
1336 )
1337 .await
1338 }
1339
1340 pub async fn get_api_v1_orgs_by_org_id_billing_bandwidth(
1342 &self,
1343 org_id: &str,
1344 query: Option<&[(&str, &str)]>,
1345 ) -> Result<Value, NubisError> {
1346 self.request_value(
1347 Method::GET,
1348 "/api/v1/orgs/:org_id/billing/bandwidth",
1349 &[("org_id", org_id)],
1350 query,
1351 Option::<&Value>::None,
1352 )
1353 .await
1354 }
1355
1356 pub async fn get_api_v1_orgs_by_org_id_billing_credits(
1358 &self,
1359 org_id: &str,
1360 query: Option<&[(&str, &str)]>,
1361 ) -> Result<Value, NubisError> {
1362 self.request_value(
1363 Method::GET,
1364 "/api/v1/orgs/:org_id/billing/credits",
1365 &[("org_id", org_id)],
1366 query,
1367 Option::<&Value>::None,
1368 )
1369 .await
1370 }
1371
1372 pub async fn get_api_v1_orgs_by_org_id_billing_credits_balance(
1374 &self,
1375 org_id: &str,
1376 query: Option<&[(&str, &str)]>,
1377 ) -> Result<Value, NubisError> {
1378 self.request_value(
1379 Method::GET,
1380 "/api/v1/orgs/:org_id/billing/credits/balance",
1381 &[("org_id", org_id)],
1382 query,
1383 Option::<&Value>::None,
1384 )
1385 .await
1386 }
1387
1388 pub async fn get_api_v1_orgs_by_org_id_billing_credits_usage(
1390 &self,
1391 org_id: &str,
1392 query: Option<&[(&str, &str)]>,
1393 ) -> Result<Value, NubisError> {
1394 self.request_value(
1395 Method::GET,
1396 "/api/v1/orgs/:org_id/billing/credits/usage",
1397 &[("org_id", org_id)],
1398 query,
1399 Option::<&Value>::None,
1400 )
1401 .await
1402 }
1403
1404 pub async fn get_api_v1_orgs_by_org_id_billing_enforcement(
1406 &self,
1407 org_id: &str,
1408 query: Option<&[(&str, &str)]>,
1409 ) -> Result<Value, NubisError> {
1410 self.request_value(
1411 Method::GET,
1412 "/api/v1/orgs/:org_id/billing/enforcement",
1413 &[("org_id", org_id)],
1414 query,
1415 Option::<&Value>::None,
1416 )
1417 .await
1418 }
1419
1420 pub async fn get_api_v1_orgs_by_org_id_billing_enforcement_settings(
1422 &self,
1423 org_id: &str,
1424 query: Option<&[(&str, &str)]>,
1425 ) -> Result<Value, NubisError> {
1426 self.request_value(
1427 Method::GET,
1428 "/api/v1/orgs/:org_id/billing/enforcement-settings",
1429 &[("org_id", org_id)],
1430 query,
1431 Option::<&Value>::None,
1432 )
1433 .await
1434 }
1435
1436 pub async fn get_api_v1_orgs_by_org_id_billing_history(
1438 &self,
1439 org_id: &str,
1440 query: Option<&[(&str, &str)]>,
1441 ) -> Result<Value, NubisError> {
1442 self.request_value(
1443 Method::GET,
1444 "/api/v1/orgs/:org_id/billing/history",
1445 &[("org_id", org_id)],
1446 query,
1447 Option::<&Value>::None,
1448 )
1449 .await
1450 }
1451
1452 pub async fn get_api_v1_orgs_by_org_id_billing_payment_method(
1454 &self,
1455 org_id: &str,
1456 query: Option<&[(&str, &str)]>,
1457 ) -> Result<Value, NubisError> {
1458 self.request_value(
1459 Method::GET,
1460 "/api/v1/orgs/:org_id/billing/payment-method",
1461 &[("org_id", org_id)],
1462 query,
1463 Option::<&Value>::None,
1464 )
1465 .await
1466 }
1467
1468 pub async fn get_api_v1_orgs_by_org_id_billing_payment_methods(
1470 &self,
1471 org_id: &str,
1472 query: Option<&[(&str, &str)]>,
1473 ) -> Result<Value, NubisError> {
1474 self.request_value(
1475 Method::GET,
1476 "/api/v1/orgs/:org_id/billing/payment-methods",
1477 &[("org_id", org_id)],
1478 query,
1479 Option::<&Value>::None,
1480 )
1481 .await
1482 }
1483
1484 pub async fn get_api_v1_orgs_by_org_id_billing_resources(
1486 &self,
1487 org_id: &str,
1488 query: Option<&[(&str, &str)]>,
1489 ) -> Result<Value, NubisError> {
1490 self.request_value(
1491 Method::GET,
1492 "/api/v1/orgs/:org_id/billing/resources",
1493 &[("org_id", org_id)],
1494 query,
1495 Option::<&Value>::None,
1496 )
1497 .await
1498 }
1499
1500 pub async fn get_api_v1_orgs_by_org_id_billing_spend_limit(
1502 &self,
1503 org_id: &str,
1504 query: Option<&[(&str, &str)]>,
1505 ) -> Result<Value, NubisError> {
1506 self.request_value(
1507 Method::GET,
1508 "/api/v1/orgs/:org_id/billing/spend-limit",
1509 &[("org_id", org_id)],
1510 query,
1511 Option::<&Value>::None,
1512 )
1513 .await
1514 }
1515
1516 pub async fn get_api_v1_orgs_by_org_id_billing_status(
1518 &self,
1519 org_id: &str,
1520 query: Option<&[(&str, &str)]>,
1521 ) -> Result<Value, NubisError> {
1522 self.request_value(
1523 Method::GET,
1524 "/api/v1/orgs/:org_id/billing/status",
1525 &[("org_id", org_id)],
1526 query,
1527 Option::<&Value>::None,
1528 )
1529 .await
1530 }
1531
1532 pub async fn get_api_v1_orgs_by_org_id_billing_tax_info(
1534 &self,
1535 org_id: &str,
1536 query: Option<&[(&str, &str)]>,
1537 ) -> Result<Value, NubisError> {
1538 self.request_value(
1539 Method::GET,
1540 "/api/v1/orgs/:org_id/billing/tax-info",
1541 &[("org_id", org_id)],
1542 query,
1543 Option::<&Value>::None,
1544 )
1545 .await
1546 }
1547
1548 pub async fn get_api_v1_orgs_by_org_id_billing_usage(
1550 &self,
1551 org_id: &str,
1552 query: Option<&[(&str, &str)]>,
1553 ) -> Result<Value, NubisError> {
1554 self.request_value(
1555 Method::GET,
1556 "/api/v1/orgs/:org_id/billing/usage",
1557 &[("org_id", org_id)],
1558 query,
1559 Option::<&Value>::None,
1560 )
1561 .await
1562 }
1563
1564 pub async fn get_api_v1_orgs_by_org_id_billing_usage_breakdown(
1566 &self,
1567 org_id: &str,
1568 query: Option<&[(&str, &str)]>,
1569 ) -> Result<Value, NubisError> {
1570 self.request_value(
1571 Method::GET,
1572 "/api/v1/orgs/:org_id/billing/usage/breakdown",
1573 &[("org_id", org_id)],
1574 query,
1575 Option::<&Value>::None,
1576 )
1577 .await
1578 }
1579
1580 pub async fn get_api_v1_orgs_by_org_id_billing_usage_export(
1582 &self,
1583 org_id: &str,
1584 query: Option<&[(&str, &str)]>,
1585 ) -> Result<Value, NubisError> {
1586 self.request_value(
1587 Method::GET,
1588 "/api/v1/orgs/:org_id/billing/usage/export",
1589 &[("org_id", org_id)],
1590 query,
1591 Option::<&Value>::None,
1592 )
1593 .await
1594 }
1595
1596 pub async fn get_api_v1_orgs_by_org_id_billing_usage_summary(
1598 &self,
1599 org_id: &str,
1600 query: Option<&[(&str, &str)]>,
1601 ) -> Result<Value, NubisError> {
1602 self.request_value(
1603 Method::GET,
1604 "/api/v1/orgs/:org_id/billing/usage/summary",
1605 &[("org_id", org_id)],
1606 query,
1607 Option::<&Value>::None,
1608 )
1609 .await
1610 }
1611
1612 pub async fn get_api_v1_orgs_by_org_id_billing_usage_timeseries(
1614 &self,
1615 org_id: &str,
1616 query: Option<&[(&str, &str)]>,
1617 ) -> Result<Value, NubisError> {
1618 self.request_value(
1619 Method::GET,
1620 "/api/v1/orgs/:org_id/billing/usage/timeseries",
1621 &[("org_id", org_id)],
1622 query,
1623 Option::<&Value>::None,
1624 )
1625 .await
1626 }
1627
1628 pub async fn get_api_v1_orgs_by_org_id_billing_verification(
1630 &self,
1631 org_id: &str,
1632 query: Option<&[(&str, &str)]>,
1633 ) -> Result<Value, NubisError> {
1634 self.request_value(
1635 Method::GET,
1636 "/api/v1/orgs/:org_id/billing/verification",
1637 &[("org_id", org_id)],
1638 query,
1639 Option::<&Value>::None,
1640 )
1641 .await
1642 }
1643
1644 pub async fn get_api_v1_orgs_by_org_id_iac_webhooks(
1646 &self,
1647 org_id: &str,
1648 query: Option<&[(&str, &str)]>,
1649 ) -> Result<Value, NubisError> {
1650 self.request_value(
1651 Method::GET,
1652 "/api/v1/orgs/:org_id/iac/webhooks",
1653 &[("org_id", org_id)],
1654 query,
1655 Option::<&Value>::None,
1656 )
1657 .await
1658 }
1659
1660 pub async fn get_api_v1_orgs_by_org_id_iac_webhooks_by_webhook_id_deliveries(
1662 &self,
1663 org_id: &str,
1664 webhook_id: &str,
1665 query: Option<&[(&str, &str)]>,
1666 ) -> Result<Value, NubisError> {
1667 self.request_value(
1668 Method::GET,
1669 "/api/v1/orgs/:org_id/iac/webhooks/:webhook_id/deliveries",
1670 &[("org_id", org_id), ("webhook_id", webhook_id)],
1671 query,
1672 Option::<&Value>::None,
1673 )
1674 .await
1675 }
1676
1677 pub async fn get_api_v1_orgs_by_org_id_iam_me(
1679 &self,
1680 org_id: &str,
1681 query: Option<&[(&str, &str)]>,
1682 ) -> Result<Value, NubisError> {
1683 self.request_value(
1684 Method::GET,
1685 "/api/v1/orgs/:org_id/iam/me",
1686 &[("org_id", org_id)],
1687 query,
1688 Option::<&Value>::None,
1689 )
1690 .await
1691 }
1692
1693 pub async fn get_api_v1_orgs_by_org_id_iam_permissions(
1695 &self,
1696 org_id: &str,
1697 query: Option<&[(&str, &str)]>,
1698 ) -> Result<Value, NubisError> {
1699 self.request_value(
1700 Method::GET,
1701 "/api/v1/orgs/:org_id/iam/permissions",
1702 &[("org_id", org_id)],
1703 query,
1704 Option::<&Value>::None,
1705 )
1706 .await
1707 }
1708
1709 pub async fn get_api_v1_orgs_by_org_id_iam_roles(
1711 &self,
1712 org_id: &str,
1713 query: Option<&[(&str, &str)]>,
1714 ) -> Result<Value, NubisError> {
1715 self.request_value(
1716 Method::GET,
1717 "/api/v1/orgs/:org_id/iam/roles",
1718 &[("org_id", org_id)],
1719 query,
1720 Option::<&Value>::None,
1721 )
1722 .await
1723 }
1724
1725 pub async fn get_api_v1_orgs_by_org_id_iam_roles_by_role_id_permissions(
1727 &self,
1728 org_id: &str,
1729 role_id: &str,
1730 query: Option<&[(&str, &str)]>,
1731 ) -> Result<Value, NubisError> {
1732 self.request_value(
1733 Method::GET,
1734 "/api/v1/orgs/:org_id/iam/roles/:role_id/permissions",
1735 &[("org_id", org_id), ("role_id", role_id)],
1736 query,
1737 Option::<&Value>::None,
1738 )
1739 .await
1740 }
1741
1742 pub async fn get_api_v1_orgs_by_org_id_iam_service_accounts(
1744 &self,
1745 org_id: &str,
1746 query: Option<&[(&str, &str)]>,
1747 ) -> Result<Value, NubisError> {
1748 self.request_value(
1749 Method::GET,
1750 "/api/v1/orgs/:org_id/iam/service-accounts",
1751 &[("org_id", org_id)],
1752 query,
1753 Option::<&Value>::None,
1754 )
1755 .await
1756 }
1757
1758 pub async fn get_api_v1_orgs_by_org_id_iam_sso(
1760 &self,
1761 org_id: &str,
1762 query: Option<&[(&str, &str)]>,
1763 ) -> Result<Value, NubisError> {
1764 self.request_value(
1765 Method::GET,
1766 "/api/v1/orgs/:org_id/iam/sso",
1767 &[("org_id", org_id)],
1768 query,
1769 Option::<&Value>::None,
1770 )
1771 .await
1772 }
1773
1774 pub async fn get_api_v1_orgs_by_org_id_invitations(
1776 &self,
1777 org_id: &str,
1778 query: Option<&[(&str, &str)]>,
1779 ) -> Result<Value, NubisError> {
1780 self.request_value(
1781 Method::GET,
1782 "/api/v1/orgs/:org_id/invitations",
1783 &[("org_id", org_id)],
1784 query,
1785 Option::<&Value>::None,
1786 )
1787 .await
1788 }
1789
1790 pub async fn get_api_v1_orgs_by_org_id_invoices(
1792 &self,
1793 org_id: &str,
1794 query: Option<&[(&str, &str)]>,
1795 ) -> Result<Value, NubisError> {
1796 self.request_value(
1797 Method::GET,
1798 "/api/v1/orgs/:org_id/invoices",
1799 &[("org_id", org_id)],
1800 query,
1801 Option::<&Value>::None,
1802 )
1803 .await
1804 }
1805
1806 pub async fn get_api_v1_orgs_by_org_id_invoices_by_invoice_id_download(
1808 &self,
1809 org_id: &str,
1810 invoice_id: &str,
1811 query: Option<&[(&str, &str)]>,
1812 ) -> Result<Value, NubisError> {
1813 self.request_value(
1814 Method::GET,
1815 "/api/v1/orgs/:org_id/invoices/:invoice_id/download",
1816 &[("org_id", org_id), ("invoice_id", invoice_id)],
1817 query,
1818 Option::<&Value>::None,
1819 )
1820 .await
1821 }
1822
1823 pub async fn get_api_v1_orgs_by_org_id_launch_access(
1825 &self,
1826 org_id: &str,
1827 query: Option<&[(&str, &str)]>,
1828 ) -> Result<Value, NubisError> {
1829 self.request_value(
1830 Method::GET,
1831 "/api/v1/orgs/:org_id/launch/access",
1832 &[("org_id", org_id)],
1833 query,
1834 Option::<&Value>::None,
1835 )
1836 .await
1837 }
1838
1839 pub async fn get_api_v1_orgs_by_org_id_launch_deployments_by_deployment_id(
1841 &self,
1842 org_id: &str,
1843 deployment_id: &str,
1844 query: Option<&[(&str, &str)]>,
1845 ) -> Result<Value, NubisError> {
1846 self.request_value(
1847 Method::GET,
1848 "/api/v1/orgs/:org_id/launch/deployments/:deployment_id",
1849 &[("org_id", org_id), ("deployment_id", deployment_id)],
1850 query,
1851 Option::<&Value>::None,
1852 )
1853 .await
1854 }
1855
1856 pub async fn get_api_v1_orgs_by_org_id_launch_deployments_by_deployment_id_events(
1858 &self,
1859 org_id: &str,
1860 deployment_id: &str,
1861 query: Option<&[(&str, &str)]>,
1862 ) -> Result<Value, NubisError> {
1863 self.request_value(
1864 Method::GET,
1865 "/api/v1/orgs/:org_id/launch/deployments/:deployment_id/events",
1866 &[("org_id", org_id), ("deployment_id", deployment_id)],
1867 query,
1868 Option::<&Value>::None,
1869 )
1870 .await
1871 }
1872
1873 pub async fn get_api_v1_orgs_by_org_id_launch_deployments_by_deployment_id_logs(
1875 &self,
1876 org_id: &str,
1877 deployment_id: &str,
1878 query: Option<&[(&str, &str)]>,
1879 ) -> Result<Value, NubisError> {
1880 self.request_value(
1881 Method::GET,
1882 "/api/v1/orgs/:org_id/launch/deployments/:deployment_id/logs",
1883 &[("org_id", org_id), ("deployment_id", deployment_id)],
1884 query,
1885 Option::<&Value>::None,
1886 )
1887 .await
1888 }
1889
1890 pub async fn get_api_v1_orgs_by_org_id_launch_github_connection(
1892 &self,
1893 org_id: &str,
1894 query: Option<&[(&str, &str)]>,
1895 ) -> Result<Value, NubisError> {
1896 self.request_value(
1897 Method::GET,
1898 "/api/v1/orgs/:org_id/launch/github/connection",
1899 &[("org_id", org_id)],
1900 query,
1901 Option::<&Value>::None,
1902 )
1903 .await
1904 }
1905
1906 pub async fn get_api_v1_orgs_by_org_id_launch_github_repositories(
1908 &self,
1909 org_id: &str,
1910 query: Option<&[(&str, &str)]>,
1911 ) -> Result<Value, NubisError> {
1912 self.request_value(
1913 Method::GET,
1914 "/api/v1/orgs/:org_id/launch/github/repositories",
1915 &[("org_id", org_id)],
1916 query,
1917 Option::<&Value>::None,
1918 )
1919 .await
1920 }
1921
1922 pub async fn get_api_v1_orgs_by_org_id_launch_projects(
1924 &self,
1925 org_id: &str,
1926 query: Option<&[(&str, &str)]>,
1927 ) -> Result<Value, NubisError> {
1928 self.request_value(
1929 Method::GET,
1930 "/api/v1/orgs/:org_id/launch/projects",
1931 &[("org_id", org_id)],
1932 query,
1933 Option::<&Value>::None,
1934 )
1935 .await
1936 }
1937
1938 pub async fn get_api_v1_orgs_by_org_id_launch_projects_by_project_id(
1940 &self,
1941 org_id: &str,
1942 project_id: &str,
1943 query: Option<&[(&str, &str)]>,
1944 ) -> Result<Value, NubisError> {
1945 self.request_value(
1946 Method::GET,
1947 "/api/v1/orgs/:org_id/launch/projects/:project_id",
1948 &[("org_id", org_id), ("project_id", project_id)],
1949 query,
1950 Option::<&Value>::None,
1951 )
1952 .await
1953 }
1954
1955 pub async fn get_api_v1_orgs_by_org_id_launch_projects_by_project_id_services(
1957 &self,
1958 org_id: &str,
1959 project_id: &str,
1960 query: Option<&[(&str, &str)]>,
1961 ) -> Result<Value, NubisError> {
1962 self.request_value(
1963 Method::GET,
1964 "/api/v1/orgs/:org_id/launch/projects/:project_id/services",
1965 &[("org_id", org_id), ("project_id", project_id)],
1966 query,
1967 Option::<&Value>::None,
1968 )
1969 .await
1970 }
1971
1972 pub async fn get_api_v1_orgs_by_org_id_launch_services_by_service_id(
1974 &self,
1975 org_id: &str,
1976 service_id: &str,
1977 query: Option<&[(&str, &str)]>,
1978 ) -> Result<Value, NubisError> {
1979 self.request_value(
1980 Method::GET,
1981 "/api/v1/orgs/:org_id/launch/services/:service_id",
1982 &[("org_id", org_id), ("service_id", service_id)],
1983 query,
1984 Option::<&Value>::None,
1985 )
1986 .await
1987 }
1988
1989 pub async fn get_api_v1_orgs_by_org_id_launch_services_by_service_id_deployments(
1991 &self,
1992 org_id: &str,
1993 service_id: &str,
1994 query: Option<&[(&str, &str)]>,
1995 ) -> Result<Value, NubisError> {
1996 self.request_value(
1997 Method::GET,
1998 "/api/v1/orgs/:org_id/launch/services/:service_id/deployments",
1999 &[("org_id", org_id), ("service_id", service_id)],
2000 query,
2001 Option::<&Value>::None,
2002 )
2003 .await
2004 }
2005
2006 pub async fn get_api_v1_orgs_by_org_id_launch_services_by_service_id_domains(
2008 &self,
2009 org_id: &str,
2010 service_id: &str,
2011 query: Option<&[(&str, &str)]>,
2012 ) -> Result<Value, NubisError> {
2013 self.request_value(
2014 Method::GET,
2015 "/api/v1/orgs/:org_id/launch/services/:service_id/domains",
2016 &[("org_id", org_id), ("service_id", service_id)],
2017 query,
2018 Option::<&Value>::None,
2019 )
2020 .await
2021 }
2022
2023 pub async fn get_api_v1_orgs_by_org_id_launch_services_by_service_id_logs(
2025 &self,
2026 org_id: &str,
2027 service_id: &str,
2028 query: Option<&[(&str, &str)]>,
2029 ) -> Result<Value, NubisError> {
2030 self.request_value(
2031 Method::GET,
2032 "/api/v1/orgs/:org_id/launch/services/:service_id/logs",
2033 &[("org_id", org_id), ("service_id", service_id)],
2034 query,
2035 Option::<&Value>::None,
2036 )
2037 .await
2038 }
2039
2040 pub async fn get_api_v1_orgs_by_org_id_launch_services_by_service_id_previews(
2042 &self,
2043 org_id: &str,
2044 service_id: &str,
2045 query: Option<&[(&str, &str)]>,
2046 ) -> Result<Value, NubisError> {
2047 self.request_value(
2048 Method::GET,
2049 "/api/v1/orgs/:org_id/launch/services/:service_id/previews",
2050 &[("org_id", org_id), ("service_id", service_id)],
2051 query,
2052 Option::<&Value>::None,
2053 )
2054 .await
2055 }
2056
2057 pub async fn get_api_v1_orgs_by_org_id_limits_enforcement(
2059 &self,
2060 org_id: &str,
2061 query: Option<&[(&str, &str)]>,
2062 ) -> Result<Value, NubisError> {
2063 self.request_value(
2064 Method::GET,
2065 "/api/v1/orgs/:org_id/limits/enforcement",
2066 &[("org_id", org_id)],
2067 query,
2068 Option::<&Value>::None,
2069 )
2070 .await
2071 }
2072
2073 pub async fn get_api_v1_orgs_by_org_id_limits_history(
2075 &self,
2076 org_id: &str,
2077 query: Option<&[(&str, &str)]>,
2078 ) -> Result<Value, NubisError> {
2079 self.request_value(
2080 Method::GET,
2081 "/api/v1/orgs/:org_id/limits/history",
2082 &[("org_id", org_id)],
2083 query,
2084 Option::<&Value>::None,
2085 )
2086 .await
2087 }
2088
2089 pub async fn get_api_v1_orgs_by_org_id_limits_overview(
2091 &self,
2092 org_id: &str,
2093 query: Option<&[(&str, &str)]>,
2094 ) -> Result<Value, NubisError> {
2095 self.request_value(
2096 Method::GET,
2097 "/api/v1/orgs/:org_id/limits/overview",
2098 &[("org_id", org_id)],
2099 query,
2100 Option::<&Value>::None,
2101 )
2102 .await
2103 }
2104
2105 pub async fn get_api_v1_orgs_by_org_id_limits_projects(
2107 &self,
2108 org_id: &str,
2109 query: Option<&[(&str, &str)]>,
2110 ) -> Result<Value, NubisError> {
2111 self.request_value(
2112 Method::GET,
2113 "/api/v1/orgs/:org_id/limits/projects",
2114 &[("org_id", org_id)],
2115 query,
2116 Option::<&Value>::None,
2117 )
2118 .await
2119 }
2120
2121 pub async fn get_api_v1_orgs_by_org_id_limits_requests(
2123 &self,
2124 org_id: &str,
2125 query: Option<&[(&str, &str)]>,
2126 ) -> Result<Value, NubisError> {
2127 self.request_value(
2128 Method::GET,
2129 "/api/v1/orgs/:org_id/limits/requests",
2130 &[("org_id", org_id)],
2131 query,
2132 Option::<&Value>::None,
2133 )
2134 .await
2135 }
2136
2137 pub async fn get_api_v1_orgs_by_org_id_limits_resources(
2139 &self,
2140 org_id: &str,
2141 query: Option<&[(&str, &str)]>,
2142 ) -> Result<Value, NubisError> {
2143 self.request_value(
2144 Method::GET,
2145 "/api/v1/orgs/:org_id/limits/resources",
2146 &[("org_id", org_id)],
2147 query,
2148 Option::<&Value>::None,
2149 )
2150 .await
2151 }
2152
2153 pub async fn get_api_v1_orgs_by_org_id_limits_spend(
2155 &self,
2156 org_id: &str,
2157 query: Option<&[(&str, &str)]>,
2158 ) -> Result<Value, NubisError> {
2159 self.request_value(
2160 Method::GET,
2161 "/api/v1/orgs/:org_id/limits/spend",
2162 &[("org_id", org_id)],
2163 query,
2164 Option::<&Value>::None,
2165 )
2166 .await
2167 }
2168
2169 pub async fn get_api_v1_orgs_by_org_id_members(
2171 &self,
2172 org_id: &str,
2173 query: Option<&[(&str, &str)]>,
2174 ) -> Result<Value, NubisError> {
2175 self.request_value(
2176 Method::GET,
2177 "/api/v1/orgs/:org_id/members",
2178 &[("org_id", org_id)],
2179 query,
2180 Option::<&Value>::None,
2181 )
2182 .await
2183 }
2184
2185 pub async fn get_api_v1_orgs_by_org_id_metrics_compute(
2187 &self,
2188 org_id: &str,
2189 query: Option<&[(&str, &str)]>,
2190 ) -> Result<Value, NubisError> {
2191 self.request_value(
2192 Method::GET,
2193 "/api/v1/orgs/:org_id/metrics/compute",
2194 &[("org_id", org_id)],
2195 query,
2196 Option::<&Value>::None,
2197 )
2198 .await
2199 }
2200
2201 pub async fn get_api_v1_orgs_by_org_id_observability_alerts(
2203 &self,
2204 org_id: &str,
2205 query: Option<&[(&str, &str)]>,
2206 ) -> Result<Value, NubisError> {
2207 self.request_value(
2208 Method::GET,
2209 "/api/v1/orgs/:org_id/observability/alerts",
2210 &[("org_id", org_id)],
2211 query,
2212 Option::<&Value>::None,
2213 )
2214 .await
2215 }
2216
2217 pub async fn get_api_v1_orgs_by_org_id_observability_alerts_events(
2219 &self,
2220 org_id: &str,
2221 query: Option<&[(&str, &str)]>,
2222 ) -> Result<Value, NubisError> {
2223 self.request_value(
2224 Method::GET,
2225 "/api/v1/orgs/:org_id/observability/alerts/events",
2226 &[("org_id", org_id)],
2227 query,
2228 Option::<&Value>::None,
2229 )
2230 .await
2231 }
2232
2233 pub async fn get_api_v1_orgs_by_org_id_observability_destinations(
2235 &self,
2236 org_id: &str,
2237 query: Option<&[(&str, &str)]>,
2238 ) -> Result<Value, NubisError> {
2239 self.request_value(
2240 Method::GET,
2241 "/api/v1/orgs/:org_id/observability/destinations",
2242 &[("org_id", org_id)],
2243 query,
2244 Option::<&Value>::None,
2245 )
2246 .await
2247 }
2248
2249 pub async fn get_api_v1_orgs_by_org_id_projects(
2251 &self,
2252 org_id: &str,
2253 query: Option<&[(&str, &str)]>,
2254 ) -> Result<Value, NubisError> {
2255 self.request_value(
2256 Method::GET,
2257 "/api/v1/orgs/:org_id/projects",
2258 &[("org_id", org_id)],
2259 query,
2260 Option::<&Value>::None,
2261 )
2262 .await
2263 }
2264
2265 pub async fn get_api_v1_orgs_by_org_id_projects_by_project_id(
2267 &self,
2268 org_id: &str,
2269 project_id: &str,
2270 query: Option<&[(&str, &str)]>,
2271 ) -> Result<Value, NubisError> {
2272 self.request_value(
2273 Method::GET,
2274 "/api/v1/orgs/:org_id/projects/:project_id",
2275 &[("org_id", org_id), ("project_id", project_id)],
2276 query,
2277 Option::<&Value>::None,
2278 )
2279 .await
2280 }
2281
2282 pub async fn get_api_v1_orgs_by_org_id_projects_by_project_id_billing_spend_limit(
2284 &self,
2285 org_id: &str,
2286 project_id: &str,
2287 query: Option<&[(&str, &str)]>,
2288 ) -> Result<Value, NubisError> {
2289 self.request_value(
2290 Method::GET,
2291 "/api/v1/orgs/:org_id/projects/:project_id/billing/spend-limit",
2292 &[("org_id", org_id), ("project_id", project_id)],
2293 query,
2294 Option::<&Value>::None,
2295 )
2296 .await
2297 }
2298
2299 pub async fn get_api_v1_orgs_by_org_id_projects_by_project_id_metrics(
2301 &self,
2302 org_id: &str,
2303 project_id: &str,
2304 query: Option<&[(&str, &str)]>,
2305 ) -> Result<Value, NubisError> {
2306 self.request_value(
2307 Method::GET,
2308 "/api/v1/orgs/:org_id/projects/:project_id/metrics",
2309 &[("org_id", org_id), ("project_id", project_id)],
2310 query,
2311 Option::<&Value>::None,
2312 )
2313 .await
2314 }
2315
2316 pub async fn get_api_v1_orgs_by_org_id_subscription(
2318 &self,
2319 org_id: &str,
2320 query: Option<&[(&str, &str)]>,
2321 ) -> Result<Value, NubisError> {
2322 self.request_value(
2323 Method::GET,
2324 "/api/v1/orgs/:org_id/subscription",
2325 &[("org_id", org_id)],
2326 query,
2327 Option::<&Value>::None,
2328 )
2329 .await
2330 }
2331
2332 pub async fn get_api_v1_orgs_by_org_id_support_plan(
2334 &self,
2335 org_id: &str,
2336 query: Option<&[(&str, &str)]>,
2337 ) -> Result<Value, NubisError> {
2338 self.request_value(
2339 Method::GET,
2340 "/api/v1/orgs/:org_id/support/plan",
2341 &[("org_id", org_id)],
2342 query,
2343 Option::<&Value>::None,
2344 )
2345 .await
2346 }
2347
2348 pub async fn get_api_v1_orgs_by_org_id_tickets(
2350 &self,
2351 org_id: &str,
2352 query: Option<&[(&str, &str)]>,
2353 ) -> Result<Value, NubisError> {
2354 self.request_value(
2355 Method::GET,
2356 "/api/v1/orgs/:org_id/tickets",
2357 &[("org_id", org_id)],
2358 query,
2359 Option::<&Value>::None,
2360 )
2361 .await
2362 }
2363
2364 pub async fn get_api_v1_orgs_by_org_id_tickets_by_ticket_id(
2366 &self,
2367 org_id: &str,
2368 ticket_id: &str,
2369 query: Option<&[(&str, &str)]>,
2370 ) -> Result<Value, NubisError> {
2371 self.request_value(
2372 Method::GET,
2373 "/api/v1/orgs/:org_id/tickets/:ticket_id",
2374 &[("org_id", org_id), ("ticket_id", ticket_id)],
2375 query,
2376 Option::<&Value>::None,
2377 )
2378 .await
2379 }
2380
2381 pub async fn get_api_v1_orgs_by_org_id_tickets_by_ticket_id_attachments_by_attachment_id(
2383 &self,
2384 org_id: &str,
2385 ticket_id: &str,
2386 attachment_id: &str,
2387 query: Option<&[(&str, &str)]>,
2388 ) -> Result<Value, NubisError> {
2389 self.request_value(
2390 Method::GET,
2391 "/api/v1/orgs/:org_id/tickets/:ticket_id/attachments/:attachment_id",
2392 &[
2393 ("org_id", org_id),
2394 ("ticket_id", ticket_id),
2395 ("attachment_id", attachment_id),
2396 ],
2397 query,
2398 Option::<&Value>::None,
2399 )
2400 .await
2401 }
2402
2403 pub async fn get_api_v1_platform_config(
2405 &self,
2406 query: Option<&[(&str, &str)]>,
2407 ) -> Result<Value, NubisError> {
2408 self.request_value(
2409 Method::GET,
2410 "/api/v1/platform/config",
2411 &[],
2412 query,
2413 Option::<&Value>::None,
2414 )
2415 .await
2416 }
2417
2418 pub async fn get_api_v1_platform_health(
2420 &self,
2421 query: Option<&[(&str, &str)]>,
2422 ) -> Result<Value, NubisError> {
2423 self.request_value(
2424 Method::GET,
2425 "/api/v1/platform/health",
2426 &[],
2427 query,
2428 Option::<&Value>::None,
2429 )
2430 .await
2431 }
2432
2433 pub async fn get_api_v1_projects_by_project_id(
2435 &self,
2436 project_id: &str,
2437 query: Option<&[(&str, &str)]>,
2438 ) -> Result<Value, NubisError> {
2439 self.request_value(
2440 Method::GET,
2441 "/api/v1/projects/:project_id",
2442 &[("project_id", project_id)],
2443 query,
2444 Option::<&Value>::None,
2445 )
2446 .await
2447 }
2448
2449 pub async fn get_api_v1_projects_by_project_id_backups_costs(
2451 &self,
2452 project_id: &str,
2453 query: Option<&[(&str, &str)]>,
2454 ) -> Result<Value, NubisError> {
2455 self.request_value(
2456 Method::GET,
2457 "/api/v1/projects/:project_id/backups/costs",
2458 &[("project_id", project_id)],
2459 query,
2460 Option::<&Value>::None,
2461 )
2462 .await
2463 }
2464
2465 pub async fn get_api_v1_projects_by_project_id_backups_overview(
2467 &self,
2468 project_id: &str,
2469 query: Option<&[(&str, &str)]>,
2470 ) -> Result<Value, NubisError> {
2471 self.request_value(
2472 Method::GET,
2473 "/api/v1/projects/:project_id/backups/overview",
2474 &[("project_id", project_id)],
2475 query,
2476 Option::<&Value>::None,
2477 )
2478 .await
2479 }
2480
2481 pub async fn get_api_v1_projects_by_project_id_backups_policies(
2483 &self,
2484 project_id: &str,
2485 query: Option<&[(&str, &str)]>,
2486 ) -> Result<Value, NubisError> {
2487 self.request_value(
2488 Method::GET,
2489 "/api/v1/projects/:project_id/backups/policies",
2490 &[("project_id", project_id)],
2491 query,
2492 Option::<&Value>::None,
2493 )
2494 .await
2495 }
2496
2497 pub async fn get_api_v1_projects_by_project_id_backups_policies_by_policy_id(
2499 &self,
2500 project_id: &str,
2501 policy_id: &str,
2502 query: Option<&[(&str, &str)]>,
2503 ) -> Result<Value, NubisError> {
2504 self.request_value(
2505 Method::GET,
2506 "/api/v1/projects/:project_id/backups/policies/:policy_id",
2507 &[("project_id", project_id), ("policy_id", policy_id)],
2508 query,
2509 Option::<&Value>::None,
2510 )
2511 .await
2512 }
2513
2514 pub async fn get_api_v1_projects_by_project_id_backups_policies_by_policy_id_runs(
2516 &self,
2517 project_id: &str,
2518 policy_id: &str,
2519 query: Option<&[(&str, &str)]>,
2520 ) -> Result<Value, NubisError> {
2521 self.request_value(
2522 Method::GET,
2523 "/api/v1/projects/:project_id/backups/policies/:policy_id/runs",
2524 &[("project_id", project_id), ("policy_id", policy_id)],
2525 query,
2526 Option::<&Value>::None,
2527 )
2528 .await
2529 }
2530
2531 pub async fn get_api_v1_projects_by_project_id_backups_snapshots(
2533 &self,
2534 project_id: &str,
2535 query: Option<&[(&str, &str)]>,
2536 ) -> Result<Value, NubisError> {
2537 self.request_value(
2538 Method::GET,
2539 "/api/v1/projects/:project_id/backups/snapshots",
2540 &[("project_id", project_id)],
2541 query,
2542 Option::<&Value>::None,
2543 )
2544 .await
2545 }
2546
2547 pub async fn get_api_v1_projects_by_project_id_certificates(
2549 &self,
2550 project_id: &str,
2551 query: Option<&[(&str, &str)]>,
2552 ) -> Result<Value, NubisError> {
2553 self.request_value(
2554 Method::GET,
2555 "/api/v1/projects/:project_id/certificates",
2556 &[("project_id", project_id)],
2557 query,
2558 Option::<&Value>::None,
2559 )
2560 .await
2561 }
2562
2563 pub async fn get_api_v1_projects_by_project_id_databases(
2565 &self,
2566 project_id: &str,
2567 query: Option<&[(&str, &str)]>,
2568 ) -> Result<Value, NubisError> {
2569 self.request_value(
2570 Method::GET,
2571 "/api/v1/projects/:project_id/databases",
2572 &[("project_id", project_id)],
2573 query,
2574 Option::<&Value>::None,
2575 )
2576 .await
2577 }
2578
2579 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id(
2581 &self,
2582 project_id: &str,
2583 database_id: &str,
2584 query: Option<&[(&str, &str)]>,
2585 ) -> Result<Value, NubisError> {
2586 self.request_value(
2587 Method::GET,
2588 "/api/v1/projects/:project_id/databases/:database_id",
2589 &[("project_id", project_id), ("database_id", database_id)],
2590 query,
2591 Option::<&Value>::None,
2592 )
2593 .await
2594 }
2595
2596 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_backups(
2598 &self,
2599 project_id: &str,
2600 database_id: &str,
2601 query: Option<&[(&str, &str)]>,
2602 ) -> Result<Value, NubisError> {
2603 self.request_value(
2604 Method::GET,
2605 "/api/v1/projects/:project_id/databases/:database_id/backups",
2606 &[("project_id", project_id), ("database_id", database_id)],
2607 query,
2608 Option::<&Value>::None,
2609 )
2610 .await
2611 }
2612
2613 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_config(
2615 &self,
2616 project_id: &str,
2617 database_id: &str,
2618 query: Option<&[(&str, &str)]>,
2619 ) -> Result<Value, NubisError> {
2620 self.request_value(
2621 Method::GET,
2622 "/api/v1/projects/:project_id/databases/:database_id/config",
2623 &[("project_id", project_id), ("database_id", database_id)],
2624 query,
2625 Option::<&Value>::None,
2626 )
2627 .await
2628 }
2629
2630 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_dbs(
2632 &self,
2633 project_id: &str,
2634 database_id: &str,
2635 query: Option<&[(&str, &str)]>,
2636 ) -> Result<Value, NubisError> {
2637 self.request_value(
2638 Method::GET,
2639 "/api/v1/projects/:project_id/databases/:database_id/dbs",
2640 &[("project_id", project_id), ("database_id", database_id)],
2641 query,
2642 Option::<&Value>::None,
2643 )
2644 .await
2645 }
2646
2647 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_firewall(
2649 &self,
2650 project_id: &str,
2651 database_id: &str,
2652 query: Option<&[(&str, &str)]>,
2653 ) -> Result<Value, NubisError> {
2654 self.request_value(
2655 Method::GET,
2656 "/api/v1/projects/:project_id/databases/:database_id/firewall",
2657 &[("project_id", project_id), ("database_id", database_id)],
2658 query,
2659 Option::<&Value>::None,
2660 )
2661 .await
2662 }
2663
2664 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_logs(
2666 &self,
2667 project_id: &str,
2668 database_id: &str,
2669 query: Option<&[(&str, &str)]>,
2670 ) -> Result<Value, NubisError> {
2671 self.request_value(
2672 Method::GET,
2673 "/api/v1/projects/:project_id/databases/:database_id/logs",
2674 &[("project_id", project_id), ("database_id", database_id)],
2675 query,
2676 Option::<&Value>::None,
2677 )
2678 .await
2679 }
2680
2681 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_logs_download(
2683 &self,
2684 project_id: &str,
2685 database_id: &str,
2686 query: Option<&[(&str, &str)]>,
2687 ) -> Result<Value, NubisError> {
2688 self.request_value(
2689 Method::GET,
2690 "/api/v1/projects/:project_id/databases/:database_id/logs/download",
2691 &[("project_id", project_id), ("database_id", database_id)],
2692 query,
2693 Option::<&Value>::None,
2694 )
2695 .await
2696 }
2697
2698 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_pools(
2700 &self,
2701 project_id: &str,
2702 database_id: &str,
2703 query: Option<&[(&str, &str)]>,
2704 ) -> Result<Value, NubisError> {
2705 self.request_value(
2706 Method::GET,
2707 "/api/v1/projects/:project_id/databases/:database_id/pools",
2708 &[("project_id", project_id), ("database_id", database_id)],
2709 query,
2710 Option::<&Value>::None,
2711 )
2712 .await
2713 }
2714
2715 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_replicas(
2717 &self,
2718 project_id: &str,
2719 database_id: &str,
2720 query: Option<&[(&str, &str)]>,
2721 ) -> Result<Value, NubisError> {
2722 self.request_value(
2723 Method::GET,
2724 "/api/v1/projects/:project_id/databases/:database_id/replicas",
2725 &[("project_id", project_id), ("database_id", database_id)],
2726 query,
2727 Option::<&Value>::None,
2728 )
2729 .await
2730 }
2731
2732 pub async fn get_api_v1_projects_by_project_id_databases_by_database_id_users(
2734 &self,
2735 project_id: &str,
2736 database_id: &str,
2737 query: Option<&[(&str, &str)]>,
2738 ) -> Result<Value, NubisError> {
2739 self.request_value(
2740 Method::GET,
2741 "/api/v1/projects/:project_id/databases/:database_id/users",
2742 &[("project_id", project_id), ("database_id", database_id)],
2743 query,
2744 Option::<&Value>::None,
2745 )
2746 .await
2747 }
2748
2749 pub async fn get_api_v1_projects_by_project_id_domains_by_domain_id_auth_code(
2751 &self,
2752 project_id: &str,
2753 domain_id: &str,
2754 query: Option<&[(&str, &str)]>,
2755 ) -> Result<Value, NubisError> {
2756 self.request_value(
2757 Method::GET,
2758 "/api/v1/projects/:project_id/domains/:domain_id/auth-code",
2759 &[("project_id", project_id), ("domain_id", domain_id)],
2760 query,
2761 Option::<&Value>::None,
2762 )
2763 .await
2764 }
2765
2766 pub async fn get_api_v1_projects_by_project_id_domains_by_domain_id_registrar_info(
2768 &self,
2769 project_id: &str,
2770 domain_id: &str,
2771 query: Option<&[(&str, &str)]>,
2772 ) -> Result<Value, NubisError> {
2773 self.request_value(
2774 Method::GET,
2775 "/api/v1/projects/:project_id/domains/:domain_id/registrar-info",
2776 &[("project_id", project_id), ("domain_id", domain_id)],
2777 query,
2778 Option::<&Value>::None,
2779 )
2780 .await
2781 }
2782
2783 pub async fn get_api_v1_projects_by_project_id_domains_orders(
2785 &self,
2786 project_id: &str,
2787 query: Option<&[(&str, &str)]>,
2788 ) -> Result<Value, NubisError> {
2789 self.request_value(
2790 Method::GET,
2791 "/api/v1/projects/:project_id/domains/orders",
2792 &[("project_id", project_id)],
2793 query,
2794 Option::<&Value>::None,
2795 )
2796 .await
2797 }
2798
2799 pub async fn get_api_v1_projects_by_project_id_firewalls(
2801 &self,
2802 project_id: &str,
2803 query: Option<&[(&str, &str)]>,
2804 ) -> Result<Value, NubisError> {
2805 self.request_value(
2806 Method::GET,
2807 "/api/v1/projects/:project_id/firewalls",
2808 &[("project_id", project_id)],
2809 query,
2810 Option::<&Value>::None,
2811 )
2812 .await
2813 }
2814
2815 pub async fn get_api_v1_projects_by_project_id_firewalls_by_firewall_id(
2817 &self,
2818 project_id: &str,
2819 firewall_id: &str,
2820 query: Option<&[(&str, &str)]>,
2821 ) -> Result<Value, NubisError> {
2822 self.request_value(
2823 Method::GET,
2824 "/api/v1/projects/:project_id/firewalls/:firewall_id",
2825 &[("project_id", project_id), ("firewall_id", firewall_id)],
2826 query,
2827 Option::<&Value>::None,
2828 )
2829 .await
2830 }
2831
2832 pub async fn get_api_v1_projects_by_project_id_floating_ips(
2834 &self,
2835 project_id: &str,
2836 query: Option<&[(&str, &str)]>,
2837 ) -> Result<Value, NubisError> {
2838 self.request_value(
2839 Method::GET,
2840 "/api/v1/projects/:project_id/floating-ips",
2841 &[("project_id", project_id)],
2842 query,
2843 Option::<&Value>::None,
2844 )
2845 .await
2846 }
2847
2848 pub async fn get_api_v1_projects_by_project_id_floating_ips_by_eip_id(
2850 &self,
2851 project_id: &str,
2852 eip_id: &str,
2853 query: Option<&[(&str, &str)]>,
2854 ) -> Result<Value, NubisError> {
2855 self.request_value(
2856 Method::GET,
2857 "/api/v1/projects/:project_id/floating-ips/:eip_id",
2858 &[("project_id", project_id), ("eip_id", eip_id)],
2859 query,
2860 Option::<&Value>::None,
2861 )
2862 .await
2863 }
2864
2865 pub async fn get_api_v1_projects_by_project_id_images(
2867 &self,
2868 project_id: &str,
2869 query: Option<&[(&str, &str)]>,
2870 ) -> Result<Value, NubisError> {
2871 self.request_value(
2872 Method::GET,
2873 "/api/v1/projects/:project_id/images",
2874 &[("project_id", project_id)],
2875 query,
2876 Option::<&Value>::None,
2877 )
2878 .await
2879 }
2880
2881 pub async fn get_api_v1_projects_by_project_id_k8s(
2883 &self,
2884 project_id: &str,
2885 query: Option<&[(&str, &str)]>,
2886 ) -> Result<Value, NubisError> {
2887 self.request_value(
2888 Method::GET,
2889 "/api/v1/projects/:project_id/k8s",
2890 &[("project_id", project_id)],
2891 query,
2892 Option::<&Value>::None,
2893 )
2894 .await
2895 }
2896
2897 pub async fn get_api_v1_projects_by_project_id_k8s_by_cluster_id(
2899 &self,
2900 project_id: &str,
2901 cluster_id: &str,
2902 query: Option<&[(&str, &str)]>,
2903 ) -> Result<Value, NubisError> {
2904 self.request_value(
2905 Method::GET,
2906 "/api/v1/projects/:project_id/k8s/:cluster_id",
2907 &[("project_id", project_id), ("cluster_id", cluster_id)],
2908 query,
2909 Option::<&Value>::None,
2910 )
2911 .await
2912 }
2913
2914 pub async fn get_api_v1_projects_by_project_id_k8s_by_cluster_id_available_upgrades(
2916 &self,
2917 project_id: &str,
2918 cluster_id: &str,
2919 query: Option<&[(&str, &str)]>,
2920 ) -> Result<Value, NubisError> {
2921 self.request_value(
2922 Method::GET,
2923 "/api/v1/projects/:project_id/k8s/:cluster_id/available-upgrades",
2924 &[("project_id", project_id), ("cluster_id", cluster_id)],
2925 query,
2926 Option::<&Value>::None,
2927 )
2928 .await
2929 }
2930
2931 pub async fn get_api_v1_projects_by_project_id_k8s_by_cluster_id_clusterlint(
2933 &self,
2934 project_id: &str,
2935 cluster_id: &str,
2936 query: Option<&[(&str, &str)]>,
2937 ) -> Result<Value, NubisError> {
2938 self.request_value(
2939 Method::GET,
2940 "/api/v1/projects/:project_id/k8s/:cluster_id/clusterlint",
2941 &[("project_id", project_id), ("cluster_id", cluster_id)],
2942 query,
2943 Option::<&Value>::None,
2944 )
2945 .await
2946 }
2947
2948 pub async fn get_api_v1_projects_by_project_id_k8s_by_cluster_id_deletion_resources(
2950 &self,
2951 project_id: &str,
2952 cluster_id: &str,
2953 query: Option<&[(&str, &str)]>,
2954 ) -> Result<Value, NubisError> {
2955 self.request_value(
2956 Method::GET,
2957 "/api/v1/projects/:project_id/k8s/:cluster_id/deletion-resources",
2958 &[("project_id", project_id), ("cluster_id", cluster_id)],
2959 query,
2960 Option::<&Value>::None,
2961 )
2962 .await
2963 }
2964
2965 pub async fn get_api_v1_projects_by_project_id_k8s_by_cluster_id_kubeconfig(
2967 &self,
2968 project_id: &str,
2969 cluster_id: &str,
2970 query: Option<&[(&str, &str)]>,
2971 ) -> Result<Value, NubisError> {
2972 self.request_value(
2973 Method::GET,
2974 "/api/v1/projects/:project_id/k8s/:cluster_id/kubeconfig",
2975 &[("project_id", project_id), ("cluster_id", cluster_id)],
2976 query,
2977 Option::<&Value>::None,
2978 )
2979 .await
2980 }
2981
2982 pub async fn get_api_v1_projects_by_project_id_k8s_by_cluster_id_status_messages(
2984 &self,
2985 project_id: &str,
2986 cluster_id: &str,
2987 query: Option<&[(&str, &str)]>,
2988 ) -> Result<Value, NubisError> {
2989 self.request_value(
2990 Method::GET,
2991 "/api/v1/projects/:project_id/k8s/:cluster_id/status-messages",
2992 &[("project_id", project_id), ("cluster_id", cluster_id)],
2993 query,
2994 Option::<&Value>::None,
2995 )
2996 .await
2997 }
2998
2999 pub async fn get_api_v1_projects_by_project_id_load_balancers(
3001 &self,
3002 project_id: &str,
3003 query: Option<&[(&str, &str)]>,
3004 ) -> Result<Value, NubisError> {
3005 self.request_value(
3006 Method::GET,
3007 "/api/v1/projects/:project_id/load-balancers",
3008 &[("project_id", project_id)],
3009 query,
3010 Option::<&Value>::None,
3011 )
3012 .await
3013 }
3014
3015 pub async fn get_api_v1_projects_by_project_id_load_balancers_by_lb_id(
3017 &self,
3018 project_id: &str,
3019 lb_id: &str,
3020 query: Option<&[(&str, &str)]>,
3021 ) -> Result<Value, NubisError> {
3022 self.request_value(
3023 Method::GET,
3024 "/api/v1/projects/:project_id/load-balancers/:lb_id",
3025 &[("project_id", project_id), ("lb_id", lb_id)],
3026 query,
3027 Option::<&Value>::None,
3028 )
3029 .await
3030 }
3031
3032 pub async fn get_api_v1_projects_by_project_id_load_balancers_by_lb_id_listeners(
3034 &self,
3035 project_id: &str,
3036 lb_id: &str,
3037 query: Option<&[(&str, &str)]>,
3038 ) -> Result<Value, NubisError> {
3039 self.request_value(
3040 Method::GET,
3041 "/api/v1/projects/:project_id/load-balancers/:lb_id/listeners",
3042 &[("project_id", project_id), ("lb_id", lb_id)],
3043 query,
3044 Option::<&Value>::None,
3045 )
3046 .await
3047 }
3048
3049 pub async fn get_api_v1_projects_by_project_id_load_balancers_by_lb_id_target_groups(
3051 &self,
3052 project_id: &str,
3053 lb_id: &str,
3054 query: Option<&[(&str, &str)]>,
3055 ) -> Result<Value, NubisError> {
3056 self.request_value(
3057 Method::GET,
3058 "/api/v1/projects/:project_id/load-balancers/:lb_id/target-groups",
3059 &[("project_id", project_id), ("lb_id", lb_id)],
3060 query,
3061 Option::<&Value>::None,
3062 )
3063 .await
3064 }
3065
3066 pub async fn get_api_v1_projects_by_project_id_load_balancers_by_lb_id_target_groups_by_tg_id_health(
3068 &self,
3069 project_id: &str,
3070 lb_id: &str,
3071 tg_id: &str,
3072 query: Option<&[(&str, &str)]>,
3073 ) -> Result<Value, NubisError> {
3074 self.request_value(
3075 Method::GET,
3076 "/api/v1/projects/:project_id/load-balancers/:lb_id/target-groups/:tg_id/health",
3077 &[
3078 ("project_id", project_id),
3079 ("lb_id", lb_id),
3080 ("tg_id", tg_id),
3081 ],
3082 query,
3083 Option::<&Value>::None,
3084 )
3085 .await
3086 }
3087
3088 pub async fn get_api_v1_projects_by_project_id_nat_gateways(
3090 &self,
3091 project_id: &str,
3092 query: Option<&[(&str, &str)]>,
3093 ) -> Result<Value, NubisError> {
3094 self.request_value(
3095 Method::GET,
3096 "/api/v1/projects/:project_id/nat-gateways",
3097 &[("project_id", project_id)],
3098 query,
3099 Option::<&Value>::None,
3100 )
3101 .await
3102 }
3103
3104 pub async fn get_api_v1_projects_by_project_id_nat_gateways_by_nat_id(
3106 &self,
3107 project_id: &str,
3108 nat_id: &str,
3109 query: Option<&[(&str, &str)]>,
3110 ) -> Result<Value, NubisError> {
3111 self.request_value(
3112 Method::GET,
3113 "/api/v1/projects/:project_id/nat-gateways/:nat_id",
3114 &[("project_id", project_id), ("nat_id", nat_id)],
3115 query,
3116 Option::<&Value>::None,
3117 )
3118 .await
3119 }
3120
3121 pub async fn get_api_v1_projects_by_project_id_networks(
3123 &self,
3124 project_id: &str,
3125 query: Option<&[(&str, &str)]>,
3126 ) -> Result<Value, NubisError> {
3127 self.request_value(
3128 Method::GET,
3129 "/api/v1/projects/:project_id/networks",
3130 &[("project_id", project_id)],
3131 query,
3132 Option::<&Value>::None,
3133 )
3134 .await
3135 }
3136
3137 pub async fn get_api_v1_projects_by_project_id_networks_by_network_id(
3139 &self,
3140 project_id: &str,
3141 network_id: &str,
3142 query: Option<&[(&str, &str)]>,
3143 ) -> Result<Value, NubisError> {
3144 self.request_value(
3145 Method::GET,
3146 "/api/v1/projects/:project_id/networks/:network_id",
3147 &[("project_id", project_id), ("network_id", network_id)],
3148 query,
3149 Option::<&Value>::None,
3150 )
3151 .await
3152 }
3153
3154 pub async fn get_api_v1_projects_by_project_id_networks_by_network_id_subnets(
3156 &self,
3157 project_id: &str,
3158 network_id: &str,
3159 query: Option<&[(&str, &str)]>,
3160 ) -> Result<Value, NubisError> {
3161 self.request_value(
3162 Method::GET,
3163 "/api/v1/projects/:project_id/networks/:network_id/subnets",
3164 &[("project_id", project_id), ("network_id", network_id)],
3165 query,
3166 Option::<&Value>::None,
3167 )
3168 .await
3169 }
3170
3171 pub async fn get_api_v1_projects_by_project_id_networks_by_network_id_subnets_by_subnet_id(
3173 &self,
3174 project_id: &str,
3175 network_id: &str,
3176 subnet_id: &str,
3177 query: Option<&[(&str, &str)]>,
3178 ) -> Result<Value, NubisError> {
3179 self.request_value(
3180 Method::GET,
3181 "/api/v1/projects/:project_id/networks/:network_id/subnets/:subnet_id",
3182 &[
3183 ("project_id", project_id),
3184 ("network_id", network_id),
3185 ("subnet_id", subnet_id),
3186 ],
3187 query,
3188 Option::<&Value>::None,
3189 )
3190 .await
3191 }
3192
3193 pub async fn get_api_v1_projects_by_project_id_scaling_groups(
3195 &self,
3196 project_id: &str,
3197 query: Option<&[(&str, &str)]>,
3198 ) -> Result<Value, NubisError> {
3199 self.request_value(
3200 Method::GET,
3201 "/api/v1/projects/:project_id/scaling-groups",
3202 &[("project_id", project_id)],
3203 query,
3204 Option::<&Value>::None,
3205 )
3206 .await
3207 }
3208
3209 pub async fn get_api_v1_projects_by_project_id_scaling_groups_by_group_id(
3211 &self,
3212 project_id: &str,
3213 group_id: &str,
3214 query: Option<&[(&str, &str)]>,
3215 ) -> Result<Value, NubisError> {
3216 self.request_value(
3217 Method::GET,
3218 "/api/v1/projects/:project_id/scaling-groups/:group_id",
3219 &[("project_id", project_id), ("group_id", group_id)],
3220 query,
3221 Option::<&Value>::None,
3222 )
3223 .await
3224 }
3225
3226 pub async fn get_api_v1_projects_by_project_id_scaling_groups_by_group_id_activities(
3228 &self,
3229 project_id: &str,
3230 group_id: &str,
3231 query: Option<&[(&str, &str)]>,
3232 ) -> Result<Value, NubisError> {
3233 self.request_value(
3234 Method::GET,
3235 "/api/v1/projects/:project_id/scaling-groups/:group_id/activities",
3236 &[("project_id", project_id), ("group_id", group_id)],
3237 query,
3238 Option::<&Value>::None,
3239 )
3240 .await
3241 }
3242
3243 pub async fn get_api_v1_projects_by_project_id_scaling_groups_by_group_id_policies(
3245 &self,
3246 project_id: &str,
3247 group_id: &str,
3248 query: Option<&[(&str, &str)]>,
3249 ) -> Result<Value, NubisError> {
3250 self.request_value(
3251 Method::GET,
3252 "/api/v1/projects/:project_id/scaling-groups/:group_id/policies",
3253 &[("project_id", project_id), ("group_id", group_id)],
3254 query,
3255 Option::<&Value>::None,
3256 )
3257 .await
3258 }
3259
3260 pub async fn get_api_v1_projects_by_project_id_security_groups(
3262 &self,
3263 project_id: &str,
3264 query: Option<&[(&str, &str)]>,
3265 ) -> Result<Value, NubisError> {
3266 self.request_value(
3267 Method::GET,
3268 "/api/v1/projects/:project_id/security-groups",
3269 &[("project_id", project_id)],
3270 query,
3271 Option::<&Value>::None,
3272 )
3273 .await
3274 }
3275
3276 pub async fn get_api_v1_projects_by_project_id_security_groups_by_sg_id(
3278 &self,
3279 project_id: &str,
3280 sg_id: &str,
3281 query: Option<&[(&str, &str)]>,
3282 ) -> Result<Value, NubisError> {
3283 self.request_value(
3284 Method::GET,
3285 "/api/v1/projects/:project_id/security-groups/:sg_id",
3286 &[("project_id", project_id), ("sg_id", sg_id)],
3287 query,
3288 Option::<&Value>::None,
3289 )
3290 .await
3291 }
3292
3293 pub async fn get_api_v1_projects_by_project_id_security_groups_by_sg_id_rules(
3295 &self,
3296 project_id: &str,
3297 sg_id: &str,
3298 query: Option<&[(&str, &str)]>,
3299 ) -> Result<Value, NubisError> {
3300 self.request_value(
3301 Method::GET,
3302 "/api/v1/projects/:project_id/security-groups/:sg_id/rules",
3303 &[("project_id", project_id), ("sg_id", sg_id)],
3304 query,
3305 Option::<&Value>::None,
3306 )
3307 .await
3308 }
3309
3310 pub async fn get_api_v1_projects_by_project_id_snapshots(
3312 &self,
3313 project_id: &str,
3314 query: Option<&[(&str, &str)]>,
3315 ) -> Result<Value, NubisError> {
3316 self.request_value(
3317 Method::GET,
3318 "/api/v1/projects/:project_id/snapshots",
3319 &[("project_id", project_id)],
3320 query,
3321 Option::<&Value>::None,
3322 )
3323 .await
3324 }
3325
3326 pub async fn get_api_v1_projects_by_project_id_ssh_keys(
3328 &self,
3329 project_id: &str,
3330 query: Option<&[(&str, &str)]>,
3331 ) -> Result<Value, NubisError> {
3332 self.request_value(
3333 Method::GET,
3334 "/api/v1/projects/:project_id/ssh_keys",
3335 &[("project_id", project_id)],
3336 query,
3337 Option::<&Value>::None,
3338 )
3339 .await
3340 }
3341
3342 pub async fn get_api_v1_projects_by_project_id_storage_access_keys(
3344 &self,
3345 project_id: &str,
3346 query: Option<&[(&str, &str)]>,
3347 ) -> Result<Value, NubisError> {
3348 self.request_value(
3349 Method::GET,
3350 "/api/v1/projects/:project_id/storage/access-keys",
3351 &[("project_id", project_id)],
3352 query,
3353 Option::<&Value>::None,
3354 )
3355 .await
3356 }
3357
3358 pub async fn get_api_v1_projects_by_project_id_storage_buckets(
3360 &self,
3361 project_id: &str,
3362 query: Option<&[(&str, &str)]>,
3363 ) -> Result<Value, NubisError> {
3364 self.request_value(
3365 Method::GET,
3366 "/api/v1/projects/:project_id/storage/buckets",
3367 &[("project_id", project_id)],
3368 query,
3369 Option::<&Value>::None,
3370 )
3371 .await
3372 }
3373
3374 pub async fn get_api_v1_projects_by_project_id_storage_buckets_by_bucket_id(
3376 &self,
3377 project_id: &str,
3378 bucket_id: &str,
3379 query: Option<&[(&str, &str)]>,
3380 ) -> Result<Value, NubisError> {
3381 self.request_value(
3382 Method::GET,
3383 "/api/v1/projects/:project_id/storage/buckets/:bucket_id",
3384 &[("project_id", project_id), ("bucket_id", bucket_id)],
3385 query,
3386 Option::<&Value>::None,
3387 )
3388 .await
3389 }
3390
3391 pub async fn get_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_cdn(
3393 &self,
3394 project_id: &str,
3395 bucket_id: &str,
3396 query: Option<&[(&str, &str)]>,
3397 ) -> Result<Value, NubisError> {
3398 self.request_value(
3399 Method::GET,
3400 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/cdn",
3401 &[("project_id", project_id), ("bucket_id", bucket_id)],
3402 query,
3403 Option::<&Value>::None,
3404 )
3405 .await
3406 }
3407
3408 pub async fn get_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_cors(
3410 &self,
3411 project_id: &str,
3412 bucket_id: &str,
3413 query: Option<&[(&str, &str)]>,
3414 ) -> Result<Value, NubisError> {
3415 self.request_value(
3416 Method::GET,
3417 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/cors",
3418 &[("project_id", project_id), ("bucket_id", bucket_id)],
3419 query,
3420 Option::<&Value>::None,
3421 )
3422 .await
3423 }
3424
3425 pub async fn get_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_lifecycle(
3427 &self,
3428 project_id: &str,
3429 bucket_id: &str,
3430 query: Option<&[(&str, &str)]>,
3431 ) -> Result<Value, NubisError> {
3432 self.request_value(
3433 Method::GET,
3434 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/lifecycle",
3435 &[("project_id", project_id), ("bucket_id", bucket_id)],
3436 query,
3437 Option::<&Value>::None,
3438 )
3439 .await
3440 }
3441
3442 pub async fn get_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_objects(
3444 &self,
3445 project_id: &str,
3446 bucket_id: &str,
3447 query: Option<&[(&str, &str)]>,
3448 ) -> Result<Value, NubisError> {
3449 self.request_value(
3450 Method::GET,
3451 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/objects",
3452 &[("project_id", project_id), ("bucket_id", bucket_id)],
3453 query,
3454 Option::<&Value>::None,
3455 )
3456 .await
3457 }
3458
3459 pub async fn get_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_signed_download_key(
3461 &self,
3462 project_id: &str,
3463 bucket_id: &str,
3464 query: Option<&[(&str, &str)]>,
3465 ) -> Result<Value, NubisError> {
3466 self.request_value(
3467 Method::GET,
3468 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/signed-download/*key",
3469 &[("project_id", project_id), ("bucket_id", bucket_id)],
3470 query,
3471 Option::<&Value>::None,
3472 )
3473 .await
3474 }
3475
3476 pub async fn get_api_v1_projects_by_project_id_templates(
3478 &self,
3479 project_id: &str,
3480 query: Option<&[(&str, &str)]>,
3481 ) -> Result<Value, NubisError> {
3482 self.request_value(
3483 Method::GET,
3484 "/api/v1/projects/:project_id/templates",
3485 &[("project_id", project_id)],
3486 query,
3487 Option::<&Value>::None,
3488 )
3489 .await
3490 }
3491
3492 pub async fn get_api_v1_projects_by_project_id_templates_by_template_id(
3494 &self,
3495 project_id: &str,
3496 template_id: &str,
3497 query: Option<&[(&str, &str)]>,
3498 ) -> Result<Value, NubisError> {
3499 self.request_value(
3500 Method::GET,
3501 "/api/v1/projects/:project_id/templates/:template_id",
3502 &[("project_id", project_id), ("template_id", template_id)],
3503 query,
3504 Option::<&Value>::None,
3505 )
3506 .await
3507 }
3508
3509 pub async fn get_api_v1_projects_by_project_id_vms(
3511 &self,
3512 project_id: &str,
3513 query: Option<&[(&str, &str)]>,
3514 ) -> Result<Value, NubisError> {
3515 self.request_value(
3516 Method::GET,
3517 "/api/v1/projects/:project_id/vms",
3518 &[("project_id", project_id)],
3519 query,
3520 Option::<&Value>::None,
3521 )
3522 .await
3523 }
3524
3525 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id(
3527 &self,
3528 project_id: &str,
3529 vm_id: &str,
3530 query: Option<&[(&str, &str)]>,
3531 ) -> Result<Value, NubisError> {
3532 self.request_value(
3533 Method::GET,
3534 "/api/v1/projects/:project_id/vms/:vm_id",
3535 &[("project_id", project_id), ("vm_id", vm_id)],
3536 query,
3537 Option::<&Value>::None,
3538 )
3539 .await
3540 }
3541
3542 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_access(
3544 &self,
3545 project_id: &str,
3546 vm_id: &str,
3547 query: Option<&[(&str, &str)]>,
3548 ) -> Result<Value, NubisError> {
3549 self.request_value(
3550 Method::GET,
3551 "/api/v1/projects/:project_id/vms/:vm_id/access",
3552 &[("project_id", project_id), ("vm_id", vm_id)],
3553 query,
3554 Option::<&Value>::None,
3555 )
3556 .await
3557 }
3558
3559 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_availability(
3561 &self,
3562 project_id: &str,
3563 vm_id: &str,
3564 query: Option<&[(&str, &str)]>,
3565 ) -> Result<Value, NubisError> {
3566 self.request_value(
3567 Method::GET,
3568 "/api/v1/projects/:project_id/vms/:vm_id/availability",
3569 &[("project_id", project_id), ("vm_id", vm_id)],
3570 query,
3571 Option::<&Value>::None,
3572 )
3573 .await
3574 }
3575
3576 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_cost(
3578 &self,
3579 project_id: &str,
3580 vm_id: &str,
3581 query: Option<&[(&str, &str)]>,
3582 ) -> Result<Value, NubisError> {
3583 self.request_value(
3584 Method::GET,
3585 "/api/v1/projects/:project_id/vms/:vm_id/cost",
3586 &[("project_id", project_id), ("vm_id", vm_id)],
3587 query,
3588 Option::<&Value>::None,
3589 )
3590 .await
3591 }
3592
3593 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_detail(
3595 &self,
3596 project_id: &str,
3597 vm_id: &str,
3598 query: Option<&[(&str, &str)]>,
3599 ) -> Result<Value, NubisError> {
3600 self.request_value(
3601 Method::GET,
3602 "/api/v1/projects/:project_id/vms/:vm_id/detail",
3603 &[("project_id", project_id), ("vm_id", vm_id)],
3604 query,
3605 Option::<&Value>::None,
3606 )
3607 .await
3608 }
3609
3610 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_disks(
3612 &self,
3613 project_id: &str,
3614 vm_id: &str,
3615 query: Option<&[(&str, &str)]>,
3616 ) -> Result<Value, NubisError> {
3617 self.request_value(
3618 Method::GET,
3619 "/api/v1/projects/:project_id/vms/:vm_id/disks",
3620 &[("project_id", project_id), ("vm_id", vm_id)],
3621 query,
3622 Option::<&Value>::None,
3623 )
3624 .await
3625 }
3626
3627 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_interfaces(
3629 &self,
3630 project_id: &str,
3631 vm_id: &str,
3632 query: Option<&[(&str, &str)]>,
3633 ) -> Result<Value, NubisError> {
3634 self.request_value(
3635 Method::GET,
3636 "/api/v1/projects/:project_id/vms/:vm_id/interfaces",
3637 &[("project_id", project_id), ("vm_id", vm_id)],
3638 query,
3639 Option::<&Value>::None,
3640 )
3641 .await
3642 }
3643
3644 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_logs(
3646 &self,
3647 project_id: &str,
3648 vm_id: &str,
3649 query: Option<&[(&str, &str)]>,
3650 ) -> Result<Value, NubisError> {
3651 self.request_value(
3652 Method::GET,
3653 "/api/v1/projects/:project_id/vms/:vm_id/logs",
3654 &[("project_id", project_id), ("vm_id", vm_id)],
3655 query,
3656 Option::<&Value>::None,
3657 )
3658 .await
3659 }
3660
3661 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_logs_download(
3663 &self,
3664 project_id: &str,
3665 vm_id: &str,
3666 query: Option<&[(&str, &str)]>,
3667 ) -> Result<Value, NubisError> {
3668 self.request_value(
3669 Method::GET,
3670 "/api/v1/projects/:project_id/vms/:vm_id/logs/download",
3671 &[("project_id", project_id), ("vm_id", vm_id)],
3672 query,
3673 Option::<&Value>::None,
3674 )
3675 .await
3676 }
3677
3678 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_metrics(
3680 &self,
3681 project_id: &str,
3682 vm_id: &str,
3683 query: Option<&[(&str, &str)]>,
3684 ) -> Result<Value, NubisError> {
3685 self.request_value(
3686 Method::GET,
3687 "/api/v1/projects/:project_id/vms/:vm_id/metrics",
3688 &[("project_id", project_id), ("vm_id", vm_id)],
3689 query,
3690 Option::<&Value>::None,
3691 )
3692 .await
3693 }
3694
3695 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_resize_history(
3697 &self,
3698 project_id: &str,
3699 vm_id: &str,
3700 query: Option<&[(&str, &str)]>,
3701 ) -> Result<Value, NubisError> {
3702 self.request_value(
3703 Method::GET,
3704 "/api/v1/projects/:project_id/vms/:vm_id/resize-history",
3705 &[("project_id", project_id), ("vm_id", vm_id)],
3706 query,
3707 Option::<&Value>::None,
3708 )
3709 .await
3710 }
3711
3712 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_sessions(
3714 &self,
3715 project_id: &str,
3716 vm_id: &str,
3717 query: Option<&[(&str, &str)]>,
3718 ) -> Result<Value, NubisError> {
3719 self.request_value(
3720 Method::GET,
3721 "/api/v1/projects/:project_id/vms/:vm_id/sessions",
3722 &[("project_id", project_id), ("vm_id", vm_id)],
3723 query,
3724 Option::<&Value>::None,
3725 )
3726 .await
3727 }
3728
3729 pub async fn get_api_v1_projects_by_project_id_vms_by_vm_id_state_transitions(
3731 &self,
3732 project_id: &str,
3733 vm_id: &str,
3734 query: Option<&[(&str, &str)]>,
3735 ) -> Result<Value, NubisError> {
3736 self.request_value(
3737 Method::GET,
3738 "/api/v1/projects/:project_id/vms/:vm_id/state-transitions",
3739 &[("project_id", project_id), ("vm_id", vm_id)],
3740 query,
3741 Option::<&Value>::None,
3742 )
3743 .await
3744 }
3745
3746 pub async fn get_api_v1_projects_by_project_id_volumes(
3748 &self,
3749 project_id: &str,
3750 query: Option<&[(&str, &str)]>,
3751 ) -> Result<Value, NubisError> {
3752 self.request_value(
3753 Method::GET,
3754 "/api/v1/projects/:project_id/volumes",
3755 &[("project_id", project_id)],
3756 query,
3757 Option::<&Value>::None,
3758 )
3759 .await
3760 }
3761
3762 pub async fn get_api_v1_projects_by_project_id_zones(
3764 &self,
3765 project_id: &str,
3766 query: Option<&[(&str, &str)]>,
3767 ) -> Result<Value, NubisError> {
3768 self.request_value(
3769 Method::GET,
3770 "/api/v1/projects/:project_id/zones",
3771 &[("project_id", project_id)],
3772 query,
3773 Option::<&Value>::None,
3774 )
3775 .await
3776 }
3777
3778 pub async fn get_api_v1_projects_by_project_id_zones_by_zone_id(
3780 &self,
3781 project_id: &str,
3782 zone_id: &str,
3783 query: Option<&[(&str, &str)]>,
3784 ) -> Result<Value, NubisError> {
3785 self.request_value(
3786 Method::GET,
3787 "/api/v1/projects/:project_id/zones/:zone_id",
3788 &[("project_id", project_id), ("zone_id", zone_id)],
3789 query,
3790 Option::<&Value>::None,
3791 )
3792 .await
3793 }
3794
3795 pub async fn get_api_v1_projects_by_project_id_zones_by_zone_id_records(
3797 &self,
3798 project_id: &str,
3799 zone_id: &str,
3800 query: Option<&[(&str, &str)]>,
3801 ) -> Result<Value, NubisError> {
3802 self.request_value(
3803 Method::GET,
3804 "/api/v1/projects/:project_id/zones/:zone_id/records",
3805 &[("project_id", project_id), ("zone_id", zone_id)],
3806 query,
3807 Option::<&Value>::None,
3808 )
3809 .await
3810 }
3811
3812 pub async fn get_api_v1_status(
3814 &self,
3815 query: Option<&[(&str, &str)]>,
3816 ) -> Result<Value, NubisError> {
3817 self.request_value(
3818 Method::GET,
3819 "/api/v1/status",
3820 &[],
3821 query,
3822 Option::<&Value>::None,
3823 )
3824 .await
3825 }
3826
3827 pub async fn get_health(&self, query: Option<&[(&str, &str)]>) -> Result<Value, NubisError> {
3829 self.request_value(Method::GET, "/health", &[], query, Option::<&Value>::None)
3830 .await
3831 }
3832
3833 pub async fn get_metrics(&self, query: Option<&[(&str, &str)]>) -> Result<Value, NubisError> {
3835 self.request_value(Method::GET, "/metrics", &[], query, Option::<&Value>::None)
3836 .await
3837 }
3838
3839 pub async fn get_ws_realtime(
3841 &self,
3842 query: Option<&[(&str, &str)]>,
3843 ) -> Result<Value, NubisError> {
3844 self.request_value(
3845 Method::GET,
3846 "/ws/realtime",
3847 &[],
3848 query,
3849 Option::<&Value>::None,
3850 )
3851 .await
3852 }
3853
3854 pub async fn get_ws_vms_by_vm_id_console(
3856 &self,
3857 vm_id: &str,
3858 query: Option<&[(&str, &str)]>,
3859 ) -> Result<Value, NubisError> {
3860 self.request_value(
3861 Method::GET,
3862 "/ws/vms/:vm_id/console",
3863 &[("vm_id", vm_id)],
3864 query,
3865 Option::<&Value>::None,
3866 )
3867 .await
3868 }
3869
3870 pub async fn get_ws_vms_by_vm_id_ssh(
3872 &self,
3873 vm_id: &str,
3874 query: Option<&[(&str, &str)]>,
3875 ) -> Result<Value, NubisError> {
3876 self.request_value(
3877 Method::GET,
3878 "/ws/vms/:vm_id/ssh",
3879 &[("vm_id", vm_id)],
3880 query,
3881 Option::<&Value>::None,
3882 )
3883 .await
3884 }
3885
3886 pub async fn patch_api_v1_orgs_by_org_id_launch_services_by_service_id_source<
3888 B: Serialize + ?Sized,
3889 >(
3890 &self,
3891 org_id: &str,
3892 service_id: &str,
3893 body: Option<&B>,
3894 query: Option<&[(&str, &str)]>,
3895 ) -> Result<Value, NubisError> {
3896 self.request_value(
3897 Method::PATCH,
3898 "/api/v1/orgs/:org_id/launch/services/:service_id/source",
3899 &[("org_id", org_id), ("service_id", service_id)],
3900 query,
3901 body,
3902 )
3903 .await
3904 }
3905
3906 pub async fn patch_api_v1_orgs_by_org_id_support<B: Serialize + ?Sized>(
3908 &self,
3909 org_id: &str,
3910 body: Option<&B>,
3911 query: Option<&[(&str, &str)]>,
3912 ) -> Result<Value, NubisError> {
3913 self.request_value(
3914 Method::PATCH,
3915 "/api/v1/orgs/:org_id/support",
3916 &[("org_id", org_id)],
3917 query,
3918 body,
3919 )
3920 .await
3921 }
3922
3923 pub async fn patch_api_v1_projects_by_project_id_databases_by_database_id_config<
3925 B: Serialize + ?Sized,
3926 >(
3927 &self,
3928 project_id: &str,
3929 database_id: &str,
3930 body: Option<&B>,
3931 query: Option<&[(&str, &str)]>,
3932 ) -> Result<Value, NubisError> {
3933 self.request_value(
3934 Method::PATCH,
3935 "/api/v1/projects/:project_id/databases/:database_id/config",
3936 &[("project_id", project_id), ("database_id", database_id)],
3937 query,
3938 body,
3939 )
3940 .await
3941 }
3942
3943 pub async fn patch_api_v1_projects_by_project_id_k8s_by_cluster_id<B: Serialize + ?Sized>(
3945 &self,
3946 project_id: &str,
3947 cluster_id: &str,
3948 body: Option<&B>,
3949 query: Option<&[(&str, &str)]>,
3950 ) -> Result<Value, NubisError> {
3951 self.request_value(
3952 Method::PATCH,
3953 "/api/v1/projects/:project_id/k8s/:cluster_id",
3954 &[("project_id", project_id), ("cluster_id", cluster_id)],
3955 query,
3956 body,
3957 )
3958 .await
3959 }
3960
3961 pub async fn post_api_v1_admin_incidents<B: Serialize + ?Sized>(
3963 &self,
3964 body: Option<&B>,
3965 query: Option<&[(&str, &str)]>,
3966 ) -> Result<Value, NubisError> {
3967 self.request_value(Method::POST, "/api/v1/admin/incidents", &[], query, body)
3968 .await
3969 }
3970
3971 pub async fn post_api_v1_admin_incidents_by_id_resolve<B: Serialize + ?Sized>(
3973 &self,
3974 id: &str,
3975 body: Option<&B>,
3976 query: Option<&[(&str, &str)]>,
3977 ) -> Result<Value, NubisError> {
3978 self.request_value(
3979 Method::POST,
3980 "/api/v1/admin/incidents/:id/resolve",
3981 &[("id", id)],
3982 query,
3983 body,
3984 )
3985 .await
3986 }
3987
3988 pub async fn post_api_v1_admin_incidents_by_id_updates<B: Serialize + ?Sized>(
3990 &self,
3991 id: &str,
3992 body: Option<&B>,
3993 query: Option<&[(&str, &str)]>,
3994 ) -> Result<Value, NubisError> {
3995 self.request_value(
3996 Method::POST,
3997 "/api/v1/admin/incidents/:id/updates",
3998 &[("id", id)],
3999 query,
4000 body,
4001 )
4002 .await
4003 }
4004
4005 pub async fn post_api_v1_api_keys<B: Serialize + ?Sized>(
4007 &self,
4008 body: Option<&B>,
4009 query: Option<&[(&str, &str)]>,
4010 ) -> Result<Value, NubisError> {
4011 self.request_value(Method::POST, "/api/v1/api-keys", &[], query, body)
4012 .await
4013 }
4014
4015 pub async fn post_api_v1_invitations_accept<B: Serialize + ?Sized>(
4017 &self,
4018 body: Option<&B>,
4019 query: Option<&[(&str, &str)]>,
4020 ) -> Result<Value, NubisError> {
4021 self.request_value(Method::POST, "/api/v1/invitations/accept", &[], query, body)
4022 .await
4023 }
4024
4025 pub async fn post_api_v1_invitations_preview<B: Serialize + ?Sized>(
4027 &self,
4028 body: Option<&B>,
4029 query: Option<&[(&str, &str)]>,
4030 ) -> Result<Value, NubisError> {
4031 self.request_value(
4032 Method::POST,
4033 "/api/v1/invitations/preview",
4034 &[],
4035 query,
4036 body,
4037 )
4038 .await
4039 }
4040
4041 pub async fn post_api_v1_kyc_start<B: Serialize + ?Sized>(
4043 &self,
4044 body: Option<&B>,
4045 query: Option<&[(&str, &str)]>,
4046 ) -> Result<Value, NubisError> {
4047 self.request_value(Method::POST, "/api/v1/kyc/start", &[], query, body)
4048 .await
4049 }
4050
4051 pub async fn post_api_v1_logs_ingest<B: Serialize + ?Sized>(
4053 &self,
4054 body: Option<&B>,
4055 query: Option<&[(&str, &str)]>,
4056 ) -> Result<Value, NubisError> {
4057 self.request_value(Method::POST, "/api/v1/logs/ingest", &[], query, body)
4058 .await
4059 }
4060
4061 pub async fn post_api_v1_logs_ingest_batch<B: Serialize + ?Sized>(
4063 &self,
4064 body: Option<&B>,
4065 query: Option<&[(&str, &str)]>,
4066 ) -> Result<Value, NubisError> {
4067 self.request_value(Method::POST, "/api/v1/logs/ingest/batch", &[], query, body)
4068 .await
4069 }
4070
4071 pub async fn post_api_v1_me_init<B: Serialize + ?Sized>(
4073 &self,
4074 body: Option<&B>,
4075 query: Option<&[(&str, &str)]>,
4076 ) -> Result<Value, NubisError> {
4077 self.request_value(Method::POST, "/api/v1/me/init", &[], query, body)
4078 .await
4079 }
4080
4081 pub async fn post_api_v1_metrics_ingest<B: Serialize + ?Sized>(
4083 &self,
4084 body: Option<&B>,
4085 query: Option<&[(&str, &str)]>,
4086 ) -> Result<Value, NubisError> {
4087 self.request_value(Method::POST, "/api/v1/metrics/ingest", &[], query, body)
4088 .await
4089 }
4090
4091 pub async fn post_api_v1_orgs<B: Serialize + ?Sized>(
4093 &self,
4094 body: Option<&B>,
4095 query: Option<&[(&str, &str)]>,
4096 ) -> Result<Value, NubisError> {
4097 self.request_value(Method::POST, "/api/v1/orgs", &[], query, body)
4098 .await
4099 }
4100
4101 pub async fn post_api_v1_orgs_by_org_id_billing_credits_redeem<B: Serialize + ?Sized>(
4103 &self,
4104 org_id: &str,
4105 body: Option<&B>,
4106 query: Option<&[(&str, &str)]>,
4107 ) -> Result<Value, NubisError> {
4108 self.request_value(
4109 Method::POST,
4110 "/api/v1/orgs/:org_id/billing/credits/redeem",
4111 &[("org_id", org_id)],
4112 query,
4113 body,
4114 )
4115 .await
4116 }
4117
4118 pub async fn post_api_v1_orgs_by_org_id_billing_payment_method<B: Serialize + ?Sized>(
4120 &self,
4121 org_id: &str,
4122 body: Option<&B>,
4123 query: Option<&[(&str, &str)]>,
4124 ) -> Result<Value, NubisError> {
4125 self.request_value(
4126 Method::POST,
4127 "/api/v1/orgs/:org_id/billing/payment-method",
4128 &[("org_id", org_id)],
4129 query,
4130 body,
4131 )
4132 .await
4133 }
4134
4135 pub async fn post_api_v1_orgs_by_org_id_billing_payment_methods<B: Serialize + ?Sized>(
4137 &self,
4138 org_id: &str,
4139 body: Option<&B>,
4140 query: Option<&[(&str, &str)]>,
4141 ) -> Result<Value, NubisError> {
4142 self.request_value(
4143 Method::POST,
4144 "/api/v1/orgs/:org_id/billing/payment-methods",
4145 &[("org_id", org_id)],
4146 query,
4147 body,
4148 )
4149 .await
4150 }
4151
4152 pub async fn post_api_v1_orgs_by_org_id_billing_prepay<B: Serialize + ?Sized>(
4154 &self,
4155 org_id: &str,
4156 body: Option<&B>,
4157 query: Option<&[(&str, &str)]>,
4158 ) -> Result<Value, NubisError> {
4159 self.request_value(
4160 Method::POST,
4161 "/api/v1/orgs/:org_id/billing/prepay",
4162 &[("org_id", org_id)],
4163 query,
4164 body,
4165 )
4166 .await
4167 }
4168
4169 pub async fn post_api_v1_orgs_by_org_id_billing_verify_transaction<B: Serialize + ?Sized>(
4171 &self,
4172 org_id: &str,
4173 body: Option<&B>,
4174 query: Option<&[(&str, &str)]>,
4175 ) -> Result<Value, NubisError> {
4176 self.request_value(
4177 Method::POST,
4178 "/api/v1/orgs/:org_id/billing/verify-transaction",
4179 &[("org_id", org_id)],
4180 query,
4181 body,
4182 )
4183 .await
4184 }
4185
4186 pub async fn post_api_v1_orgs_by_org_id_iac_webhooks<B: Serialize + ?Sized>(
4188 &self,
4189 org_id: &str,
4190 body: Option<&B>,
4191 query: Option<&[(&str, &str)]>,
4192 ) -> Result<Value, NubisError> {
4193 self.request_value(
4194 Method::POST,
4195 "/api/v1/orgs/:org_id/iac/webhooks",
4196 &[("org_id", org_id)],
4197 query,
4198 body,
4199 )
4200 .await
4201 }
4202
4203 pub async fn post_api_v1_orgs_by_org_id_iam_service_accounts<B: Serialize + ?Sized>(
4205 &self,
4206 org_id: &str,
4207 body: Option<&B>,
4208 query: Option<&[(&str, &str)]>,
4209 ) -> Result<Value, NubisError> {
4210 self.request_value(
4211 Method::POST,
4212 "/api/v1/orgs/:org_id/iam/service-accounts",
4213 &[("org_id", org_id)],
4214 query,
4215 body,
4216 )
4217 .await
4218 }
4219
4220 pub async fn post_api_v1_orgs_by_org_id_iam_sso_verify<B: Serialize + ?Sized>(
4222 &self,
4223 org_id: &str,
4224 body: Option<&B>,
4225 query: Option<&[(&str, &str)]>,
4226 ) -> Result<Value, NubisError> {
4227 self.request_value(
4228 Method::POST,
4229 "/api/v1/orgs/:org_id/iam/sso/verify",
4230 &[("org_id", org_id)],
4231 query,
4232 body,
4233 )
4234 .await
4235 }
4236
4237 pub async fn post_api_v1_orgs_by_org_id_invoices_by_invoice_id_pay<B: Serialize + ?Sized>(
4239 &self,
4240 org_id: &str,
4241 invoice_id: &str,
4242 body: Option<&B>,
4243 query: Option<&[(&str, &str)]>,
4244 ) -> Result<Value, NubisError> {
4245 self.request_value(
4246 Method::POST,
4247 "/api/v1/orgs/:org_id/invoices/:invoice_id/pay",
4248 &[("org_id", org_id), ("invoice_id", invoice_id)],
4249 query,
4250 body,
4251 )
4252 .await
4253 }
4254
4255 pub async fn post_api_v1_orgs_by_org_id_invoices_reissue_malformed<B: Serialize + ?Sized>(
4257 &self,
4258 org_id: &str,
4259 body: Option<&B>,
4260 query: Option<&[(&str, &str)]>,
4261 ) -> Result<Value, NubisError> {
4262 self.request_value(
4263 Method::POST,
4264 "/api/v1/orgs/:org_id/invoices/reissue-malformed",
4265 &[("org_id", org_id)],
4266 query,
4267 body,
4268 )
4269 .await
4270 }
4271
4272 pub async fn post_api_v1_orgs_by_org_id_launch_github_connect<B: Serialize + ?Sized>(
4274 &self,
4275 org_id: &str,
4276 body: Option<&B>,
4277 query: Option<&[(&str, &str)]>,
4278 ) -> Result<Value, NubisError> {
4279 self.request_value(
4280 Method::POST,
4281 "/api/v1/orgs/:org_id/launch/github/connect",
4282 &[("org_id", org_id)],
4283 query,
4284 body,
4285 )
4286 .await
4287 }
4288
4289 pub async fn post_api_v1_orgs_by_org_id_launch_github_repositories_sync<
4291 B: Serialize + ?Sized,
4292 >(
4293 &self,
4294 org_id: &str,
4295 body: Option<&B>,
4296 query: Option<&[(&str, &str)]>,
4297 ) -> Result<Value, NubisError> {
4298 self.request_value(
4299 Method::POST,
4300 "/api/v1/orgs/:org_id/launch/github/repositories/sync",
4301 &[("org_id", org_id)],
4302 query,
4303 body,
4304 )
4305 .await
4306 }
4307
4308 pub async fn post_api_v1_orgs_by_org_id_launch_projects<B: Serialize + ?Sized>(
4310 &self,
4311 org_id: &str,
4312 body: Option<&B>,
4313 query: Option<&[(&str, &str)]>,
4314 ) -> Result<Value, NubisError> {
4315 self.request_value(
4316 Method::POST,
4317 "/api/v1/orgs/:org_id/launch/projects",
4318 &[("org_id", org_id)],
4319 query,
4320 body,
4321 )
4322 .await
4323 }
4324
4325 pub async fn post_api_v1_orgs_by_org_id_launch_projects_by_project_id_services<
4327 B: Serialize + ?Sized,
4328 >(
4329 &self,
4330 org_id: &str,
4331 project_id: &str,
4332 body: Option<&B>,
4333 query: Option<&[(&str, &str)]>,
4334 ) -> Result<Value, NubisError> {
4335 self.request_value(
4336 Method::POST,
4337 "/api/v1/orgs/:org_id/launch/projects/:project_id/services",
4338 &[("org_id", org_id), ("project_id", project_id)],
4339 query,
4340 body,
4341 )
4342 .await
4343 }
4344
4345 pub async fn post_api_v1_orgs_by_org_id_launch_services_by_service_id_deployments<
4347 B: Serialize + ?Sized,
4348 >(
4349 &self,
4350 org_id: &str,
4351 service_id: &str,
4352 body: Option<&B>,
4353 query: Option<&[(&str, &str)]>,
4354 ) -> Result<Value, NubisError> {
4355 self.request_value(
4356 Method::POST,
4357 "/api/v1/orgs/:org_id/launch/services/:service_id/deployments",
4358 &[("org_id", org_id), ("service_id", service_id)],
4359 query,
4360 body,
4361 )
4362 .await
4363 }
4364
4365 pub async fn post_api_v1_orgs_by_org_id_launch_services_by_service_id_domains<
4367 B: Serialize + ?Sized,
4368 >(
4369 &self,
4370 org_id: &str,
4371 service_id: &str,
4372 body: Option<&B>,
4373 query: Option<&[(&str, &str)]>,
4374 ) -> Result<Value, NubisError> {
4375 self.request_value(
4376 Method::POST,
4377 "/api/v1/orgs/:org_id/launch/services/:service_id/domains",
4378 &[("org_id", org_id), ("service_id", service_id)],
4379 query,
4380 body,
4381 )
4382 .await
4383 }
4384
4385 pub async fn post_api_v1_orgs_by_org_id_launch_services_by_service_id_rollback<
4387 B: Serialize + ?Sized,
4388 >(
4389 &self,
4390 org_id: &str,
4391 service_id: &str,
4392 body: Option<&B>,
4393 query: Option<&[(&str, &str)]>,
4394 ) -> Result<Value, NubisError> {
4395 self.request_value(
4396 Method::POST,
4397 "/api/v1/orgs/:org_id/launch/services/:service_id/rollback",
4398 &[("org_id", org_id), ("service_id", service_id)],
4399 query,
4400 body,
4401 )
4402 .await
4403 }
4404
4405 pub async fn post_api_v1_orgs_by_org_id_launch_services_by_service_id_source_repair_webhook<
4407 B: Serialize + ?Sized,
4408 >(
4409 &self,
4410 org_id: &str,
4411 service_id: &str,
4412 body: Option<&B>,
4413 query: Option<&[(&str, &str)]>,
4414 ) -> Result<Value, NubisError> {
4415 self.request_value(
4416 Method::POST,
4417 "/api/v1/orgs/:org_id/launch/services/:service_id/source/repair-webhook",
4418 &[("org_id", org_id), ("service_id", service_id)],
4419 query,
4420 body,
4421 )
4422 .await
4423 }
4424
4425 pub async fn post_api_v1_orgs_by_org_id_members<B: Serialize + ?Sized>(
4427 &self,
4428 org_id: &str,
4429 body: Option<&B>,
4430 query: Option<&[(&str, &str)]>,
4431 ) -> Result<Value, NubisError> {
4432 self.request_value(
4433 Method::POST,
4434 "/api/v1/orgs/:org_id/members",
4435 &[("org_id", org_id)],
4436 query,
4437 body,
4438 )
4439 .await
4440 }
4441
4442 pub async fn post_api_v1_orgs_by_org_id_observability_alerts<B: Serialize + ?Sized>(
4444 &self,
4445 org_id: &str,
4446 body: Option<&B>,
4447 query: Option<&[(&str, &str)]>,
4448 ) -> Result<Value, NubisError> {
4449 self.request_value(
4450 Method::POST,
4451 "/api/v1/orgs/:org_id/observability/alerts",
4452 &[("org_id", org_id)],
4453 query,
4454 body,
4455 )
4456 .await
4457 }
4458
4459 pub async fn post_api_v1_orgs_by_org_id_observability_destinations<B: Serialize + ?Sized>(
4461 &self,
4462 org_id: &str,
4463 body: Option<&B>,
4464 query: Option<&[(&str, &str)]>,
4465 ) -> Result<Value, NubisError> {
4466 self.request_value(
4467 Method::POST,
4468 "/api/v1/orgs/:org_id/observability/destinations",
4469 &[("org_id", org_id)],
4470 query,
4471 body,
4472 )
4473 .await
4474 }
4475
4476 pub async fn post_api_v1_orgs_by_org_id_observability_destinations_by_destination_id_test<
4478 B: Serialize + ?Sized,
4479 >(
4480 &self,
4481 org_id: &str,
4482 destination_id: &str,
4483 body: Option<&B>,
4484 query: Option<&[(&str, &str)]>,
4485 ) -> Result<Value, NubisError> {
4486 self.request_value(
4487 Method::POST,
4488 "/api/v1/orgs/:org_id/observability/destinations/:destination_id/test",
4489 &[("org_id", org_id), ("destination_id", destination_id)],
4490 query,
4491 body,
4492 )
4493 .await
4494 }
4495
4496 pub async fn post_api_v1_orgs_by_org_id_phone_send_code<B: Serialize + ?Sized>(
4498 &self,
4499 org_id: &str,
4500 body: Option<&B>,
4501 query: Option<&[(&str, &str)]>,
4502 ) -> Result<Value, NubisError> {
4503 self.request_value(
4504 Method::POST,
4505 "/api/v1/orgs/:org_id/phone/send-code",
4506 &[("org_id", org_id)],
4507 query,
4508 body,
4509 )
4510 .await
4511 }
4512
4513 pub async fn post_api_v1_orgs_by_org_id_phone_verify<B: Serialize + ?Sized>(
4515 &self,
4516 org_id: &str,
4517 body: Option<&B>,
4518 query: Option<&[(&str, &str)]>,
4519 ) -> Result<Value, NubisError> {
4520 self.request_value(
4521 Method::POST,
4522 "/api/v1/orgs/:org_id/phone/verify",
4523 &[("org_id", org_id)],
4524 query,
4525 body,
4526 )
4527 .await
4528 }
4529
4530 pub async fn post_api_v1_orgs_by_org_id_projects<B: Serialize + ?Sized>(
4532 &self,
4533 org_id: &str,
4534 body: Option<&B>,
4535 query: Option<&[(&str, &str)]>,
4536 ) -> Result<Value, NubisError> {
4537 self.request_value(
4538 Method::POST,
4539 "/api/v1/orgs/:org_id/projects",
4540 &[("org_id", org_id)],
4541 query,
4542 body,
4543 )
4544 .await
4545 }
4546
4547 pub async fn post_api_v1_orgs_by_org_id_projects_by_project_id_infrastructure_apply<
4549 B: Serialize + ?Sized,
4550 >(
4551 &self,
4552 org_id: &str,
4553 project_id: &str,
4554 body: Option<&B>,
4555 query: Option<&[(&str, &str)]>,
4556 ) -> Result<Value, NubisError> {
4557 self.request_value(
4558 Method::POST,
4559 "/api/v1/orgs/:org_id/projects/:project_id/infrastructure/apply",
4560 &[("org_id", org_id), ("project_id", project_id)],
4561 query,
4562 body,
4563 )
4564 .await
4565 }
4566
4567 pub async fn post_api_v1_orgs_by_org_id_subscription<B: Serialize + ?Sized>(
4569 &self,
4570 org_id: &str,
4571 body: Option<&B>,
4572 query: Option<&[(&str, &str)]>,
4573 ) -> Result<Value, NubisError> {
4574 self.request_value(
4575 Method::POST,
4576 "/api/v1/orgs/:org_id/subscription",
4577 &[("org_id", org_id)],
4578 query,
4579 body,
4580 )
4581 .await
4582 }
4583
4584 pub async fn post_api_v1_orgs_by_org_id_support_upgrade<B: Serialize + ?Sized>(
4586 &self,
4587 org_id: &str,
4588 body: Option<&B>,
4589 query: Option<&[(&str, &str)]>,
4590 ) -> Result<Value, NubisError> {
4591 self.request_value(
4592 Method::POST,
4593 "/api/v1/orgs/:org_id/support/upgrade",
4594 &[("org_id", org_id)],
4595 query,
4596 body,
4597 )
4598 .await
4599 }
4600
4601 pub async fn post_api_v1_orgs_by_org_id_tickets<B: Serialize + ?Sized>(
4603 &self,
4604 org_id: &str,
4605 body: Option<&B>,
4606 query: Option<&[(&str, &str)]>,
4607 ) -> Result<Value, NubisError> {
4608 self.request_value(
4609 Method::POST,
4610 "/api/v1/orgs/:org_id/tickets",
4611 &[("org_id", org_id)],
4612 query,
4613 body,
4614 )
4615 .await
4616 }
4617
4618 pub async fn post_api_v1_orgs_by_org_id_tickets_by_ticket_id_attachments<
4620 B: Serialize + ?Sized,
4621 >(
4622 &self,
4623 org_id: &str,
4624 ticket_id: &str,
4625 body: Option<&B>,
4626 query: Option<&[(&str, &str)]>,
4627 ) -> Result<Value, NubisError> {
4628 self.request_value(
4629 Method::POST,
4630 "/api/v1/orgs/:org_id/tickets/:ticket_id/attachments",
4631 &[("org_id", org_id), ("ticket_id", ticket_id)],
4632 query,
4633 body,
4634 )
4635 .await
4636 }
4637
4638 pub async fn post_api_v1_orgs_by_org_id_tickets_by_ticket_id_close<B: Serialize + ?Sized>(
4640 &self,
4641 org_id: &str,
4642 ticket_id: &str,
4643 body: Option<&B>,
4644 query: Option<&[(&str, &str)]>,
4645 ) -> Result<Value, NubisError> {
4646 self.request_value(
4647 Method::POST,
4648 "/api/v1/orgs/:org_id/tickets/:ticket_id/close",
4649 &[("org_id", org_id), ("ticket_id", ticket_id)],
4650 query,
4651 body,
4652 )
4653 .await
4654 }
4655
4656 pub async fn post_api_v1_orgs_by_org_id_tickets_by_ticket_id_messages<B: Serialize + ?Sized>(
4658 &self,
4659 org_id: &str,
4660 ticket_id: &str,
4661 body: Option<&B>,
4662 query: Option<&[(&str, &str)]>,
4663 ) -> Result<Value, NubisError> {
4664 self.request_value(
4665 Method::POST,
4666 "/api/v1/orgs/:org_id/tickets/:ticket_id/messages",
4667 &[("org_id", org_id), ("ticket_id", ticket_id)],
4668 query,
4669 body,
4670 )
4671 .await
4672 }
4673
4674 pub async fn post_api_v1_projects_by_project_id_advisor_recommendation<
4676 B: Serialize + ?Sized,
4677 >(
4678 &self,
4679 project_id: &str,
4680 body: Option<&B>,
4681 query: Option<&[(&str, &str)]>,
4682 ) -> Result<Value, NubisError> {
4683 self.request_value(
4684 Method::POST,
4685 "/api/v1/projects/:project_id/advisor/recommendation",
4686 &[("project_id", project_id)],
4687 query,
4688 body,
4689 )
4690 .await
4691 }
4692
4693 pub async fn post_api_v1_projects_by_project_id_backups_policies<B: Serialize + ?Sized>(
4695 &self,
4696 project_id: &str,
4697 body: Option<&B>,
4698 query: Option<&[(&str, &str)]>,
4699 ) -> Result<Value, NubisError> {
4700 self.request_value(
4701 Method::POST,
4702 "/api/v1/projects/:project_id/backups/policies",
4703 &[("project_id", project_id)],
4704 query,
4705 body,
4706 )
4707 .await
4708 }
4709
4710 pub async fn post_api_v1_projects_by_project_id_backups_policies_by_policy_id_pause<
4712 B: Serialize + ?Sized,
4713 >(
4714 &self,
4715 project_id: &str,
4716 policy_id: &str,
4717 body: Option<&B>,
4718 query: Option<&[(&str, &str)]>,
4719 ) -> Result<Value, NubisError> {
4720 self.request_value(
4721 Method::POST,
4722 "/api/v1/projects/:project_id/backups/policies/:policy_id/pause",
4723 &[("project_id", project_id), ("policy_id", policy_id)],
4724 query,
4725 body,
4726 )
4727 .await
4728 }
4729
4730 pub async fn post_api_v1_projects_by_project_id_backups_policies_by_policy_id_resume<
4732 B: Serialize + ?Sized,
4733 >(
4734 &self,
4735 project_id: &str,
4736 policy_id: &str,
4737 body: Option<&B>,
4738 query: Option<&[(&str, &str)]>,
4739 ) -> Result<Value, NubisError> {
4740 self.request_value(
4741 Method::POST,
4742 "/api/v1/projects/:project_id/backups/policies/:policy_id/resume",
4743 &[("project_id", project_id), ("policy_id", policy_id)],
4744 query,
4745 body,
4746 )
4747 .await
4748 }
4749
4750 pub async fn post_api_v1_projects_by_project_id_backups_restore<B: Serialize + ?Sized>(
4752 &self,
4753 project_id: &str,
4754 body: Option<&B>,
4755 query: Option<&[(&str, &str)]>,
4756 ) -> Result<Value, NubisError> {
4757 self.request_value(
4758 Method::POST,
4759 "/api/v1/projects/:project_id/backups/restore",
4760 &[("project_id", project_id)],
4761 query,
4762 body,
4763 )
4764 .await
4765 }
4766
4767 pub async fn post_api_v1_projects_by_project_id_certificates<B: Serialize + ?Sized>(
4769 &self,
4770 project_id: &str,
4771 body: Option<&B>,
4772 query: Option<&[(&str, &str)]>,
4773 ) -> Result<Value, NubisError> {
4774 self.request_value(
4775 Method::POST,
4776 "/api/v1/projects/:project_id/certificates",
4777 &[("project_id", project_id)],
4778 query,
4779 body,
4780 )
4781 .await
4782 }
4783
4784 pub async fn post_api_v1_projects_by_project_id_databases<B: Serialize + ?Sized>(
4786 &self,
4787 project_id: &str,
4788 body: Option<&B>,
4789 query: Option<&[(&str, &str)]>,
4790 ) -> Result<Value, NubisError> {
4791 self.request_value(
4792 Method::POST,
4793 "/api/v1/projects/:project_id/databases",
4794 &[("project_id", project_id)],
4795 query,
4796 body,
4797 )
4798 .await
4799 }
4800
4801 pub async fn post_api_v1_projects_by_project_id_databases_by_database_id_dbs<
4803 B: Serialize + ?Sized,
4804 >(
4805 &self,
4806 project_id: &str,
4807 database_id: &str,
4808 body: Option<&B>,
4809 query: Option<&[(&str, &str)]>,
4810 ) -> Result<Value, NubisError> {
4811 self.request_value(
4812 Method::POST,
4813 "/api/v1/projects/:project_id/databases/:database_id/dbs",
4814 &[("project_id", project_id), ("database_id", database_id)],
4815 query,
4816 body,
4817 )
4818 .await
4819 }
4820
4821 pub async fn post_api_v1_projects_by_project_id_databases_by_database_id_pools<
4823 B: Serialize + ?Sized,
4824 >(
4825 &self,
4826 project_id: &str,
4827 database_id: &str,
4828 body: Option<&B>,
4829 query: Option<&[(&str, &str)]>,
4830 ) -> Result<Value, NubisError> {
4831 self.request_value(
4832 Method::POST,
4833 "/api/v1/projects/:project_id/databases/:database_id/pools",
4834 &[("project_id", project_id), ("database_id", database_id)],
4835 query,
4836 body,
4837 )
4838 .await
4839 }
4840
4841 pub async fn post_api_v1_projects_by_project_id_databases_by_database_id_replicas<
4843 B: Serialize + ?Sized,
4844 >(
4845 &self,
4846 project_id: &str,
4847 database_id: &str,
4848 body: Option<&B>,
4849 query: Option<&[(&str, &str)]>,
4850 ) -> Result<Value, NubisError> {
4851 self.request_value(
4852 Method::POST,
4853 "/api/v1/projects/:project_id/databases/:database_id/replicas",
4854 &[("project_id", project_id), ("database_id", database_id)],
4855 query,
4856 body,
4857 )
4858 .await
4859 }
4860
4861 pub async fn post_api_v1_projects_by_project_id_databases_by_database_id_resize<
4863 B: Serialize + ?Sized,
4864 >(
4865 &self,
4866 project_id: &str,
4867 database_id: &str,
4868 body: Option<&B>,
4869 query: Option<&[(&str, &str)]>,
4870 ) -> Result<Value, NubisError> {
4871 self.request_value(
4872 Method::POST,
4873 "/api/v1/projects/:project_id/databases/:database_id/resize",
4874 &[("project_id", project_id), ("database_id", database_id)],
4875 query,
4876 body,
4877 )
4878 .await
4879 }
4880
4881 pub async fn post_api_v1_projects_by_project_id_databases_by_database_id_restore<
4883 B: Serialize + ?Sized,
4884 >(
4885 &self,
4886 project_id: &str,
4887 database_id: &str,
4888 body: Option<&B>,
4889 query: Option<&[(&str, &str)]>,
4890 ) -> Result<Value, NubisError> {
4891 self.request_value(
4892 Method::POST,
4893 "/api/v1/projects/:project_id/databases/:database_id/restore",
4894 &[("project_id", project_id), ("database_id", database_id)],
4895 query,
4896 body,
4897 )
4898 .await
4899 }
4900
4901 pub async fn post_api_v1_projects_by_project_id_databases_by_database_id_users<
4903 B: Serialize + ?Sized,
4904 >(
4905 &self,
4906 project_id: &str,
4907 database_id: &str,
4908 body: Option<&B>,
4909 query: Option<&[(&str, &str)]>,
4910 ) -> Result<Value, NubisError> {
4911 self.request_value(
4912 Method::POST,
4913 "/api/v1/projects/:project_id/databases/:database_id/users",
4914 &[("project_id", project_id), ("database_id", database_id)],
4915 query,
4916 body,
4917 )
4918 .await
4919 }
4920
4921 pub async fn post_api_v1_projects_by_project_id_databases_by_database_id_users_by_username_reset_auth<
4923 B: Serialize + ?Sized,
4924 >(
4925 &self,
4926 project_id: &str,
4927 database_id: &str,
4928 username: &str,
4929 body: Option<&B>,
4930 query: Option<&[(&str, &str)]>,
4931 ) -> Result<Value, NubisError> {
4932 self.request_value(
4933 Method::POST,
4934 "/api/v1/projects/:project_id/databases/:database_id/users/:username/reset_auth",
4935 &[
4936 ("project_id", project_id),
4937 ("database_id", database_id),
4938 ("username", username),
4939 ],
4940 query,
4941 body,
4942 )
4943 .await
4944 }
4945
4946 pub async fn post_api_v1_projects_by_project_id_domains_by_domain_id_pay<
4948 B: Serialize + ?Sized,
4949 >(
4950 &self,
4951 project_id: &str,
4952 domain_id: &str,
4953 body: Option<&B>,
4954 query: Option<&[(&str, &str)]>,
4955 ) -> Result<Value, NubisError> {
4956 self.request_value(
4957 Method::POST,
4958 "/api/v1/projects/:project_id/domains/:domain_id/pay",
4959 &[("project_id", project_id), ("domain_id", domain_id)],
4960 query,
4961 body,
4962 )
4963 .await
4964 }
4965
4966 pub async fn post_api_v1_projects_by_project_id_domains_by_domain_id_recheck_registrar<
4968 B: Serialize + ?Sized,
4969 >(
4970 &self,
4971 project_id: &str,
4972 domain_id: &str,
4973 body: Option<&B>,
4974 query: Option<&[(&str, &str)]>,
4975 ) -> Result<Value, NubisError> {
4976 self.request_value(
4977 Method::POST,
4978 "/api/v1/projects/:project_id/domains/:domain_id/recheck-registrar",
4979 &[("project_id", project_id), ("domain_id", domain_id)],
4980 query,
4981 body,
4982 )
4983 .await
4984 }
4985
4986 pub async fn post_api_v1_projects_by_project_id_domains_by_domain_id_renew<
4988 B: Serialize + ?Sized,
4989 >(
4990 &self,
4991 project_id: &str,
4992 domain_id: &str,
4993 body: Option<&B>,
4994 query: Option<&[(&str, &str)]>,
4995 ) -> Result<Value, NubisError> {
4996 self.request_value(
4997 Method::POST,
4998 "/api/v1/projects/:project_id/domains/:domain_id/renew",
4999 &[("project_id", project_id), ("domain_id", domain_id)],
5000 query,
5001 body,
5002 )
5003 .await
5004 }
5005
5006 pub async fn post_api_v1_projects_by_project_id_domains_by_domain_id_set_nameservers<
5008 B: Serialize + ?Sized,
5009 >(
5010 &self,
5011 project_id: &str,
5012 domain_id: &str,
5013 body: Option<&B>,
5014 query: Option<&[(&str, &str)]>,
5015 ) -> Result<Value, NubisError> {
5016 self.request_value(
5017 Method::POST,
5018 "/api/v1/projects/:project_id/domains/:domain_id/set-nameservers",
5019 &[("project_id", project_id), ("domain_id", domain_id)],
5020 query,
5021 body,
5022 )
5023 .await
5024 }
5025
5026 pub async fn post_api_v1_projects_by_project_id_domains_checkout<B: Serialize + ?Sized>(
5028 &self,
5029 project_id: &str,
5030 body: Option<&B>,
5031 query: Option<&[(&str, &str)]>,
5032 ) -> Result<Value, NubisError> {
5033 self.request_value(
5034 Method::POST,
5035 "/api/v1/projects/:project_id/domains/checkout",
5036 &[("project_id", project_id)],
5037 query,
5038 body,
5039 )
5040 .await
5041 }
5042
5043 pub async fn post_api_v1_projects_by_project_id_domains_search<B: Serialize + ?Sized>(
5045 &self,
5046 project_id: &str,
5047 body: Option<&B>,
5048 query: Option<&[(&str, &str)]>,
5049 ) -> Result<Value, NubisError> {
5050 self.request_value(
5051 Method::POST,
5052 "/api/v1/projects/:project_id/domains/search",
5053 &[("project_id", project_id)],
5054 query,
5055 body,
5056 )
5057 .await
5058 }
5059
5060 pub async fn post_api_v1_projects_by_project_id_domains_verify_checkout<
5062 B: Serialize + ?Sized,
5063 >(
5064 &self,
5065 project_id: &str,
5066 body: Option<&B>,
5067 query: Option<&[(&str, &str)]>,
5068 ) -> Result<Value, NubisError> {
5069 self.request_value(
5070 Method::POST,
5071 "/api/v1/projects/:project_id/domains/verify-checkout",
5072 &[("project_id", project_id)],
5073 query,
5074 body,
5075 )
5076 .await
5077 }
5078
5079 pub async fn post_api_v1_projects_by_project_id_firewalls<B: Serialize + ?Sized>(
5081 &self,
5082 project_id: &str,
5083 body: Option<&B>,
5084 query: Option<&[(&str, &str)]>,
5085 ) -> Result<Value, NubisError> {
5086 self.request_value(
5087 Method::POST,
5088 "/api/v1/projects/:project_id/firewalls",
5089 &[("project_id", project_id)],
5090 query,
5091 body,
5092 )
5093 .await
5094 }
5095
5096 pub async fn post_api_v1_projects_by_project_id_firewalls_by_firewall_id_attach_by_vm_id<
5098 B: Serialize + ?Sized,
5099 >(
5100 &self,
5101 project_id: &str,
5102 firewall_id: &str,
5103 vm_id: &str,
5104 body: Option<&B>,
5105 query: Option<&[(&str, &str)]>,
5106 ) -> Result<Value, NubisError> {
5107 self.request_value(
5108 Method::POST,
5109 "/api/v1/projects/:project_id/firewalls/:firewall_id/attach/:vm_id",
5110 &[
5111 ("project_id", project_id),
5112 ("firewall_id", firewall_id),
5113 ("vm_id", vm_id),
5114 ],
5115 query,
5116 body,
5117 )
5118 .await
5119 }
5120
5121 pub async fn post_api_v1_projects_by_project_id_firewalls_by_firewall_id_detach_by_vm_id<
5123 B: Serialize + ?Sized,
5124 >(
5125 &self,
5126 project_id: &str,
5127 firewall_id: &str,
5128 vm_id: &str,
5129 body: Option<&B>,
5130 query: Option<&[(&str, &str)]>,
5131 ) -> Result<Value, NubisError> {
5132 self.request_value(
5133 Method::POST,
5134 "/api/v1/projects/:project_id/firewalls/:firewall_id/detach/:vm_id",
5135 &[
5136 ("project_id", project_id),
5137 ("firewall_id", firewall_id),
5138 ("vm_id", vm_id),
5139 ],
5140 query,
5141 body,
5142 )
5143 .await
5144 }
5145
5146 pub async fn post_api_v1_projects_by_project_id_firewalls_by_firewall_id_rules<
5148 B: Serialize + ?Sized,
5149 >(
5150 &self,
5151 project_id: &str,
5152 firewall_id: &str,
5153 body: Option<&B>,
5154 query: Option<&[(&str, &str)]>,
5155 ) -> Result<Value, NubisError> {
5156 self.request_value(
5157 Method::POST,
5158 "/api/v1/projects/:project_id/firewalls/:firewall_id/rules",
5159 &[("project_id", project_id), ("firewall_id", firewall_id)],
5160 query,
5161 body,
5162 )
5163 .await
5164 }
5165
5166 pub async fn post_api_v1_projects_by_project_id_floating_ips<B: Serialize + ?Sized>(
5168 &self,
5169 project_id: &str,
5170 body: Option<&B>,
5171 query: Option<&[(&str, &str)]>,
5172 ) -> Result<Value, NubisError> {
5173 self.request_value(
5174 Method::POST,
5175 "/api/v1/projects/:project_id/floating-ips",
5176 &[("project_id", project_id)],
5177 query,
5178 body,
5179 )
5180 .await
5181 }
5182
5183 pub async fn post_api_v1_projects_by_project_id_floating_ips_by_eip_id_attach_by_vm_id<
5185 B: Serialize + ?Sized,
5186 >(
5187 &self,
5188 project_id: &str,
5189 eip_id: &str,
5190 vm_id: &str,
5191 body: Option<&B>,
5192 query: Option<&[(&str, &str)]>,
5193 ) -> Result<Value, NubisError> {
5194 self.request_value(
5195 Method::POST,
5196 "/api/v1/projects/:project_id/floating-ips/:eip_id/attach/:vm_id",
5197 &[
5198 ("project_id", project_id),
5199 ("eip_id", eip_id),
5200 ("vm_id", vm_id),
5201 ],
5202 query,
5203 body,
5204 )
5205 .await
5206 }
5207
5208 pub async fn post_api_v1_projects_by_project_id_floating_ips_by_eip_id_detach<
5210 B: Serialize + ?Sized,
5211 >(
5212 &self,
5213 project_id: &str,
5214 eip_id: &str,
5215 body: Option<&B>,
5216 query: Option<&[(&str, &str)]>,
5217 ) -> Result<Value, NubisError> {
5218 self.request_value(
5219 Method::POST,
5220 "/api/v1/projects/:project_id/floating-ips/:eip_id/detach",
5221 &[("project_id", project_id), ("eip_id", eip_id)],
5222 query,
5223 body,
5224 )
5225 .await
5226 }
5227
5228 pub async fn post_api_v1_projects_by_project_id_images_import_url<B: Serialize + ?Sized>(
5230 &self,
5231 project_id: &str,
5232 body: Option<&B>,
5233 query: Option<&[(&str, &str)]>,
5234 ) -> Result<Value, NubisError> {
5235 self.request_value(
5236 Method::POST,
5237 "/api/v1/projects/:project_id/images/import-url",
5238 &[("project_id", project_id)],
5239 query,
5240 body,
5241 )
5242 .await
5243 }
5244
5245 pub async fn post_api_v1_projects_by_project_id_k8s<B: Serialize + ?Sized>(
5247 &self,
5248 project_id: &str,
5249 body: Option<&B>,
5250 query: Option<&[(&str, &str)]>,
5251 ) -> Result<Value, NubisError> {
5252 self.request_value(
5253 Method::POST,
5254 "/api/v1/projects/:project_id/k8s",
5255 &[("project_id", project_id)],
5256 query,
5257 body,
5258 )
5259 .await
5260 }
5261
5262 pub async fn post_api_v1_projects_by_project_id_k8s_by_cluster_id_clusterlint<
5264 B: Serialize + ?Sized,
5265 >(
5266 &self,
5267 project_id: &str,
5268 cluster_id: &str,
5269 body: Option<&B>,
5270 query: Option<&[(&str, &str)]>,
5271 ) -> Result<Value, NubisError> {
5272 self.request_value(
5273 Method::POST,
5274 "/api/v1/projects/:project_id/k8s/:cluster_id/clusterlint",
5275 &[("project_id", project_id), ("cluster_id", cluster_id)],
5276 query,
5277 body,
5278 )
5279 .await
5280 }
5281
5282 pub async fn post_api_v1_projects_by_project_id_k8s_by_cluster_id_destroy_with_resources_dangerous<
5284 B: Serialize + ?Sized,
5285 >(
5286 &self,
5287 project_id: &str,
5288 cluster_id: &str,
5289 body: Option<&B>,
5290 query: Option<&[(&str, &str)]>,
5291 ) -> Result<Value, NubisError> {
5292 self.request_value(
5293 Method::POST,
5294 "/api/v1/projects/:project_id/k8s/:cluster_id/destroy-with-resources/dangerous",
5295 &[("project_id", project_id), ("cluster_id", cluster_id)],
5296 query,
5297 body,
5298 )
5299 .await
5300 }
5301
5302 pub async fn post_api_v1_projects_by_project_id_k8s_by_cluster_id_destroy_with_resources_selective<
5304 B: Serialize + ?Sized,
5305 >(
5306 &self,
5307 project_id: &str,
5308 cluster_id: &str,
5309 body: Option<&B>,
5310 query: Option<&[(&str, &str)]>,
5311 ) -> Result<Value, NubisError> {
5312 self.request_value(
5313 Method::POST,
5314 "/api/v1/projects/:project_id/k8s/:cluster_id/destroy-with-resources/selective",
5315 &[("project_id", project_id), ("cluster_id", cluster_id)],
5316 query,
5317 body,
5318 )
5319 .await
5320 }
5321
5322 pub async fn post_api_v1_projects_by_project_id_k8s_by_cluster_id_node_pools<
5324 B: Serialize + ?Sized,
5325 >(
5326 &self,
5327 project_id: &str,
5328 cluster_id: &str,
5329 body: Option<&B>,
5330 query: Option<&[(&str, &str)]>,
5331 ) -> Result<Value, NubisError> {
5332 self.request_value(
5333 Method::POST,
5334 "/api/v1/projects/:project_id/k8s/:cluster_id/node_pools",
5335 &[("project_id", project_id), ("cluster_id", cluster_id)],
5336 query,
5337 body,
5338 )
5339 .await
5340 }
5341
5342 pub async fn post_api_v1_projects_by_project_id_load_balancers<B: Serialize + ?Sized>(
5344 &self,
5345 project_id: &str,
5346 body: Option<&B>,
5347 query: Option<&[(&str, &str)]>,
5348 ) -> Result<Value, NubisError> {
5349 self.request_value(
5350 Method::POST,
5351 "/api/v1/projects/:project_id/load-balancers",
5352 &[("project_id", project_id)],
5353 query,
5354 body,
5355 )
5356 .await
5357 }
5358
5359 pub async fn post_api_v1_projects_by_project_id_load_balancers_by_lb_id_target_groups_by_tg_id_targets<
5361 B: Serialize + ?Sized,
5362 >(
5363 &self,
5364 project_id: &str,
5365 lb_id: &str,
5366 tg_id: &str,
5367 body: Option<&B>,
5368 query: Option<&[(&str, &str)]>,
5369 ) -> Result<Value, NubisError> {
5370 self.request_value(
5371 Method::POST,
5372 "/api/v1/projects/:project_id/load-balancers/:lb_id/target-groups/:tg_id/targets",
5373 &[
5374 ("project_id", project_id),
5375 ("lb_id", lb_id),
5376 ("tg_id", tg_id),
5377 ],
5378 query,
5379 body,
5380 )
5381 .await
5382 }
5383
5384 pub async fn post_api_v1_projects_by_project_id_nat_gateways<B: Serialize + ?Sized>(
5386 &self,
5387 project_id: &str,
5388 body: Option<&B>,
5389 query: Option<&[(&str, &str)]>,
5390 ) -> Result<Value, NubisError> {
5391 self.request_value(
5392 Method::POST,
5393 "/api/v1/projects/:project_id/nat-gateways",
5394 &[("project_id", project_id)],
5395 query,
5396 body,
5397 )
5398 .await
5399 }
5400
5401 pub async fn post_api_v1_projects_by_project_id_networks<B: Serialize + ?Sized>(
5403 &self,
5404 project_id: &str,
5405 body: Option<&B>,
5406 query: Option<&[(&str, &str)]>,
5407 ) -> Result<Value, NubisError> {
5408 self.request_value(
5409 Method::POST,
5410 "/api/v1/projects/:project_id/networks",
5411 &[("project_id", project_id)],
5412 query,
5413 body,
5414 )
5415 .await
5416 }
5417
5418 pub async fn post_api_v1_projects_by_project_id_networks_by_network_id_subnets<
5420 B: Serialize + ?Sized,
5421 >(
5422 &self,
5423 project_id: &str,
5424 network_id: &str,
5425 body: Option<&B>,
5426 query: Option<&[(&str, &str)]>,
5427 ) -> Result<Value, NubisError> {
5428 self.request_value(
5429 Method::POST,
5430 "/api/v1/projects/:project_id/networks/:network_id/subnets",
5431 &[("project_id", project_id), ("network_id", network_id)],
5432 query,
5433 body,
5434 )
5435 .await
5436 }
5437
5438 pub async fn post_api_v1_projects_by_project_id_scaling_groups<B: Serialize + ?Sized>(
5440 &self,
5441 project_id: &str,
5442 body: Option<&B>,
5443 query: Option<&[(&str, &str)]>,
5444 ) -> Result<Value, NubisError> {
5445 self.request_value(
5446 Method::POST,
5447 "/api/v1/projects/:project_id/scaling-groups",
5448 &[("project_id", project_id)],
5449 query,
5450 body,
5451 )
5452 .await
5453 }
5454
5455 pub async fn post_api_v1_projects_by_project_id_scaling_groups_by_group_id_policies<
5457 B: Serialize + ?Sized,
5458 >(
5459 &self,
5460 project_id: &str,
5461 group_id: &str,
5462 body: Option<&B>,
5463 query: Option<&[(&str, &str)]>,
5464 ) -> Result<Value, NubisError> {
5465 self.request_value(
5466 Method::POST,
5467 "/api/v1/projects/:project_id/scaling-groups/:group_id/policies",
5468 &[("project_id", project_id), ("group_id", group_id)],
5469 query,
5470 body,
5471 )
5472 .await
5473 }
5474
5475 pub async fn post_api_v1_projects_by_project_id_security_groups<B: Serialize + ?Sized>(
5477 &self,
5478 project_id: &str,
5479 body: Option<&B>,
5480 query: Option<&[(&str, &str)]>,
5481 ) -> Result<Value, NubisError> {
5482 self.request_value(
5483 Method::POST,
5484 "/api/v1/projects/:project_id/security-groups",
5485 &[("project_id", project_id)],
5486 query,
5487 body,
5488 )
5489 .await
5490 }
5491
5492 pub async fn post_api_v1_projects_by_project_id_security_groups_by_sg_id_attach_by_vm_id<
5494 B: Serialize + ?Sized,
5495 >(
5496 &self,
5497 project_id: &str,
5498 sg_id: &str,
5499 vm_id: &str,
5500 body: Option<&B>,
5501 query: Option<&[(&str, &str)]>,
5502 ) -> Result<Value, NubisError> {
5503 self.request_value(
5504 Method::POST,
5505 "/api/v1/projects/:project_id/security-groups/:sg_id/attach/:vm_id",
5506 &[
5507 ("project_id", project_id),
5508 ("sg_id", sg_id),
5509 ("vm_id", vm_id),
5510 ],
5511 query,
5512 body,
5513 )
5514 .await
5515 }
5516
5517 pub async fn post_api_v1_projects_by_project_id_security_groups_by_sg_id_detach_by_vm_id<
5519 B: Serialize + ?Sized,
5520 >(
5521 &self,
5522 project_id: &str,
5523 sg_id: &str,
5524 vm_id: &str,
5525 body: Option<&B>,
5526 query: Option<&[(&str, &str)]>,
5527 ) -> Result<Value, NubisError> {
5528 self.request_value(
5529 Method::POST,
5530 "/api/v1/projects/:project_id/security-groups/:sg_id/detach/:vm_id",
5531 &[
5532 ("project_id", project_id),
5533 ("sg_id", sg_id),
5534 ("vm_id", vm_id),
5535 ],
5536 query,
5537 body,
5538 )
5539 .await
5540 }
5541
5542 pub async fn post_api_v1_projects_by_project_id_security_groups_by_sg_id_rules<
5544 B: Serialize + ?Sized,
5545 >(
5546 &self,
5547 project_id: &str,
5548 sg_id: &str,
5549 body: Option<&B>,
5550 query: Option<&[(&str, &str)]>,
5551 ) -> Result<Value, NubisError> {
5552 self.request_value(
5553 Method::POST,
5554 "/api/v1/projects/:project_id/security-groups/:sg_id/rules",
5555 &[("project_id", project_id), ("sg_id", sg_id)],
5556 query,
5557 body,
5558 )
5559 .await
5560 }
5561
5562 pub async fn post_api_v1_projects_by_project_id_ssh_keys<B: Serialize + ?Sized>(
5564 &self,
5565 project_id: &str,
5566 body: Option<&B>,
5567 query: Option<&[(&str, &str)]>,
5568 ) -> Result<Value, NubisError> {
5569 self.request_value(
5570 Method::POST,
5571 "/api/v1/projects/:project_id/ssh_keys",
5572 &[("project_id", project_id)],
5573 query,
5574 body,
5575 )
5576 .await
5577 }
5578
5579 pub async fn post_api_v1_projects_by_project_id_storage_access_keys<B: Serialize + ?Sized>(
5581 &self,
5582 project_id: &str,
5583 body: Option<&B>,
5584 query: Option<&[(&str, &str)]>,
5585 ) -> Result<Value, NubisError> {
5586 self.request_value(
5587 Method::POST,
5588 "/api/v1/projects/:project_id/storage/access-keys",
5589 &[("project_id", project_id)],
5590 query,
5591 body,
5592 )
5593 .await
5594 }
5595
5596 pub async fn post_api_v1_projects_by_project_id_storage_buckets<B: Serialize + ?Sized>(
5598 &self,
5599 project_id: &str,
5600 body: Option<&B>,
5601 query: Option<&[(&str, &str)]>,
5602 ) -> Result<Value, NubisError> {
5603 self.request_value(
5604 Method::POST,
5605 "/api/v1/projects/:project_id/storage/buckets",
5606 &[("project_id", project_id)],
5607 query,
5608 body,
5609 )
5610 .await
5611 }
5612
5613 pub async fn post_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_cors<
5615 B: Serialize + ?Sized,
5616 >(
5617 &self,
5618 project_id: &str,
5619 bucket_id: &str,
5620 body: Option<&B>,
5621 query: Option<&[(&str, &str)]>,
5622 ) -> Result<Value, NubisError> {
5623 self.request_value(
5624 Method::POST,
5625 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/cors",
5626 &[("project_id", project_id), ("bucket_id", bucket_id)],
5627 query,
5628 body,
5629 )
5630 .await
5631 }
5632
5633 pub async fn post_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_lifecycle<
5635 B: Serialize + ?Sized,
5636 >(
5637 &self,
5638 project_id: &str,
5639 bucket_id: &str,
5640 body: Option<&B>,
5641 query: Option<&[(&str, &str)]>,
5642 ) -> Result<Value, NubisError> {
5643 self.request_value(
5644 Method::POST,
5645 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/lifecycle",
5646 &[("project_id", project_id), ("bucket_id", bucket_id)],
5647 query,
5648 body,
5649 )
5650 .await
5651 }
5652
5653 pub async fn post_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_objects_signed_upload<
5655 B: Serialize + ?Sized,
5656 >(
5657 &self,
5658 project_id: &str,
5659 bucket_id: &str,
5660 body: Option<&B>,
5661 query: Option<&[(&str, &str)]>,
5662 ) -> Result<Value, NubisError> {
5663 self.request_value(
5664 Method::POST,
5665 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/objects/signed-upload",
5666 &[("project_id", project_id), ("bucket_id", bucket_id)],
5667 query,
5668 body,
5669 )
5670 .await
5671 }
5672
5673 pub async fn post_api_v1_projects_by_project_id_templates<B: Serialize + ?Sized>(
5675 &self,
5676 project_id: &str,
5677 body: Option<&B>,
5678 query: Option<&[(&str, &str)]>,
5679 ) -> Result<Value, NubisError> {
5680 self.request_value(
5681 Method::POST,
5682 "/api/v1/projects/:project_id/templates",
5683 &[("project_id", project_id)],
5684 query,
5685 body,
5686 )
5687 .await
5688 }
5689
5690 pub async fn post_api_v1_projects_by_project_id_vms<B: Serialize + ?Sized>(
5692 &self,
5693 project_id: &str,
5694 body: Option<&B>,
5695 query: Option<&[(&str, &str)]>,
5696 ) -> Result<Value, NubisError> {
5697 self.request_value(
5698 Method::POST,
5699 "/api/v1/projects/:project_id/vms",
5700 &[("project_id", project_id)],
5701 query,
5702 body,
5703 )
5704 .await
5705 }
5706
5707 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_access_reset_password<
5709 B: Serialize + ?Sized,
5710 >(
5711 &self,
5712 project_id: &str,
5713 vm_id: &str,
5714 body: Option<&B>,
5715 query: Option<&[(&str, &str)]>,
5716 ) -> Result<Value, NubisError> {
5717 self.request_value(
5718 Method::POST,
5719 "/api/v1/projects/:project_id/vms/:vm_id/access/reset-password",
5720 &[("project_id", project_id), ("vm_id", vm_id)],
5721 query,
5722 body,
5723 )
5724 .await
5725 }
5726
5727 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_console_session<
5729 B: Serialize + ?Sized,
5730 >(
5731 &self,
5732 project_id: &str,
5733 vm_id: &str,
5734 body: Option<&B>,
5735 query: Option<&[(&str, &str)]>,
5736 ) -> Result<Value, NubisError> {
5737 self.request_value(
5738 Method::POST,
5739 "/api/v1/projects/:project_id/vms/:vm_id/console-session",
5740 &[("project_id", project_id), ("vm_id", vm_id)],
5741 query,
5742 body,
5743 )
5744 .await
5745 }
5746
5747 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_disks<B: Serialize + ?Sized>(
5749 &self,
5750 project_id: &str,
5751 vm_id: &str,
5752 body: Option<&B>,
5753 query: Option<&[(&str, &str)]>,
5754 ) -> Result<Value, NubisError> {
5755 self.request_value(
5756 Method::POST,
5757 "/api/v1/projects/:project_id/vms/:vm_id/disks",
5758 &[("project_id", project_id), ("vm_id", vm_id)],
5759 query,
5760 body,
5761 )
5762 .await
5763 }
5764
5765 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_disks_by_disk_id_attach<
5767 B: Serialize + ?Sized,
5768 >(
5769 &self,
5770 project_id: &str,
5771 vm_id: &str,
5772 disk_id: &str,
5773 body: Option<&B>,
5774 query: Option<&[(&str, &str)]>,
5775 ) -> Result<Value, NubisError> {
5776 self.request_value(
5777 Method::POST,
5778 "/api/v1/projects/:project_id/vms/:vm_id/disks/:disk_id/attach",
5779 &[
5780 ("project_id", project_id),
5781 ("vm_id", vm_id),
5782 ("disk_id", disk_id),
5783 ],
5784 query,
5785 body,
5786 )
5787 .await
5788 }
5789
5790 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_disks_by_disk_id_detach<
5792 B: Serialize + ?Sized,
5793 >(
5794 &self,
5795 project_id: &str,
5796 vm_id: &str,
5797 disk_id: &str,
5798 body: Option<&B>,
5799 query: Option<&[(&str, &str)]>,
5800 ) -> Result<Value, NubisError> {
5801 self.request_value(
5802 Method::POST,
5803 "/api/v1/projects/:project_id/vms/:vm_id/disks/:disk_id/detach",
5804 &[
5805 ("project_id", project_id),
5806 ("vm_id", vm_id),
5807 ("disk_id", disk_id),
5808 ],
5809 query,
5810 body,
5811 )
5812 .await
5813 }
5814
5815 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_disks_by_disk_id_resize<
5817 B: Serialize + ?Sized,
5818 >(
5819 &self,
5820 project_id: &str,
5821 vm_id: &str,
5822 disk_id: &str,
5823 body: Option<&B>,
5824 query: Option<&[(&str, &str)]>,
5825 ) -> Result<Value, NubisError> {
5826 self.request_value(
5827 Method::POST,
5828 "/api/v1/projects/:project_id/vms/:vm_id/disks/:disk_id/resize",
5829 &[
5830 ("project_id", project_id),
5831 ("vm_id", vm_id),
5832 ("disk_id", disk_id),
5833 ],
5834 query,
5835 body,
5836 )
5837 .await
5838 }
5839
5840 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_reboot<B: Serialize + ?Sized>(
5842 &self,
5843 project_id: &str,
5844 vm_id: &str,
5845 body: Option<&B>,
5846 query: Option<&[(&str, &str)]>,
5847 ) -> Result<Value, NubisError> {
5848 self.request_value(
5849 Method::POST,
5850 "/api/v1/projects/:project_id/vms/:vm_id/reboot",
5851 &[("project_id", project_id), ("vm_id", vm_id)],
5852 query,
5853 body,
5854 )
5855 .await
5856 }
5857
5858 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_refresh<B: Serialize + ?Sized>(
5860 &self,
5861 project_id: &str,
5862 vm_id: &str,
5863 body: Option<&B>,
5864 query: Option<&[(&str, &str)]>,
5865 ) -> Result<Value, NubisError> {
5866 self.request_value(
5867 Method::POST,
5868 "/api/v1/projects/:project_id/vms/:vm_id/refresh",
5869 &[("project_id", project_id), ("vm_id", vm_id)],
5870 query,
5871 body,
5872 )
5873 .await
5874 }
5875
5876 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_rename<B: Serialize + ?Sized>(
5878 &self,
5879 project_id: &str,
5880 vm_id: &str,
5881 body: Option<&B>,
5882 query: Option<&[(&str, &str)]>,
5883 ) -> Result<Value, NubisError> {
5884 self.request_value(
5885 Method::POST,
5886 "/api/v1/projects/:project_id/vms/:vm_id/rename",
5887 &[("project_id", project_id), ("vm_id", vm_id)],
5888 query,
5889 body,
5890 )
5891 .await
5892 }
5893
5894 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_resize<B: Serialize + ?Sized>(
5896 &self,
5897 project_id: &str,
5898 vm_id: &str,
5899 body: Option<&B>,
5900 query: Option<&[(&str, &str)]>,
5901 ) -> Result<Value, NubisError> {
5902 self.request_value(
5903 Method::POST,
5904 "/api/v1/projects/:project_id/vms/:vm_id/resize",
5905 &[("project_id", project_id), ("vm_id", vm_id)],
5906 query,
5907 body,
5908 )
5909 .await
5910 }
5911
5912 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_snapshots<
5914 B: Serialize + ?Sized,
5915 >(
5916 &self,
5917 project_id: &str,
5918 vm_id: &str,
5919 body: Option<&B>,
5920 query: Option<&[(&str, &str)]>,
5921 ) -> Result<Value, NubisError> {
5922 self.request_value(
5923 Method::POST,
5924 "/api/v1/projects/:project_id/vms/:vm_id/snapshots",
5925 &[("project_id", project_id), ("vm_id", vm_id)],
5926 query,
5927 body,
5928 )
5929 .await
5930 }
5931
5932 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_ssh_session<
5934 B: Serialize + ?Sized,
5935 >(
5936 &self,
5937 project_id: &str,
5938 vm_id: &str,
5939 body: Option<&B>,
5940 query: Option<&[(&str, &str)]>,
5941 ) -> Result<Value, NubisError> {
5942 self.request_value(
5943 Method::POST,
5944 "/api/v1/projects/:project_id/vms/:vm_id/ssh-session",
5945 &[("project_id", project_id), ("vm_id", vm_id)],
5946 query,
5947 body,
5948 )
5949 .await
5950 }
5951
5952 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_start<B: Serialize + ?Sized>(
5954 &self,
5955 project_id: &str,
5956 vm_id: &str,
5957 body: Option<&B>,
5958 query: Option<&[(&str, &str)]>,
5959 ) -> Result<Value, NubisError> {
5960 self.request_value(
5961 Method::POST,
5962 "/api/v1/projects/:project_id/vms/:vm_id/start",
5963 &[("project_id", project_id), ("vm_id", vm_id)],
5964 query,
5965 body,
5966 )
5967 .await
5968 }
5969
5970 pub async fn post_api_v1_projects_by_project_id_vms_by_vm_id_stop<B: Serialize + ?Sized>(
5972 &self,
5973 project_id: &str,
5974 vm_id: &str,
5975 body: Option<&B>,
5976 query: Option<&[(&str, &str)]>,
5977 ) -> Result<Value, NubisError> {
5978 self.request_value(
5979 Method::POST,
5980 "/api/v1/projects/:project_id/vms/:vm_id/stop",
5981 &[("project_id", project_id), ("vm_id", vm_id)],
5982 query,
5983 body,
5984 )
5985 .await
5986 }
5987
5988 pub async fn post_api_v1_projects_by_project_id_volumes<B: Serialize + ?Sized>(
5990 &self,
5991 project_id: &str,
5992 body: Option<&B>,
5993 query: Option<&[(&str, &str)]>,
5994 ) -> Result<Value, NubisError> {
5995 self.request_value(
5996 Method::POST,
5997 "/api/v1/projects/:project_id/volumes",
5998 &[("project_id", project_id)],
5999 query,
6000 body,
6001 )
6002 .await
6003 }
6004
6005 pub async fn post_api_v1_projects_by_project_id_zones<B: Serialize + ?Sized>(
6007 &self,
6008 project_id: &str,
6009 body: Option<&B>,
6010 query: Option<&[(&str, &str)]>,
6011 ) -> Result<Value, NubisError> {
6012 self.request_value(
6013 Method::POST,
6014 "/api/v1/projects/:project_id/zones",
6015 &[("project_id", project_id)],
6016 query,
6017 body,
6018 )
6019 .await
6020 }
6021
6022 pub async fn post_api_v1_projects_by_project_id_zones_by_zone_id_recheck_dns<
6024 B: Serialize + ?Sized,
6025 >(
6026 &self,
6027 project_id: &str,
6028 zone_id: &str,
6029 body: Option<&B>,
6030 query: Option<&[(&str, &str)]>,
6031 ) -> Result<Value, NubisError> {
6032 self.request_value(
6033 Method::POST,
6034 "/api/v1/projects/:project_id/zones/:zone_id/recheck-dns",
6035 &[("project_id", project_id), ("zone_id", zone_id)],
6036 query,
6037 body,
6038 )
6039 .await
6040 }
6041
6042 pub async fn post_api_v1_projects_by_project_id_zones_by_zone_id_records<
6044 B: Serialize + ?Sized,
6045 >(
6046 &self,
6047 project_id: &str,
6048 zone_id: &str,
6049 body: Option<&B>,
6050 query: Option<&[(&str, &str)]>,
6051 ) -> Result<Value, NubisError> {
6052 self.request_value(
6053 Method::POST,
6054 "/api/v1/projects/:project_id/zones/:zone_id/records",
6055 &[("project_id", project_id), ("zone_id", zone_id)],
6056 query,
6057 body,
6058 )
6059 .await
6060 }
6061
6062 pub async fn post_api_v1_webhooks_github_launch_by_delivery_key<B: Serialize + ?Sized>(
6064 &self,
6065 delivery_key: &str,
6066 body: Option<&B>,
6067 query: Option<&[(&str, &str)]>,
6068 ) -> Result<Value, NubisError> {
6069 self.request_value(
6070 Method::POST,
6071 "/api/v1/webhooks/github/launch/:delivery_key",
6072 &[("delivery_key", delivery_key)],
6073 query,
6074 body,
6075 )
6076 .await
6077 }
6078
6079 pub async fn post_api_v1_webhooks_intercom<B: Serialize + ?Sized>(
6081 &self,
6082 body: Option<&B>,
6083 query: Option<&[(&str, &str)]>,
6084 ) -> Result<Value, NubisError> {
6085 self.request_value(Method::POST, "/api/v1/webhooks/intercom", &[], query, body)
6086 .await
6087 }
6088
6089 pub async fn post_api_v1_webhooks_paystack<B: Serialize + ?Sized>(
6091 &self,
6092 body: Option<&B>,
6093 query: Option<&[(&str, &str)]>,
6094 ) -> Result<Value, NubisError> {
6095 self.request_value(Method::POST, "/api/v1/webhooks/paystack", &[], query, body)
6096 .await
6097 }
6098
6099 pub async fn post_api_v1_webhooks_polar<B: Serialize + ?Sized>(
6101 &self,
6102 body: Option<&B>,
6103 query: Option<&[(&str, &str)]>,
6104 ) -> Result<Value, NubisError> {
6105 self.request_value(Method::POST, "/api/v1/webhooks/polar", &[], query, body)
6106 .await
6107 }
6108
6109 pub async fn put_api_v1_orgs_by_org_id_billing_enforcement_settings<B: Serialize + ?Sized>(
6111 &self,
6112 org_id: &str,
6113 body: Option<&B>,
6114 query: Option<&[(&str, &str)]>,
6115 ) -> Result<Value, NubisError> {
6116 self.request_value(
6117 Method::PUT,
6118 "/api/v1/orgs/:org_id/billing/enforcement-settings",
6119 &[("org_id", org_id)],
6120 query,
6121 body,
6122 )
6123 .await
6124 }
6125
6126 pub async fn put_api_v1_orgs_by_org_id_billing_payment_methods_by_method_id_default<
6128 B: Serialize + ?Sized,
6129 >(
6130 &self,
6131 org_id: &str,
6132 method_id: &str,
6133 body: Option<&B>,
6134 query: Option<&[(&str, &str)]>,
6135 ) -> Result<Value, NubisError> {
6136 self.request_value(
6137 Method::PUT,
6138 "/api/v1/orgs/:org_id/billing/payment-methods/:method_id/default",
6139 &[("org_id", org_id), ("method_id", method_id)],
6140 query,
6141 body,
6142 )
6143 .await
6144 }
6145
6146 pub async fn put_api_v1_orgs_by_org_id_billing_spend_limit<B: Serialize + ?Sized>(
6148 &self,
6149 org_id: &str,
6150 body: Option<&B>,
6151 query: Option<&[(&str, &str)]>,
6152 ) -> Result<Value, NubisError> {
6153 self.request_value(
6154 Method::PUT,
6155 "/api/v1/orgs/:org_id/billing/spend-limit",
6156 &[("org_id", org_id)],
6157 query,
6158 body,
6159 )
6160 .await
6161 }
6162
6163 pub async fn put_api_v1_orgs_by_org_id_billing_tax_info<B: Serialize + ?Sized>(
6165 &self,
6166 org_id: &str,
6167 body: Option<&B>,
6168 query: Option<&[(&str, &str)]>,
6169 ) -> Result<Value, NubisError> {
6170 self.request_value(
6171 Method::PUT,
6172 "/api/v1/orgs/:org_id/billing/tax-info",
6173 &[("org_id", org_id)],
6174 query,
6175 body,
6176 )
6177 .await
6178 }
6179
6180 pub async fn put_api_v1_orgs_by_org_id_currency<B: Serialize + ?Sized>(
6182 &self,
6183 org_id: &str,
6184 body: Option<&B>,
6185 query: Option<&[(&str, &str)]>,
6186 ) -> Result<Value, NubisError> {
6187 self.request_value(
6188 Method::PUT,
6189 "/api/v1/orgs/:org_id/currency",
6190 &[("org_id", org_id)],
6191 query,
6192 body,
6193 )
6194 .await
6195 }
6196
6197 pub async fn put_api_v1_orgs_by_org_id_iac_webhooks_by_webhook_id<B: Serialize + ?Sized>(
6199 &self,
6200 org_id: &str,
6201 webhook_id: &str,
6202 body: Option<&B>,
6203 query: Option<&[(&str, &str)]>,
6204 ) -> Result<Value, NubisError> {
6205 self.request_value(
6206 Method::PUT,
6207 "/api/v1/orgs/:org_id/iac/webhooks/:webhook_id",
6208 &[("org_id", org_id), ("webhook_id", webhook_id)],
6209 query,
6210 body,
6211 )
6212 .await
6213 }
6214
6215 pub async fn put_api_v1_orgs_by_org_id_iam_roles_by_role_id_permissions<
6217 B: Serialize + ?Sized,
6218 >(
6219 &self,
6220 org_id: &str,
6221 role_id: &str,
6222 body: Option<&B>,
6223 query: Option<&[(&str, &str)]>,
6224 ) -> Result<Value, NubisError> {
6225 self.request_value(
6226 Method::PUT,
6227 "/api/v1/orgs/:org_id/iam/roles/:role_id/permissions",
6228 &[("org_id", org_id), ("role_id", role_id)],
6229 query,
6230 body,
6231 )
6232 .await
6233 }
6234
6235 pub async fn put_api_v1_orgs_by_org_id_iam_service_accounts_by_sa_id<B: Serialize + ?Sized>(
6237 &self,
6238 org_id: &str,
6239 sa_id: &str,
6240 body: Option<&B>,
6241 query: Option<&[(&str, &str)]>,
6242 ) -> Result<Value, NubisError> {
6243 self.request_value(
6244 Method::PUT,
6245 "/api/v1/orgs/:org_id/iam/service-accounts/:sa_id",
6246 &[("org_id", org_id), ("sa_id", sa_id)],
6247 query,
6248 body,
6249 )
6250 .await
6251 }
6252
6253 pub async fn put_api_v1_orgs_by_org_id_iam_sso<B: Serialize + ?Sized>(
6255 &self,
6256 org_id: &str,
6257 body: Option<&B>,
6258 query: Option<&[(&str, &str)]>,
6259 ) -> Result<Value, NubisError> {
6260 self.request_value(
6261 Method::PUT,
6262 "/api/v1/orgs/:org_id/iam/sso",
6263 &[("org_id", org_id)],
6264 query,
6265 body,
6266 )
6267 .await
6268 }
6269
6270 pub async fn put_api_v1_orgs_by_org_id_limits_spend<B: Serialize + ?Sized>(
6272 &self,
6273 org_id: &str,
6274 body: Option<&B>,
6275 query: Option<&[(&str, &str)]>,
6276 ) -> Result<Value, NubisError> {
6277 self.request_value(
6278 Method::PUT,
6279 "/api/v1/orgs/:org_id/limits/spend",
6280 &[("org_id", org_id)],
6281 query,
6282 body,
6283 )
6284 .await
6285 }
6286
6287 pub async fn put_api_v1_orgs_by_org_id_observability_alerts_by_policy_id<
6289 B: Serialize + ?Sized,
6290 >(
6291 &self,
6292 org_id: &str,
6293 policy_id: &str,
6294 body: Option<&B>,
6295 query: Option<&[(&str, &str)]>,
6296 ) -> Result<Value, NubisError> {
6297 self.request_value(
6298 Method::PUT,
6299 "/api/v1/orgs/:org_id/observability/alerts/:policy_id",
6300 &[("org_id", org_id), ("policy_id", policy_id)],
6301 query,
6302 body,
6303 )
6304 .await
6305 }
6306
6307 pub async fn put_api_v1_orgs_by_org_id_observability_destinations_by_destination_id<
6309 B: Serialize + ?Sized,
6310 >(
6311 &self,
6312 org_id: &str,
6313 destination_id: &str,
6314 body: Option<&B>,
6315 query: Option<&[(&str, &str)]>,
6316 ) -> Result<Value, NubisError> {
6317 self.request_value(
6318 Method::PUT,
6319 "/api/v1/orgs/:org_id/observability/destinations/:destination_id",
6320 &[("org_id", org_id), ("destination_id", destination_id)],
6321 query,
6322 body,
6323 )
6324 .await
6325 }
6326
6327 pub async fn put_api_v1_orgs_by_org_id_projects_by_project_id_billing_spend_limit<
6329 B: Serialize + ?Sized,
6330 >(
6331 &self,
6332 org_id: &str,
6333 project_id: &str,
6334 body: Option<&B>,
6335 query: Option<&[(&str, &str)]>,
6336 ) -> Result<Value, NubisError> {
6337 self.request_value(
6338 Method::PUT,
6339 "/api/v1/orgs/:org_id/projects/:project_id/billing/spend-limit",
6340 &[("org_id", org_id), ("project_id", project_id)],
6341 query,
6342 body,
6343 )
6344 .await
6345 }
6346
6347 pub async fn put_api_v1_orgs_by_org_id_projects_by_project_id_compliance<
6349 B: Serialize + ?Sized,
6350 >(
6351 &self,
6352 org_id: &str,
6353 project_id: &str,
6354 body: Option<&B>,
6355 query: Option<&[(&str, &str)]>,
6356 ) -> Result<Value, NubisError> {
6357 self.request_value(
6358 Method::PUT,
6359 "/api/v1/orgs/:org_id/projects/:project_id/compliance",
6360 &[("org_id", org_id), ("project_id", project_id)],
6361 query,
6362 body,
6363 )
6364 .await
6365 }
6366
6367 pub async fn put_api_v1_projects_by_project_id_databases_by_database_id_firewall<
6369 B: Serialize + ?Sized,
6370 >(
6371 &self,
6372 project_id: &str,
6373 database_id: &str,
6374 body: Option<&B>,
6375 query: Option<&[(&str, &str)]>,
6376 ) -> Result<Value, NubisError> {
6377 self.request_value(
6378 Method::PUT,
6379 "/api/v1/projects/:project_id/databases/:database_id/firewall",
6380 &[("project_id", project_id), ("database_id", database_id)],
6381 query,
6382 body,
6383 )
6384 .await
6385 }
6386
6387 pub async fn put_api_v1_projects_by_project_id_databases_by_database_id_maintenance<
6389 B: Serialize + ?Sized,
6390 >(
6391 &self,
6392 project_id: &str,
6393 database_id: &str,
6394 body: Option<&B>,
6395 query: Option<&[(&str, &str)]>,
6396 ) -> Result<Value, NubisError> {
6397 self.request_value(
6398 Method::PUT,
6399 "/api/v1/projects/:project_id/databases/:database_id/maintenance",
6400 &[("project_id", project_id), ("database_id", database_id)],
6401 query,
6402 body,
6403 )
6404 .await
6405 }
6406
6407 pub async fn put_api_v1_projects_by_project_id_domains_by_domain_id_auto_renew<
6409 B: Serialize + ?Sized,
6410 >(
6411 &self,
6412 project_id: &str,
6413 domain_id: &str,
6414 body: Option<&B>,
6415 query: Option<&[(&str, &str)]>,
6416 ) -> Result<Value, NubisError> {
6417 self.request_value(
6418 Method::PUT,
6419 "/api/v1/projects/:project_id/domains/:domain_id/auto-renew",
6420 &[("project_id", project_id), ("domain_id", domain_id)],
6421 query,
6422 body,
6423 )
6424 .await
6425 }
6426
6427 pub async fn put_api_v1_projects_by_project_id_domains_by_domain_id_contact<
6429 B: Serialize + ?Sized,
6430 >(
6431 &self,
6432 project_id: &str,
6433 domain_id: &str,
6434 body: Option<&B>,
6435 query: Option<&[(&str, &str)]>,
6436 ) -> Result<Value, NubisError> {
6437 self.request_value(
6438 Method::PUT,
6439 "/api/v1/projects/:project_id/domains/:domain_id/contact",
6440 &[("project_id", project_id), ("domain_id", domain_id)],
6441 query,
6442 body,
6443 )
6444 .await
6445 }
6446
6447 pub async fn put_api_v1_projects_by_project_id_domains_by_domain_id_lock<
6449 B: Serialize + ?Sized,
6450 >(
6451 &self,
6452 project_id: &str,
6453 domain_id: &str,
6454 body: Option<&B>,
6455 query: Option<&[(&str, &str)]>,
6456 ) -> Result<Value, NubisError> {
6457 self.request_value(
6458 Method::PUT,
6459 "/api/v1/projects/:project_id/domains/:domain_id/lock",
6460 &[("project_id", project_id), ("domain_id", domain_id)],
6461 query,
6462 body,
6463 )
6464 .await
6465 }
6466
6467 pub async fn put_api_v1_projects_by_project_id_domains_by_domain_id_privacy<
6469 B: Serialize + ?Sized,
6470 >(
6471 &self,
6472 project_id: &str,
6473 domain_id: &str,
6474 body: Option<&B>,
6475 query: Option<&[(&str, &str)]>,
6476 ) -> Result<Value, NubisError> {
6477 self.request_value(
6478 Method::PUT,
6479 "/api/v1/projects/:project_id/domains/:domain_id/privacy",
6480 &[("project_id", project_id), ("domain_id", domain_id)],
6481 query,
6482 body,
6483 )
6484 .await
6485 }
6486
6487 pub async fn put_api_v1_projects_by_project_id_k8s_by_cluster_id_node_pools_by_pool_id<
6489 B: Serialize + ?Sized,
6490 >(
6491 &self,
6492 project_id: &str,
6493 cluster_id: &str,
6494 pool_id: &str,
6495 body: Option<&B>,
6496 query: Option<&[(&str, &str)]>,
6497 ) -> Result<Value, NubisError> {
6498 self.request_value(
6499 Method::PUT,
6500 "/api/v1/projects/:project_id/k8s/:cluster_id/node_pools/:pool_id",
6501 &[
6502 ("project_id", project_id),
6503 ("cluster_id", cluster_id),
6504 ("pool_id", pool_id),
6505 ],
6506 query,
6507 body,
6508 )
6509 .await
6510 }
6511
6512 pub async fn put_api_v1_projects_by_project_id_scaling_groups_by_group_id_desired<
6514 B: Serialize + ?Sized,
6515 >(
6516 &self,
6517 project_id: &str,
6518 group_id: &str,
6519 body: Option<&B>,
6520 query: Option<&[(&str, &str)]>,
6521 ) -> Result<Value, NubisError> {
6522 self.request_value(
6523 Method::PUT,
6524 "/api/v1/projects/:project_id/scaling-groups/:group_id/desired",
6525 &[("project_id", project_id), ("group_id", group_id)],
6526 query,
6527 body,
6528 )
6529 .await
6530 }
6531
6532 pub async fn put_api_v1_projects_by_project_id_storage_buckets_by_bucket_id<
6534 B: Serialize + ?Sized,
6535 >(
6536 &self,
6537 project_id: &str,
6538 bucket_id: &str,
6539 body: Option<&B>,
6540 query: Option<&[(&str, &str)]>,
6541 ) -> Result<Value, NubisError> {
6542 self.request_value(
6543 Method::PUT,
6544 "/api/v1/projects/:project_id/storage/buckets/:bucket_id",
6545 &[("project_id", project_id), ("bucket_id", bucket_id)],
6546 query,
6547 body,
6548 )
6549 .await
6550 }
6551
6552 pub async fn put_api_v1_projects_by_project_id_storage_buckets_by_bucket_id_cdn<
6554 B: Serialize + ?Sized,
6555 >(
6556 &self,
6557 project_id: &str,
6558 bucket_id: &str,
6559 body: Option<&B>,
6560 query: Option<&[(&str, &str)]>,
6561 ) -> Result<Value, NubisError> {
6562 self.request_value(
6563 Method::PUT,
6564 "/api/v1/projects/:project_id/storage/buckets/:bucket_id/cdn",
6565 &[("project_id", project_id), ("bucket_id", bucket_id)],
6566 query,
6567 body,
6568 )
6569 .await
6570 }
6571
6572 pub async fn put_api_v1_projects_by_project_id_vms_by_vm_id_access_ssh_key<
6574 B: Serialize + ?Sized,
6575 >(
6576 &self,
6577 project_id: &str,
6578 vm_id: &str,
6579 body: Option<&B>,
6580 query: Option<&[(&str, &str)]>,
6581 ) -> Result<Value, NubisError> {
6582 self.request_value(
6583 Method::PUT,
6584 "/api/v1/projects/:project_id/vms/:vm_id/access/ssh-key",
6585 &[("project_id", project_id), ("vm_id", vm_id)],
6586 query,
6587 body,
6588 )
6589 .await
6590 }
6591
6592 pub async fn put_api_v1_projects_by_project_id_zones_by_zone_id_records_by_record_id<
6594 B: Serialize + ?Sized,
6595 >(
6596 &self,
6597 project_id: &str,
6598 zone_id: &str,
6599 record_id: &str,
6600 body: Option<&B>,
6601 query: Option<&[(&str, &str)]>,
6602 ) -> Result<Value, NubisError> {
6603 self.request_value(
6604 Method::PUT,
6605 "/api/v1/projects/:project_id/zones/:zone_id/records/:record_id",
6606 &[
6607 ("project_id", project_id),
6608 ("zone_id", zone_id),
6609 ("record_id", record_id),
6610 ],
6611 query,
6612 body,
6613 )
6614 .await
6615 }
6616}