bitwarden_api_api/apis/
collections_api.rs

1/*
2 * Bitwarden Internal API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: latest
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12use serde::{de::Error as _, Deserialize, Serialize};
13
14use super::{configuration, ContentType, Error};
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method [`collections_get`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum CollectionsGetError {
21    UnknownValue(serde_json::Value),
22}
23
24/// struct for typed errors of method [`organizations_org_id_collections_bulk_access_post`]
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum OrganizationsOrgIdCollectionsBulkAccessPostError {
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`organizations_org_id_collections_delete`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum OrganizationsOrgIdCollectionsDeleteError {
35    UnknownValue(serde_json::Value),
36}
37
38/// struct for typed errors of method [`organizations_org_id_collections_delete_post`]
39#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum OrganizationsOrgIdCollectionsDeletePostError {
42    UnknownValue(serde_json::Value),
43}
44
45/// struct for typed errors of method [`organizations_org_id_collections_details_get`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum OrganizationsOrgIdCollectionsDetailsGetError {
49    UnknownValue(serde_json::Value),
50}
51
52/// struct for typed errors of method [`organizations_org_id_collections_get`]
53#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum OrganizationsOrgIdCollectionsGetError {
56    UnknownValue(serde_json::Value),
57}
58
59/// struct for typed errors of method [`organizations_org_id_collections_id_delete`]
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum OrganizationsOrgIdCollectionsIdDeleteError {
63    UnknownValue(serde_json::Value),
64}
65
66/// struct for typed errors of method [`organizations_org_id_collections_id_delete_post`]
67#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum OrganizationsOrgIdCollectionsIdDeletePostError {
70    UnknownValue(serde_json::Value),
71}
72
73/// struct for typed errors of method
74/// [`organizations_org_id_collections_id_delete_user_org_user_id_post`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum OrganizationsOrgIdCollectionsIdDeleteUserOrgUserIdPostError {
78    UnknownValue(serde_json::Value),
79}
80
81/// struct for typed errors of method [`organizations_org_id_collections_id_details_get`]
82#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum OrganizationsOrgIdCollectionsIdDetailsGetError {
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`organizations_org_id_collections_id_get`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum OrganizationsOrgIdCollectionsIdGetError {
92    UnknownValue(serde_json::Value),
93}
94
95/// struct for typed errors of method [`organizations_org_id_collections_id_post`]
96#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum OrganizationsOrgIdCollectionsIdPostError {
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`organizations_org_id_collections_id_put`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum OrganizationsOrgIdCollectionsIdPutError {
106    UnknownValue(serde_json::Value),
107}
108
109/// struct for typed errors of method
110/// [`organizations_org_id_collections_id_user_org_user_id_delete`]
111#[derive(Debug, Clone, Serialize, Deserialize)]
112#[serde(untagged)]
113pub enum OrganizationsOrgIdCollectionsIdUserOrgUserIdDeleteError {
114    UnknownValue(serde_json::Value),
115}
116
117/// struct for typed errors of method [`organizations_org_id_collections_id_users_get`]
118#[derive(Debug, Clone, Serialize, Deserialize)]
119#[serde(untagged)]
120pub enum OrganizationsOrgIdCollectionsIdUsersGetError {
121    UnknownValue(serde_json::Value),
122}
123
124/// struct for typed errors of method [`organizations_org_id_collections_id_users_put`]
125#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(untagged)]
127pub enum OrganizationsOrgIdCollectionsIdUsersPutError {
128    UnknownValue(serde_json::Value),
129}
130
131/// struct for typed errors of method [`organizations_org_id_collections_post`]
132#[derive(Debug, Clone, Serialize, Deserialize)]
133#[serde(untagged)]
134pub enum OrganizationsOrgIdCollectionsPostError {
135    UnknownValue(serde_json::Value),
136}
137
138pub async fn collections_get(
139    configuration: &configuration::Configuration,
140) -> Result<models::CollectionDetailsResponseModelListResponseModel, Error<CollectionsGetError>> {
141    let uri_str = format!("{}/collections", configuration.base_path);
142    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
143
144    if let Some(ref user_agent) = configuration.user_agent {
145        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
146    }
147    if let Some(ref token) = configuration.oauth_access_token {
148        req_builder = req_builder.bearer_auth(token.to_owned());
149    };
150
151    let req = req_builder.build()?;
152    let resp = configuration.client.execute(req).await?;
153
154    let status = resp.status();
155    let content_type = resp
156        .headers()
157        .get("content-type")
158        .and_then(|v| v.to_str().ok())
159        .unwrap_or("application/octet-stream");
160    let content_type = super::ContentType::from(content_type);
161
162    if !status.is_client_error() && !status.is_server_error() {
163        let content = resp.text().await?;
164        match content_type {
165            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
166            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionDetailsResponseModelListResponseModel`"))),
167            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionDetailsResponseModelListResponseModel`")))),
168        }
169    } else {
170        let content = resp.text().await?;
171        let entity: Option<CollectionsGetError> = serde_json::from_str(&content).ok();
172        Err(Error::ResponseError(ResponseContent {
173            status,
174            content,
175            entity,
176        }))
177    }
178}
179
180pub async fn organizations_org_id_collections_bulk_access_post(
181    configuration: &configuration::Configuration,
182    org_id: uuid::Uuid,
183    bulk_collection_access_request_model: Option<models::BulkCollectionAccessRequestModel>,
184) -> Result<(), Error<OrganizationsOrgIdCollectionsBulkAccessPostError>> {
185    // add a prefix to parameters to efficiently prevent name collisions
186    let p_org_id = org_id;
187    let p_bulk_collection_access_request_model = bulk_collection_access_request_model;
188
189    let uri_str = format!(
190        "{}/organizations/{orgId}/collections/bulk-access",
191        configuration.base_path,
192        orgId = crate::apis::urlencode(p_org_id.to_string())
193    );
194    let mut req_builder = configuration
195        .client
196        .request(reqwest::Method::POST, &uri_str);
197
198    if let Some(ref user_agent) = configuration.user_agent {
199        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
200    }
201    if let Some(ref token) = configuration.oauth_access_token {
202        req_builder = req_builder.bearer_auth(token.to_owned());
203    };
204    req_builder = req_builder.json(&p_bulk_collection_access_request_model);
205
206    let req = req_builder.build()?;
207    let resp = configuration.client.execute(req).await?;
208
209    let status = resp.status();
210
211    if !status.is_client_error() && !status.is_server_error() {
212        Ok(())
213    } else {
214        let content = resp.text().await?;
215        let entity: Option<OrganizationsOrgIdCollectionsBulkAccessPostError> =
216            serde_json::from_str(&content).ok();
217        Err(Error::ResponseError(ResponseContent {
218            status,
219            content,
220            entity,
221        }))
222    }
223}
224
225pub async fn organizations_org_id_collections_delete(
226    configuration: &configuration::Configuration,
227    org_id: uuid::Uuid,
228    collection_bulk_delete_request_model: Option<models::CollectionBulkDeleteRequestModel>,
229) -> Result<(), Error<OrganizationsOrgIdCollectionsDeleteError>> {
230    // add a prefix to parameters to efficiently prevent name collisions
231    let p_org_id = org_id;
232    let p_collection_bulk_delete_request_model = collection_bulk_delete_request_model;
233
234    let uri_str = format!(
235        "{}/organizations/{orgId}/collections",
236        configuration.base_path,
237        orgId = crate::apis::urlencode(p_org_id.to_string())
238    );
239    let mut req_builder = configuration
240        .client
241        .request(reqwest::Method::DELETE, &uri_str);
242
243    if let Some(ref user_agent) = configuration.user_agent {
244        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
245    }
246    if let Some(ref token) = configuration.oauth_access_token {
247        req_builder = req_builder.bearer_auth(token.to_owned());
248    };
249    req_builder = req_builder.json(&p_collection_bulk_delete_request_model);
250
251    let req = req_builder.build()?;
252    let resp = configuration.client.execute(req).await?;
253
254    let status = resp.status();
255
256    if !status.is_client_error() && !status.is_server_error() {
257        Ok(())
258    } else {
259        let content = resp.text().await?;
260        let entity: Option<OrganizationsOrgIdCollectionsDeleteError> =
261            serde_json::from_str(&content).ok();
262        Err(Error::ResponseError(ResponseContent {
263            status,
264            content,
265            entity,
266        }))
267    }
268}
269
270pub async fn organizations_org_id_collections_delete_post(
271    configuration: &configuration::Configuration,
272    org_id: uuid::Uuid,
273    collection_bulk_delete_request_model: Option<models::CollectionBulkDeleteRequestModel>,
274) -> Result<(), Error<OrganizationsOrgIdCollectionsDeletePostError>> {
275    // add a prefix to parameters to efficiently prevent name collisions
276    let p_org_id = org_id;
277    let p_collection_bulk_delete_request_model = collection_bulk_delete_request_model;
278
279    let uri_str = format!(
280        "{}/organizations/{orgId}/collections/delete",
281        configuration.base_path,
282        orgId = crate::apis::urlencode(p_org_id.to_string())
283    );
284    let mut req_builder = configuration
285        .client
286        .request(reqwest::Method::POST, &uri_str);
287
288    if let Some(ref user_agent) = configuration.user_agent {
289        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
290    }
291    if let Some(ref token) = configuration.oauth_access_token {
292        req_builder = req_builder.bearer_auth(token.to_owned());
293    };
294    req_builder = req_builder.json(&p_collection_bulk_delete_request_model);
295
296    let req = req_builder.build()?;
297    let resp = configuration.client.execute(req).await?;
298
299    let status = resp.status();
300
301    if !status.is_client_error() && !status.is_server_error() {
302        Ok(())
303    } else {
304        let content = resp.text().await?;
305        let entity: Option<OrganizationsOrgIdCollectionsDeletePostError> =
306            serde_json::from_str(&content).ok();
307        Err(Error::ResponseError(ResponseContent {
308            status,
309            content,
310            entity,
311        }))
312    }
313}
314
315pub async fn organizations_org_id_collections_details_get(
316    configuration: &configuration::Configuration,
317    org_id: uuid::Uuid,
318) -> Result<
319    models::CollectionAccessDetailsResponseModelListResponseModel,
320    Error<OrganizationsOrgIdCollectionsDetailsGetError>,
321> {
322    // add a prefix to parameters to efficiently prevent name collisions
323    let p_org_id = org_id;
324
325    let uri_str = format!(
326        "{}/organizations/{orgId}/collections/details",
327        configuration.base_path,
328        orgId = crate::apis::urlencode(p_org_id.to_string())
329    );
330    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
331
332    if let Some(ref user_agent) = configuration.user_agent {
333        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
334    }
335    if let Some(ref token) = configuration.oauth_access_token {
336        req_builder = req_builder.bearer_auth(token.to_owned());
337    };
338
339    let req = req_builder.build()?;
340    let resp = configuration.client.execute(req).await?;
341
342    let status = resp.status();
343    let content_type = resp
344        .headers()
345        .get("content-type")
346        .and_then(|v| v.to_str().ok())
347        .unwrap_or("application/octet-stream");
348    let content_type = super::ContentType::from(content_type);
349
350    if !status.is_client_error() && !status.is_server_error() {
351        let content = resp.text().await?;
352        match content_type {
353            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
354            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionAccessDetailsResponseModelListResponseModel`"))),
355            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionAccessDetailsResponseModelListResponseModel`")))),
356        }
357    } else {
358        let content = resp.text().await?;
359        let entity: Option<OrganizationsOrgIdCollectionsDetailsGetError> =
360            serde_json::from_str(&content).ok();
361        Err(Error::ResponseError(ResponseContent {
362            status,
363            content,
364            entity,
365        }))
366    }
367}
368
369pub async fn organizations_org_id_collections_get(
370    configuration: &configuration::Configuration,
371    org_id: uuid::Uuid,
372) -> Result<
373    models::CollectionResponseModelListResponseModel,
374    Error<OrganizationsOrgIdCollectionsGetError>,
375> {
376    // add a prefix to parameters to efficiently prevent name collisions
377    let p_org_id = org_id;
378
379    let uri_str = format!(
380        "{}/organizations/{orgId}/collections",
381        configuration.base_path,
382        orgId = crate::apis::urlencode(p_org_id.to_string())
383    );
384    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
385
386    if let Some(ref user_agent) = configuration.user_agent {
387        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
388    }
389    if let Some(ref token) = configuration.oauth_access_token {
390        req_builder = req_builder.bearer_auth(token.to_owned());
391    };
392
393    let req = req_builder.build()?;
394    let resp = configuration.client.execute(req).await?;
395
396    let status = resp.status();
397    let content_type = resp
398        .headers()
399        .get("content-type")
400        .and_then(|v| v.to_str().ok())
401        .unwrap_or("application/octet-stream");
402    let content_type = super::ContentType::from(content_type);
403
404    if !status.is_client_error() && !status.is_server_error() {
405        let content = resp.text().await?;
406        match content_type {
407            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
408            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionResponseModelListResponseModel`"))),
409            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionResponseModelListResponseModel`")))),
410        }
411    } else {
412        let content = resp.text().await?;
413        let entity: Option<OrganizationsOrgIdCollectionsGetError> =
414            serde_json::from_str(&content).ok();
415        Err(Error::ResponseError(ResponseContent {
416            status,
417            content,
418            entity,
419        }))
420    }
421}
422
423pub async fn organizations_org_id_collections_id_delete(
424    configuration: &configuration::Configuration,
425    org_id: uuid::Uuid,
426    id: uuid::Uuid,
427) -> Result<(), Error<OrganizationsOrgIdCollectionsIdDeleteError>> {
428    // add a prefix to parameters to efficiently prevent name collisions
429    let p_org_id = org_id;
430    let p_id = id;
431
432    let uri_str = format!(
433        "{}/organizations/{orgId}/collections/{id}",
434        configuration.base_path,
435        orgId = crate::apis::urlencode(p_org_id.to_string()),
436        id = crate::apis::urlencode(p_id.to_string())
437    );
438    let mut req_builder = configuration
439        .client
440        .request(reqwest::Method::DELETE, &uri_str);
441
442    if let Some(ref user_agent) = configuration.user_agent {
443        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
444    }
445    if let Some(ref token) = configuration.oauth_access_token {
446        req_builder = req_builder.bearer_auth(token.to_owned());
447    };
448
449    let req = req_builder.build()?;
450    let resp = configuration.client.execute(req).await?;
451
452    let status = resp.status();
453
454    if !status.is_client_error() && !status.is_server_error() {
455        Ok(())
456    } else {
457        let content = resp.text().await?;
458        let entity: Option<OrganizationsOrgIdCollectionsIdDeleteError> =
459            serde_json::from_str(&content).ok();
460        Err(Error::ResponseError(ResponseContent {
461            status,
462            content,
463            entity,
464        }))
465    }
466}
467
468pub async fn organizations_org_id_collections_id_delete_post(
469    configuration: &configuration::Configuration,
470    org_id: uuid::Uuid,
471    id: uuid::Uuid,
472) -> Result<(), Error<OrganizationsOrgIdCollectionsIdDeletePostError>> {
473    // add a prefix to parameters to efficiently prevent name collisions
474    let p_org_id = org_id;
475    let p_id = id;
476
477    let uri_str = format!(
478        "{}/organizations/{orgId}/collections/{id}/delete",
479        configuration.base_path,
480        orgId = crate::apis::urlencode(p_org_id.to_string()),
481        id = crate::apis::urlencode(p_id.to_string())
482    );
483    let mut req_builder = configuration
484        .client
485        .request(reqwest::Method::POST, &uri_str);
486
487    if let Some(ref user_agent) = configuration.user_agent {
488        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
489    }
490    if let Some(ref token) = configuration.oauth_access_token {
491        req_builder = req_builder.bearer_auth(token.to_owned());
492    };
493
494    let req = req_builder.build()?;
495    let resp = configuration.client.execute(req).await?;
496
497    let status = resp.status();
498
499    if !status.is_client_error() && !status.is_server_error() {
500        Ok(())
501    } else {
502        let content = resp.text().await?;
503        let entity: Option<OrganizationsOrgIdCollectionsIdDeletePostError> =
504            serde_json::from_str(&content).ok();
505        Err(Error::ResponseError(ResponseContent {
506            status,
507            content,
508            entity,
509        }))
510    }
511}
512
513pub async fn organizations_org_id_collections_id_delete_user_org_user_id_post(
514    configuration: &configuration::Configuration,
515    org_id: uuid::Uuid,
516    id: uuid::Uuid,
517    org_user_id: uuid::Uuid,
518) -> Result<(), Error<OrganizationsOrgIdCollectionsIdDeleteUserOrgUserIdPostError>> {
519    // add a prefix to parameters to efficiently prevent name collisions
520    let p_org_id = org_id;
521    let p_id = id;
522    let p_org_user_id = org_user_id;
523
524    let uri_str = format!(
525        "{}/organizations/{orgId}/collections/{id}/delete-user/{orgUserId}",
526        configuration.base_path,
527        orgId = crate::apis::urlencode(p_org_id.to_string()),
528        id = crate::apis::urlencode(p_id.to_string()),
529        orgUserId = crate::apis::urlencode(p_org_user_id.to_string())
530    );
531    let mut req_builder = configuration
532        .client
533        .request(reqwest::Method::POST, &uri_str);
534
535    if let Some(ref user_agent) = configuration.user_agent {
536        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
537    }
538    if let Some(ref token) = configuration.oauth_access_token {
539        req_builder = req_builder.bearer_auth(token.to_owned());
540    };
541
542    let req = req_builder.build()?;
543    let resp = configuration.client.execute(req).await?;
544
545    let status = resp.status();
546
547    if !status.is_client_error() && !status.is_server_error() {
548        Ok(())
549    } else {
550        let content = resp.text().await?;
551        let entity: Option<OrganizationsOrgIdCollectionsIdDeleteUserOrgUserIdPostError> =
552            serde_json::from_str(&content).ok();
553        Err(Error::ResponseError(ResponseContent {
554            status,
555            content,
556            entity,
557        }))
558    }
559}
560
561pub async fn organizations_org_id_collections_id_details_get(
562    configuration: &configuration::Configuration,
563    org_id: uuid::Uuid,
564    id: uuid::Uuid,
565) -> Result<
566    models::CollectionAccessDetailsResponseModel,
567    Error<OrganizationsOrgIdCollectionsIdDetailsGetError>,
568> {
569    // add a prefix to parameters to efficiently prevent name collisions
570    let p_org_id = org_id;
571    let p_id = id;
572
573    let uri_str = format!(
574        "{}/organizations/{orgId}/collections/{id}/details",
575        configuration.base_path,
576        orgId = crate::apis::urlencode(p_org_id.to_string()),
577        id = crate::apis::urlencode(p_id.to_string())
578    );
579    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
580
581    if let Some(ref user_agent) = configuration.user_agent {
582        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
583    }
584    if let Some(ref token) = configuration.oauth_access_token {
585        req_builder = req_builder.bearer_auth(token.to_owned());
586    };
587
588    let req = req_builder.build()?;
589    let resp = configuration.client.execute(req).await?;
590
591    let status = resp.status();
592    let content_type = resp
593        .headers()
594        .get("content-type")
595        .and_then(|v| v.to_str().ok())
596        .unwrap_or("application/octet-stream");
597    let content_type = super::ContentType::from(content_type);
598
599    if !status.is_client_error() && !status.is_server_error() {
600        let content = resp.text().await?;
601        match content_type {
602            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
603            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionAccessDetailsResponseModel`"))),
604            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionAccessDetailsResponseModel`")))),
605        }
606    } else {
607        let content = resp.text().await?;
608        let entity: Option<OrganizationsOrgIdCollectionsIdDetailsGetError> =
609            serde_json::from_str(&content).ok();
610        Err(Error::ResponseError(ResponseContent {
611            status,
612            content,
613            entity,
614        }))
615    }
616}
617
618pub async fn organizations_org_id_collections_id_get(
619    configuration: &configuration::Configuration,
620    org_id: uuid::Uuid,
621    id: uuid::Uuid,
622) -> Result<models::CollectionResponseModel, Error<OrganizationsOrgIdCollectionsIdGetError>> {
623    // add a prefix to parameters to efficiently prevent name collisions
624    let p_org_id = org_id;
625    let p_id = id;
626
627    let uri_str = format!(
628        "{}/organizations/{orgId}/collections/{id}",
629        configuration.base_path,
630        orgId = crate::apis::urlencode(p_org_id.to_string()),
631        id = crate::apis::urlencode(p_id.to_string())
632    );
633    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
634
635    if let Some(ref user_agent) = configuration.user_agent {
636        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
637    }
638    if let Some(ref token) = configuration.oauth_access_token {
639        req_builder = req_builder.bearer_auth(token.to_owned());
640    };
641
642    let req = req_builder.build()?;
643    let resp = configuration.client.execute(req).await?;
644
645    let status = resp.status();
646    let content_type = resp
647        .headers()
648        .get("content-type")
649        .and_then(|v| v.to_str().ok())
650        .unwrap_or("application/octet-stream");
651    let content_type = super::ContentType::from(content_type);
652
653    if !status.is_client_error() && !status.is_server_error() {
654        let content = resp.text().await?;
655        match content_type {
656            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
657            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionResponseModel`"))),
658            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionResponseModel`")))),
659        }
660    } else {
661        let content = resp.text().await?;
662        let entity: Option<OrganizationsOrgIdCollectionsIdGetError> =
663            serde_json::from_str(&content).ok();
664        Err(Error::ResponseError(ResponseContent {
665            status,
666            content,
667            entity,
668        }))
669    }
670}
671
672pub async fn organizations_org_id_collections_id_post(
673    configuration: &configuration::Configuration,
674    org_id: uuid::Uuid,
675    id: uuid::Uuid,
676    collection_request_model: Option<models::CollectionRequestModel>,
677) -> Result<models::CollectionResponseModel, Error<OrganizationsOrgIdCollectionsIdPostError>> {
678    // add a prefix to parameters to efficiently prevent name collisions
679    let p_org_id = org_id;
680    let p_id = id;
681    let p_collection_request_model = collection_request_model;
682
683    let uri_str = format!(
684        "{}/organizations/{orgId}/collections/{id}",
685        configuration.base_path,
686        orgId = crate::apis::urlencode(p_org_id.to_string()),
687        id = crate::apis::urlencode(p_id.to_string())
688    );
689    let mut req_builder = configuration
690        .client
691        .request(reqwest::Method::POST, &uri_str);
692
693    if let Some(ref user_agent) = configuration.user_agent {
694        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
695    }
696    if let Some(ref token) = configuration.oauth_access_token {
697        req_builder = req_builder.bearer_auth(token.to_owned());
698    };
699    req_builder = req_builder.json(&p_collection_request_model);
700
701    let req = req_builder.build()?;
702    let resp = configuration.client.execute(req).await?;
703
704    let status = resp.status();
705    let content_type = resp
706        .headers()
707        .get("content-type")
708        .and_then(|v| v.to_str().ok())
709        .unwrap_or("application/octet-stream");
710    let content_type = super::ContentType::from(content_type);
711
712    if !status.is_client_error() && !status.is_server_error() {
713        let content = resp.text().await?;
714        match content_type {
715            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
716            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionResponseModel`"))),
717            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionResponseModel`")))),
718        }
719    } else {
720        let content = resp.text().await?;
721        let entity: Option<OrganizationsOrgIdCollectionsIdPostError> =
722            serde_json::from_str(&content).ok();
723        Err(Error::ResponseError(ResponseContent {
724            status,
725            content,
726            entity,
727        }))
728    }
729}
730
731pub async fn organizations_org_id_collections_id_put(
732    configuration: &configuration::Configuration,
733    org_id: uuid::Uuid,
734    id: uuid::Uuid,
735    collection_request_model: Option<models::CollectionRequestModel>,
736) -> Result<models::CollectionResponseModel, Error<OrganizationsOrgIdCollectionsIdPutError>> {
737    // add a prefix to parameters to efficiently prevent name collisions
738    let p_org_id = org_id;
739    let p_id = id;
740    let p_collection_request_model = collection_request_model;
741
742    let uri_str = format!(
743        "{}/organizations/{orgId}/collections/{id}",
744        configuration.base_path,
745        orgId = crate::apis::urlencode(p_org_id.to_string()),
746        id = crate::apis::urlencode(p_id.to_string())
747    );
748    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
749
750    if let Some(ref user_agent) = configuration.user_agent {
751        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
752    }
753    if let Some(ref token) = configuration.oauth_access_token {
754        req_builder = req_builder.bearer_auth(token.to_owned());
755    };
756    req_builder = req_builder.json(&p_collection_request_model);
757
758    let req = req_builder.build()?;
759    let resp = configuration.client.execute(req).await?;
760
761    let status = resp.status();
762    let content_type = resp
763        .headers()
764        .get("content-type")
765        .and_then(|v| v.to_str().ok())
766        .unwrap_or("application/octet-stream");
767    let content_type = super::ContentType::from(content_type);
768
769    if !status.is_client_error() && !status.is_server_error() {
770        let content = resp.text().await?;
771        match content_type {
772            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
773            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionResponseModel`"))),
774            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionResponseModel`")))),
775        }
776    } else {
777        let content = resp.text().await?;
778        let entity: Option<OrganizationsOrgIdCollectionsIdPutError> =
779            serde_json::from_str(&content).ok();
780        Err(Error::ResponseError(ResponseContent {
781            status,
782            content,
783            entity,
784        }))
785    }
786}
787
788pub async fn organizations_org_id_collections_id_user_org_user_id_delete(
789    configuration: &configuration::Configuration,
790    org_id: uuid::Uuid,
791    id: uuid::Uuid,
792    org_user_id: uuid::Uuid,
793) -> Result<(), Error<OrganizationsOrgIdCollectionsIdUserOrgUserIdDeleteError>> {
794    // add a prefix to parameters to efficiently prevent name collisions
795    let p_org_id = org_id;
796    let p_id = id;
797    let p_org_user_id = org_user_id;
798
799    let uri_str = format!(
800        "{}/organizations/{orgId}/collections/{id}/user/{orgUserId}",
801        configuration.base_path,
802        orgId = crate::apis::urlencode(p_org_id.to_string()),
803        id = crate::apis::urlencode(p_id.to_string()),
804        orgUserId = crate::apis::urlencode(p_org_user_id.to_string())
805    );
806    let mut req_builder = configuration
807        .client
808        .request(reqwest::Method::DELETE, &uri_str);
809
810    if let Some(ref user_agent) = configuration.user_agent {
811        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
812    }
813    if let Some(ref token) = configuration.oauth_access_token {
814        req_builder = req_builder.bearer_auth(token.to_owned());
815    };
816
817    let req = req_builder.build()?;
818    let resp = configuration.client.execute(req).await?;
819
820    let status = resp.status();
821
822    if !status.is_client_error() && !status.is_server_error() {
823        Ok(())
824    } else {
825        let content = resp.text().await?;
826        let entity: Option<OrganizationsOrgIdCollectionsIdUserOrgUserIdDeleteError> =
827            serde_json::from_str(&content).ok();
828        Err(Error::ResponseError(ResponseContent {
829            status,
830            content,
831            entity,
832        }))
833    }
834}
835
836pub async fn organizations_org_id_collections_id_users_get(
837    configuration: &configuration::Configuration,
838    org_id: uuid::Uuid,
839    id: uuid::Uuid,
840) -> Result<
841    Vec<models::SelectionReadOnlyResponseModel>,
842    Error<OrganizationsOrgIdCollectionsIdUsersGetError>,
843> {
844    // add a prefix to parameters to efficiently prevent name collisions
845    let p_org_id = org_id;
846    let p_id = id;
847
848    let uri_str = format!(
849        "{}/organizations/{orgId}/collections/{id}/users",
850        configuration.base_path,
851        orgId = crate::apis::urlencode(p_org_id.to_string()),
852        id = crate::apis::urlencode(p_id.to_string())
853    );
854    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
855
856    if let Some(ref user_agent) = configuration.user_agent {
857        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
858    }
859    if let Some(ref token) = configuration.oauth_access_token {
860        req_builder = req_builder.bearer_auth(token.to_owned());
861    };
862
863    let req = req_builder.build()?;
864    let resp = configuration.client.execute(req).await?;
865
866    let status = resp.status();
867    let content_type = resp
868        .headers()
869        .get("content-type")
870        .and_then(|v| v.to_str().ok())
871        .unwrap_or("application/octet-stream");
872    let content_type = super::ContentType::from(content_type);
873
874    if !status.is_client_error() && !status.is_server_error() {
875        let content = resp.text().await?;
876        match content_type {
877            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
878            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::SelectionReadOnlyResponseModel&gt;`"))),
879            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::SelectionReadOnlyResponseModel&gt;`")))),
880        }
881    } else {
882        let content = resp.text().await?;
883        let entity: Option<OrganizationsOrgIdCollectionsIdUsersGetError> =
884            serde_json::from_str(&content).ok();
885        Err(Error::ResponseError(ResponseContent {
886            status,
887            content,
888            entity,
889        }))
890    }
891}
892
893pub async fn organizations_org_id_collections_id_users_put(
894    configuration: &configuration::Configuration,
895    org_id: uuid::Uuid,
896    id: uuid::Uuid,
897    selection_read_only_request_model: Option<Vec<models::SelectionReadOnlyRequestModel>>,
898) -> Result<(), Error<OrganizationsOrgIdCollectionsIdUsersPutError>> {
899    // add a prefix to parameters to efficiently prevent name collisions
900    let p_org_id = org_id;
901    let p_id = id;
902    let p_selection_read_only_request_model = selection_read_only_request_model;
903
904    let uri_str = format!(
905        "{}/organizations/{orgId}/collections/{id}/users",
906        configuration.base_path,
907        orgId = crate::apis::urlencode(p_org_id.to_string()),
908        id = crate::apis::urlencode(p_id.to_string())
909    );
910    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
911
912    if let Some(ref user_agent) = configuration.user_agent {
913        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
914    }
915    if let Some(ref token) = configuration.oauth_access_token {
916        req_builder = req_builder.bearer_auth(token.to_owned());
917    };
918    req_builder = req_builder.json(&p_selection_read_only_request_model);
919
920    let req = req_builder.build()?;
921    let resp = configuration.client.execute(req).await?;
922
923    let status = resp.status();
924
925    if !status.is_client_error() && !status.is_server_error() {
926        Ok(())
927    } else {
928        let content = resp.text().await?;
929        let entity: Option<OrganizationsOrgIdCollectionsIdUsersPutError> =
930            serde_json::from_str(&content).ok();
931        Err(Error::ResponseError(ResponseContent {
932            status,
933            content,
934            entity,
935        }))
936    }
937}
938
939pub async fn organizations_org_id_collections_post(
940    configuration: &configuration::Configuration,
941    org_id: uuid::Uuid,
942    collection_request_model: Option<models::CollectionRequestModel>,
943) -> Result<models::CollectionResponseModel, Error<OrganizationsOrgIdCollectionsPostError>> {
944    // add a prefix to parameters to efficiently prevent name collisions
945    let p_org_id = org_id;
946    let p_collection_request_model = collection_request_model;
947
948    let uri_str = format!(
949        "{}/organizations/{orgId}/collections",
950        configuration.base_path,
951        orgId = crate::apis::urlencode(p_org_id.to_string())
952    );
953    let mut req_builder = configuration
954        .client
955        .request(reqwest::Method::POST, &uri_str);
956
957    if let Some(ref user_agent) = configuration.user_agent {
958        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
959    }
960    if let Some(ref token) = configuration.oauth_access_token {
961        req_builder = req_builder.bearer_auth(token.to_owned());
962    };
963    req_builder = req_builder.json(&p_collection_request_model);
964
965    let req = req_builder.build()?;
966    let resp = configuration.client.execute(req).await?;
967
968    let status = resp.status();
969    let content_type = resp
970        .headers()
971        .get("content-type")
972        .and_then(|v| v.to_str().ok())
973        .unwrap_or("application/octet-stream");
974    let content_type = super::ContentType::from(content_type);
975
976    if !status.is_client_error() && !status.is_server_error() {
977        let content = resp.text().await?;
978        match content_type {
979            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
980            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CollectionResponseModel`"))),
981            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CollectionResponseModel`")))),
982        }
983    } else {
984        let content = resp.text().await?;
985        let entity: Option<OrganizationsOrgIdCollectionsPostError> =
986            serde_json::from_str(&content).ok();
987        Err(Error::ResponseError(ResponseContent {
988            status,
989            content,
990            entity,
991        }))
992    }
993}
bitwarden_api_api/apis/collections_api.rs

bitwarden_api_api/apis/
collections_api.rs
