1#![recursion_limit = "1024"]
3pub mod request_types;
4pub mod schemas;
5use request_types::*;
6use reqwest::blocking::Client as ReqwestClient;
7use reqwest::Error as ReqwestError;
8use schemas::*;
9
10#[derive(Clone, Debug)]
11pub struct SidekoClient {
12 pub client: ReqwestClient,
13 pub base_url: String,
14}
15
16#[derive(Debug, thiserror::Error)]
17pub enum CannotFormRequest {
18 #[error("Invalid data provided: {input}")]
19 InvalidArguments { input: String },
20 #[error("Unknown error forming the request")]
21 UnknownError { msg: String },
22}
23
24#[derive(Clone, Debug)]
25pub struct ErrorResponse {
26 pub status_code: u16,
27 pub message: String,
28}
29
30#[derive(Clone, Debug)]
31pub enum Error {
32 CannotFormRequest,
33 ErrorResponse(ErrorResponse),
34}
35
36impl SidekoClient {
37 pub fn new(api_key: String) -> Result<Self, ReqwestError> {
38 let base_url = "https://api.getpostman.com".to_string();
39
40 let mut default_headers = reqwest::header::HeaderMap::new();
41 default_headers.insert(
43 "x-api-key",
44 reqwest::header::HeaderValue::from_str(&api_key).expect("Must provide API key"),
45 );
46
47 let client = ReqwestClient::builder()
48 .default_headers(default_headers)
49 .build()?;
50
51 Ok(Self {
52 client,
53 base_url,
54
55 })
56 }
57
58 pub fn delete_api(&self, request: DeleteApisApiIdRequest) -> Result<serde_json::Value, Error> {
59 let endpoint = format!("/apis/{}", request.api_id);
60 let url = format!("{}{}", self.base_url, endpoint);
61
62 let mut query_params: Vec<(&str, String)> = vec![];
63
64 let response = self
65 .client
66 .delete(url)
67 .query(&query_params)
68
69 .send()
70 .unwrap();
71
72 if response.status().is_success() {
73 let response: serde_json::Value = response.json().unwrap();
74 Ok(response)
75 } else {
76 let status_code = response.status().as_u16();
77 let message = response.text().unwrap_or_default();
78 let err = ErrorResponse { status_code, message };
79 Err(Error::ErrorResponse(err))
80 }
81 }
82 pub fn delete_schema_file(&self, request: DeleteApisApiIdSchemasSchemaIdFilesFilePathRequest) -> Result<serde_json::Value, Error> {
83 let endpoint = format!("/apis/{}/schemas/{}/files/{}", request.api_id, request.schema_id, request.file_path);
84 let url = format!("{}{}", self.base_url, endpoint);
85
86 let mut query_params: Vec<(&str, String)> = vec![];
87
88 let response = self
89 .client
90 .delete(url)
91 .query(&query_params)
92
93 .send()
94 .unwrap();
95
96 if response.status().is_success() {
97 let response: serde_json::Value = response.json().unwrap();
98 Ok(response)
99 } else {
100 let status_code = response.status().as_u16();
101 let message = response.text().unwrap_or_default();
102 let err = ErrorResponse { status_code, message };
103 Err(Error::ErrorResponse(err))
104 }
105 }
106 pub fn delete_api_version(&self, request: DeleteApisApiIdVersionsVersionIdRequest) -> Result<serde_json::Value, Error> {
107 let endpoint = format!("/apis/{}/versions/{}", request.api_id, request.version_id);
108 let url = format!("{}{}", self.base_url, endpoint);
109
110 let mut query_params: Vec<(&str, String)> = vec![];
111
112 let response = self
113 .client
114 .delete(url)
115 .query(&query_params)
116
117 .send()
118 .unwrap();
119
120 if response.status().is_success() {
121 let response: serde_json::Value = response.json().unwrap();
122 Ok(response)
123 } else {
124 let status_code = response.status().as_u16();
125 let message = response.text().unwrap_or_default();
126 let err = ErrorResponse { status_code, message };
127 Err(Error::ErrorResponse(err))
128 }
129 }
130 pub fn delete_collection(&self, request: DeleteCollectionsCollectionIdRequest) -> Result<DeleteCollectionsCollectionIdResponse, Error> {
131 let endpoint = format!("/collections/{}", request.collection_id);
132 let url = format!("{}{}", self.base_url, endpoint);
133
134 let mut query_params: Vec<(&str, String)> = vec![];
135
136 let response = self
137 .client
138 .delete(url)
139 .query(&query_params)
140
141 .send()
142 .unwrap();
143
144 if response.status().is_success() {
145 let response: DeleteCollectionsCollectionIdResponse = response.json().unwrap();
146 Ok(response)
147 } else {
148 let status_code = response.status().as_u16();
149 let message = response.text().unwrap_or_default();
150 let err = ErrorResponse { status_code, message };
151 Err(Error::ErrorResponse(err))
152 }
153 }
154 pub fn delete_collection_folder(&self, request: DeleteCollectionsCollectionIdFoldersFolderIdRequest) -> Result<DeleteCollectionsCollectionIdFoldersFolderIdResponse, Error> {
155 let endpoint = format!("/collections/{}/folders/{}", request.collection_id, request.folder_id);
156 let url = format!("{}{}", self.base_url, endpoint);
157
158 let mut query_params: Vec<(&str, String)> = vec![];
159
160 let response = self
161 .client
162 .delete(url)
163 .query(&query_params)
164
165 .send()
166 .unwrap();
167
168 if response.status().is_success() {
169 let response: DeleteCollectionsCollectionIdFoldersFolderIdResponse = response.json().unwrap();
170 Ok(response)
171 } else {
172 let status_code = response.status().as_u16();
173 let message = response.text().unwrap_or_default();
174 let err = ErrorResponse { status_code, message };
175 Err(Error::ErrorResponse(err))
176 }
177 }
178 pub fn delete_collection_request(&self, request: DeleteCollectionsCollectionIdRequestsRequestIdRequest) -> Result<DeleteCollectionsCollectionIdRequestsRequestIdResponse, Error> {
179 let endpoint = format!("/collections/{}/requests/{}", request.collection_id, request.request_id);
180 let url = format!("{}{}", self.base_url, endpoint);
181
182 let mut query_params: Vec<(&str, String)> = vec![];
183
184 let response = self
185 .client
186 .delete(url)
187 .query(&query_params)
188
189 .send()
190 .unwrap();
191
192 if response.status().is_success() {
193 let response: DeleteCollectionsCollectionIdRequestsRequestIdResponse = response.json().unwrap();
194 Ok(response)
195 } else {
196 let status_code = response.status().as_u16();
197 let message = response.text().unwrap_or_default();
198 let err = ErrorResponse { status_code, message };
199 Err(Error::ErrorResponse(err))
200 }
201 }
202 pub fn delete_collection_response(&self, request: DeleteCollectionsCollectionIdResponsesResponseIdRequest) -> Result<DeleteCollectionsCollectionIdResponsesResponseIdResponse, Error> {
203 let endpoint = format!("/collections/{}/responses/{}", request.collection_id, request.response_id);
204 let url = format!("{}{}", self.base_url, endpoint);
205
206 let mut query_params: Vec<(&str, String)> = vec![];
207
208 let response = self
209 .client
210 .delete(url)
211 .query(&query_params)
212
213 .send()
214 .unwrap();
215
216 if response.status().is_success() {
217 let response: DeleteCollectionsCollectionIdResponsesResponseIdResponse = response.json().unwrap();
218 Ok(response)
219 } else {
220 let status_code = response.status().as_u16();
221 let message = response.text().unwrap_or_default();
222 let err = ErrorResponse { status_code, message };
223 Err(Error::ErrorResponse(err))
224 }
225 }
226 pub fn delete_environment(&self, request: DeleteEnvironmentsEnvironmentIdRequest) -> Result<DeleteEnvironmentsEnvironmentIdResponse, Error> {
227 let endpoint = format!("/environments/{}", request.environment_id);
228 let url = format!("{}{}", self.base_url, endpoint);
229
230 let mut query_params: Vec<(&str, String)> = vec![];
231
232 let response = self
233 .client
234 .delete(url)
235 .query(&query_params)
236
237 .send()
238 .unwrap();
239
240 if response.status().is_success() {
241 let response: DeleteEnvironmentsEnvironmentIdResponse = response.json().unwrap();
242 Ok(response)
243 } else {
244 let status_code = response.status().as_u16();
245 let message = response.text().unwrap_or_default();
246 let err = ErrorResponse { status_code, message };
247 Err(Error::ErrorResponse(err))
248 }
249 }
250 pub fn delete_mock(&self, request: DeleteMocksMockIdRequest) -> Result<DeleteMocksMockIdResponse, Error> {
251 let endpoint = format!("/mocks/{}", request.mock_id);
252 let url = format!("{}{}", self.base_url, endpoint);
253
254 let mut query_params: Vec<(&str, String)> = vec![];
255
256 let response = self
257 .client
258 .delete(url)
259 .query(&query_params)
260
261 .send()
262 .unwrap();
263
264 if response.status().is_success() {
265 let response: DeleteMocksMockIdResponse = response.json().unwrap();
266 Ok(response)
267 } else {
268 let status_code = response.status().as_u16();
269 let message = response.text().unwrap_or_default();
270 let err = ErrorResponse { status_code, message };
271 Err(Error::ErrorResponse(err))
272 }
273 }
274 pub fn delete_mock_server_response(&self, request: DeleteMocksMockIdServerResponsesServerResponseIdRequest) -> Result<DeleteMocksMockIdServerResponsesServerResponseIdResponse, Error> {
275 let endpoint = format!("/mocks/{}/server-responses/{}", request.mock_id, request.server_response_id);
276 let url = format!("{}{}", self.base_url, endpoint);
277
278 let mut query_params: Vec<(&str, String)> = vec![];
279
280 let response = self
281 .client
282 .delete(url)
283 .query(&query_params)
284
285 .send()
286 .unwrap();
287
288 if response.status().is_success() {
289 let response: DeleteMocksMockIdServerResponsesServerResponseIdResponse = response.json().unwrap();
290 Ok(response)
291 } else {
292 let status_code = response.status().as_u16();
293 let message = response.text().unwrap_or_default();
294 let err = ErrorResponse { status_code, message };
295 Err(Error::ErrorResponse(err))
296 }
297 }
298 pub fn unpublish_mock(&self, request: DeleteMocksMockIdUnpublishRequest) -> Result<DeleteMocksMockIdUnpublishResponse, Error> {
299 let endpoint = format!("/mocks/{}/unpublish", request.mock_id);
300 let url = format!("{}{}", self.base_url, endpoint);
301
302 let mut query_params: Vec<(&str, String)> = vec![];
303
304 let response = self
305 .client
306 .delete(url)
307 .query(&query_params)
308
309 .send()
310 .unwrap();
311
312 if response.status().is_success() {
313 let response: DeleteMocksMockIdUnpublishResponse = response.json().unwrap();
314 Ok(response)
315 } else {
316 let status_code = response.status().as_u16();
317 let message = response.text().unwrap_or_default();
318 let err = ErrorResponse { status_code, message };
319 Err(Error::ErrorResponse(err))
320 }
321 }
322 pub fn delete_monitor(&self, request: DeleteMonitorsMonitorIdRequest) -> Result<DeleteMonitorsMonitorIdResponse, Error> {
323 let endpoint = format!("/monitors/{}", request.monitor_id);
324 let url = format!("{}{}", self.base_url, endpoint);
325
326 let mut query_params: Vec<(&str, String)> = vec![];
327
328 let response = self
329 .client
330 .delete(url)
331 .query(&query_params)
332
333 .send()
334 .unwrap();
335
336 if response.status().is_success() {
337 let response: DeleteMonitorsMonitorIdResponse = response.json().unwrap();
338 Ok(response)
339 } else {
340 let status_code = response.status().as_u16();
341 let message = response.text().unwrap_or_default();
342 let err = ErrorResponse { status_code, message };
343 Err(Error::ErrorResponse(err))
344 }
345 }
346 pub fn remove_element_or_folder(&self, request: DeleteNetworkPrivateElementTypeElementIdRequest) -> Result<DeleteNetworkPrivateElementTypeElementIdResponse, Error> {
347 let endpoint = format!("/network/private/{}/{}", request.element_type, request.element_id);
348 let url = format!("{}{}", self.base_url, endpoint);
349
350 let mut query_params: Vec<(&str, String)> = vec![];
351
352 let response = self
353 .client
354 .delete(url)
355 .query(&query_params)
356
357 .send()
358 .unwrap();
359
360 if response.status().is_success() {
361 let response: DeleteNetworkPrivateElementTypeElementIdResponse = response.json().unwrap();
362 Ok(response)
363 } else {
364 let status_code = response.status().as_u16();
365 let message = response.text().unwrap_or_default();
366 let err = ErrorResponse { status_code, message };
367 Err(Error::ErrorResponse(err))
368 }
369 }
370 pub fn delete_group(&self, request: DeleteScimV2GroupsGroupIdRequest) -> Result<serde_json::Value, Error> {
371 let endpoint = format!("/scim/v2/Groups/{}", request.group_id);
372 let url = format!("{}{}", self.base_url, endpoint);
373
374 let mut query_params: Vec<(&str, String)> = vec![];
375
376 let response = self
377 .client
378 .delete(url)
379 .query(&query_params)
380
381 .send()
382 .unwrap();
383
384 if response.status().is_success() {
385 let response: serde_json::Value = response.json().unwrap();
386 Ok(response)
387 } else {
388 let status_code = response.status().as_u16();
389 let message = response.text().unwrap_or_default();
390 let err = ErrorResponse { status_code, message };
391 Err(Error::ErrorResponse(err))
392 }
393 }
394 pub fn delete_workspace(&self, request: DeleteWorkspacesWorkspaceIdRequest) -> Result<DeleteWorkspacesWorkspaceIdResponse, Error> {
395 let endpoint = format!("/workspaces/{}", request.workspace_id);
396 let url = format!("{}{}", self.base_url, endpoint);
397
398 let mut query_params: Vec<(&str, String)> = vec![];
399
400 let response = self
401 .client
402 .delete(url)
403 .query(&query_params)
404
405 .send()
406 .unwrap();
407
408 if response.status().is_success() {
409 let response: DeleteWorkspacesWorkspaceIdResponse = response.json().unwrap();
410 Ok(response)
411 } else {
412 let status_code = response.status().as_u16();
413 let message = response.text().unwrap_or_default();
414 let err = ErrorResponse { status_code, message };
415 Err(Error::ErrorResponse(err))
416 }
417 }
418 pub fn get_all_apis(&self, request: GetApisRequest) -> Result<GetApisResponse, Error> {
419 let endpoint = "/apis";
420 let url = format!("{}{}", self.base_url, endpoint);
421
422 let mut query_params: Vec<(&str, String)> = vec![];
423 query_params.push(("workspace_id", format!("{:?}", &request.workspace_id)));
424 if let Some(created_by) = request.created_by {
425 query_params.push(("created_by", format!("{:?}", &created_by)));
426 }
427 if let Some(cursor) = request.cursor {
428 query_params.push(("cursor", format!("{:?}", &cursor)));
429 }
430 if let Some(description) = request.description {
431 query_params.push(("description", format!("{:?}", &description)));
432 }
433 if let Some(limit) = request.limit {
434 query_params.push(("limit", format!("{:?}", &limit)));
435 }
436
437 let response = self
438 .client
439 .get(url)
440 .query(&query_params)
441
442 .send()
443 .unwrap();
444
445 if response.status().is_success() {
446 let response: GetApisResponse = response.json().unwrap();
447 Ok(response)
448 } else {
449 let status_code = response.status().as_u16();
450 let message = response.text().unwrap_or_default();
451 let err = ErrorResponse { status_code, message };
452 Err(Error::ErrorResponse(err))
453 }
454 }
455 pub fn get_an_api(&self, request: GetApisApiIdRequest) -> Result<serde_json::Value, Error> {
456 let endpoint = format!("/apis/{}", request.api_id);
457 let url = format!("{}{}", self.base_url, endpoint);
458
459 let mut query_params: Vec<(&str, String)> = vec![];
460 if let Some(include) = request.include {
461 query_params.push(("include", format!("{:?}", &include)));
462 }
463
464 let response = self
465 .client
466 .get(url)
467 .query(&query_params)
468
469 .send()
470 .unwrap();
471
472 if response.status().is_success() {
473 let response: serde_json::Value = response.json().unwrap();
474 Ok(response)
475 } else {
476 let status_code = response.status().as_u16();
477 let message = response.text().unwrap_or_default();
478 let err = ErrorResponse { status_code, message };
479 Err(Error::ErrorResponse(err))
480 }
481 }
482 pub fn get_collection(&self, request: GetApisApiIdCollectionsCollectionIdRequest) -> Result<GetApisApiIdCollectionsCollectionIdResponse, Error> {
483 let endpoint = format!("/apis/{}/collections/{}", request.api_id, request.collection_id);
484 let url = format!("{}{}", self.base_url, endpoint);
485
486 let mut query_params: Vec<(&str, String)> = vec![];
487 if let Some(version_id) = request.version_id {
488 query_params.push(("version_id", format!("{:?}", &version_id)));
489 }
490
491 let response = self
492 .client
493 .get(url)
494 .query(&query_params)
495
496 .send()
497 .unwrap();
498
499 if response.status().is_success() {
500 let response: GetApisApiIdCollectionsCollectionIdResponse = response.json().unwrap();
501 Ok(response)
502 } else {
503 let status_code = response.status().as_u16();
504 let message = response.text().unwrap_or_default();
505 let err = ErrorResponse { status_code, message };
506 Err(Error::ErrorResponse(err))
507 }
508 }
509 pub fn get_schema(&self, request: GetApisApiIdSchemasSchemaIdRequest) -> Result<serde_json::Value, Error> {
510 let endpoint = format!("/apis/{}/schemas/{}", request.api_id, request.schema_id);
511 let url = format!("{}{}", self.base_url, endpoint);
512
513 let mut query_params: Vec<(&str, String)> = vec![];
514 if let Some(bundled) = request.bundled {
515 query_params.push(("bundled", format!("{:?}", &bundled)));
516 }
517 if let Some(version_id) = request.version_id {
518 query_params.push(("version_id", format!("{:?}", &version_id)));
519 }
520
521 let response = self
522 .client
523 .get(url)
524 .query(&query_params)
525
526 .send()
527 .unwrap();
528
529 if response.status().is_success() {
530 let response: serde_json::Value = response.json().unwrap();
531 Ok(response)
532 } else {
533 let status_code = response.status().as_u16();
534 let message = response.text().unwrap_or_default();
535 let err = ErrorResponse { status_code, message };
536 Err(Error::ErrorResponse(err))
537 }
538 }
539 pub fn get_schema_files(&self, request: GetApisApiIdSchemasSchemaIdFilesRequest) -> Result<GetApisApiIdSchemasSchemaIdFilesResponse, Error> {
540 let endpoint = format!("/apis/{}/schemas/{}/files", request.api_id, request.schema_id);
541 let url = format!("{}{}", self.base_url, endpoint);
542
543 let mut query_params: Vec<(&str, String)> = vec![];
544 if let Some(cursor) = request.cursor {
545 query_params.push(("cursor", format!("{:?}", &cursor)));
546 }
547 if let Some(limit) = request.limit {
548 query_params.push(("limit", format!("{:?}", &limit)));
549 }
550 if let Some(version_id) = request.version_id {
551 query_params.push(("version_id", format!("{:?}", &version_id)));
552 }
553
554 let response = self
555 .client
556 .get(url)
557 .query(&query_params)
558
559 .send()
560 .unwrap();
561
562 if response.status().is_success() {
563 let response: GetApisApiIdSchemasSchemaIdFilesResponse = response.json().unwrap();
564 Ok(response)
565 } else {
566 let status_code = response.status().as_u16();
567 let message = response.text().unwrap_or_default();
568 let err = ErrorResponse { status_code, message };
569 Err(Error::ErrorResponse(err))
570 }
571 }
572 pub fn get_schema_file_contents(&self, request: GetApisApiIdSchemasSchemaIdFilesFilePathRequest) -> Result<GetApisApiIdSchemasSchemaIdFilesFilePathResponse, Error> {
573 let endpoint = format!("/apis/{}/schemas/{}/files/{}", request.api_id, request.schema_id, request.file_path);
574 let url = format!("{}{}", self.base_url, endpoint);
575
576 let mut query_params: Vec<(&str, String)> = vec![];
577 if let Some(version_id) = request.version_id {
578 query_params.push(("version_id", format!("{:?}", &version_id)));
579 }
580
581 let response = self
582 .client
583 .get(url)
584 .query(&query_params)
585
586 .send()
587 .unwrap();
588
589 if response.status().is_success() {
590 let response: GetApisApiIdSchemasSchemaIdFilesFilePathResponse = response.json().unwrap();
591 Ok(response)
592 } else {
593 let status_code = response.status().as_u16();
594 let message = response.text().unwrap_or_default();
595 let err = ErrorResponse { status_code, message };
596 Err(Error::ErrorResponse(err))
597 }
598 }
599 pub fn get_api_tags(&self, request: GetApisApiIdTagsRequest) -> Result<GetApisApiIdTagsResponse, Error> {
600 let endpoint = format!("/apis/{}/tags", request.api_id);
601 let url = format!("{}{}", self.base_url, endpoint);
602
603 let mut query_params: Vec<(&str, String)> = vec![];
604
605 let response = self
606 .client
607 .get(url)
608 .query(&query_params)
609
610 .send()
611 .unwrap();
612
613 if response.status().is_success() {
614 let response: GetApisApiIdTagsResponse = response.json().unwrap();
615 Ok(response)
616 } else {
617 let status_code = response.status().as_u16();
618 let message = response.text().unwrap_or_default();
619 let err = ErrorResponse { status_code, message };
620 Err(Error::ErrorResponse(err))
621 }
622 }
623 pub fn get_status_of_an_async_task(&self, request: GetApisApiIdTasksTaskIdRequest) -> Result<GetApisApiIdTasksTaskIdResponse, Error> {
624 let endpoint = format!("/apis/{}/tasks/{}", request.api_id, request.task_id);
625 let url = format!("{}{}", self.base_url, endpoint);
626
627 let mut query_params: Vec<(&str, String)> = vec![];
628
629 let response = self
630 .client
631 .get(url)
632 .query(&query_params)
633
634 .send()
635 .unwrap();
636
637 if response.status().is_success() {
638 let response: GetApisApiIdTasksTaskIdResponse = response.json().unwrap();
639 Ok(response)
640 } else {
641 let status_code = response.status().as_u16();
642 let message = response.text().unwrap_or_default();
643 let err = ErrorResponse { status_code, message };
644 Err(Error::ErrorResponse(err))
645 }
646 }
647 pub fn get_all_versions(&self, request: GetApisApiIdVersionsRequest) -> Result<GetApisApiIdVersionsResponse, Error> {
648 let endpoint = format!("/apis/{}/versions", request.api_id);
649 let url = format!("{}{}", self.base_url, endpoint);
650
651 let mut query_params: Vec<(&str, String)> = vec![];
652 if let Some(cursor) = request.cursor {
653 query_params.push(("cursor", format!("{:?}", &cursor)));
654 }
655 if let Some(limit) = request.limit {
656 query_params.push(("limit", format!("{:?}", &limit)));
657 }
658
659 let response = self
660 .client
661 .get(url)
662 .query(&query_params)
663
664 .send()
665 .unwrap();
666
667 if response.status().is_success() {
668 let response: GetApisApiIdVersionsResponse = response.json().unwrap();
669 Ok(response)
670 } else {
671 let status_code = response.status().as_u16();
672 let message = response.text().unwrap_or_default();
673 let err = ErrorResponse { status_code, message };
674 Err(Error::ErrorResponse(err))
675 }
676 }
677 pub fn get_api_version(&self, request: GetApisApiIdVersionsVersionIdRequest) -> Result<GetApisApiIdVersionsVersionIdResponse, Error> {
678 let endpoint = format!("/apis/{}/versions/{}", request.api_id, request.version_id);
679 let url = format!("{}{}", self.base_url, endpoint);
680
681 let mut query_params: Vec<(&str, String)> = vec![];
682
683 let response = self
684 .client
685 .get(url)
686 .query(&query_params)
687
688 .send()
689 .unwrap();
690
691 if response.status().is_success() {
692 let response: GetApisApiIdVersionsVersionIdResponse = response.json().unwrap();
693 Ok(response)
694 } else {
695 let status_code = response.status().as_u16();
696 let message = response.text().unwrap_or_default();
697 let err = ErrorResponse { status_code, message };
698 Err(Error::ErrorResponse(err))
699 }
700 }
701 pub fn get_audit_logs(&self, request: GetAuditLogsRequest) -> Result<GetAuditLogsResponse, Error> {
702 let endpoint = "/audit/logs";
703 let url = format!("{}{}", self.base_url, endpoint);
704
705 let mut query_params: Vec<(&str, String)> = vec![];
706 if let Some(cursor) = request.cursor {
707 query_params.push(("cursor", format!("{:?}", &cursor)));
708 }
709 if let Some(limit) = request.limit {
710 query_params.push(("limit", format!("{:?}", &limit)));
711 }
712 if let Some(order_by) = request.order_by {
713 query_params.push(("order_by", format!("{:?}", &order_by)));
714 }
715 if let Some(since) = request.since {
716 query_params.push(("since", format!("{:?}", &since)));
717 }
718 if let Some(until) = request.until {
719 query_params.push(("until", format!("{:?}", &until)));
720 }
721
722 let response = self
723 .client
724 .get(url)
725 .query(&query_params)
726
727 .send()
728 .unwrap();
729
730 if response.status().is_success() {
731 let response: GetAuditLogsResponse = response.json().unwrap();
732 Ok(response)
733 } else {
734 let status_code = response.status().as_u16();
735 let message = response.text().unwrap_or_default();
736 let err = ErrorResponse { status_code, message };
737 Err(Error::ErrorResponse(err))
738 }
739 }
740 pub fn all_collections(&self, request: GetCollectionsRequest) -> Result<GetCollectionsResponse, Error> {
741 let endpoint = "/collections";
742 let url = format!("{}{}", self.base_url, endpoint);
743
744 let mut query_params: Vec<(&str, String)> = vec![];
745 if let Some(name) = request.name {
746 query_params.push(("name", format!("{:?}", &name)));
747 }
748 if let Some(workspace_id) = request.workspace_id {
749 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
750 }
751
752 let response = self
753 .client
754 .get(url)
755 .query(&query_params)
756
757 .send()
758 .unwrap();
759
760 if response.status().is_success() {
761 let response: GetCollectionsResponse = response.json().unwrap();
762 Ok(response)
763 } else {
764 let status_code = response.status().as_u16();
765 let message = response.text().unwrap_or_default();
766 let err = ErrorResponse { status_code, message };
767 Err(Error::ErrorResponse(err))
768 }
769 }
770 pub fn single_collection(&self, request: GetCollectionsCollectionIdRequest) -> Result<GetCollectionsCollectionIdResponse, Error> {
771 let endpoint = format!("/collections/{}", request.collection_id);
772 let url = format!("{}{}", self.base_url, endpoint);
773
774 let mut query_params: Vec<(&str, String)> = vec![];
775 if let Some(access_key) = request.access_key {
776 query_params.push(("access_key", format!("{:?}", &access_key)));
777 }
778
779 let response = self
780 .client
781 .get(url)
782 .query(&query_params)
783
784 .send()
785 .unwrap();
786
787 if response.status().is_success() {
788 let response: GetCollectionsCollectionIdResponse = response.json().unwrap();
789 Ok(response)
790 } else {
791 let status_code = response.status().as_u16();
792 let message = response.text().unwrap_or_default();
793 let err = ErrorResponse { status_code, message };
794 Err(Error::ErrorResponse(err))
795 }
796 }
797 pub fn get_collection_folder(&self, request: GetCollectionsCollectionIdFoldersFolderIdRequest) -> Result<GetCollectionsCollectionIdFoldersFolderIdResponse, Error> {
798 let endpoint = format!("/collections/{}/folders/{}", request.collection_id, request.folder_id);
799 let url = format!("{}{}", self.base_url, endpoint);
800
801 let mut query_params: Vec<(&str, String)> = vec![];
802 if let Some(ids) = request.ids {
803 query_params.push(("ids", format!("{:?}", &ids)));
804 }
805 if let Some(populate) = request.populate {
806 query_params.push(("populate", format!("{:?}", &populate)));
807 }
808 if let Some(uid) = request.uid {
809 query_params.push(("uid", format!("{:?}", &uid)));
810 }
811
812 let response = self
813 .client
814 .get(url)
815 .query(&query_params)
816
817 .send()
818 .unwrap();
819
820 if response.status().is_success() {
821 let response: GetCollectionsCollectionIdFoldersFolderIdResponse = response.json().unwrap();
822 Ok(response)
823 } else {
824 let status_code = response.status().as_u16();
825 let message = response.text().unwrap_or_default();
826 let err = ErrorResponse { status_code, message };
827 Err(Error::ErrorResponse(err))
828 }
829 }
830 pub fn get_collection_request(&self, request: GetCollectionsCollectionIdRequestsRequestIdRequest) -> Result<GetCollectionsCollectionIdRequestsRequestIdResponse, Error> {
831 let endpoint = format!("/collections/{}/requests/{}", request.collection_id, request.request_id);
832 let url = format!("{}{}", self.base_url, endpoint);
833
834 let mut query_params: Vec<(&str, String)> = vec![];
835 if let Some(ids) = request.ids {
836 query_params.push(("ids", format!("{:?}", &ids)));
837 }
838 if let Some(populate) = request.populate {
839 query_params.push(("populate", format!("{:?}", &populate)));
840 }
841 if let Some(uid) = request.uid {
842 query_params.push(("uid", format!("{:?}", &uid)));
843 }
844
845 let response = self
846 .client
847 .get(url)
848 .query(&query_params)
849
850 .send()
851 .unwrap();
852
853 if response.status().is_success() {
854 let response: GetCollectionsCollectionIdRequestsRequestIdResponse = response.json().unwrap();
855 Ok(response)
856 } else {
857 let status_code = response.status().as_u16();
858 let message = response.text().unwrap_or_default();
859 let err = ErrorResponse { status_code, message };
860 Err(Error::ErrorResponse(err))
861 }
862 }
863 pub fn get_collection_response(&self, request: GetCollectionsCollectionIdResponsesResponseIdRequest) -> Result<GetCollectionsCollectionIdResponsesResponseIdResponse, Error> {
864 let endpoint = format!("/collections/{}/responses/{}", request.collection_id, request.response_id);
865 let url = format!("{}{}", self.base_url, endpoint);
866
867 let mut query_params: Vec<(&str, String)> = vec![];
868 if let Some(ids) = request.ids {
869 query_params.push(("ids", format!("{:?}", &ids)));
870 }
871 if let Some(populate) = request.populate {
872 query_params.push(("populate", format!("{:?}", &populate)));
873 }
874 if let Some(uid) = request.uid {
875 query_params.push(("uid", format!("{:?}", &uid)));
876 }
877
878 let response = self
879 .client
880 .get(url)
881 .query(&query_params)
882
883 .send()
884 .unwrap();
885
886 if response.status().is_success() {
887 let response: GetCollectionsCollectionIdResponsesResponseIdResponse = response.json().unwrap();
888 Ok(response)
889 } else {
890 let status_code = response.status().as_u16();
891 let message = response.text().unwrap_or_default();
892 let err = ErrorResponse { status_code, message };
893 Err(Error::ErrorResponse(err))
894 }
895 }
896 pub fn get_collection_tags(&self, request: GetCollectionsCollectionIdTagsRequest) -> Result<GetCollectionsCollectionIdTagsResponse, Error> {
897 let endpoint = format!("/collections/{}/tags", request.collection_id);
898 let url = format!("{}{}", self.base_url, endpoint);
899
900 let mut query_params: Vec<(&str, String)> = vec![];
901
902 let response = self
903 .client
904 .get(url)
905 .query(&query_params)
906
907 .send()
908 .unwrap();
909
910 if response.status().is_success() {
911 let response: GetCollectionsCollectionIdTagsResponse = response.json().unwrap();
912 Ok(response)
913 } else {
914 let status_code = response.status().as_u16();
915 let message = response.text().unwrap_or_default();
916 let err = ErrorResponse { status_code, message };
917 Err(Error::ErrorResponse(err))
918 }
919 }
920 pub fn transform_collection_to_open_api(&self, request: GetCollectionsCollectionIdTransformationsRequest) -> Result<GetCollectionsCollectionIdTransformationsResponse, Error> {
921 let endpoint = format!("/collections/{}/transformations", request.collection_id);
922 let url = format!("{}{}", self.base_url, endpoint);
923
924 let mut query_params: Vec<(&str, String)> = vec![];
925
926 let response = self
927 .client
928 .get(url)
929 .query(&query_params)
930
931 .send()
932 .unwrap();
933
934 if response.status().is_success() {
935 let response: GetCollectionsCollectionIdTransformationsResponse = response.json().unwrap();
936 Ok(response)
937 } else {
938 let status_code = response.status().as_u16();
939 let message = response.text().unwrap_or_default();
940 let err = ErrorResponse { status_code, message };
941 Err(Error::ErrorResponse(err))
942 }
943 }
944 pub fn get_detected_secrets_locations(&self, request: GetDetectedSecretsSecretIdLocationsRequest) -> Result<GetDetectedSecretsSecretIdLocationsResponse, Error> {
945 let endpoint = format!("/detected-secrets/{}/locations", request.secret_id);
946 let url = format!("{}{}", self.base_url, endpoint);
947
948 let mut query_params: Vec<(&str, String)> = vec![];
949 query_params.push(("workspace_id", format!("{:?}", &request.workspace_id)));
950 if let Some(cursor) = request.cursor {
951 query_params.push(("cursor", format!("{:?}", &cursor)));
952 }
953 if let Some(limit) = request.limit {
954 query_params.push(("limit", format!("{:?}", &limit)));
955 }
956
957 let response = self
958 .client
959 .get(url)
960 .query(&query_params)
961
962 .send()
963 .unwrap();
964
965 if response.status().is_success() {
966 let response: GetDetectedSecretsSecretIdLocationsResponse = response.json().unwrap();
967 Ok(response)
968 } else {
969 let status_code = response.status().as_u16();
970 let message = response.text().unwrap_or_default();
971 let err = ErrorResponse { status_code, message };
972 Err(Error::ErrorResponse(err))
973 }
974 }
975 pub fn all_environments(&self, request: GetEnvironmentsRequest) -> Result<GetEnvironmentsResponse, Error> {
976 let endpoint = "/environments";
977 let url = format!("{}{}", self.base_url, endpoint);
978
979 let mut query_params: Vec<(&str, String)> = vec![];
980 if let Some(workspace_id) = request.workspace_id {
981 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
982 }
983
984 let response = self
985 .client
986 .get(url)
987 .query(&query_params)
988
989 .send()
990 .unwrap();
991
992 if response.status().is_success() {
993 let response: GetEnvironmentsResponse = response.json().unwrap();
994 Ok(response)
995 } else {
996 let status_code = response.status().as_u16();
997 let message = response.text().unwrap_or_default();
998 let err = ErrorResponse { status_code, message };
999 Err(Error::ErrorResponse(err))
1000 }
1001 }
1002 pub fn single_environment(&self, request: GetEnvironmentsEnvironmentIdRequest) -> Result<GetEnvironmentsEnvironmentIdResponse, Error> {
1003 let endpoint = format!("/environments/{}", request.environment_id);
1004 let url = format!("{}{}", self.base_url, endpoint);
1005
1006 let mut query_params: Vec<(&str, String)> = vec![];
1007
1008 let response = self
1009 .client
1010 .get(url)
1011 .query(&query_params)
1012
1013 .send()
1014 .unwrap();
1015
1016 if response.status().is_success() {
1017 let response: GetEnvironmentsEnvironmentIdResponse = response.json().unwrap();
1018 Ok(response)
1019 } else {
1020 let status_code = response.status().as_u16();
1021 let message = response.text().unwrap_or_default();
1022 let err = ErrorResponse { status_code, message };
1023 Err(Error::ErrorResponse(err))
1024 }
1025 }
1026 pub fn api_key_owner(&self) -> Result<GetMeResponse, Error> {
1027 let endpoint = "/me";
1028 let url = format!("{}{}", self.base_url, endpoint);
1029
1030 let mut query_params: Vec<(&str, String)> = vec![];
1031
1032 let response = self
1033 .client
1034 .get(url)
1035 .query(&query_params)
1036
1037 .send()
1038 .unwrap();
1039
1040 if response.status().is_success() {
1041 let response: GetMeResponse = response.json().unwrap();
1042 Ok(response)
1043 } else {
1044 let status_code = response.status().as_u16();
1045 let message = response.text().unwrap_or_default();
1046 let err = ErrorResponse { status_code, message };
1047 Err(Error::ErrorResponse(err))
1048 }
1049 }
1050 pub fn get_mocks(&self, request: GetMocksRequest) -> Result<GetMocksResponse, Error> {
1051 let endpoint = "/mocks";
1052 let url = format!("{}{}", self.base_url, endpoint);
1053
1054 let mut query_params: Vec<(&str, String)> = vec![];
1055 if let Some(team_id) = request.team_id {
1056 query_params.push(("team_id", format!("{:?}", &team_id)));
1057 }
1058 if let Some(workspace) = request.workspace {
1059 query_params.push(("workspace", format!("{:?}", &workspace)));
1060 }
1061
1062 let response = self
1063 .client
1064 .get(url)
1065 .query(&query_params)
1066
1067 .send()
1068 .unwrap();
1069
1070 if response.status().is_success() {
1071 let response: GetMocksResponse = response.json().unwrap();
1072 Ok(response)
1073 } else {
1074 let status_code = response.status().as_u16();
1075 let message = response.text().unwrap_or_default();
1076 let err = ErrorResponse { status_code, message };
1077 Err(Error::ErrorResponse(err))
1078 }
1079 }
1080 pub fn get_mock(&self, request: GetMocksMockIdRequest) -> Result<GetMocksMockIdResponse, Error> {
1081 let endpoint = format!("/mocks/{}", request.mock_id);
1082 let url = format!("{}{}", self.base_url, endpoint);
1083
1084 let mut query_params: Vec<(&str, String)> = vec![];
1085
1086 let response = self
1087 .client
1088 .get(url)
1089 .query(&query_params)
1090
1091 .send()
1092 .unwrap();
1093
1094 if response.status().is_success() {
1095 let response: GetMocksMockIdResponse = response.json().unwrap();
1096 Ok(response)
1097 } else {
1098 let status_code = response.status().as_u16();
1099 let message = response.text().unwrap_or_default();
1100 let err = ErrorResponse { status_code, message };
1101 Err(Error::ErrorResponse(err))
1102 }
1103 }
1104 pub fn get_mock_call_logs(&self, request: GetMocksMockIdCallLogsRequest) -> Result<GetMocksMockIdCallLogsResponse, Error> {
1105 let endpoint = format!("/mocks/{}/call-logs", request.mock_id);
1106 let url = format!("{}{}", self.base_url, endpoint);
1107
1108 let mut query_params: Vec<(&str, String)> = vec![];
1109 if let Some(cursor) = request.cursor {
1110 query_params.push(("cursor", format!("{:?}", &cursor)));
1111 }
1112 if let Some(direction) = request.direction {
1113 query_params.push(("direction", format!("{:?}", &direction)));
1114 }
1115 if let Some(include) = request.include {
1116 query_params.push(("include", format!("{:?}", &include)));
1117 }
1118 if let Some(limit) = request.limit {
1119 query_params.push(("limit", format!("{:?}", &limit)));
1120 }
1121 if let Some(request_method) = request.request_method {
1122 query_params.push(("request_method", format!("{:?}", &request_method)));
1123 }
1124 if let Some(request_path) = request.request_path {
1125 query_params.push(("request_path", format!("{:?}", &request_path)));
1126 }
1127 if let Some(response_status_code) = request.response_status_code {
1128 query_params.push(("response_status_code", format!("{:?}", &response_status_code)));
1129 }
1130 if let Some(response_type) = request.response_type {
1131 query_params.push(("response_type", format!("{:?}", &response_type)));
1132 }
1133 if let Some(since) = request.since {
1134 query_params.push(("since", format!("{:?}", &since)));
1135 }
1136 if let Some(sort) = request.sort {
1137 query_params.push(("sort", format!("{:?}", &sort)));
1138 }
1139 if let Some(until) = request.until {
1140 query_params.push(("until", format!("{:?}", &until)));
1141 }
1142
1143 let response = self
1144 .client
1145 .get(url)
1146 .query(&query_params)
1147
1148 .send()
1149 .unwrap();
1150
1151 if response.status().is_success() {
1152 let response: GetMocksMockIdCallLogsResponse = response.json().unwrap();
1153 Ok(response)
1154 } else {
1155 let status_code = response.status().as_u16();
1156 let message = response.text().unwrap_or_default();
1157 let err = ErrorResponse { status_code, message };
1158 Err(Error::ErrorResponse(err))
1159 }
1160 }
1161 pub fn get_mock_server_responses(&self, request: GetMocksMockIdServerResponsesRequest) -> Result<Vec<GetMocksMockIdServerResponsesResponseItem>, Error> {
1162 let endpoint = format!("/mocks/{}/server-responses", request.mock_id);
1163 let url = format!("{}{}", self.base_url, endpoint);
1164
1165 let mut query_params: Vec<(&str, String)> = vec![];
1166
1167 let response = self
1168 .client
1169 .get(url)
1170 .query(&query_params)
1171
1172 .send()
1173 .unwrap();
1174
1175 if response.status().is_success() {
1176 let response: Vec<GetMocksMockIdServerResponsesResponseItem> = response.json().unwrap();
1177 Ok(response)
1178 } else {
1179 let status_code = response.status().as_u16();
1180 let message = response.text().unwrap_or_default();
1181 let err = ErrorResponse { status_code, message };
1182 Err(Error::ErrorResponse(err))
1183 }
1184 }
1185 pub fn get_mock_server_response(&self, request: GetMocksMockIdServerResponsesServerResponseIdRequest) -> Result<Vec<GetMocksMockIdServerResponsesServerResponseIdResponseItem>, Error> {
1186 let endpoint = format!("/mocks/{}/server-responses/{}", request.mock_id, request.server_response_id);
1187 let url = format!("{}{}", self.base_url, endpoint);
1188
1189 let mut query_params: Vec<(&str, String)> = vec![];
1190
1191 let response = self
1192 .client
1193 .get(url)
1194 .query(&query_params)
1195
1196 .send()
1197 .unwrap();
1198
1199 if response.status().is_success() {
1200 let response: Vec<GetMocksMockIdServerResponsesServerResponseIdResponseItem> = response.json().unwrap();
1201 Ok(response)
1202 } else {
1203 let status_code = response.status().as_u16();
1204 let message = response.text().unwrap_or_default();
1205 let err = ErrorResponse { status_code, message };
1206 Err(Error::ErrorResponse(err))
1207 }
1208 }
1209 pub fn all_monitors(&self, request: GetMonitorsRequest) -> Result<GetMonitorsResponse, Error> {
1210 let endpoint = "/monitors";
1211 let url = format!("{}{}", self.base_url, endpoint);
1212
1213 let mut query_params: Vec<(&str, String)> = vec![];
1214 if let Some(workspace) = request.workspace {
1215 query_params.push(("workspace", format!("{:?}", &workspace)));
1216 }
1217
1218 let response = self
1219 .client
1220 .get(url)
1221 .query(&query_params)
1222
1223 .send()
1224 .unwrap();
1225
1226 if response.status().is_success() {
1227 let response: GetMonitorsResponse = response.json().unwrap();
1228 Ok(response)
1229 } else {
1230 let status_code = response.status().as_u16();
1231 let message = response.text().unwrap_or_default();
1232 let err = ErrorResponse { status_code, message };
1233 Err(Error::ErrorResponse(err))
1234 }
1235 }
1236 pub fn single_monitor(&self, request: GetMonitorsMonitorIdRequest) -> Result<GetMonitorsMonitorIdResponse, Error> {
1237 let endpoint = format!("/monitors/{}", request.monitor_id);
1238 let url = format!("{}{}", self.base_url, endpoint);
1239
1240 let mut query_params: Vec<(&str, String)> = vec![];
1241
1242 let response = self
1243 .client
1244 .get(url)
1245 .query(&query_params)
1246
1247 .send()
1248 .unwrap();
1249
1250 if response.status().is_success() {
1251 let response: GetMonitorsMonitorIdResponse = response.json().unwrap();
1252 Ok(response)
1253 } else {
1254 let status_code = response.status().as_u16();
1255 let message = response.text().unwrap_or_default();
1256 let err = ErrorResponse { status_code, message };
1257 Err(Error::ErrorResponse(err))
1258 }
1259 }
1260 pub fn get_all_elements_and_folders(&self, request: GetNetworkPrivateRequest) -> Result<GetNetworkPrivateResponse, Error> {
1261 let endpoint = "/network/private";
1262 let url = format!("{}{}", self.base_url, endpoint);
1263
1264 let mut query_params: Vec<(&str, String)> = vec![];
1265 if let Some(added_by) = request.added_by {
1266 query_params.push(("added_by", format!("{:?}", &added_by)));
1267 }
1268 if let Some(created_by) = request.created_by {
1269 query_params.push(("created_by", format!("{:?}", &created_by)));
1270 }
1271 if let Some(description) = request.description {
1272 query_params.push(("description", format!("{:?}", &description)));
1273 }
1274 if let Some(direction) = request.direction {
1275 query_params.push(("direction", format!("{:?}", &direction)));
1276 }
1277 if let Some(limit) = request.limit {
1278 query_params.push(("limit", format!("{:?}", &limit)));
1279 }
1280 if let Some(name) = request.name {
1281 query_params.push(("name", format!("{:?}", &name)));
1282 }
1283 if let Some(offset) = request.offset {
1284 query_params.push(("offset", format!("{:?}", &offset)));
1285 }
1286 if let Some(parent_folder_id) = request.parent_folder_id {
1287 query_params.push(("parent_folder_id", format!("{:?}", &parent_folder_id)));
1288 }
1289 if let Some(since) = request.since {
1290 query_params.push(("since", format!("{:?}", &since)));
1291 }
1292 if let Some(sort) = request.sort {
1293 query_params.push(("sort", format!("{:?}", &sort)));
1294 }
1295 if let Some(summary) = request.summary {
1296 query_params.push(("summary", format!("{:?}", &summary)));
1297 }
1298 if let Some(type_field) = request.type_field {
1299 query_params.push(("type", format!("{:?}", &type_field)));
1300 }
1301 if let Some(until) = request.until {
1302 query_params.push(("until", format!("{:?}", &until)));
1303 }
1304
1305 let response = self
1306 .client
1307 .get(url)
1308 .query(&query_params)
1309
1310 .send()
1311 .unwrap();
1312
1313 if response.status().is_success() {
1314 let response: GetNetworkPrivateResponse = response.json().unwrap();
1315 Ok(response)
1316 } else {
1317 let status_code = response.status().as_u16();
1318 let message = response.text().unwrap_or_default();
1319 let err = ErrorResponse { status_code, message };
1320 Err(Error::ErrorResponse(err))
1321 }
1322 }
1323 pub fn get_all_add_element_requests(&self, request: GetNetworkPrivateNetworkEntityRequestAllRequest) -> Result<GetNetworkPrivateNetworkEntityRequestAllResponse, Error> {
1324 let endpoint = "/network/private/network-entity/request/all";
1325 let url = format!("{}{}", self.base_url, endpoint);
1326
1327 let mut query_params: Vec<(&str, String)> = vec![];
1328 if let Some(direction) = request.direction {
1329 query_params.push(("direction", format!("{:?}", &direction)));
1330 }
1331 if let Some(limit) = request.limit {
1332 query_params.push(("limit", format!("{:?}", &limit)));
1333 }
1334 if let Some(name) = request.name {
1335 query_params.push(("name", format!("{:?}", &name)));
1336 }
1337 if let Some(offset) = request.offset {
1338 query_params.push(("offset", format!("{:?}", &offset)));
1339 }
1340 if let Some(requested_by) = request.requested_by {
1341 query_params.push(("requested_by", format!("{:?}", &requested_by)));
1342 }
1343 if let Some(since) = request.since {
1344 query_params.push(("since", format!("{:?}", &since)));
1345 }
1346 if let Some(sort) = request.sort {
1347 query_params.push(("sort", format!("{:?}", &sort)));
1348 }
1349 if let Some(status) = request.status {
1350 query_params.push(("status", format!("{:?}", &status)));
1351 }
1352 if let Some(type_field) = request.type_field {
1353 query_params.push(("type", format!("{:?}", &type_field)));
1354 }
1355 if let Some(until) = request.until {
1356 query_params.push(("until", format!("{:?}", &until)));
1357 }
1358
1359 let response = self
1360 .client
1361 .get(url)
1362 .query(&query_params)
1363
1364 .send()
1365 .unwrap();
1366
1367 if response.status().is_success() {
1368 let response: GetNetworkPrivateNetworkEntityRequestAllResponse = response.json().unwrap();
1369 Ok(response)
1370 } else {
1371 let status_code = response.status().as_u16();
1372 let message = response.text().unwrap_or_default();
1373 let err = ErrorResponse { status_code, message };
1374 Err(Error::ErrorResponse(err))
1375 }
1376 }
1377 pub fn fetch_all_group_resources(&self, request: GetScimV2GroupsRequest) -> Result<GetScimV2GroupsResponse, Error> {
1378 let endpoint = "/scim/v2/Groups";
1379 let url = format!("{}{}", self.base_url, endpoint);
1380
1381 let mut query_params: Vec<(&str, String)> = vec![];
1382 if let Some(count) = request.count {
1383 query_params.push(("count", format!("{:?}", &count)));
1384 }
1385 if let Some(filter) = request.filter {
1386 query_params.push(("filter", format!("{:?}", &filter)));
1387 }
1388 if let Some(start_index) = request.start_index {
1389 query_params.push(("start_index", format!("{:?}", &start_index)));
1390 }
1391
1392 let response = self
1393 .client
1394 .get(url)
1395 .query(&query_params)
1396
1397 .send()
1398 .unwrap();
1399
1400 if response.status().is_success() {
1401 let response: GetScimV2GroupsResponse = response.json().unwrap();
1402 Ok(response)
1403 } else {
1404 let status_code = response.status().as_u16();
1405 let message = response.text().unwrap_or_default();
1406 let err = ErrorResponse { status_code, message };
1407 Err(Error::ErrorResponse(err))
1408 }
1409 }
1410 pub fn fetch_group_resource(&self, request: GetScimV2GroupsGroupIdRequest) -> Result<GetScimV2GroupsGroupIdResponse, Error> {
1411 let endpoint = format!("/scim/v2/Groups/{}", request.group_id);
1412 let url = format!("{}{}", self.base_url, endpoint);
1413
1414 let mut query_params: Vec<(&str, String)> = vec![];
1415
1416 let response = self
1417 .client
1418 .get(url)
1419 .query(&query_params)
1420
1421 .send()
1422 .unwrap();
1423
1424 if response.status().is_success() {
1425 let response: GetScimV2GroupsGroupIdResponse = response.json().unwrap();
1426 Ok(response)
1427 } else {
1428 let status_code = response.status().as_u16();
1429 let message = response.text().unwrap_or_default();
1430 let err = ErrorResponse { status_code, message };
1431 Err(Error::ErrorResponse(err))
1432 }
1433 }
1434 pub fn get_resource_types(&self) -> Result<Vec<GetScimV2ResourceTypesResponseItem>, Error> {
1435 let endpoint = "/scim/v2/ResourceTypes";
1436 let url = format!("{}{}", self.base_url, endpoint);
1437
1438 let mut query_params: Vec<(&str, String)> = vec![];
1439
1440 let response = self
1441 .client
1442 .get(url)
1443 .query(&query_params)
1444
1445 .send()
1446 .unwrap();
1447
1448 if response.status().is_success() {
1449 let response: Vec<GetScimV2ResourceTypesResponseItem> = response.json().unwrap();
1450 Ok(response)
1451 } else {
1452 let status_code = response.status().as_u16();
1453 let message = response.text().unwrap_or_default();
1454 let err = ErrorResponse { status_code, message };
1455 Err(Error::ErrorResponse(err))
1456 }
1457 }
1458 pub fn service_provider_config(&self) -> Result<GetScimV2ServiceProviderConfigResponse, Error> {
1459 let endpoint = "/scim/v2/ServiceProviderConfig";
1460 let url = format!("{}{}", self.base_url, endpoint);
1461
1462 let mut query_params: Vec<(&str, String)> = vec![];
1463
1464 let response = self
1465 .client
1466 .get(url)
1467 .query(&query_params)
1468
1469 .send()
1470 .unwrap();
1471
1472 if response.status().is_success() {
1473 let response: GetScimV2ServiceProviderConfigResponse = response.json().unwrap();
1474 Ok(response)
1475 } else {
1476 let status_code = response.status().as_u16();
1477 let message = response.text().unwrap_or_default();
1478 let err = ErrorResponse { status_code, message };
1479 Err(Error::ErrorResponse(err))
1480 }
1481 }
1482 pub fn fetch_all_user_resources(&self, request: GetScimV2UsersRequest) -> Result<GetScimV2UsersResponse, Error> {
1483 let endpoint = "/scim/v2/Users";
1484 let url = format!("{}{}", self.base_url, endpoint);
1485
1486 let mut query_params: Vec<(&str, String)> = vec![];
1487 if let Some(count) = request.count {
1488 query_params.push(("count", format!("{:?}", &count)));
1489 }
1490 if let Some(filter) = request.filter {
1491 query_params.push(("filter", format!("{:?}", &filter)));
1492 }
1493 if let Some(start_index) = request.start_index {
1494 query_params.push(("start_index", format!("{:?}", &start_index)));
1495 }
1496
1497 let response = self
1498 .client
1499 .get(url)
1500 .query(&query_params)
1501
1502 .send()
1503 .unwrap();
1504
1505 if response.status().is_success() {
1506 let response: GetScimV2UsersResponse = response.json().unwrap();
1507 Ok(response)
1508 } else {
1509 let status_code = response.status().as_u16();
1510 let message = response.text().unwrap_or_default();
1511 let err = ErrorResponse { status_code, message };
1512 Err(Error::ErrorResponse(err))
1513 }
1514 }
1515 pub fn fetch_user_resource(&self, request: GetScimV2UsersUserIdRequest) -> Result<GetScimV2UsersUserIdResponse, Error> {
1516 let endpoint = format!("/scim/v2/Users/{}", request.user_id);
1517 let url = format!("{}{}", self.base_url, endpoint);
1518
1519 let mut query_params: Vec<(&str, String)> = vec![];
1520
1521 let response = self
1522 .client
1523 .get(url)
1524 .query(&query_params)
1525
1526 .send()
1527 .unwrap();
1528
1529 if response.status().is_success() {
1530 let response: GetScimV2UsersUserIdResponse = response.json().unwrap();
1531 Ok(response)
1532 } else {
1533 let status_code = response.status().as_u16();
1534 let message = response.text().unwrap_or_default();
1535 let err = ErrorResponse { status_code, message };
1536 Err(Error::ErrorResponse(err))
1537 }
1538 }
1539 pub fn get_secret_types(&self) -> Result<GetSecretTypesResponse, Error> {
1540 let endpoint = "/secret-types";
1541 let url = format!("{}{}", self.base_url, endpoint);
1542
1543 let mut query_params: Vec<(&str, String)> = vec![];
1544
1545 let response = self
1546 .client
1547 .get(url)
1548 .query(&query_params)
1549
1550 .send()
1551 .unwrap();
1552
1553 if response.status().is_success() {
1554 let response: GetSecretTypesResponse = response.json().unwrap();
1555 Ok(response)
1556 } else {
1557 let status_code = response.status().as_u16();
1558 let message = response.text().unwrap_or_default();
1559 let err = ErrorResponse { status_code, message };
1560 Err(Error::ErrorResponse(err))
1561 }
1562 }
1563 pub fn get_tagged_entities(&self, request: GetTagsSlugEntitiesRequest) -> Result<GetTagsSlugEntitiesResponse, Error> {
1564 let endpoint = format!("/tags/{}/entities", request.slug);
1565 let url = format!("{}{}", self.base_url, endpoint);
1566
1567 let mut query_params: Vec<(&str, String)> = vec![];
1568 if let Some(cursor) = request.cursor {
1569 query_params.push(("cursor", format!("{:?}", &cursor)));
1570 }
1571 if let Some(direction) = request.direction {
1572 query_params.push(("direction", format!("{:?}", &direction)));
1573 }
1574 if let Some(entity_type) = request.entity_type {
1575 query_params.push(("entity_type", format!("{:?}", &entity_type)));
1576 }
1577 if let Some(limit) = request.limit {
1578 query_params.push(("limit", format!("{:?}", &limit)));
1579 }
1580
1581 let response = self
1582 .client
1583 .get(url)
1584 .query(&query_params)
1585
1586 .send()
1587 .unwrap();
1588
1589 if response.status().is_success() {
1590 let response: GetTagsSlugEntitiesResponse = response.json().unwrap();
1591 Ok(response)
1592 } else {
1593 let status_code = response.status().as_u16();
1594 let message = response.text().unwrap_or_default();
1595 let err = ErrorResponse { status_code, message };
1596 Err(Error::ErrorResponse(err))
1597 }
1598 }
1599 pub fn all_workspaces(&self, request: GetWorkspacesRequest) -> Result<GetWorkspacesResponse, Error> {
1600 let endpoint = "/workspaces";
1601 let url = format!("{}{}", self.base_url, endpoint);
1602
1603 let mut query_params: Vec<(&str, String)> = vec![];
1604 if let Some(type_field) = request.type_field {
1605 query_params.push(("type", format!("{:?}", &type_field)));
1606 }
1607
1608 let response = self
1609 .client
1610 .get(url)
1611 .query(&query_params)
1612
1613 .send()
1614 .unwrap();
1615
1616 if response.status().is_success() {
1617 let response: GetWorkspacesResponse = response.json().unwrap();
1618 Ok(response)
1619 } else {
1620 let status_code = response.status().as_u16();
1621 let message = response.text().unwrap_or_default();
1622 let err = ErrorResponse { status_code, message };
1623 Err(Error::ErrorResponse(err))
1624 }
1625 }
1626 pub fn single_workspace(&self, request: GetWorkspacesWorkspaceIdRequest) -> Result<GetWorkspacesWorkspaceIdResponse, Error> {
1627 let endpoint = format!("/workspaces/{}", request.workspace_id);
1628 let url = format!("{}{}", self.base_url, endpoint);
1629
1630 let mut query_params: Vec<(&str, String)> = vec![];
1631
1632 let response = self
1633 .client
1634 .get(url)
1635 .query(&query_params)
1636
1637 .send()
1638 .unwrap();
1639
1640 if response.status().is_success() {
1641 let response: GetWorkspacesWorkspaceIdResponse = response.json().unwrap();
1642 Ok(response)
1643 } else {
1644 let status_code = response.status().as_u16();
1645 let message = response.text().unwrap_or_default();
1646 let err = ErrorResponse { status_code, message };
1647 Err(Error::ErrorResponse(err))
1648 }
1649 }
1650 pub fn get_workspace_global_variables(&self, request: GetWorkspacesWorkspaceIdGlobalVariablesRequest) -> Result<GetWorkspacesWorkspaceIdGlobalVariablesResponse, Error> {
1651 let endpoint = format!("/workspaces/{}/global-variables", request.workspace_id);
1652 let url = format!("{}{}", self.base_url, endpoint);
1653
1654 let mut query_params: Vec<(&str, String)> = vec![];
1655
1656 let response = self
1657 .client
1658 .get(url)
1659 .query(&query_params)
1660
1661 .send()
1662 .unwrap();
1663
1664 if response.status().is_success() {
1665 let response: GetWorkspacesWorkspaceIdGlobalVariablesResponse = response.json().unwrap();
1666 Ok(response)
1667 } else {
1668 let status_code = response.status().as_u16();
1669 let message = response.text().unwrap_or_default();
1670 let err = ErrorResponse { status_code, message };
1671 Err(Error::ErrorResponse(err))
1672 }
1673 }
1674 pub fn get_workspace_tags(&self, request: GetWorkspacesWorkspaceIdTagsRequest) -> Result<GetWorkspacesWorkspaceIdTagsResponse, Error> {
1675 let endpoint = format!("/workspaces/{}/tags", request.workspace_id);
1676 let url = format!("{}{}", self.base_url, endpoint);
1677
1678 let mut query_params: Vec<(&str, String)> = vec![];
1679
1680 let response = self
1681 .client
1682 .get(url)
1683 .query(&query_params)
1684
1685 .send()
1686 .unwrap();
1687
1688 if response.status().is_success() {
1689 let response: GetWorkspacesWorkspaceIdTagsResponse = response.json().unwrap();
1690 Ok(response)
1691 } else {
1692 let status_code = response.status().as_u16();
1693 let message = response.text().unwrap_or_default();
1694 let err = ErrorResponse { status_code, message };
1695 Err(Error::ErrorResponse(err))
1696 }
1697 }
1698 pub fn patch_collection(&self, request: PatchCollectionsCollectionIdRequest) -> Result<PatchCollectionsCollectionIdResponse, Error> {
1699 let endpoint = format!("/collections/{}", request.collection_id);
1700 let url = format!("{}{}", self.base_url, endpoint);
1701
1702 let mut query_params: Vec<(&str, String)> = vec![];
1703
1704 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1705 let response = self
1706 .client
1707 .patch(url)
1708 .query(&query_params)
1709 .json(&request_body)
1710 .send()
1711 .unwrap();
1712
1713 if response.status().is_success() {
1714 let response: PatchCollectionsCollectionIdResponse = response.json().unwrap();
1715 Ok(response)
1716 } else {
1717 let status_code = response.status().as_u16();
1718 let message = response.text().unwrap_or_default();
1719 let err = ErrorResponse { status_code, message };
1720 Err(Error::ErrorResponse(err))
1721 }
1722 }
1723 pub fn patch_scim_v2_groups_group_id(&self, request: PatchScimV2GroupsGroupIdRequest) -> Result<PatchScimV2GroupsGroupIdResponse, Error> {
1724 let endpoint = format!("/scim/v2/Groups/{}", request.group_id);
1725 let url = format!("{}{}", self.base_url, endpoint);
1726
1727 let mut query_params: Vec<(&str, String)> = vec![];
1728
1729 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1730 let response = self
1731 .client
1732 .patch(url)
1733 .query(&query_params)
1734 .json(&request_body)
1735 .send()
1736 .unwrap();
1737
1738 if response.status().is_success() {
1739 let response: PatchScimV2GroupsGroupIdResponse = response.json().unwrap();
1740 Ok(response)
1741 } else {
1742 let status_code = response.status().as_u16();
1743 let message = response.text().unwrap_or_default();
1744 let err = ErrorResponse { status_code, message };
1745 Err(Error::ErrorResponse(err))
1746 }
1747 }
1748 pub fn update_user_state(&self, request: PatchScimV2UsersUserIdRequest) -> Result<PatchScimV2UsersUserIdResponse, Error> {
1749 let endpoint = format!("/scim/v2/Users/{}", request.user_id);
1750 let url = format!("{}{}", self.base_url, endpoint);
1751
1752 let mut query_params: Vec<(&str, String)> = vec![];
1753
1754 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1755 let response = self
1756 .client
1757 .patch(url)
1758 .query(&query_params)
1759 .json(&request_body)
1760 .send()
1761 .unwrap();
1762
1763 if response.status().is_success() {
1764 let response: PatchScimV2UsersUserIdResponse = response.json().unwrap();
1765 Ok(response)
1766 } else {
1767 let status_code = response.status().as_u16();
1768 let message = response.text().unwrap_or_default();
1769 let err = ErrorResponse { status_code, message };
1770 Err(Error::ErrorResponse(err))
1771 }
1772 }
1773 pub fn create_api(&self, request: PostApisRequest) -> Result<PostApisResponse, Error> {
1774 let endpoint = "/apis";
1775 let url = format!("{}{}", self.base_url, endpoint);
1776
1777 let mut query_params: Vec<(&str, String)> = vec![];
1778 query_params.push(("workspace_id", format!("{:?}", &request.workspace_id)));
1779
1780 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1781 let response = self
1782 .client
1783 .post(url)
1784 .query(&query_params)
1785 .json(&request_body)
1786 .send()
1787 .unwrap();
1788
1789 if response.status().is_success() {
1790 let response: PostApisResponse = response.json().unwrap();
1791 Ok(response)
1792 } else {
1793 let status_code = response.status().as_u16();
1794 let message = response.text().unwrap_or_default();
1795 let err = ErrorResponse { status_code, message };
1796 Err(Error::ErrorResponse(err))
1797 }
1798 }
1799 pub fn add_collection(&self, request: PostApisApiIdCollectionsRequest) -> Result<PostApisApiIdCollectionsResponse, Error> {
1800 let endpoint = format!("/apis/{}/collections", request.api_id);
1801 let url = format!("{}{}", self.base_url, endpoint);
1802
1803 let mut query_params: Vec<(&str, String)> = vec![];
1804
1805 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1806 let response = self
1807 .client
1808 .post(url)
1809 .query(&query_params)
1810 .json(&request_body)
1811 .send()
1812 .unwrap();
1813
1814 if response.status().is_success() {
1815 let response: PostApisApiIdCollectionsResponse = response.json().unwrap();
1816 Ok(response)
1817 } else {
1818 let status_code = response.status().as_u16();
1819 let message = response.text().unwrap_or_default();
1820 let err = ErrorResponse { status_code, message };
1821 Err(Error::ErrorResponse(err))
1822 }
1823 }
1824 pub fn create_api_schema(&self, request: PostApisApiIdSchemasRequest) -> Result<PostApisApiIdSchemasResponse, Error> {
1825 let endpoint = format!("/apis/{}/schemas", request.api_id);
1826 let url = format!("{}{}", self.base_url, endpoint);
1827
1828 let mut query_params: Vec<(&str, String)> = vec![];
1829
1830 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1831 let response = self
1832 .client
1833 .post(url)
1834 .query(&query_params)
1835 .json(&request_body)
1836 .send()
1837 .unwrap();
1838
1839 if response.status().is_success() {
1840 let response: PostApisApiIdSchemasResponse = response.json().unwrap();
1841 Ok(response)
1842 } else {
1843 let status_code = response.status().as_u16();
1844 let message = response.text().unwrap_or_default();
1845 let err = ErrorResponse { status_code, message };
1846 Err(Error::ErrorResponse(err))
1847 }
1848 }
1849 pub fn create_api_version(&self, request: PostApisApiIdVersionsRequest) -> Result<PostApisApiIdVersionsResponse, Error> {
1850 let endpoint = format!("/apis/{}/versions", request.api_id);
1851 let url = format!("{}{}", self.base_url, endpoint);
1852
1853 let mut query_params: Vec<(&str, String)> = vec![];
1854
1855 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1856 let response = self
1857 .client
1858 .post(url)
1859 .query(&query_params)
1860 .json(&request_body)
1861 .send()
1862 .unwrap();
1863
1864 if response.status().is_success() {
1865 let response: PostApisApiIdVersionsResponse = response.json().unwrap();
1866 Ok(response)
1867 } else {
1868 let status_code = response.status().as_u16();
1869 let message = response.text().unwrap_or_default();
1870 let err = ErrorResponse { status_code, message };
1871 Err(Error::ErrorResponse(err))
1872 }
1873 }
1874 pub fn create_collection(&self, request: PostCollectionsRequest) -> Result<PostCollectionsResponse, Error> {
1875 let endpoint = "/collections";
1876 let url = format!("{}{}", self.base_url, endpoint);
1877
1878 let mut query_params: Vec<(&str, String)> = vec![];
1879 if let Some(workspace_id) = request.workspace_id {
1880 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
1881 }
1882
1883 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1884 let response = self
1885 .client
1886 .post(url)
1887 .query(&query_params)
1888 .json(&request_body)
1889 .send()
1890 .unwrap();
1891
1892 if response.status().is_success() {
1893 let response: PostCollectionsResponse = response.json().unwrap();
1894 Ok(response)
1895 } else {
1896 let status_code = response.status().as_u16();
1897 let message = response.text().unwrap_or_default();
1898 let err = ErrorResponse { status_code, message };
1899 Err(Error::ErrorResponse(err))
1900 }
1901 }
1902 pub fn create_a_fork(&self, request: PostCollectionsForkCollectionIdRequest) -> Result<PostCollectionsForkCollectionIdResponse, Error> {
1903 let endpoint = format!("/collections/fork/{}", request.collection_id);
1904 let url = format!("{}{}", self.base_url, endpoint);
1905
1906 let mut query_params: Vec<(&str, String)> = vec![];
1907 query_params.push(("workspace", format!("{:?}", &request.workspace)));
1908
1909 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1910 let response = self
1911 .client
1912 .post(url)
1913 .query(&query_params)
1914 .json(&request_body)
1915 .send()
1916 .unwrap();
1917
1918 if response.status().is_success() {
1919 let response: PostCollectionsForkCollectionIdResponse = response.json().unwrap();
1920 Ok(response)
1921 } else {
1922 let status_code = response.status().as_u16();
1923 let message = response.text().unwrap_or_default();
1924 let err = ErrorResponse { status_code, message };
1925 Err(Error::ErrorResponse(err))
1926 }
1927 }
1928 pub fn merge_a_fork(&self, request: PostCollectionsMergeRequest) -> Result<PostCollectionsMergeResponse, Error> {
1929 let endpoint = "/collections/merge";
1930 let url = format!("{}{}", self.base_url, endpoint);
1931
1932 let mut query_params: Vec<(&str, String)> = vec![];
1933
1934 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1935 let response = self
1936 .client
1937 .post(url)
1938 .query(&query_params)
1939 .json(&request_body)
1940 .send()
1941 .unwrap();
1942
1943 if response.status().is_success() {
1944 let response: PostCollectionsMergeResponse = response.json().unwrap();
1945 Ok(response)
1946 } else {
1947 let status_code = response.status().as_u16();
1948 let message = response.text().unwrap_or_default();
1949 let err = ErrorResponse { status_code, message };
1950 Err(Error::ErrorResponse(err))
1951 }
1952 }
1953 pub fn create_collection_folder(&self, request: PostCollectionsCollectionIdFoldersRequest) -> Result<PostCollectionsCollectionIdFoldersResponse, Error> {
1954 let endpoint = format!("/collections/{}/folders", request.collection_id);
1955 let url = format!("{}{}", self.base_url, endpoint);
1956
1957 let mut query_params: Vec<(&str, String)> = vec![];
1958
1959 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1960 let response = self
1961 .client
1962 .post(url)
1963 .query(&query_params)
1964 .json(&request_body)
1965 .send()
1966 .unwrap();
1967
1968 if response.status().is_success() {
1969 let response: PostCollectionsCollectionIdFoldersResponse = response.json().unwrap();
1970 Ok(response)
1971 } else {
1972 let status_code = response.status().as_u16();
1973 let message = response.text().unwrap_or_default();
1974 let err = ErrorResponse { status_code, message };
1975 Err(Error::ErrorResponse(err))
1976 }
1977 }
1978 pub fn create_collection_request(&self, request: PostCollectionsCollectionIdRequestsRequest) -> Result<PostCollectionsCollectionIdRequestsResponse, Error> {
1979 let endpoint = format!("/collections/{}/requests", request.collection_id);
1980 let url = format!("{}{}", self.base_url, endpoint);
1981
1982 let mut query_params: Vec<(&str, String)> = vec![];
1983 if let Some(folder_id) = request.folder_id {
1984 query_params.push(("folder_id", format!("{:?}", &folder_id)));
1985 }
1986
1987 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
1988 let response = self
1989 .client
1990 .post(url)
1991 .query(&query_params)
1992 .json(&request_body)
1993 .send()
1994 .unwrap();
1995
1996 if response.status().is_success() {
1997 let response: PostCollectionsCollectionIdRequestsResponse = response.json().unwrap();
1998 Ok(response)
1999 } else {
2000 let status_code = response.status().as_u16();
2001 let message = response.text().unwrap_or_default();
2002 let err = ErrorResponse { status_code, message };
2003 Err(Error::ErrorResponse(err))
2004 }
2005 }
2006 pub fn create_collection_response(&self, request: PostCollectionsCollectionIdResponsesRequest) -> Result<PostCollectionsCollectionIdResponsesResponse, Error> {
2007 let endpoint = format!("/collections/{}/responses", request.collection_id);
2008 let url = format!("{}{}", self.base_url, endpoint);
2009
2010 let mut query_params: Vec<(&str, String)> = vec![];
2011 query_params.push(("request_id", format!("{:?}", &request.request_id)));
2012
2013 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2014 let response = self
2015 .client
2016 .post(url)
2017 .query(&query_params)
2018 .json(&request_body)
2019 .send()
2020 .unwrap();
2021
2022 if response.status().is_success() {
2023 let response: PostCollectionsCollectionIdResponsesResponse = response.json().unwrap();
2024 Ok(response)
2025 } else {
2026 let status_code = response.status().as_u16();
2027 let message = response.text().unwrap_or_default();
2028 let err = ErrorResponse { status_code, message };
2029 Err(Error::ErrorResponse(err))
2030 }
2031 }
2032 pub fn detected_secrets_queries(&self, request: PostDetectedSecretsQueriesRequest) -> Result<PostDetectedSecretsQueriesResponse, Error> {
2033 let endpoint = "/detected-secrets-queries";
2034 let url = format!("{}{}", self.base_url, endpoint);
2035
2036 let mut query_params: Vec<(&str, String)> = vec![];
2037 if let Some(cursor) = request.cursor {
2038 query_params.push(("cursor", format!("{:?}", &cursor)));
2039 }
2040 if let Some(include) = request.include {
2041 query_params.push(("include", format!("{:?}", &include)));
2042 }
2043 if let Some(limit) = request.limit {
2044 query_params.push(("limit", format!("{:?}", &limit)));
2045 }
2046
2047 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2048 let response = self
2049 .client
2050 .post(url)
2051 .query(&query_params)
2052 .json(&request_body)
2053 .send()
2054 .unwrap();
2055
2056 if response.status().is_success() {
2057 let response: PostDetectedSecretsQueriesResponse = response.json().unwrap();
2058 Ok(response)
2059 } else {
2060 let status_code = response.status().as_u16();
2061 let message = response.text().unwrap_or_default();
2062 let err = ErrorResponse { status_code, message };
2063 Err(Error::ErrorResponse(err))
2064 }
2065 }
2066 pub fn create_environment(&self, request: PostEnvironmentsRequest) -> Result<PostEnvironmentsResponse, Error> {
2067 let endpoint = "/environments";
2068 let url = format!("{}{}", self.base_url, endpoint);
2069
2070 let mut query_params: Vec<(&str, String)> = vec![];
2071 if let Some(workspace_id) = request.workspace_id {
2072 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
2073 }
2074
2075 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2076 let response = self
2077 .client
2078 .post(url)
2079 .query(&query_params)
2080 .json(&request_body)
2081 .send()
2082 .unwrap();
2083
2084 if response.status().is_success() {
2085 let response: PostEnvironmentsResponse = response.json().unwrap();
2086 Ok(response)
2087 } else {
2088 let status_code = response.status().as_u16();
2089 let message = response.text().unwrap_or_default();
2090 let err = ErrorResponse { status_code, message };
2091 Err(Error::ErrorResponse(err))
2092 }
2093 }
2094 pub fn import_external_api_specification(&self, request: PostImportOpenapiRequest) -> Result<PostImportOpenapiResponse, Error> {
2095 let endpoint = "/import/openapi";
2096 let url = format!("{}{}", self.base_url, endpoint);
2097
2098 let mut query_params: Vec<(&str, String)> = vec![];
2099 if let Some(workspace_id) = request.workspace_id {
2100 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
2101 }
2102
2103 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2104 let response = self
2105 .client
2106 .post(url)
2107 .query(&query_params)
2108 .json(&request_body)
2109 .send()
2110 .unwrap();
2111
2112 if response.status().is_success() {
2113 let response: PostImportOpenapiResponse = response.json().unwrap();
2114 Ok(response)
2115 } else {
2116 let status_code = response.status().as_u16();
2117 let message = response.text().unwrap_or_default();
2118 let err = ErrorResponse { status_code, message };
2119 Err(Error::ErrorResponse(err))
2120 }
2121 }
2122 pub fn create_mock(&self, request: PostMocksRequest) -> Result<PostMocksResponse, Error> {
2123 let endpoint = "/mocks";
2124 let url = format!("{}{}", self.base_url, endpoint);
2125
2126 let mut query_params: Vec<(&str, String)> = vec![];
2127 if let Some(workspace_id) = request.workspace_id {
2128 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
2129 }
2130
2131 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2132 let response = self
2133 .client
2134 .post(url)
2135 .query(&query_params)
2136 .json(&request_body)
2137 .send()
2138 .unwrap();
2139
2140 if response.status().is_success() {
2141 let response: PostMocksResponse = response.json().unwrap();
2142 Ok(response)
2143 } else {
2144 let status_code = response.status().as_u16();
2145 let message = response.text().unwrap_or_default();
2146 let err = ErrorResponse { status_code, message };
2147 Err(Error::ErrorResponse(err))
2148 }
2149 }
2150 pub fn publish_mock(&self, request: PostMocksMockIdPublishRequest) -> Result<PostMocksMockIdPublishResponse, Error> {
2151 let endpoint = format!("/mocks/{}/publish", request.mock_id);
2152 let url = format!("{}{}", self.base_url, endpoint);
2153
2154 let mut query_params: Vec<(&str, String)> = vec![];
2155
2156 let response = self
2157 .client
2158 .post(url)
2159 .query(&query_params)
2160
2161 .send()
2162 .unwrap();
2163
2164 if response.status().is_success() {
2165 let response: PostMocksMockIdPublishResponse = response.json().unwrap();
2166 Ok(response)
2167 } else {
2168 let status_code = response.status().as_u16();
2169 let message = response.text().unwrap_or_default();
2170 let err = ErrorResponse { status_code, message };
2171 Err(Error::ErrorResponse(err))
2172 }
2173 }
2174 pub fn create_server_response(&self, request: PostMocksMockIdServerResponsesRequest) -> Result<Vec<PostMocksMockIdServerResponsesResponseItem>, Error> {
2175 let endpoint = format!("/mocks/{}/server-responses", request.mock_id);
2176 let url = format!("{}{}", self.base_url, endpoint);
2177
2178 let mut query_params: Vec<(&str, String)> = vec![];
2179
2180 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2181 let response = self
2182 .client
2183 .post(url)
2184 .query(&query_params)
2185 .json(&request_body)
2186 .send()
2187 .unwrap();
2188
2189 if response.status().is_success() {
2190 let response: Vec<PostMocksMockIdServerResponsesResponseItem> = response.json().unwrap();
2191 Ok(response)
2192 } else {
2193 let status_code = response.status().as_u16();
2194 let message = response.text().unwrap_or_default();
2195 let err = ErrorResponse { status_code, message };
2196 Err(Error::ErrorResponse(err))
2197 }
2198 }
2199 pub fn create_monitor(&self, request: PostMonitorsRequest) -> Result<PostMonitorsResponse, Error> {
2200 let endpoint = "/monitors";
2201 let url = format!("{}{}", self.base_url, endpoint);
2202
2203 let mut query_params: Vec<(&str, String)> = vec![];
2204 if let Some(workspace_id) = request.workspace_id {
2205 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
2206 }
2207
2208 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2209 let response = self
2210 .client
2211 .post(url)
2212 .query(&query_params)
2213 .json(&request_body)
2214 .send()
2215 .unwrap();
2216
2217 if response.status().is_success() {
2218 let response: PostMonitorsResponse = response.json().unwrap();
2219 Ok(response)
2220 } else {
2221 let status_code = response.status().as_u16();
2222 let message = response.text().unwrap_or_default();
2223 let err = ErrorResponse { status_code, message };
2224 Err(Error::ErrorResponse(err))
2225 }
2226 }
2227 pub fn run_a_monitor(&self, request: PostMonitorsMonitorIdRunRequest) -> Result<PostMonitorsMonitorIdRunResponse, Error> {
2228 let endpoint = format!("/monitors/{}/run", request.monitor_id);
2229 let url = format!("{}{}", self.base_url, endpoint);
2230
2231 let mut query_params: Vec<(&str, String)> = vec![];
2232
2233 let response = self
2234 .client
2235 .post(url)
2236 .query(&query_params)
2237
2238 .send()
2239 .unwrap();
2240
2241 if response.status().is_success() {
2242 let response: PostMonitorsMonitorIdRunResponse = response.json().unwrap();
2243 Ok(response)
2244 } else {
2245 let status_code = response.status().as_u16();
2246 let message = response.text().unwrap_or_default();
2247 let err = ErrorResponse { status_code, message };
2248 Err(Error::ErrorResponse(err))
2249 }
2250 }
2251 pub fn post_element_or_folder(&self, request: PostNetworkPrivateRequest) -> Result<serde_json::Value, Error> {
2252 let endpoint = "/network/private";
2253 let url = format!("{}{}", self.base_url, endpoint);
2254
2255 let mut query_params: Vec<(&str, String)> = vec![];
2256
2257 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2258 let response = self
2259 .client
2260 .post(url)
2261 .query(&query_params)
2262 .json(&request_body)
2263 .send()
2264 .unwrap();
2265
2266 if response.status().is_success() {
2267 let response: serde_json::Value = response.json().unwrap();
2268 Ok(response)
2269 } else {
2270 let status_code = response.status().as_u16();
2271 let message = response.text().unwrap_or_default();
2272 let err = ErrorResponse { status_code, message };
2273 Err(Error::ErrorResponse(err))
2274 }
2275 }
2276 pub fn create_group(&self, request: PostScimV2GroupsRequest) -> Result<PostScimV2GroupsResponse, Error> {
2277 let endpoint = "/scim/v2/Groups";
2278 let url = format!("{}{}", self.base_url, endpoint);
2279
2280 let mut query_params: Vec<(&str, String)> = vec![];
2281
2282 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2283 let response = self
2284 .client
2285 .post(url)
2286 .query(&query_params)
2287 .json(&request_body)
2288 .send()
2289 .unwrap();
2290
2291 if response.status().is_success() {
2292 let response: PostScimV2GroupsResponse = response.json().unwrap();
2293 Ok(response)
2294 } else {
2295 let status_code = response.status().as_u16();
2296 let message = response.text().unwrap_or_default();
2297 let err = ErrorResponse { status_code, message };
2298 Err(Error::ErrorResponse(err))
2299 }
2300 }
2301 pub fn create_user(&self, request: PostScimV2UsersRequest) -> Result<PostScimV2UsersResponse, Error> {
2302 let endpoint = "/scim/v2/Users";
2303 let url = format!("{}{}", self.base_url, endpoint);
2304
2305 let mut query_params: Vec<(&str, String)> = vec![];
2306
2307 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2308 let response = self
2309 .client
2310 .post(url)
2311 .query(&query_params)
2312 .json(&request_body)
2313 .send()
2314 .unwrap();
2315
2316 if response.status().is_success() {
2317 let response: PostScimV2UsersResponse = response.json().unwrap();
2318 Ok(response)
2319 } else {
2320 let status_code = response.status().as_u16();
2321 let message = response.text().unwrap_or_default();
2322 let err = ErrorResponse { status_code, message };
2323 Err(Error::ErrorResponse(err))
2324 }
2325 }
2326 pub fn schema_security_validation(&self, request: PostSecurityApiValidationRequest) -> Result<PostSecurityApiValidationResponse, Error> {
2327 let endpoint = "/security/api-validation";
2328 let url = format!("{}{}", self.base_url, endpoint);
2329
2330 let mut query_params: Vec<(&str, String)> = vec![];
2331
2332 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2333 let response = self
2334 .client
2335 .post(url)
2336 .query(&query_params)
2337 .json(&request_body)
2338 .send()
2339 .unwrap();
2340
2341 if response.status().is_success() {
2342 let response: PostSecurityApiValidationResponse = response.json().unwrap();
2343 Ok(response)
2344 } else {
2345 let status_code = response.status().as_u16();
2346 let message = response.text().unwrap_or_default();
2347 let err = ErrorResponse { status_code, message };
2348 Err(Error::ErrorResponse(err))
2349 }
2350 }
2351 pub fn create_webhook(&self, request: PostWebhooksRequest) -> Result<PostWebhooksResponse, Error> {
2352 let endpoint = "/webhooks";
2353 let url = format!("{}{}", self.base_url, endpoint);
2354
2355 let mut query_params: Vec<(&str, String)> = vec![];
2356 if let Some(workspace_id) = request.workspace_id {
2357 query_params.push(("workspace_id", format!("{:?}", &workspace_id)));
2358 }
2359
2360 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2361 let response = self
2362 .client
2363 .post(url)
2364 .query(&query_params)
2365 .json(&request_body)
2366 .send()
2367 .unwrap();
2368
2369 if response.status().is_success() {
2370 let response: PostWebhooksResponse = response.json().unwrap();
2371 Ok(response)
2372 } else {
2373 let status_code = response.status().as_u16();
2374 let message = response.text().unwrap_or_default();
2375 let err = ErrorResponse { status_code, message };
2376 Err(Error::ErrorResponse(err))
2377 }
2378 }
2379 pub fn create_workspace(&self, request: PostWorkspacesRequest) -> Result<PostWorkspacesResponse, Error> {
2380 let endpoint = "/workspaces";
2381 let url = format!("{}{}", self.base_url, endpoint);
2382
2383 let mut query_params: Vec<(&str, String)> = vec![];
2384
2385 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2386 let response = self
2387 .client
2388 .post(url)
2389 .query(&query_params)
2390 .json(&request_body)
2391 .send()
2392 .unwrap();
2393
2394 if response.status().is_success() {
2395 let response: PostWorkspacesResponse = response.json().unwrap();
2396 Ok(response)
2397 } else {
2398 let status_code = response.status().as_u16();
2399 let message = response.text().unwrap_or_default();
2400 let err = ErrorResponse { status_code, message };
2401 Err(Error::ErrorResponse(err))
2402 }
2403 }
2404 pub fn update_an_api(&self, request: PutApisApiIdRequest) -> Result<PutApisApiIdResponse, Error> {
2405 let endpoint = format!("/apis/{}", request.api_id);
2406 let url = format!("{}{}", self.base_url, endpoint);
2407
2408 let mut query_params: Vec<(&str, String)> = vec![];
2409
2410 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2411 let response = self
2412 .client
2413 .put(url)
2414 .query(&query_params)
2415 .json(&request_body)
2416 .send()
2417 .unwrap();
2418
2419 if response.status().is_success() {
2420 let response: PutApisApiIdResponse = response.json().unwrap();
2421 Ok(response)
2422 } else {
2423 let status_code = response.status().as_u16();
2424 let message = response.text().unwrap_or_default();
2425 let err = ErrorResponse { status_code, message };
2426 Err(Error::ErrorResponse(err))
2427 }
2428 }
2429 pub fn sync_collection_with_schema(&self, request: PutApisApiIdCollectionsCollectionIdSyncWithSchemaTasksRequest) -> Result<PutApisApiIdCollectionsCollectionIdSyncWithSchemaTasksResponse, Error> {
2430 let endpoint = format!("/apis/{}/collections/{}/sync-with-schema-tasks", request.api_id, request.collection_id);
2431 let url = format!("{}{}", self.base_url, endpoint);
2432
2433 let mut query_params: Vec<(&str, String)> = vec![];
2434
2435 let response = self
2436 .client
2437 .put(url)
2438 .query(&query_params)
2439
2440 .send()
2441 .unwrap();
2442
2443 if response.status().is_success() {
2444 let response: PutApisApiIdCollectionsCollectionIdSyncWithSchemaTasksResponse = response.json().unwrap();
2445 Ok(response)
2446 } else {
2447 let status_code = response.status().as_u16();
2448 let message = response.text().unwrap_or_default();
2449 let err = ErrorResponse { status_code, message };
2450 Err(Error::ErrorResponse(err))
2451 }
2452 }
2453 pub fn create_or_update_schema_file(&self, request: PutApisApiIdSchemasSchemaIdFilesFilePathRequest) -> Result<PutApisApiIdSchemasSchemaIdFilesFilePathResponse, Error> {
2454 let endpoint = format!("/apis/{}/schemas/{}/files/{}", request.api_id, request.schema_id, request.file_path);
2455 let url = format!("{}{}", self.base_url, endpoint);
2456
2457 let mut query_params: Vec<(&str, String)> = vec![];
2458
2459 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2460 let response = self
2461 .client
2462 .put(url)
2463 .query(&query_params)
2464 .json(&request_body)
2465 .send()
2466 .unwrap();
2467
2468 if response.status().is_success() {
2469 let response: PutApisApiIdSchemasSchemaIdFilesFilePathResponse = response.json().unwrap();
2470 Ok(response)
2471 } else {
2472 let status_code = response.status().as_u16();
2473 let message = response.text().unwrap_or_default();
2474 let err = ErrorResponse { status_code, message };
2475 Err(Error::ErrorResponse(err))
2476 }
2477 }
2478 pub fn update_api_tags(&self, request: PutApisApiIdTagsRequest) -> Result<PutApisApiIdTagsResponse, Error> {
2479 let endpoint = format!("/apis/{}/tags", request.api_id);
2480 let url = format!("{}{}", self.base_url, endpoint);
2481
2482 let mut query_params: Vec<(&str, String)> = vec![];
2483
2484 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2485 let response = self
2486 .client
2487 .put(url)
2488 .query(&query_params)
2489 .json(&request_body)
2490 .send()
2491 .unwrap();
2492
2493 if response.status().is_success() {
2494 let response: PutApisApiIdTagsResponse = response.json().unwrap();
2495 Ok(response)
2496 } else {
2497 let status_code = response.status().as_u16();
2498 let message = response.text().unwrap_or_default();
2499 let err = ErrorResponse { status_code, message };
2500 Err(Error::ErrorResponse(err))
2501 }
2502 }
2503 pub fn update_api_version(&self, request: PutApisApiIdVersionsVersionIdRequest) -> Result<PutApisApiIdVersionsVersionIdResponse, Error> {
2504 let endpoint = format!("/apis/{}/versions/{}", request.api_id, request.version_id);
2505 let url = format!("{}{}", self.base_url, endpoint);
2506
2507 let mut query_params: Vec<(&str, String)> = vec![];
2508
2509 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2510 let response = self
2511 .client
2512 .put(url)
2513 .query(&query_params)
2514 .json(&request_body)
2515 .send()
2516 .unwrap();
2517
2518 if response.status().is_success() {
2519 let response: PutApisApiIdVersionsVersionIdResponse = response.json().unwrap();
2520 Ok(response)
2521 } else {
2522 let status_code = response.status().as_u16();
2523 let message = response.text().unwrap_or_default();
2524 let err = ErrorResponse { status_code, message };
2525 Err(Error::ErrorResponse(err))
2526 }
2527 }
2528 pub fn put_collection(&self, request: PutCollectionsCollectionIdRequest) -> Result<PutCollectionsCollectionIdResponse, Error> {
2529 let endpoint = format!("/collections/{}", request.collection_id);
2530 let url = format!("{}{}", self.base_url, endpoint);
2531
2532 let mut query_params: Vec<(&str, String)> = vec![];
2533
2534 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2535 let response = self
2536 .client
2537 .put(url)
2538 .query(&query_params)
2539 .json(&request_body)
2540 .send()
2541 .unwrap();
2542
2543 if response.status().is_success() {
2544 let response: PutCollectionsCollectionIdResponse = response.json().unwrap();
2545 Ok(response)
2546 } else {
2547 let status_code = response.status().as_u16();
2548 let message = response.text().unwrap_or_default();
2549 let err = ErrorResponse { status_code, message };
2550 Err(Error::ErrorResponse(err))
2551 }
2552 }
2553 pub fn update_collection_folder(&self, request: PutCollectionsCollectionIdFoldersFolderIdRequest) -> Result<PutCollectionsCollectionIdFoldersFolderIdResponse, Error> {
2554 let endpoint = format!("/collections/{}/folders/{}", request.collection_id, request.folder_id);
2555 let url = format!("{}{}", self.base_url, endpoint);
2556
2557 let mut query_params: Vec<(&str, String)> = vec![];
2558
2559 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2560 let response = self
2561 .client
2562 .put(url)
2563 .query(&query_params)
2564 .json(&request_body)
2565 .send()
2566 .unwrap();
2567
2568 if response.status().is_success() {
2569 let response: PutCollectionsCollectionIdFoldersFolderIdResponse = response.json().unwrap();
2570 Ok(response)
2571 } else {
2572 let status_code = response.status().as_u16();
2573 let message = response.text().unwrap_or_default();
2574 let err = ErrorResponse { status_code, message };
2575 Err(Error::ErrorResponse(err))
2576 }
2577 }
2578 pub fn update_collection_request(&self, request: PutCollectionsCollectionIdRequestsRequestIdRequest) -> Result<PutCollectionsCollectionIdRequestsRequestIdResponse, Error> {
2579 let endpoint = format!("/collections/{}/requests/{}", request.collection_id, request.request_id);
2580 let url = format!("{}{}", self.base_url, endpoint);
2581
2582 let mut query_params: Vec<(&str, String)> = vec![];
2583
2584 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2585 let response = self
2586 .client
2587 .put(url)
2588 .query(&query_params)
2589 .json(&request_body)
2590 .send()
2591 .unwrap();
2592
2593 if response.status().is_success() {
2594 let response: PutCollectionsCollectionIdRequestsRequestIdResponse = response.json().unwrap();
2595 Ok(response)
2596 } else {
2597 let status_code = response.status().as_u16();
2598 let message = response.text().unwrap_or_default();
2599 let err = ErrorResponse { status_code, message };
2600 Err(Error::ErrorResponse(err))
2601 }
2602 }
2603 pub fn update_collection_response(&self, request: PutCollectionsCollectionIdResponsesResponseIdRequest) -> Result<PutCollectionsCollectionIdResponsesResponseIdResponse, Error> {
2604 let endpoint = format!("/collections/{}/responses/{}", request.collection_id, request.response_id);
2605 let url = format!("{}{}", self.base_url, endpoint);
2606
2607 let mut query_params: Vec<(&str, String)> = vec![];
2608
2609 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2610 let response = self
2611 .client
2612 .put(url)
2613 .query(&query_params)
2614 .json(&request_body)
2615 .send()
2616 .unwrap();
2617
2618 if response.status().is_success() {
2619 let response: PutCollectionsCollectionIdResponsesResponseIdResponse = response.json().unwrap();
2620 Ok(response)
2621 } else {
2622 let status_code = response.status().as_u16();
2623 let message = response.text().unwrap_or_default();
2624 let err = ErrorResponse { status_code, message };
2625 Err(Error::ErrorResponse(err))
2626 }
2627 }
2628 pub fn update_collection_tags(&self, request: PutCollectionsCollectionIdTagsRequest) -> Result<PutCollectionsCollectionIdTagsResponse, Error> {
2629 let endpoint = format!("/collections/{}/tags", request.collection_id);
2630 let url = format!("{}{}", self.base_url, endpoint);
2631
2632 let mut query_params: Vec<(&str, String)> = vec![];
2633
2634 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2635 let response = self
2636 .client
2637 .put(url)
2638 .query(&query_params)
2639 .json(&request_body)
2640 .send()
2641 .unwrap();
2642
2643 if response.status().is_success() {
2644 let response: PutCollectionsCollectionIdTagsResponse = response.json().unwrap();
2645 Ok(response)
2646 } else {
2647 let status_code = response.status().as_u16();
2648 let message = response.text().unwrap_or_default();
2649 let err = ErrorResponse { status_code, message };
2650 Err(Error::ErrorResponse(err))
2651 }
2652 }
2653 pub fn update_detected_secret_resolutions(&self, request: PutDetectedSecretsSecretIdRequest) -> Result<PutDetectedSecretsSecretIdResponse, Error> {
2654 let endpoint = format!("/detected-secrets/{}", request.secret_id);
2655 let url = format!("{}{}", self.base_url, endpoint);
2656
2657 let mut query_params: Vec<(&str, String)> = vec![];
2658
2659 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2660 let response = self
2661 .client
2662 .put(url)
2663 .query(&query_params)
2664 .json(&request_body)
2665 .send()
2666 .unwrap();
2667
2668 if response.status().is_success() {
2669 let response: PutDetectedSecretsSecretIdResponse = response.json().unwrap();
2670 Ok(response)
2671 } else {
2672 let status_code = response.status().as_u16();
2673 let message = response.text().unwrap_or_default();
2674 let err = ErrorResponse { status_code, message };
2675 Err(Error::ErrorResponse(err))
2676 }
2677 }
2678 pub fn update_environment(&self, request: PutEnvironmentsEnvironmentIdRequest) -> Result<PutEnvironmentsEnvironmentIdResponse, Error> {
2679 let endpoint = format!("/environments/{}", request.environment_id);
2680 let url = format!("{}{}", self.base_url, endpoint);
2681
2682 let mut query_params: Vec<(&str, String)> = vec![];
2683
2684 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2685 let response = self
2686 .client
2687 .put(url)
2688 .query(&query_params)
2689 .json(&request_body)
2690 .send()
2691 .unwrap();
2692
2693 if response.status().is_success() {
2694 let response: PutEnvironmentsEnvironmentIdResponse = response.json().unwrap();
2695 Ok(response)
2696 } else {
2697 let status_code = response.status().as_u16();
2698 let message = response.text().unwrap_or_default();
2699 let err = ErrorResponse { status_code, message };
2700 Err(Error::ErrorResponse(err))
2701 }
2702 }
2703 pub fn update_mock(&self, request: PutMocksMockIdRequest) -> Result<PutMocksMockIdResponse, Error> {
2704 let endpoint = format!("/mocks/{}", request.mock_id);
2705 let url = format!("{}{}", self.base_url, endpoint);
2706
2707 let mut query_params: Vec<(&str, String)> = vec![];
2708
2709 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2710 let response = self
2711 .client
2712 .put(url)
2713 .query(&query_params)
2714 .json(&request_body)
2715 .send()
2716 .unwrap();
2717
2718 if response.status().is_success() {
2719 let response: PutMocksMockIdResponse = response.json().unwrap();
2720 Ok(response)
2721 } else {
2722 let status_code = response.status().as_u16();
2723 let message = response.text().unwrap_or_default();
2724 let err = ErrorResponse { status_code, message };
2725 Err(Error::ErrorResponse(err))
2726 }
2727 }
2728 pub fn update_server_response(&self, request: PutMocksMockIdServerResponsesServerResponseIdRequest) -> Result<Vec<PutMocksMockIdServerResponsesServerResponseIdResponseItem>, Error> {
2729 let endpoint = format!("/mocks/{}/server-responses/{}", request.mock_id, request.server_response_id);
2730 let url = format!("{}{}", self.base_url, endpoint);
2731
2732 let mut query_params: Vec<(&str, String)> = vec![];
2733
2734 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2735 let response = self
2736 .client
2737 .put(url)
2738 .query(&query_params)
2739 .json(&request_body)
2740 .send()
2741 .unwrap();
2742
2743 if response.status().is_success() {
2744 let response: Vec<PutMocksMockIdServerResponsesServerResponseIdResponseItem> = response.json().unwrap();
2745 Ok(response)
2746 } else {
2747 let status_code = response.status().as_u16();
2748 let message = response.text().unwrap_or_default();
2749 let err = ErrorResponse { status_code, message };
2750 Err(Error::ErrorResponse(err))
2751 }
2752 }
2753 pub fn update_monitor(&self, request: PutMonitorsMonitorIdRequest) -> Result<PutMonitorsMonitorIdResponse, Error> {
2754 let endpoint = format!("/monitors/{}", request.monitor_id);
2755 let url = format!("{}{}", self.base_url, endpoint);
2756
2757 let mut query_params: Vec<(&str, String)> = vec![];
2758
2759 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2760 let response = self
2761 .client
2762 .put(url)
2763 .query(&query_params)
2764 .json(&request_body)
2765 .send()
2766 .unwrap();
2767
2768 if response.status().is_success() {
2769 let response: PutMonitorsMonitorIdResponse = response.json().unwrap();
2770 Ok(response)
2771 } else {
2772 let status_code = response.status().as_u16();
2773 let message = response.text().unwrap_or_default();
2774 let err = ErrorResponse { status_code, message };
2775 Err(Error::ErrorResponse(err))
2776 }
2777 }
2778 pub fn respond_element_add_request(&self, request: PutNetworkPrivateNetworkEntityRequestRequestIdRequest) -> Result<PutNetworkPrivateNetworkEntityRequestRequestIdResponse, Error> {
2779 let endpoint = format!("/network/private/network-entity/request/{}", request.request_id);
2780 let url = format!("{}{}", self.base_url, endpoint);
2781
2782 let mut query_params: Vec<(&str, String)> = vec![];
2783
2784 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2785 let response = self
2786 .client
2787 .put(url)
2788 .query(&query_params)
2789 .json(&request_body)
2790 .send()
2791 .unwrap();
2792
2793 if response.status().is_success() {
2794 let response: PutNetworkPrivateNetworkEntityRequestRequestIdResponse = response.json().unwrap();
2795 Ok(response)
2796 } else {
2797 let status_code = response.status().as_u16();
2798 let message = response.text().unwrap_or_default();
2799 let err = ErrorResponse { status_code, message };
2800 Err(Error::ErrorResponse(err))
2801 }
2802 }
2803 pub fn put_element_or_folder(&self, request: PutNetworkPrivateElementTypeElementIdRequest) -> Result<serde_json::Value, Error> {
2804 let endpoint = format!("/network/private/{}/{}", request.element_type, request.element_id);
2805 let url = format!("{}{}", self.base_url, endpoint);
2806
2807 let mut query_params: Vec<(&str, String)> = vec![];
2808
2809 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2810 let response = self
2811 .client
2812 .put(url)
2813 .query(&query_params)
2814 .json(&request_body)
2815 .send()
2816 .unwrap();
2817
2818 if response.status().is_success() {
2819 let response: serde_json::Value = response.json().unwrap();
2820 Ok(response)
2821 } else {
2822 let status_code = response.status().as_u16();
2823 let message = response.text().unwrap_or_default();
2824 let err = ErrorResponse { status_code, message };
2825 Err(Error::ErrorResponse(err))
2826 }
2827 }
2828 pub fn update_user_information(&self, request: PutScimV2UsersUserIdRequest) -> Result<PutScimV2UsersUserIdResponse, Error> {
2829 let endpoint = format!("/scim/v2/Users/{}", request.user_id);
2830 let url = format!("{}{}", self.base_url, endpoint);
2831
2832 let mut query_params: Vec<(&str, String)> = vec![];
2833
2834 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2835 let response = self
2836 .client
2837 .put(url)
2838 .query(&query_params)
2839 .json(&request_body)
2840 .send()
2841 .unwrap();
2842
2843 if response.status().is_success() {
2844 let response: PutScimV2UsersUserIdResponse = response.json().unwrap();
2845 Ok(response)
2846 } else {
2847 let status_code = response.status().as_u16();
2848 let message = response.text().unwrap_or_default();
2849 let err = ErrorResponse { status_code, message };
2850 Err(Error::ErrorResponse(err))
2851 }
2852 }
2853 pub fn update_workspace(&self, request: PutWorkspacesWorkspaceIdRequest) -> Result<PutWorkspacesWorkspaceIdResponse, Error> {
2854 let endpoint = format!("/workspaces/{}", request.workspace_id);
2855 let url = format!("{}{}", self.base_url, endpoint);
2856
2857 let mut query_params: Vec<(&str, String)> = vec![];
2858
2859 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2860 let response = self
2861 .client
2862 .put(url)
2863 .query(&query_params)
2864 .json(&request_body)
2865 .send()
2866 .unwrap();
2867
2868 if response.status().is_success() {
2869 let response: PutWorkspacesWorkspaceIdResponse = response.json().unwrap();
2870 Ok(response)
2871 } else {
2872 let status_code = response.status().as_u16();
2873 let message = response.text().unwrap_or_default();
2874 let err = ErrorResponse { status_code, message };
2875 Err(Error::ErrorResponse(err))
2876 }
2877 }
2878 pub fn put_workspace_global_variables(&self, request: PutWorkspacesWorkspaceIdGlobalVariablesRequest) -> Result<PutWorkspacesWorkspaceIdGlobalVariablesResponse, Error> {
2879 let endpoint = format!("/workspaces/{}/global-variables", request.workspace_id);
2880 let url = format!("{}{}", self.base_url, endpoint);
2881
2882 let mut query_params: Vec<(&str, String)> = vec![];
2883
2884 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2885 let response = self
2886 .client
2887 .put(url)
2888 .query(&query_params)
2889 .json(&request_body)
2890 .send()
2891 .unwrap();
2892
2893 if response.status().is_success() {
2894 let response: PutWorkspacesWorkspaceIdGlobalVariablesResponse = response.json().unwrap();
2895 Ok(response)
2896 } else {
2897 let status_code = response.status().as_u16();
2898 let message = response.text().unwrap_or_default();
2899 let err = ErrorResponse { status_code, message };
2900 Err(Error::ErrorResponse(err))
2901 }
2902 }
2903 pub fn update_workspace_tags(&self, request: PutWorkspacesWorkspaceIdTagsRequest) -> Result<PutWorkspacesWorkspaceIdTagsResponse, Error> {
2904 let endpoint = format!("/workspaces/{}/tags", request.workspace_id);
2905 let url = format!("{}{}", self.base_url, endpoint);
2906
2907 let mut query_params: Vec<(&str, String)> = vec![];
2908
2909 let request_body: serde_json::Value = serde_json::to_value(request.data).unwrap();
2910 let response = self
2911 .client
2912 .put(url)
2913 .query(&query_params)
2914 .json(&request_body)
2915 .send()
2916 .unwrap();
2917
2918 if response.status().is_success() {
2919 let response: PutWorkspacesWorkspaceIdTagsResponse = response.json().unwrap();
2920 Ok(response)
2921 } else {
2922 let status_code = response.status().as_u16();
2923 let message = response.text().unwrap_or_default();
2924 let err = ErrorResponse { status_code, message };
2925 Err(Error::ErrorResponse(err))
2926 }
2927 }
2928
2929}