Skip to main content

basaltic/services/
workspace.rs

1//! Generated API methods; do not edit.
2#![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    /// Add user to organization
1036    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    /// Add user to group
1048    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    /// Assign account role
1060    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    /// Attach policy to group
1076    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    /// Attach policy to role
1092    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    /// Attach policy to service account
1108    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    /// Attach policy to user
1124    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    /// Cancel invitation
1140    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    /// Create account
1152    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    /// Create group
1164    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    /// Create policy
1176    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    /// Delete account
1188    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    /// Delete group
1200    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    /// Delete a group's inline policy by name
1212    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    /// Delete organization
1224    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    /// Delete policy
1236    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    /// Delete a user's inline policy by name
1248    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    /// Detach policy from group
1260    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    /// Detach policy from role
1272    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    /// Detach policy from service account
1284    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    /// Detach policy from user
1303    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    /// Get account
1315    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1327    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    /// Get shared account setup progress
1359    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    /// Check account resource presence
1374    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    /// Get group
1389    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1401    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    /// Get a group's inline policy by name
1433    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1449    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    /// Get invitation
1482    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1494    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    /// Get organization
1526    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1538    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    /// Get policy
1570    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1582    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    /// Get user
1614    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1626    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    /// Get a user's inline policy by name
1658    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    /// Resolve one resource by UUID, CRN, or an unambiguous name.
1674    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    /// Get a user's permission boundary
1707    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    /// List account role assignments
1722    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    /// List assigned account roles
1741    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    /// List accounts
1758    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    /// List a group's inline policies
1776    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    /// List group policies
1795    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    /// List group users
1814    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    /// List groups
1833    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    /// List invitations
1851    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    /// List organizations
1869    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    /// List policies
1887    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    /// List groups with policy
1905    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    /// List roles with policy
1924    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    /// List service accounts with policy
1943    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    /// List users with policy
1962    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    /// List role policies
1981    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    /// List service account policies
2000    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    /// List user groups
2020    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    /// List a user's inline policies
2039    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    /// List user policies
2058    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    /// List users
2077    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    /// Create or replace a group's inline policy
2095    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    /// Create or replace a user's inline policy
2112    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    /// Remove account role assignment
2129    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    /// Remove user from organization
2145    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    /// Remove user from group
2157    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    /// Remove a user's permission boundary
2169    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    /// Resume failed default network provisioning
2181    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    /// Set a user's permission boundary
2196    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    /// Update account
2212    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    /// Update shared account guide preferences
2228    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    /// Update group
2244    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    /// Update organization
2260    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    /// Update policy
2276    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}