1#![allow(unused_imports)]
3use crate::models::workspace as m;
4use crate::transport::{Core, Operation, Payload, QueryEncoding};
5use crate::{BinaryRequest, Client, EmptyRequest, PagedRequest, Request, WebSocketRequest};
6const ENDPOINT: &str = "https://workspace.basaltic.sh";
7static OP_0: Operation = Operation {
8 id: "addUser",
9 method: "POST",
10 path: "/v1/users",
11 authenticated: true,
12 required_query: &[],
13 required_headers: &[],
14 content_type: "application/json",
15 accept: "application/json",
16 query_encoding: &[],
17};
18static OP_1: Operation = Operation {
19 id: "addUserToGroup",
20 method: "POST",
21 path: "/v1/users/{user_id}/groups",
22 authenticated: true,
23 required_query: &[],
24 required_headers: &[],
25 content_type: "application/json",
26 accept: "application/json",
27 query_encoding: &[],
28};
29static OP_2: Operation = Operation {
30 id: "assignAccountRole",
31 method: "POST",
32 path: "/v1/accounts/{account_id}/role-assignments",
33 authenticated: true,
34 required_query: &[],
35 required_headers: &[],
36 content_type: "application/json",
37 accept: "application/json",
38 query_encoding: &[],
39};
40static OP_3: Operation = Operation {
41 id: "attachGroupPolicy",
42 method: "POST",
43 path: "/v1/groups/{group_id}/policies",
44 authenticated: true,
45 required_query: &[],
46 required_headers: &[],
47 content_type: "application/json",
48 accept: "application/json",
49 query_encoding: &[],
50};
51static OP_4: Operation = Operation {
52 id: "attachRolePolicy",
53 method: "POST",
54 path: "/v1/roles/{role_id}/policies",
55 authenticated: true,
56 required_query: &[],
57 required_headers: &[],
58 content_type: "application/json",
59 accept: "application/json",
60 query_encoding: &[],
61};
62static OP_5: Operation = Operation {
63 id: "attachServiceAccountPolicy",
64 method: "POST",
65 path: "/v1/service-accounts/{service_account_id}/policies",
66 authenticated: true,
67 required_query: &[],
68 required_headers: &[],
69 content_type: "application/json",
70 accept: "application/json",
71 query_encoding: &[],
72};
73static OP_6: Operation = Operation {
74 id: "attachUserPolicy",
75 method: "POST",
76 path: "/v1/users/{user_id}/policies",
77 authenticated: true,
78 required_query: &[],
79 required_headers: &[],
80 content_type: "application/json",
81 accept: "application/json",
82 query_encoding: &[],
83};
84static OP_7: Operation = Operation {
85 id: "cancelInvitation",
86 method: "DELETE",
87 path: "/v1/invitations/{invitation_id}",
88 authenticated: true,
89 required_query: &[],
90 required_headers: &[],
91 content_type: "",
92 accept: "application/json",
93 query_encoding: &[],
94};
95static OP_8: Operation = Operation {
96 id: "createAccount",
97 method: "POST",
98 path: "/v1/accounts",
99 authenticated: true,
100 required_query: &[],
101 required_headers: &[],
102 content_type: "application/json",
103 accept: "application/json",
104 query_encoding: &[],
105};
106static OP_9: Operation = Operation {
107 id: "createGroup",
108 method: "POST",
109 path: "/v1/groups",
110 authenticated: true,
111 required_query: &[],
112 required_headers: &[],
113 content_type: "application/json",
114 accept: "application/json",
115 query_encoding: &[],
116};
117static OP_10: Operation = Operation {
118 id: "createPolicy",
119 method: "POST",
120 path: "/v1/policies",
121 authenticated: true,
122 required_query: &[],
123 required_headers: &[],
124 content_type: "application/json",
125 accept: "application/json",
126 query_encoding: &[],
127};
128static OP_11: Operation = Operation {
129 id: "deleteAccount",
130 method: "DELETE",
131 path: "/v1/accounts/{account_id}",
132 authenticated: true,
133 required_query: &[],
134 required_headers: &[],
135 content_type: "",
136 accept: "application/json",
137 query_encoding: &[],
138};
139static OP_12: Operation = Operation {
140 id: "deleteGroup",
141 method: "DELETE",
142 path: "/v1/groups/{group_id}",
143 authenticated: true,
144 required_query: &[],
145 required_headers: &[],
146 content_type: "",
147 accept: "application/json",
148 query_encoding: &[],
149};
150static OP_13: Operation = Operation {
151 id: "deleteGroupInlinePolicy",
152 method: "DELETE",
153 path: "/v1/groups/{group_id}/inline-policies/{policy_name}",
154 authenticated: true,
155 required_query: &[],
156 required_headers: &[],
157 content_type: "",
158 accept: "application/json",
159 query_encoding: &[],
160};
161static OP_14: Operation = Operation {
162 id: "deleteOrganization",
163 method: "DELETE",
164 path: "/v1/organizations/{organization_id}",
165 authenticated: true,
166 required_query: &[],
167 required_headers: &[],
168 content_type: "",
169 accept: "application/json",
170 query_encoding: &[],
171};
172static OP_15: Operation = Operation {
173 id: "deletePolicy",
174 method: "DELETE",
175 path: "/v1/policies/{policy_id}",
176 authenticated: true,
177 required_query: &[],
178 required_headers: &[],
179 content_type: "",
180 accept: "application/json",
181 query_encoding: &[],
182};
183static OP_16: Operation = Operation {
184 id: "deleteUserInlinePolicy",
185 method: "DELETE",
186 path: "/v1/users/{user_id}/inline-policies/{policy_name}",
187 authenticated: true,
188 required_query: &[],
189 required_headers: &[],
190 content_type: "",
191 accept: "application/json",
192 query_encoding: &[],
193};
194static OP_17: Operation = Operation {
195 id: "detachGroupPolicy",
196 method: "DELETE",
197 path: "/v1/groups/{group_id}/policies/{policy_id}",
198 authenticated: true,
199 required_query: &[],
200 required_headers: &[],
201 content_type: "",
202 accept: "application/json",
203 query_encoding: &[],
204};
205static OP_18: Operation = Operation {
206 id: "detachRolePolicy",
207 method: "DELETE",
208 path: "/v1/roles/{role_id}/policies/{policy_id}",
209 authenticated: true,
210 required_query: &[],
211 required_headers: &[],
212 content_type: "",
213 accept: "application/json",
214 query_encoding: &[],
215};
216static OP_19: Operation = Operation {
217 id: "detachServiceAccountPolicy",
218 method: "DELETE",
219 path: "/v1/service-accounts/{service_account_id}/policies/{policy_id}",
220 authenticated: true,
221 required_query: &[],
222 required_headers: &[],
223 content_type: "",
224 accept: "application/json",
225 query_encoding: &[],
226};
227static OP_20: Operation = Operation {
228 id: "detachUserPolicy",
229 method: "DELETE",
230 path: "/v1/users/{user_id}/policies/{policy_id}",
231 authenticated: true,
232 required_query: &[],
233 required_headers: &[],
234 content_type: "",
235 accept: "application/json",
236 query_encoding: &[],
237};
238static OP_21: Operation = Operation {
239 id: "getAccount",
240 method: "GET",
241 path: "/v1/accounts/{account_id}",
242 authenticated: true,
243 required_query: &[],
244 required_headers: &[],
245 content_type: "",
246 accept: "application/json",
247 query_encoding: &[],
248};
249static OP_22: Operation = Operation {
250 id: "getAccountOnboarding",
251 method: "GET",
252 path: "/v1/accounts/{account_id}/onboarding",
253 authenticated: true,
254 required_query: &[],
255 required_headers: &[],
256 content_type: "",
257 accept: "application/json",
258 query_encoding: &[],
259};
260static OP_23: Operation = Operation {
261 id: "getAccountResources",
262 method: "GET",
263 path: "/v1/accounts/{account_id}/resources",
264 authenticated: true,
265 required_query: &[],
266 required_headers: &[],
267 content_type: "",
268 accept: "application/json",
269 query_encoding: &[],
270};
271static OP_24: Operation = Operation {
272 id: "getGroup",
273 method: "GET",
274 path: "/v1/groups/{group_id}",
275 authenticated: true,
276 required_query: &[],
277 required_headers: &[],
278 content_type: "",
279 accept: "application/json",
280 query_encoding: &[],
281};
282static OP_25: Operation = Operation {
283 id: "getGroupInlinePolicy",
284 method: "GET",
285 path: "/v1/groups/{group_id}/inline-policies/{policy_name}",
286 authenticated: true,
287 required_query: &[],
288 required_headers: &[],
289 content_type: "",
290 accept: "application/json",
291 query_encoding: &[],
292};
293static OP_26: Operation = Operation {
294 id: "getInvitation",
295 method: "GET",
296 path: "/v1/invitations/{invitation_id}",
297 authenticated: true,
298 required_query: &[],
299 required_headers: &[],
300 content_type: "",
301 accept: "application/json",
302 query_encoding: &[],
303};
304static OP_27: Operation = Operation {
305 id: "getOrganization",
306 method: "GET",
307 path: "/v1/organizations/{organization_id}",
308 authenticated: true,
309 required_query: &[],
310 required_headers: &[],
311 content_type: "",
312 accept: "application/json",
313 query_encoding: &[],
314};
315static OP_28: Operation = Operation {
316 id: "getPolicy",
317 method: "GET",
318 path: "/v1/policies/{policy_id}",
319 authenticated: true,
320 required_query: &[],
321 required_headers: &[],
322 content_type: "",
323 accept: "application/json",
324 query_encoding: &[],
325};
326static OP_29: Operation = Operation {
327 id: "getUser",
328 method: "GET",
329 path: "/v1/users/{user_id}",
330 authenticated: true,
331 required_query: &[],
332 required_headers: &[],
333 content_type: "",
334 accept: "application/json",
335 query_encoding: &[],
336};
337static OP_30: Operation = Operation {
338 id: "getUserInlinePolicy",
339 method: "GET",
340 path: "/v1/users/{user_id}/inline-policies/{policy_name}",
341 authenticated: true,
342 required_query: &[],
343 required_headers: &[],
344 content_type: "",
345 accept: "application/json",
346 query_encoding: &[],
347};
348static OP_31: Operation = Operation {
349 id: "getUserPermissionBoundary",
350 method: "GET",
351 path: "/v1/users/{user_id}/permission-boundary",
352 authenticated: true,
353 required_query: &[],
354 required_headers: &[],
355 content_type: "",
356 accept: "application/json",
357 query_encoding: &[],
358};
359static OP_32: Operation = Operation {
360 id: "listAccountRoleAssignments",
361 method: "GET",
362 path: "/v1/accounts/{account_id}/role-assignments",
363 authenticated: true,
364 required_query: &[],
365 required_headers: &[],
366 content_type: "",
367 accept: "application/json",
368 query_encoding: &[],
369};
370static OP_33: Operation = Operation {
371 id: "listAccountRoles",
372 method: "GET",
373 path: "/v1/account-roles",
374 authenticated: true,
375 required_query: &[],
376 required_headers: &[],
377 content_type: "",
378 accept: "application/json",
379 query_encoding: &[],
380};
381static OP_34: Operation = Operation {
382 id: "listAccounts",
383 method: "GET",
384 path: "/v1/accounts",
385 authenticated: true,
386 required_query: &[],
387 required_headers: &[],
388 content_type: "",
389 accept: "application/json",
390 query_encoding: &[
391 QueryEncoding {
392 name: "name",
393 style: "form",
394 explode: true,
395 },
396 QueryEncoding {
397 name: "crn",
398 style: "form",
399 explode: true,
400 },
401 QueryEncoding {
402 name: "limit",
403 style: "form",
404 explode: true,
405 },
406 QueryEncoding {
407 name: "marker",
408 style: "form",
409 explode: true,
410 },
411 ],
412};
413static OP_35: Operation = Operation {
414 id: "listGroupInlinePolicies",
415 method: "GET",
416 path: "/v1/groups/{group_id}/inline-policies",
417 authenticated: true,
418 required_query: &[],
419 required_headers: &[],
420 content_type: "",
421 accept: "application/json",
422 query_encoding: &[
423 QueryEncoding {
424 name: "name",
425 style: "form",
426 explode: true,
427 },
428 QueryEncoding {
429 name: "crn",
430 style: "form",
431 explode: true,
432 },
433 ],
434};
435static OP_36: Operation = Operation {
436 id: "listGroupPolicies",
437 method: "GET",
438 path: "/v1/groups/{group_id}/policies",
439 authenticated: true,
440 required_query: &[],
441 required_headers: &[],
442 content_type: "",
443 accept: "application/json",
444 query_encoding: &[
445 QueryEncoding {
446 name: "name",
447 style: "form",
448 explode: true,
449 },
450 QueryEncoding {
451 name: "crn",
452 style: "form",
453 explode: true,
454 },
455 ],
456};
457static OP_37: Operation = Operation {
458 id: "listGroupUsers",
459 method: "GET",
460 path: "/v1/groups/{group_id}/users",
461 authenticated: true,
462 required_query: &[],
463 required_headers: &[],
464 content_type: "",
465 accept: "application/json",
466 query_encoding: &[
467 QueryEncoding {
468 name: "name",
469 style: "form",
470 explode: true,
471 },
472 QueryEncoding {
473 name: "crn",
474 style: "form",
475 explode: true,
476 },
477 QueryEncoding {
478 name: "limit",
479 style: "form",
480 explode: true,
481 },
482 QueryEncoding {
483 name: "marker",
484 style: "form",
485 explode: true,
486 },
487 ],
488};
489static OP_38: Operation = Operation {
490 id: "listGroups",
491 method: "GET",
492 path: "/v1/groups",
493 authenticated: true,
494 required_query: &[],
495 required_headers: &[],
496 content_type: "",
497 accept: "application/json",
498 query_encoding: &[
499 QueryEncoding {
500 name: "name",
501 style: "form",
502 explode: true,
503 },
504 QueryEncoding {
505 name: "crn",
506 style: "form",
507 explode: true,
508 },
509 QueryEncoding {
510 name: "limit",
511 style: "form",
512 explode: true,
513 },
514 QueryEncoding {
515 name: "marker",
516 style: "form",
517 explode: true,
518 },
519 ],
520};
521static OP_39: Operation = Operation {
522 id: "listInvitations",
523 method: "GET",
524 path: "/v1/invitations",
525 authenticated: true,
526 required_query: &[],
527 required_headers: &[],
528 content_type: "",
529 accept: "application/json",
530 query_encoding: &[
531 QueryEncoding {
532 name: "name",
533 style: "form",
534 explode: true,
535 },
536 QueryEncoding {
537 name: "crn",
538 style: "form",
539 explode: true,
540 },
541 QueryEncoding {
542 name: "limit",
543 style: "form",
544 explode: true,
545 },
546 QueryEncoding {
547 name: "marker",
548 style: "form",
549 explode: true,
550 },
551 ],
552};
553static OP_40: Operation = Operation {
554 id: "listOrganizations",
555 method: "GET",
556 path: "/v1/organizations",
557 authenticated: true,
558 required_query: &[],
559 required_headers: &[],
560 content_type: "",
561 accept: "application/json",
562 query_encoding: &[
563 QueryEncoding {
564 name: "name",
565 style: "form",
566 explode: true,
567 },
568 QueryEncoding {
569 name: "crn",
570 style: "form",
571 explode: true,
572 },
573 QueryEncoding {
574 name: "limit",
575 style: "form",
576 explode: true,
577 },
578 QueryEncoding {
579 name: "marker",
580 style: "form",
581 explode: true,
582 },
583 ],
584};
585static OP_41: Operation = Operation {
586 id: "listPolicies",
587 method: "GET",
588 path: "/v1/policies",
589 authenticated: true,
590 required_query: &[],
591 required_headers: &[],
592 content_type: "",
593 accept: "application/json",
594 query_encoding: &[
595 QueryEncoding {
596 name: "name",
597 style: "form",
598 explode: true,
599 },
600 QueryEncoding {
601 name: "crn",
602 style: "form",
603 explode: true,
604 },
605 QueryEncoding {
606 name: "limit",
607 style: "form",
608 explode: true,
609 },
610 QueryEncoding {
611 name: "marker",
612 style: "form",
613 explode: true,
614 },
615 ],
616};
617static OP_42: Operation = Operation {
618 id: "listPolicyGroups",
619 method: "GET",
620 path: "/v1/policies/{policy_id}/groups",
621 authenticated: true,
622 required_query: &[],
623 required_headers: &[],
624 content_type: "",
625 accept: "application/json",
626 query_encoding: &[
627 QueryEncoding {
628 name: "name",
629 style: "form",
630 explode: true,
631 },
632 QueryEncoding {
633 name: "crn",
634 style: "form",
635 explode: true,
636 },
637 QueryEncoding {
638 name: "limit",
639 style: "form",
640 explode: true,
641 },
642 QueryEncoding {
643 name: "marker",
644 style: "form",
645 explode: true,
646 },
647 ],
648};
649static OP_43: Operation = Operation {
650 id: "listPolicyRoles",
651 method: "GET",
652 path: "/v1/policies/{policy_id}/roles",
653 authenticated: true,
654 required_query: &[],
655 required_headers: &[],
656 content_type: "",
657 accept: "application/json",
658 query_encoding: &[
659 QueryEncoding {
660 name: "name",
661 style: "form",
662 explode: true,
663 },
664 QueryEncoding {
665 name: "crn",
666 style: "form",
667 explode: true,
668 },
669 QueryEncoding {
670 name: "limit",
671 style: "form",
672 explode: true,
673 },
674 QueryEncoding {
675 name: "marker",
676 style: "form",
677 explode: true,
678 },
679 ],
680};
681static OP_44: Operation = Operation {
682 id: "listPolicyServiceAccounts",
683 method: "GET",
684 path: "/v1/policies/{policy_id}/service-accounts",
685 authenticated: true,
686 required_query: &[],
687 required_headers: &[],
688 content_type: "",
689 accept: "application/json",
690 query_encoding: &[
691 QueryEncoding {
692 name: "name",
693 style: "form",
694 explode: true,
695 },
696 QueryEncoding {
697 name: "crn",
698 style: "form",
699 explode: true,
700 },
701 QueryEncoding {
702 name: "limit",
703 style: "form",
704 explode: true,
705 },
706 QueryEncoding {
707 name: "marker",
708 style: "form",
709 explode: true,
710 },
711 ],
712};
713static OP_45: Operation = Operation {
714 id: "listPolicyUsers",
715 method: "GET",
716 path: "/v1/policies/{policy_id}/users",
717 authenticated: true,
718 required_query: &[],
719 required_headers: &[],
720 content_type: "",
721 accept: "application/json",
722 query_encoding: &[
723 QueryEncoding {
724 name: "name",
725 style: "form",
726 explode: true,
727 },
728 QueryEncoding {
729 name: "crn",
730 style: "form",
731 explode: true,
732 },
733 QueryEncoding {
734 name: "limit",
735 style: "form",
736 explode: true,
737 },
738 QueryEncoding {
739 name: "marker",
740 style: "form",
741 explode: true,
742 },
743 ],
744};
745static OP_46: Operation = Operation {
746 id: "listRolePolicies",
747 method: "GET",
748 path: "/v1/roles/{role_id}/policies",
749 authenticated: true,
750 required_query: &[],
751 required_headers: &[],
752 content_type: "",
753 accept: "application/json",
754 query_encoding: &[
755 QueryEncoding {
756 name: "name",
757 style: "form",
758 explode: true,
759 },
760 QueryEncoding {
761 name: "crn",
762 style: "form",
763 explode: true,
764 },
765 ],
766};
767static OP_47: Operation = Operation {
768 id: "listServiceAccountPolicies",
769 method: "GET",
770 path: "/v1/service-accounts/{service_account_id}/policies",
771 authenticated: true,
772 required_query: &[],
773 required_headers: &[],
774 content_type: "",
775 accept: "application/json",
776 query_encoding: &[
777 QueryEncoding {
778 name: "name",
779 style: "form",
780 explode: true,
781 },
782 QueryEncoding {
783 name: "crn",
784 style: "form",
785 explode: true,
786 },
787 ],
788};
789static OP_48: Operation = Operation {
790 id: "listUserGroups",
791 method: "GET",
792 path: "/v1/users/{user_id}/groups",
793 authenticated: true,
794 required_query: &[],
795 required_headers: &[],
796 content_type: "",
797 accept: "application/json",
798 query_encoding: &[
799 QueryEncoding {
800 name: "name",
801 style: "form",
802 explode: true,
803 },
804 QueryEncoding {
805 name: "crn",
806 style: "form",
807 explode: true,
808 },
809 ],
810};
811static OP_49: Operation = Operation {
812 id: "listUserInlinePolicies",
813 method: "GET",
814 path: "/v1/users/{user_id}/inline-policies",
815 authenticated: true,
816 required_query: &[],
817 required_headers: &[],
818 content_type: "",
819 accept: "application/json",
820 query_encoding: &[
821 QueryEncoding {
822 name: "name",
823 style: "form",
824 explode: true,
825 },
826 QueryEncoding {
827 name: "crn",
828 style: "form",
829 explode: true,
830 },
831 ],
832};
833static OP_50: Operation = Operation {
834 id: "listUserPolicies",
835 method: "GET",
836 path: "/v1/users/{user_id}/policies",
837 authenticated: true,
838 required_query: &[],
839 required_headers: &[],
840 content_type: "",
841 accept: "application/json",
842 query_encoding: &[
843 QueryEncoding {
844 name: "name",
845 style: "form",
846 explode: true,
847 },
848 QueryEncoding {
849 name: "crn",
850 style: "form",
851 explode: true,
852 },
853 ],
854};
855static OP_51: Operation = Operation {
856 id: "listUsers",
857 method: "GET",
858 path: "/v1/users",
859 authenticated: true,
860 required_query: &[],
861 required_headers: &[],
862 content_type: "",
863 accept: "application/json",
864 query_encoding: &[
865 QueryEncoding {
866 name: "name",
867 style: "form",
868 explode: true,
869 },
870 QueryEncoding {
871 name: "crn",
872 style: "form",
873 explode: true,
874 },
875 QueryEncoding {
876 name: "limit",
877 style: "form",
878 explode: true,
879 },
880 QueryEncoding {
881 name: "marker",
882 style: "form",
883 explode: true,
884 },
885 ],
886};
887static OP_52: Operation = Operation {
888 id: "putGroupInlinePolicy",
889 method: "PUT",
890 path: "/v1/groups/{group_id}/inline-policies/{policy_name}",
891 authenticated: true,
892 required_query: &[],
893 required_headers: &[],
894 content_type: "application/json",
895 accept: "application/json",
896 query_encoding: &[],
897};
898static OP_53: Operation = Operation {
899 id: "putUserInlinePolicy",
900 method: "PUT",
901 path: "/v1/users/{user_id}/inline-policies/{policy_name}",
902 authenticated: true,
903 required_query: &[],
904 required_headers: &[],
905 content_type: "application/json",
906 accept: "application/json",
907 query_encoding: &[],
908};
909static OP_54: Operation = Operation {
910 id: "removeAccountRoleAssignment",
911 method: "DELETE",
912 path: "/v1/accounts/{account_id}/role-assignments/{assignment_id}",
913 authenticated: true,
914 required_query: &[],
915 required_headers: &[],
916 content_type: "",
917 accept: "application/json",
918 query_encoding: &[],
919};
920static OP_55: Operation = Operation {
921 id: "removeUser",
922 method: "DELETE",
923 path: "/v1/users/{user_id}",
924 authenticated: true,
925 required_query: &[],
926 required_headers: &[],
927 content_type: "",
928 accept: "application/json",
929 query_encoding: &[],
930};
931static OP_56: Operation = Operation {
932 id: "removeUserFromGroup",
933 method: "DELETE",
934 path: "/v1/users/{user_id}/groups/{group_id}",
935 authenticated: true,
936 required_query: &[],
937 required_headers: &[],
938 content_type: "",
939 accept: "application/json",
940 query_encoding: &[],
941};
942static OP_57: Operation = Operation {
943 id: "removeUserPermissionBoundary",
944 method: "DELETE",
945 path: "/v1/users/{user_id}/permission-boundary",
946 authenticated: true,
947 required_query: &[],
948 required_headers: &[],
949 content_type: "",
950 accept: "application/json",
951 query_encoding: &[],
952};
953static OP_58: Operation = Operation {
954 id: "retryAccountProvisioning",
955 method: "POST",
956 path: "/v1/accounts/{account_id}/onboarding/retry",
957 authenticated: true,
958 required_query: &[],
959 required_headers: &[],
960 content_type: "",
961 accept: "application/json",
962 query_encoding: &[],
963};
964static OP_59: Operation = Operation {
965 id: "setUserPermissionBoundary",
966 method: "PUT",
967 path: "/v1/users/{user_id}/permission-boundary",
968 authenticated: true,
969 required_query: &[],
970 required_headers: &[],
971 content_type: "application/json",
972 accept: "application/json",
973 query_encoding: &[],
974};
975static OP_60: Operation = Operation {
976 id: "updateAccount",
977 method: "PATCH",
978 path: "/v1/accounts/{account_id}",
979 authenticated: true,
980 required_query: &[],
981 required_headers: &[],
982 content_type: "application/json",
983 accept: "application/json",
984 query_encoding: &[],
985};
986static OP_61: Operation = Operation {
987 id: "updateAccountOnboarding",
988 method: "PATCH",
989 path: "/v1/accounts/{account_id}/onboarding",
990 authenticated: true,
991 required_query: &[],
992 required_headers: &[],
993 content_type: "application/json",
994 accept: "application/json",
995 query_encoding: &[],
996};
997static OP_62: Operation = Operation {
998 id: "updateGroup",
999 method: "PATCH",
1000 path: "/v1/groups/{group_id}",
1001 authenticated: true,
1002 required_query: &[],
1003 required_headers: &[],
1004 content_type: "application/json",
1005 accept: "application/json",
1006 query_encoding: &[],
1007};
1008static OP_63: Operation = Operation {
1009 id: "updateOrganization",
1010 method: "PATCH",
1011 path: "/v1/organizations/{organization_id}",
1012 authenticated: true,
1013 required_query: &[],
1014 required_headers: &[],
1015 content_type: "application/json",
1016 accept: "application/json",
1017 query_encoding: &[],
1018};
1019static OP_64: Operation = Operation {
1020 id: "updatePolicy",
1021 method: "PATCH",
1022 path: "/v1/policies/{policy_id}",
1023 authenticated: true,
1024 required_query: &[],
1025 required_headers: &[],
1026 content_type: "application/json",
1027 accept: "application/json",
1028 query_encoding: &[],
1029};
1030#[derive(Clone, Debug)]
1031pub struct WorkspaceService {
1032 pub(crate) client: Client,
1033}
1034impl WorkspaceService {
1035 pub fn add_user(&self, body: &m::AddUserBody) -> Request<m::AddUserResponse> {
1037 Request::new(Core::new(
1038 self.client.clone(),
1039 "workspace",
1040 ENDPOINT,
1041 &OP_0,
1042 &[],
1043 Payload::json(body),
1044 Ok(serde_json::json!({})),
1045 ))
1046 }
1047 pub fn add_user_to_group(&self, user_id: &str, body: &m::AddUserToGroupBody) -> EmptyRequest {
1049 EmptyRequest::new(Core::new(
1050 self.client.clone(),
1051 "workspace",
1052 ENDPOINT,
1053 &OP_1,
1054 &[("user_id", user_id)],
1055 Payload::json(body),
1056 Ok(serde_json::json!({})),
1057 ))
1058 }
1059 pub fn assign_account_role(
1061 &self,
1062 account_id: &str,
1063 body: &m::AssignAccountRoleBody,
1064 ) -> Request<m::AssignAccountRoleResponse> {
1065 Request::new(Core::new(
1066 self.client.clone(),
1067 "workspace",
1068 ENDPOINT,
1069 &OP_2,
1070 &[("account_id", account_id)],
1071 Payload::json(body),
1072 Ok(serde_json::json!({})),
1073 ))
1074 }
1075 pub fn attach_group_policy(
1077 &self,
1078 group_id: &str,
1079 body: &m::AttachGroupPolicyBody,
1080 ) -> EmptyRequest {
1081 EmptyRequest::new(Core::new(
1082 self.client.clone(),
1083 "workspace",
1084 ENDPOINT,
1085 &OP_3,
1086 &[("group_id", group_id)],
1087 Payload::json(body),
1088 Ok(serde_json::json!({})),
1089 ))
1090 }
1091 pub fn attach_role_policy(
1093 &self,
1094 role_id: &str,
1095 body: &m::AttachRolePolicyBody,
1096 ) -> EmptyRequest {
1097 EmptyRequest::new(Core::new(
1098 self.client.clone(),
1099 "workspace",
1100 ENDPOINT,
1101 &OP_4,
1102 &[("role_id", role_id)],
1103 Payload::json(body),
1104 Ok(serde_json::json!({})),
1105 ))
1106 }
1107 pub fn attach_service_account_policy(
1109 &self,
1110 service_account_id: &str,
1111 body: &m::AttachServiceAccountPolicyBody,
1112 ) -> EmptyRequest {
1113 EmptyRequest::new(Core::new(
1114 self.client.clone(),
1115 "workspace",
1116 ENDPOINT,
1117 &OP_5,
1118 &[("service_account_id", service_account_id)],
1119 Payload::json(body),
1120 Ok(serde_json::json!({})),
1121 ))
1122 }
1123 pub fn attach_user_policy(
1125 &self,
1126 user_id: &str,
1127 body: &m::AttachUserPolicyBody,
1128 ) -> EmptyRequest {
1129 EmptyRequest::new(Core::new(
1130 self.client.clone(),
1131 "workspace",
1132 ENDPOINT,
1133 &OP_6,
1134 &[("user_id", user_id)],
1135 Payload::json(body),
1136 Ok(serde_json::json!({})),
1137 ))
1138 }
1139 pub fn cancel_invitation(&self, invitation_id: &str) -> EmptyRequest {
1141 EmptyRequest::new(Core::new(
1142 self.client.clone(),
1143 "workspace",
1144 ENDPOINT,
1145 &OP_7,
1146 &[("invitation_id", invitation_id)],
1147 Ok(Payload::Empty),
1148 Ok(serde_json::json!({})),
1149 ))
1150 }
1151 pub fn create_account(&self, body: &m::CreateAccountBody) -> Request<m::CreateAccountResponse> {
1153 Request::new(Core::new(
1154 self.client.clone(),
1155 "workspace",
1156 ENDPOINT,
1157 &OP_8,
1158 &[],
1159 Payload::json(body),
1160 Ok(serde_json::json!({})),
1161 ))
1162 }
1163 pub fn create_group(&self, body: &m::CreateGroupBody) -> Request<m::CreateGroupResponse> {
1165 Request::new(Core::new(
1166 self.client.clone(),
1167 "workspace",
1168 ENDPOINT,
1169 &OP_9,
1170 &[],
1171 Payload::json(body),
1172 Ok(serde_json::json!({})),
1173 ))
1174 }
1175 pub fn create_policy(&self, body: &m::CreatePolicyBody) -> Request<m::CreatePolicyResponse> {
1177 Request::new(Core::new(
1178 self.client.clone(),
1179 "workspace",
1180 ENDPOINT,
1181 &OP_10,
1182 &[],
1183 Payload::json(body),
1184 Ok(serde_json::json!({})),
1185 ))
1186 }
1187 pub fn delete_account(&self, account_id: &str) -> EmptyRequest {
1189 EmptyRequest::new(Core::new(
1190 self.client.clone(),
1191 "workspace",
1192 ENDPOINT,
1193 &OP_11,
1194 &[("account_id", account_id)],
1195 Ok(Payload::Empty),
1196 Ok(serde_json::json!({})),
1197 ))
1198 }
1199 pub fn delete_group(&self, group_id: &str) -> EmptyRequest {
1201 EmptyRequest::new(Core::new(
1202 self.client.clone(),
1203 "workspace",
1204 ENDPOINT,
1205 &OP_12,
1206 &[("group_id", group_id)],
1207 Ok(Payload::Empty),
1208 Ok(serde_json::json!({})),
1209 ))
1210 }
1211 pub fn delete_group_inline_policy(&self, group_id: &str, policy_name: &str) -> EmptyRequest {
1213 EmptyRequest::new(Core::new(
1214 self.client.clone(),
1215 "workspace",
1216 ENDPOINT,
1217 &OP_13,
1218 &[("group_id", group_id), ("policy_name", policy_name)],
1219 Ok(Payload::Empty),
1220 Ok(serde_json::json!({})),
1221 ))
1222 }
1223 pub fn delete_organization(&self, organization_id: &str) -> EmptyRequest {
1225 EmptyRequest::new(Core::new(
1226 self.client.clone(),
1227 "workspace",
1228 ENDPOINT,
1229 &OP_14,
1230 &[("organization_id", organization_id)],
1231 Ok(Payload::Empty),
1232 Ok(serde_json::json!({})),
1233 ))
1234 }
1235 pub fn delete_policy(&self, policy_id: &str) -> EmptyRequest {
1237 EmptyRequest::new(Core::new(
1238 self.client.clone(),
1239 "workspace",
1240 ENDPOINT,
1241 &OP_15,
1242 &[("policy_id", policy_id)],
1243 Ok(Payload::Empty),
1244 Ok(serde_json::json!({})),
1245 ))
1246 }
1247 pub fn delete_user_inline_policy(&self, user_id: &str, policy_name: &str) -> EmptyRequest {
1249 EmptyRequest::new(Core::new(
1250 self.client.clone(),
1251 "workspace",
1252 ENDPOINT,
1253 &OP_16,
1254 &[("user_id", user_id), ("policy_name", policy_name)],
1255 Ok(Payload::Empty),
1256 Ok(serde_json::json!({})),
1257 ))
1258 }
1259 pub fn detach_group_policy(&self, group_id: &str, policy_id: &str) -> EmptyRequest {
1261 EmptyRequest::new(Core::new(
1262 self.client.clone(),
1263 "workspace",
1264 ENDPOINT,
1265 &OP_17,
1266 &[("group_id", group_id), ("policy_id", policy_id)],
1267 Ok(Payload::Empty),
1268 Ok(serde_json::json!({})),
1269 ))
1270 }
1271 pub fn detach_role_policy(&self, role_id: &str, policy_id: &str) -> EmptyRequest {
1273 EmptyRequest::new(Core::new(
1274 self.client.clone(),
1275 "workspace",
1276 ENDPOINT,
1277 &OP_18,
1278 &[("role_id", role_id), ("policy_id", policy_id)],
1279 Ok(Payload::Empty),
1280 Ok(serde_json::json!({})),
1281 ))
1282 }
1283 pub fn detach_service_account_policy(
1285 &self,
1286 service_account_id: &str,
1287 policy_id: &str,
1288 ) -> EmptyRequest {
1289 EmptyRequest::new(Core::new(
1290 self.client.clone(),
1291 "workspace",
1292 ENDPOINT,
1293 &OP_19,
1294 &[
1295 ("service_account_id", service_account_id),
1296 ("policy_id", policy_id),
1297 ],
1298 Ok(Payload::Empty),
1299 Ok(serde_json::json!({})),
1300 ))
1301 }
1302 pub fn detach_user_policy(&self, user_id: &str, policy_id: &str) -> EmptyRequest {
1304 EmptyRequest::new(Core::new(
1305 self.client.clone(),
1306 "workspace",
1307 ENDPOINT,
1308 &OP_20,
1309 &[("user_id", user_id), ("policy_id", policy_id)],
1310 Ok(Payload::Empty),
1311 Ok(serde_json::json!({})),
1312 ))
1313 }
1314 pub fn get_account(&self, account_id: &str) -> Request<m::GetAccountResponse> {
1316 Request::new(Core::new(
1317 self.client.clone(),
1318 "workspace",
1319 ENDPOINT,
1320 &OP_21,
1321 &[("account_id", account_id)],
1322 Ok(Payload::Empty),
1323 Ok(serde_json::json!({})),
1324 ))
1325 }
1326 pub fn get_account_by_reference(
1328 &self,
1329 reference: &str,
1330 scope: &m::GetAccountScope,
1331 ) -> Request<m::GetAccountResource> {
1332 let (core, extract) = crate::request::reference_core(
1333 Core::new(
1334 self.client.clone(),
1335 "workspace",
1336 ENDPOINT,
1337 &OP_21,
1338 &[("account_id", reference)],
1339 Ok(Payload::Empty),
1340 Ok(serde_json::json!({})),
1341 ),
1342 Core::new(
1343 self.client.clone(),
1344 "workspace",
1345 ENDPOINT,
1346 &OP_34,
1347 &[],
1348 Ok(Payload::Empty),
1349 serde_json::to_value(scope).map_err(crate::Error::from),
1350 ),
1351 reference,
1352 true,
1353 Some("account"),
1354 "accounts",
1355 );
1356 Request::reference(core, extract)
1357 }
1358 pub fn get_account_onboarding(
1360 &self,
1361 account_id: &str,
1362 ) -> Request<m::GetAccountOnboardingResponse> {
1363 Request::new(Core::new(
1364 self.client.clone(),
1365 "workspace",
1366 ENDPOINT,
1367 &OP_22,
1368 &[("account_id", account_id)],
1369 Ok(Payload::Empty),
1370 Ok(serde_json::json!({})),
1371 ))
1372 }
1373 pub fn get_account_resources(
1375 &self,
1376 account_id: &str,
1377 ) -> Request<m::GetAccountResourcesResponse> {
1378 Request::new(Core::new(
1379 self.client.clone(),
1380 "workspace",
1381 ENDPOINT,
1382 &OP_23,
1383 &[("account_id", account_id)],
1384 Ok(Payload::Empty),
1385 Ok(serde_json::json!({})),
1386 ))
1387 }
1388 pub fn get_group(&self, group_id: &str) -> Request<m::GetGroupResponse> {
1390 Request::new(Core::new(
1391 self.client.clone(),
1392 "workspace",
1393 ENDPOINT,
1394 &OP_24,
1395 &[("group_id", group_id)],
1396 Ok(Payload::Empty),
1397 Ok(serde_json::json!({})),
1398 ))
1399 }
1400 pub fn get_group_by_reference(
1402 &self,
1403 reference: &str,
1404 scope: &m::GetGroupScope,
1405 ) -> Request<m::GetGroupResource> {
1406 let (core, extract) = crate::request::reference_core(
1407 Core::new(
1408 self.client.clone(),
1409 "workspace",
1410 ENDPOINT,
1411 &OP_24,
1412 &[("group_id", reference)],
1413 Ok(Payload::Empty),
1414 Ok(serde_json::json!({})),
1415 ),
1416 Core::new(
1417 self.client.clone(),
1418 "workspace",
1419 ENDPOINT,
1420 &OP_38,
1421 &[],
1422 Ok(Payload::Empty),
1423 serde_json::to_value(scope).map_err(crate::Error::from),
1424 ),
1425 reference,
1426 true,
1427 Some("group"),
1428 "groups",
1429 );
1430 Request::reference(core, extract)
1431 }
1432 pub fn get_group_inline_policy(
1434 &self,
1435 group_id: &str,
1436 policy_name: &str,
1437 ) -> Request<m::GetGroupInlinePolicyResponse> {
1438 Request::new(Core::new(
1439 self.client.clone(),
1440 "workspace",
1441 ENDPOINT,
1442 &OP_25,
1443 &[("group_id", group_id), ("policy_name", policy_name)],
1444 Ok(Payload::Empty),
1445 Ok(serde_json::json!({})),
1446 ))
1447 }
1448 pub fn get_group_inline_policy_by_reference(
1450 &self,
1451 group_id: &str,
1452 reference: &str,
1453 scope: &m::GetGroupInlinePolicyScope,
1454 ) -> Request<m::GetGroupInlinePolicyResource> {
1455 let (core, extract) = crate::request::reference_core(
1456 Core::new(
1457 self.client.clone(),
1458 "workspace",
1459 ENDPOINT,
1460 &OP_25,
1461 &[("group_id", group_id), ("policy_name", reference)],
1462 Ok(Payload::Empty),
1463 Ok(serde_json::json!({})),
1464 ),
1465 Core::new(
1466 self.client.clone(),
1467 "workspace",
1468 ENDPOINT,
1469 &OP_35,
1470 &[("group_id", group_id)],
1471 Ok(Payload::Empty),
1472 serde_json::to_value(scope).map_err(crate::Error::from),
1473 ),
1474 reference,
1475 true,
1476 Some("inline_policy"),
1477 "inline_policies",
1478 );
1479 Request::reference(core, extract)
1480 }
1481 pub fn get_invitation(&self, invitation_id: &str) -> Request<m::GetInvitationResponse> {
1483 Request::new(Core::new(
1484 self.client.clone(),
1485 "workspace",
1486 ENDPOINT,
1487 &OP_26,
1488 &[("invitation_id", invitation_id)],
1489 Ok(Payload::Empty),
1490 Ok(serde_json::json!({})),
1491 ))
1492 }
1493 pub fn get_invitation_by_reference(
1495 &self,
1496 reference: &str,
1497 scope: &m::GetInvitationScope,
1498 ) -> Request<m::GetInvitationResource> {
1499 let (core, extract) = crate::request::reference_core(
1500 Core::new(
1501 self.client.clone(),
1502 "workspace",
1503 ENDPOINT,
1504 &OP_26,
1505 &[("invitation_id", reference)],
1506 Ok(Payload::Empty),
1507 Ok(serde_json::json!({})),
1508 ),
1509 Core::new(
1510 self.client.clone(),
1511 "workspace",
1512 ENDPOINT,
1513 &OP_39,
1514 &[],
1515 Ok(Payload::Empty),
1516 serde_json::to_value(scope).map_err(crate::Error::from),
1517 ),
1518 reference,
1519 true,
1520 Some("invitation"),
1521 "invitations",
1522 );
1523 Request::reference(core, extract)
1524 }
1525 pub fn get_organization(&self, organization_id: &str) -> Request<m::GetOrganizationResponse> {
1527 Request::new(Core::new(
1528 self.client.clone(),
1529 "workspace",
1530 ENDPOINT,
1531 &OP_27,
1532 &[("organization_id", organization_id)],
1533 Ok(Payload::Empty),
1534 Ok(serde_json::json!({})),
1535 ))
1536 }
1537 pub fn get_organization_by_reference(
1539 &self,
1540 reference: &str,
1541 scope: &m::GetOrganizationScope,
1542 ) -> Request<m::GetOrganizationResource> {
1543 let (core, extract) = crate::request::reference_core(
1544 Core::new(
1545 self.client.clone(),
1546 "workspace",
1547 ENDPOINT,
1548 &OP_27,
1549 &[("organization_id", reference)],
1550 Ok(Payload::Empty),
1551 Ok(serde_json::json!({})),
1552 ),
1553 Core::new(
1554 self.client.clone(),
1555 "workspace",
1556 ENDPOINT,
1557 &OP_40,
1558 &[],
1559 Ok(Payload::Empty),
1560 serde_json::to_value(scope).map_err(crate::Error::from),
1561 ),
1562 reference,
1563 true,
1564 Some("organization"),
1565 "organizations",
1566 );
1567 Request::reference(core, extract)
1568 }
1569 pub fn get_policy(&self, policy_id: &str) -> Request<m::GetPolicyResponse> {
1571 Request::new(Core::new(
1572 self.client.clone(),
1573 "workspace",
1574 ENDPOINT,
1575 &OP_28,
1576 &[("policy_id", policy_id)],
1577 Ok(Payload::Empty),
1578 Ok(serde_json::json!({})),
1579 ))
1580 }
1581 pub fn get_policy_by_reference(
1583 &self,
1584 reference: &str,
1585 scope: &m::GetPolicyScope,
1586 ) -> Request<m::GetPolicyResource> {
1587 let (core, extract) = crate::request::reference_core(
1588 Core::new(
1589 self.client.clone(),
1590 "workspace",
1591 ENDPOINT,
1592 &OP_28,
1593 &[("policy_id", reference)],
1594 Ok(Payload::Empty),
1595 Ok(serde_json::json!({})),
1596 ),
1597 Core::new(
1598 self.client.clone(),
1599 "workspace",
1600 ENDPOINT,
1601 &OP_41,
1602 &[],
1603 Ok(Payload::Empty),
1604 serde_json::to_value(scope).map_err(crate::Error::from),
1605 ),
1606 reference,
1607 true,
1608 Some("policy"),
1609 "policies",
1610 );
1611 Request::reference(core, extract)
1612 }
1613 pub fn get_user(&self, user_id: &str) -> Request<m::GetUserResponse> {
1615 Request::new(Core::new(
1616 self.client.clone(),
1617 "workspace",
1618 ENDPOINT,
1619 &OP_29,
1620 &[("user_id", user_id)],
1621 Ok(Payload::Empty),
1622 Ok(serde_json::json!({})),
1623 ))
1624 }
1625 pub fn get_user_by_reference(
1627 &self,
1628 reference: &str,
1629 scope: &m::GetUserScope,
1630 ) -> Request<m::GetUserResource> {
1631 let (core, extract) = crate::request::reference_core(
1632 Core::new(
1633 self.client.clone(),
1634 "workspace",
1635 ENDPOINT,
1636 &OP_29,
1637 &[("user_id", reference)],
1638 Ok(Payload::Empty),
1639 Ok(serde_json::json!({})),
1640 ),
1641 Core::new(
1642 self.client.clone(),
1643 "workspace",
1644 ENDPOINT,
1645 &OP_51,
1646 &[],
1647 Ok(Payload::Empty),
1648 serde_json::to_value(scope).map_err(crate::Error::from),
1649 ),
1650 reference,
1651 true,
1652 Some("user"),
1653 "users",
1654 );
1655 Request::reference(core, extract)
1656 }
1657 pub fn get_user_inline_policy(
1659 &self,
1660 user_id: &str,
1661 policy_name: &str,
1662 ) -> Request<m::GetUserInlinePolicyResponse> {
1663 Request::new(Core::new(
1664 self.client.clone(),
1665 "workspace",
1666 ENDPOINT,
1667 &OP_30,
1668 &[("user_id", user_id), ("policy_name", policy_name)],
1669 Ok(Payload::Empty),
1670 Ok(serde_json::json!({})),
1671 ))
1672 }
1673 pub fn get_user_inline_policy_by_reference(
1675 &self,
1676 user_id: &str,
1677 reference: &str,
1678 scope: &m::GetUserInlinePolicyScope,
1679 ) -> Request<m::GetUserInlinePolicyResource> {
1680 let (core, extract) = crate::request::reference_core(
1681 Core::new(
1682 self.client.clone(),
1683 "workspace",
1684 ENDPOINT,
1685 &OP_30,
1686 &[("user_id", user_id), ("policy_name", reference)],
1687 Ok(Payload::Empty),
1688 Ok(serde_json::json!({})),
1689 ),
1690 Core::new(
1691 self.client.clone(),
1692 "workspace",
1693 ENDPOINT,
1694 &OP_49,
1695 &[("user_id", user_id)],
1696 Ok(Payload::Empty),
1697 serde_json::to_value(scope).map_err(crate::Error::from),
1698 ),
1699 reference,
1700 true,
1701 Some("inline_policy"),
1702 "inline_policies",
1703 );
1704 Request::reference(core, extract)
1705 }
1706 pub fn get_user_permission_boundary(
1708 &self,
1709 user_id: &str,
1710 ) -> Request<m::GetUserPermissionBoundaryResponse> {
1711 Request::new(Core::new(
1712 self.client.clone(),
1713 "workspace",
1714 ENDPOINT,
1715 &OP_31,
1716 &[("user_id", user_id)],
1717 Ok(Payload::Empty),
1718 Ok(serde_json::json!({})),
1719 ))
1720 }
1721 pub fn list_account_role_assignments(
1723 &self,
1724 account_id: &str,
1725 ) -> PagedRequest<m::ListAccountRoleAssignmentsResponse, m::ListAccountRoleAssignmentsItem>
1726 {
1727 PagedRequest::new(
1728 Core::new(
1729 self.client.clone(),
1730 "workspace",
1731 ENDPOINT,
1732 &OP_32,
1733 &[("account_id", account_id)],
1734 Ok(Payload::Empty),
1735 Ok(serde_json::json!({})),
1736 ),
1737 "role_assignments",
1738 )
1739 }
1740 pub fn list_account_roles(
1742 &self,
1743 ) -> PagedRequest<m::ListAccountRolesResponse, m::ListAccountRolesItem> {
1744 PagedRequest::new(
1745 Core::new(
1746 self.client.clone(),
1747 "workspace",
1748 ENDPOINT,
1749 &OP_33,
1750 &[],
1751 Ok(Payload::Empty),
1752 Ok(serde_json::json!({})),
1753 ),
1754 "account_roles",
1755 )
1756 }
1757 pub fn list_accounts(
1759 &self,
1760 query: &m::ListAccountsQuery,
1761 ) -> PagedRequest<m::ListAccountsResponse, m::ListAccountsItem> {
1762 PagedRequest::new(
1763 Core::new(
1764 self.client.clone(),
1765 "workspace",
1766 ENDPOINT,
1767 &OP_34,
1768 &[],
1769 Ok(Payload::Empty),
1770 serde_json::to_value(query).map_err(crate::Error::from),
1771 ),
1772 "accounts",
1773 )
1774 }
1775 pub fn list_group_inline_policies(
1777 &self,
1778 group_id: &str,
1779 query: &m::ListGroupInlinePoliciesQuery,
1780 ) -> PagedRequest<m::ListGroupInlinePoliciesResponse, m::ListGroupInlinePoliciesItem> {
1781 PagedRequest::new(
1782 Core::new(
1783 self.client.clone(),
1784 "workspace",
1785 ENDPOINT,
1786 &OP_35,
1787 &[("group_id", group_id)],
1788 Ok(Payload::Empty),
1789 serde_json::to_value(query).map_err(crate::Error::from),
1790 ),
1791 "inline_policies",
1792 )
1793 }
1794 pub fn list_group_policies(
1796 &self,
1797 group_id: &str,
1798 query: &m::ListGroupPoliciesQuery,
1799 ) -> PagedRequest<m::ListGroupPoliciesResponse, m::ListGroupPoliciesItem> {
1800 PagedRequest::new(
1801 Core::new(
1802 self.client.clone(),
1803 "workspace",
1804 ENDPOINT,
1805 &OP_36,
1806 &[("group_id", group_id)],
1807 Ok(Payload::Empty),
1808 serde_json::to_value(query).map_err(crate::Error::from),
1809 ),
1810 "policies",
1811 )
1812 }
1813 pub fn list_group_users(
1815 &self,
1816 group_id: &str,
1817 query: &m::ListGroupUsersQuery,
1818 ) -> PagedRequest<m::ListGroupUsersResponse, m::ListGroupUsersItem> {
1819 PagedRequest::new(
1820 Core::new(
1821 self.client.clone(),
1822 "workspace",
1823 ENDPOINT,
1824 &OP_37,
1825 &[("group_id", group_id)],
1826 Ok(Payload::Empty),
1827 serde_json::to_value(query).map_err(crate::Error::from),
1828 ),
1829 "users",
1830 )
1831 }
1832 pub fn list_groups(
1834 &self,
1835 query: &m::ListGroupsQuery,
1836 ) -> PagedRequest<m::ListGroupsResponse, m::ListGroupsItem> {
1837 PagedRequest::new(
1838 Core::new(
1839 self.client.clone(),
1840 "workspace",
1841 ENDPOINT,
1842 &OP_38,
1843 &[],
1844 Ok(Payload::Empty),
1845 serde_json::to_value(query).map_err(crate::Error::from),
1846 ),
1847 "groups",
1848 )
1849 }
1850 pub fn list_invitations(
1852 &self,
1853 query: &m::ListInvitationsQuery,
1854 ) -> PagedRequest<m::ListInvitationsResponse, m::ListInvitationsItem> {
1855 PagedRequest::new(
1856 Core::new(
1857 self.client.clone(),
1858 "workspace",
1859 ENDPOINT,
1860 &OP_39,
1861 &[],
1862 Ok(Payload::Empty),
1863 serde_json::to_value(query).map_err(crate::Error::from),
1864 ),
1865 "invitations",
1866 )
1867 }
1868 pub fn list_organizations(
1870 &self,
1871 query: &m::ListOrganizationsQuery,
1872 ) -> PagedRequest<m::ListOrganizationsResponse, m::ListOrganizationsItem> {
1873 PagedRequest::new(
1874 Core::new(
1875 self.client.clone(),
1876 "workspace",
1877 ENDPOINT,
1878 &OP_40,
1879 &[],
1880 Ok(Payload::Empty),
1881 serde_json::to_value(query).map_err(crate::Error::from),
1882 ),
1883 "organizations",
1884 )
1885 }
1886 pub fn list_policies(
1888 &self,
1889 query: &m::ListPoliciesQuery,
1890 ) -> PagedRequest<m::ListPoliciesResponse, m::ListPoliciesItem> {
1891 PagedRequest::new(
1892 Core::new(
1893 self.client.clone(),
1894 "workspace",
1895 ENDPOINT,
1896 &OP_41,
1897 &[],
1898 Ok(Payload::Empty),
1899 serde_json::to_value(query).map_err(crate::Error::from),
1900 ),
1901 "policies",
1902 )
1903 }
1904 pub fn list_policy_groups(
1906 &self,
1907 policy_id: &str,
1908 query: &m::ListPolicyGroupsQuery,
1909 ) -> PagedRequest<m::ListPolicyGroupsResponse, m::ListPolicyGroupsItem> {
1910 PagedRequest::new(
1911 Core::new(
1912 self.client.clone(),
1913 "workspace",
1914 ENDPOINT,
1915 &OP_42,
1916 &[("policy_id", policy_id)],
1917 Ok(Payload::Empty),
1918 serde_json::to_value(query).map_err(crate::Error::from),
1919 ),
1920 "groups",
1921 )
1922 }
1923 pub fn list_policy_roles(
1925 &self,
1926 policy_id: &str,
1927 query: &m::ListPolicyRolesQuery,
1928 ) -> PagedRequest<m::ListPolicyRolesResponse, m::ListPolicyRolesItem> {
1929 PagedRequest::new(
1930 Core::new(
1931 self.client.clone(),
1932 "workspace",
1933 ENDPOINT,
1934 &OP_43,
1935 &[("policy_id", policy_id)],
1936 Ok(Payload::Empty),
1937 serde_json::to_value(query).map_err(crate::Error::from),
1938 ),
1939 "roles",
1940 )
1941 }
1942 pub fn list_policy_service_accounts(
1944 &self,
1945 policy_id: &str,
1946 query: &m::ListPolicyServiceAccountsQuery,
1947 ) -> PagedRequest<m::ListPolicyServiceAccountsResponse, m::ListPolicyServiceAccountsItem> {
1948 PagedRequest::new(
1949 Core::new(
1950 self.client.clone(),
1951 "workspace",
1952 ENDPOINT,
1953 &OP_44,
1954 &[("policy_id", policy_id)],
1955 Ok(Payload::Empty),
1956 serde_json::to_value(query).map_err(crate::Error::from),
1957 ),
1958 "service_accounts",
1959 )
1960 }
1961 pub fn list_policy_users(
1963 &self,
1964 policy_id: &str,
1965 query: &m::ListPolicyUsersQuery,
1966 ) -> PagedRequest<m::ListPolicyUsersResponse, m::ListPolicyUsersItem> {
1967 PagedRequest::new(
1968 Core::new(
1969 self.client.clone(),
1970 "workspace",
1971 ENDPOINT,
1972 &OP_45,
1973 &[("policy_id", policy_id)],
1974 Ok(Payload::Empty),
1975 serde_json::to_value(query).map_err(crate::Error::from),
1976 ),
1977 "users",
1978 )
1979 }
1980 pub fn list_role_policies(
1982 &self,
1983 role_id: &str,
1984 query: &m::ListRolePoliciesQuery,
1985 ) -> PagedRequest<m::ListRolePoliciesResponse, m::ListRolePoliciesItem> {
1986 PagedRequest::new(
1987 Core::new(
1988 self.client.clone(),
1989 "workspace",
1990 ENDPOINT,
1991 &OP_46,
1992 &[("role_id", role_id)],
1993 Ok(Payload::Empty),
1994 serde_json::to_value(query).map_err(crate::Error::from),
1995 ),
1996 "policies",
1997 )
1998 }
1999 pub fn list_service_account_policies(
2001 &self,
2002 service_account_id: &str,
2003 query: &m::ListServiceAccountPoliciesQuery,
2004 ) -> PagedRequest<m::ListServiceAccountPoliciesResponse, m::ListServiceAccountPoliciesItem>
2005 {
2006 PagedRequest::new(
2007 Core::new(
2008 self.client.clone(),
2009 "workspace",
2010 ENDPOINT,
2011 &OP_47,
2012 &[("service_account_id", service_account_id)],
2013 Ok(Payload::Empty),
2014 serde_json::to_value(query).map_err(crate::Error::from),
2015 ),
2016 "policies",
2017 )
2018 }
2019 pub fn list_user_groups(
2021 &self,
2022 user_id: &str,
2023 query: &m::ListUserGroupsQuery,
2024 ) -> PagedRequest<m::ListUserGroupsResponse, m::ListUserGroupsItem> {
2025 PagedRequest::new(
2026 Core::new(
2027 self.client.clone(),
2028 "workspace",
2029 ENDPOINT,
2030 &OP_48,
2031 &[("user_id", user_id)],
2032 Ok(Payload::Empty),
2033 serde_json::to_value(query).map_err(crate::Error::from),
2034 ),
2035 "groups",
2036 )
2037 }
2038 pub fn list_user_inline_policies(
2040 &self,
2041 user_id: &str,
2042 query: &m::ListUserInlinePoliciesQuery,
2043 ) -> PagedRequest<m::ListUserInlinePoliciesResponse, m::ListUserInlinePoliciesItem> {
2044 PagedRequest::new(
2045 Core::new(
2046 self.client.clone(),
2047 "workspace",
2048 ENDPOINT,
2049 &OP_49,
2050 &[("user_id", user_id)],
2051 Ok(Payload::Empty),
2052 serde_json::to_value(query).map_err(crate::Error::from),
2053 ),
2054 "inline_policies",
2055 )
2056 }
2057 pub fn list_user_policies(
2059 &self,
2060 user_id: &str,
2061 query: &m::ListUserPoliciesQuery,
2062 ) -> PagedRequest<m::ListUserPoliciesResponse, m::ListUserPoliciesItem> {
2063 PagedRequest::new(
2064 Core::new(
2065 self.client.clone(),
2066 "workspace",
2067 ENDPOINT,
2068 &OP_50,
2069 &[("user_id", user_id)],
2070 Ok(Payload::Empty),
2071 serde_json::to_value(query).map_err(crate::Error::from),
2072 ),
2073 "policies",
2074 )
2075 }
2076 pub fn list_users(
2078 &self,
2079 query: &m::ListUsersQuery,
2080 ) -> PagedRequest<m::ListUsersResponse, m::ListUsersItem> {
2081 PagedRequest::new(
2082 Core::new(
2083 self.client.clone(),
2084 "workspace",
2085 ENDPOINT,
2086 &OP_51,
2087 &[],
2088 Ok(Payload::Empty),
2089 serde_json::to_value(query).map_err(crate::Error::from),
2090 ),
2091 "users",
2092 )
2093 }
2094 pub fn put_group_inline_policy(
2096 &self,
2097 group_id: &str,
2098 policy_name: &str,
2099 body: &m::PutGroupInlinePolicyBody,
2100 ) -> Request<m::PutGroupInlinePolicyResponse> {
2101 Request::new(Core::new(
2102 self.client.clone(),
2103 "workspace",
2104 ENDPOINT,
2105 &OP_52,
2106 &[("group_id", group_id), ("policy_name", policy_name)],
2107 Payload::json(body),
2108 Ok(serde_json::json!({})),
2109 ))
2110 }
2111 pub fn put_user_inline_policy(
2113 &self,
2114 user_id: &str,
2115 policy_name: &str,
2116 body: &m::PutUserInlinePolicyBody,
2117 ) -> Request<m::PutUserInlinePolicyResponse> {
2118 Request::new(Core::new(
2119 self.client.clone(),
2120 "workspace",
2121 ENDPOINT,
2122 &OP_53,
2123 &[("user_id", user_id), ("policy_name", policy_name)],
2124 Payload::json(body),
2125 Ok(serde_json::json!({})),
2126 ))
2127 }
2128 pub fn remove_account_role_assignment(
2130 &self,
2131 account_id: &str,
2132 assignment_id: &str,
2133 ) -> EmptyRequest {
2134 EmptyRequest::new(Core::new(
2135 self.client.clone(),
2136 "workspace",
2137 ENDPOINT,
2138 &OP_54,
2139 &[("account_id", account_id), ("assignment_id", assignment_id)],
2140 Ok(Payload::Empty),
2141 Ok(serde_json::json!({})),
2142 ))
2143 }
2144 pub fn remove_user(&self, user_id: &str) -> EmptyRequest {
2146 EmptyRequest::new(Core::new(
2147 self.client.clone(),
2148 "workspace",
2149 ENDPOINT,
2150 &OP_55,
2151 &[("user_id", user_id)],
2152 Ok(Payload::Empty),
2153 Ok(serde_json::json!({})),
2154 ))
2155 }
2156 pub fn remove_user_from_group(&self, user_id: &str, group_id: &str) -> EmptyRequest {
2158 EmptyRequest::new(Core::new(
2159 self.client.clone(),
2160 "workspace",
2161 ENDPOINT,
2162 &OP_56,
2163 &[("user_id", user_id), ("group_id", group_id)],
2164 Ok(Payload::Empty),
2165 Ok(serde_json::json!({})),
2166 ))
2167 }
2168 pub fn remove_user_permission_boundary(&self, user_id: &str) -> EmptyRequest {
2170 EmptyRequest::new(Core::new(
2171 self.client.clone(),
2172 "workspace",
2173 ENDPOINT,
2174 &OP_57,
2175 &[("user_id", user_id)],
2176 Ok(Payload::Empty),
2177 Ok(serde_json::json!({})),
2178 ))
2179 }
2180 pub fn retry_account_provisioning(
2182 &self,
2183 account_id: &str,
2184 ) -> Request<m::RetryAccountProvisioningResponse> {
2185 Request::new(Core::new(
2186 self.client.clone(),
2187 "workspace",
2188 ENDPOINT,
2189 &OP_58,
2190 &[("account_id", account_id)],
2191 Ok(Payload::Empty),
2192 Ok(serde_json::json!({})),
2193 ))
2194 }
2195 pub fn set_user_permission_boundary(
2197 &self,
2198 user_id: &str,
2199 body: &m::SetUserPermissionBoundaryBody,
2200 ) -> EmptyRequest {
2201 EmptyRequest::new(Core::new(
2202 self.client.clone(),
2203 "workspace",
2204 ENDPOINT,
2205 &OP_59,
2206 &[("user_id", user_id)],
2207 Payload::json(body),
2208 Ok(serde_json::json!({})),
2209 ))
2210 }
2211 pub fn update_account(
2213 &self,
2214 account_id: &str,
2215 body: &m::UpdateAccountBody,
2216 ) -> Request<m::UpdateAccountResponse> {
2217 Request::new(Core::new(
2218 self.client.clone(),
2219 "workspace",
2220 ENDPOINT,
2221 &OP_60,
2222 &[("account_id", account_id)],
2223 Payload::json(body),
2224 Ok(serde_json::json!({})),
2225 ))
2226 }
2227 pub fn update_account_onboarding(
2229 &self,
2230 account_id: &str,
2231 body: &m::UpdateAccountOnboardingBody,
2232 ) -> Request<m::UpdateAccountOnboardingResponse> {
2233 Request::new(Core::new(
2234 self.client.clone(),
2235 "workspace",
2236 ENDPOINT,
2237 &OP_61,
2238 &[("account_id", account_id)],
2239 Payload::json(body),
2240 Ok(serde_json::json!({})),
2241 ))
2242 }
2243 pub fn update_group(
2245 &self,
2246 group_id: &str,
2247 body: &m::UpdateGroupBody,
2248 ) -> Request<m::UpdateGroupResponse> {
2249 Request::new(Core::new(
2250 self.client.clone(),
2251 "workspace",
2252 ENDPOINT,
2253 &OP_62,
2254 &[("group_id", group_id)],
2255 Payload::json(body),
2256 Ok(serde_json::json!({})),
2257 ))
2258 }
2259 pub fn update_organization(
2261 &self,
2262 organization_id: &str,
2263 body: &m::UpdateOrganizationBody,
2264 ) -> Request<m::UpdateOrganizationResponse> {
2265 Request::new(Core::new(
2266 self.client.clone(),
2267 "workspace",
2268 ENDPOINT,
2269 &OP_63,
2270 &[("organization_id", organization_id)],
2271 Payload::json(body),
2272 Ok(serde_json::json!({})),
2273 ))
2274 }
2275 pub fn update_policy(
2277 &self,
2278 policy_id: &str,
2279 body: &m::UpdatePolicyBody,
2280 ) -> Request<m::UpdatePolicyResponse> {
2281 Request::new(Core::new(
2282 self.client.clone(),
2283 "workspace",
2284 ENDPOINT,
2285 &OP_64,
2286 &[("policy_id", policy_id)],
2287 Payload::json(body),
2288 Ok(serde_json::json!({})),
2289 ))
2290 }
2291}