bitwarden_api_api/apis/
provider_users_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 [`providers_provider_id_users_confirm_post`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum ProvidersProviderIdUsersConfirmPostError {
21    UnknownValue(serde_json::Value),
22}
23
24/// struct for typed errors of method [`providers_provider_id_users_delete`]
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum ProvidersProviderIdUsersDeleteError {
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`providers_provider_id_users_delete_post`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum ProvidersProviderIdUsersDeletePostError {
35    UnknownValue(serde_json::Value),
36}
37
38/// struct for typed errors of method [`providers_provider_id_users_get`]
39#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum ProvidersProviderIdUsersGetError {
42    UnknownValue(serde_json::Value),
43}
44
45/// struct for typed errors of method [`providers_provider_id_users_id_accept_post`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum ProvidersProviderIdUsersIdAcceptPostError {
49    UnknownValue(serde_json::Value),
50}
51
52/// struct for typed errors of method [`providers_provider_id_users_id_confirm_post`]
53#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum ProvidersProviderIdUsersIdConfirmPostError {
56    UnknownValue(serde_json::Value),
57}
58
59/// struct for typed errors of method [`providers_provider_id_users_id_delete`]
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum ProvidersProviderIdUsersIdDeleteError {
63    UnknownValue(serde_json::Value),
64}
65
66/// struct for typed errors of method [`providers_provider_id_users_id_delete_post`]
67#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum ProvidersProviderIdUsersIdDeletePostError {
70    UnknownValue(serde_json::Value),
71}
72
73/// struct for typed errors of method [`providers_provider_id_users_id_get`]
74#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum ProvidersProviderIdUsersIdGetError {
77    UnknownValue(serde_json::Value),
78}
79
80/// struct for typed errors of method [`providers_provider_id_users_id_post`]
81#[derive(Debug, Clone, Serialize, Deserialize)]
82#[serde(untagged)]
83pub enum ProvidersProviderIdUsersIdPostError {
84    UnknownValue(serde_json::Value),
85}
86
87/// struct for typed errors of method [`providers_provider_id_users_id_put`]
88#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum ProvidersProviderIdUsersIdPutError {
91    UnknownValue(serde_json::Value),
92}
93
94/// struct for typed errors of method [`providers_provider_id_users_id_reinvite_post`]
95#[derive(Debug, Clone, Serialize, Deserialize)]
96#[serde(untagged)]
97pub enum ProvidersProviderIdUsersIdReinvitePostError {
98    UnknownValue(serde_json::Value),
99}
100
101/// struct for typed errors of method [`providers_provider_id_users_invite_post`]
102#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum ProvidersProviderIdUsersInvitePostError {
105    UnknownValue(serde_json::Value),
106}
107
108/// struct for typed errors of method [`providers_provider_id_users_public_keys_post`]
109#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(untagged)]
111pub enum ProvidersProviderIdUsersPublicKeysPostError {
112    UnknownValue(serde_json::Value),
113}
114
115/// struct for typed errors of method [`providers_provider_id_users_reinvite_post`]
116#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum ProvidersProviderIdUsersReinvitePostError {
119    UnknownValue(serde_json::Value),
120}
121
122pub async fn providers_provider_id_users_confirm_post(
123    configuration: &configuration::Configuration,
124    provider_id: uuid::Uuid,
125    provider_user_bulk_confirm_request_model: Option<models::ProviderUserBulkConfirmRequestModel>,
126) -> Result<
127    models::ProviderUserBulkResponseModelListResponseModel,
128    Error<ProvidersProviderIdUsersConfirmPostError>,
129> {
130    // add a prefix to parameters to efficiently prevent name collisions
131    let p_provider_id = provider_id;
132    let p_provider_user_bulk_confirm_request_model = provider_user_bulk_confirm_request_model;
133
134    let uri_str = format!(
135        "{}/providers/{providerId}/users/confirm",
136        configuration.base_path,
137        providerId = crate::apis::urlencode(p_provider_id.to_string())
138    );
139    let mut req_builder = configuration
140        .client
141        .request(reqwest::Method::POST, &uri_str);
142
143    if let Some(ref user_agent) = configuration.user_agent {
144        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
145    }
146    if let Some(ref token) = configuration.oauth_access_token {
147        req_builder = req_builder.bearer_auth(token.to_owned());
148    };
149    req_builder = req_builder.json(&p_provider_user_bulk_confirm_request_model);
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::ProviderUserBulkResponseModelListResponseModel`"))),
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::ProviderUserBulkResponseModelListResponseModel`")))),
168        }
169    } else {
170        let content = resp.text().await?;
171        let entity: Option<ProvidersProviderIdUsersConfirmPostError> =
172            serde_json::from_str(&content).ok();
173        Err(Error::ResponseError(ResponseContent {
174            status,
175            content,
176            entity,
177        }))
178    }
179}
180
181pub async fn providers_provider_id_users_delete(
182    configuration: &configuration::Configuration,
183    provider_id: uuid::Uuid,
184    provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
185) -> Result<
186    models::ProviderUserBulkResponseModelListResponseModel,
187    Error<ProvidersProviderIdUsersDeleteError>,
188> {
189    // add a prefix to parameters to efficiently prevent name collisions
190    let p_provider_id = provider_id;
191    let p_provider_user_bulk_request_model = provider_user_bulk_request_model;
192
193    let uri_str = format!(
194        "{}/providers/{providerId}/users",
195        configuration.base_path,
196        providerId = crate::apis::urlencode(p_provider_id.to_string())
197    );
198    let mut req_builder = configuration
199        .client
200        .request(reqwest::Method::DELETE, &uri_str);
201
202    if let Some(ref user_agent) = configuration.user_agent {
203        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
204    }
205    if let Some(ref token) = configuration.oauth_access_token {
206        req_builder = req_builder.bearer_auth(token.to_owned());
207    };
208    req_builder = req_builder.json(&p_provider_user_bulk_request_model);
209
210    let req = req_builder.build()?;
211    let resp = configuration.client.execute(req).await?;
212
213    let status = resp.status();
214    let content_type = resp
215        .headers()
216        .get("content-type")
217        .and_then(|v| v.to_str().ok())
218        .unwrap_or("application/octet-stream");
219    let content_type = super::ContentType::from(content_type);
220
221    if !status.is_client_error() && !status.is_server_error() {
222        let content = resp.text().await?;
223        match content_type {
224            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
225            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`"))),
226            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::ProviderUserBulkResponseModelListResponseModel`")))),
227        }
228    } else {
229        let content = resp.text().await?;
230        let entity: Option<ProvidersProviderIdUsersDeleteError> =
231            serde_json::from_str(&content).ok();
232        Err(Error::ResponseError(ResponseContent {
233            status,
234            content,
235            entity,
236        }))
237    }
238}
239
240pub async fn providers_provider_id_users_delete_post(
241    configuration: &configuration::Configuration,
242    provider_id: uuid::Uuid,
243    provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
244) -> Result<
245    models::ProviderUserBulkResponseModelListResponseModel,
246    Error<ProvidersProviderIdUsersDeletePostError>,
247> {
248    // add a prefix to parameters to efficiently prevent name collisions
249    let p_provider_id = provider_id;
250    let p_provider_user_bulk_request_model = provider_user_bulk_request_model;
251
252    let uri_str = format!(
253        "{}/providers/{providerId}/users/delete",
254        configuration.base_path,
255        providerId = crate::apis::urlencode(p_provider_id.to_string())
256    );
257    let mut req_builder = configuration
258        .client
259        .request(reqwest::Method::POST, &uri_str);
260
261    if let Some(ref user_agent) = configuration.user_agent {
262        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
263    }
264    if let Some(ref token) = configuration.oauth_access_token {
265        req_builder = req_builder.bearer_auth(token.to_owned());
266    };
267    req_builder = req_builder.json(&p_provider_user_bulk_request_model);
268
269    let req = req_builder.build()?;
270    let resp = configuration.client.execute(req).await?;
271
272    let status = resp.status();
273    let content_type = resp
274        .headers()
275        .get("content-type")
276        .and_then(|v| v.to_str().ok())
277        .unwrap_or("application/octet-stream");
278    let content_type = super::ContentType::from(content_type);
279
280    if !status.is_client_error() && !status.is_server_error() {
281        let content = resp.text().await?;
282        match content_type {
283            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
284            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`"))),
285            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::ProviderUserBulkResponseModelListResponseModel`")))),
286        }
287    } else {
288        let content = resp.text().await?;
289        let entity: Option<ProvidersProviderIdUsersDeletePostError> =
290            serde_json::from_str(&content).ok();
291        Err(Error::ResponseError(ResponseContent {
292            status,
293            content,
294            entity,
295        }))
296    }
297}
298
299pub async fn providers_provider_id_users_get(
300    configuration: &configuration::Configuration,
301    provider_id: uuid::Uuid,
302) -> Result<
303    models::ProviderUserUserDetailsResponseModelListResponseModel,
304    Error<ProvidersProviderIdUsersGetError>,
305> {
306    // add a prefix to parameters to efficiently prevent name collisions
307    let p_provider_id = provider_id;
308
309    let uri_str = format!(
310        "{}/providers/{providerId}/users",
311        configuration.base_path,
312        providerId = crate::apis::urlencode(p_provider_id.to_string())
313    );
314    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
315
316    if let Some(ref user_agent) = configuration.user_agent {
317        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
318    }
319    if let Some(ref token) = configuration.oauth_access_token {
320        req_builder = req_builder.bearer_auth(token.to_owned());
321    };
322
323    let req = req_builder.build()?;
324    let resp = configuration.client.execute(req).await?;
325
326    let status = resp.status();
327    let content_type = resp
328        .headers()
329        .get("content-type")
330        .and_then(|v| v.to_str().ok())
331        .unwrap_or("application/octet-stream");
332    let content_type = super::ContentType::from(content_type);
333
334    if !status.is_client_error() && !status.is_server_error() {
335        let content = resp.text().await?;
336        match content_type {
337            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
338            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderUserUserDetailsResponseModelListResponseModel`"))),
339            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::ProviderUserUserDetailsResponseModelListResponseModel`")))),
340        }
341    } else {
342        let content = resp.text().await?;
343        let entity: Option<ProvidersProviderIdUsersGetError> = serde_json::from_str(&content).ok();
344        Err(Error::ResponseError(ResponseContent {
345            status,
346            content,
347            entity,
348        }))
349    }
350}
351
352pub async fn providers_provider_id_users_id_accept_post(
353    configuration: &configuration::Configuration,
354    provider_id: uuid::Uuid,
355    id: uuid::Uuid,
356    provider_user_accept_request_model: Option<models::ProviderUserAcceptRequestModel>,
357) -> Result<(), Error<ProvidersProviderIdUsersIdAcceptPostError>> {
358    // add a prefix to parameters to efficiently prevent name collisions
359    let p_provider_id = provider_id;
360    let p_id = id;
361    let p_provider_user_accept_request_model = provider_user_accept_request_model;
362
363    let uri_str = format!(
364        "{}/providers/{providerId}/users/{id}/accept",
365        configuration.base_path,
366        providerId = crate::apis::urlencode(p_provider_id.to_string()),
367        id = crate::apis::urlencode(p_id.to_string())
368    );
369    let mut req_builder = configuration
370        .client
371        .request(reqwest::Method::POST, &uri_str);
372
373    if let Some(ref user_agent) = configuration.user_agent {
374        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
375    }
376    if let Some(ref token) = configuration.oauth_access_token {
377        req_builder = req_builder.bearer_auth(token.to_owned());
378    };
379    req_builder = req_builder.json(&p_provider_user_accept_request_model);
380
381    let req = req_builder.build()?;
382    let resp = configuration.client.execute(req).await?;
383
384    let status = resp.status();
385
386    if !status.is_client_error() && !status.is_server_error() {
387        Ok(())
388    } else {
389        let content = resp.text().await?;
390        let entity: Option<ProvidersProviderIdUsersIdAcceptPostError> =
391            serde_json::from_str(&content).ok();
392        Err(Error::ResponseError(ResponseContent {
393            status,
394            content,
395            entity,
396        }))
397    }
398}
399
400pub async fn providers_provider_id_users_id_confirm_post(
401    configuration: &configuration::Configuration,
402    provider_id: uuid::Uuid,
403    id: uuid::Uuid,
404    provider_user_confirm_request_model: Option<models::ProviderUserConfirmRequestModel>,
405) -> Result<(), Error<ProvidersProviderIdUsersIdConfirmPostError>> {
406    // add a prefix to parameters to efficiently prevent name collisions
407    let p_provider_id = provider_id;
408    let p_id = id;
409    let p_provider_user_confirm_request_model = provider_user_confirm_request_model;
410
411    let uri_str = format!(
412        "{}/providers/{providerId}/users/{id}/confirm",
413        configuration.base_path,
414        providerId = crate::apis::urlencode(p_provider_id.to_string()),
415        id = crate::apis::urlencode(p_id.to_string())
416    );
417    let mut req_builder = configuration
418        .client
419        .request(reqwest::Method::POST, &uri_str);
420
421    if let Some(ref user_agent) = configuration.user_agent {
422        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
423    }
424    if let Some(ref token) = configuration.oauth_access_token {
425        req_builder = req_builder.bearer_auth(token.to_owned());
426    };
427    req_builder = req_builder.json(&p_provider_user_confirm_request_model);
428
429    let req = req_builder.build()?;
430    let resp = configuration.client.execute(req).await?;
431
432    let status = resp.status();
433
434    if !status.is_client_error() && !status.is_server_error() {
435        Ok(())
436    } else {
437        let content = resp.text().await?;
438        let entity: Option<ProvidersProviderIdUsersIdConfirmPostError> =
439            serde_json::from_str(&content).ok();
440        Err(Error::ResponseError(ResponseContent {
441            status,
442            content,
443            entity,
444        }))
445    }
446}
447
448pub async fn providers_provider_id_users_id_delete(
449    configuration: &configuration::Configuration,
450    provider_id: uuid::Uuid,
451    id: uuid::Uuid,
452) -> Result<(), Error<ProvidersProviderIdUsersIdDeleteError>> {
453    // add a prefix to parameters to efficiently prevent name collisions
454    let p_provider_id = provider_id;
455    let p_id = id;
456
457    let uri_str = format!(
458        "{}/providers/{providerId}/users/{id}",
459        configuration.base_path,
460        providerId = crate::apis::urlencode(p_provider_id.to_string()),
461        id = crate::apis::urlencode(p_id.to_string())
462    );
463    let mut req_builder = configuration
464        .client
465        .request(reqwest::Method::DELETE, &uri_str);
466
467    if let Some(ref user_agent) = configuration.user_agent {
468        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
469    }
470    if let Some(ref token) = configuration.oauth_access_token {
471        req_builder = req_builder.bearer_auth(token.to_owned());
472    };
473
474    let req = req_builder.build()?;
475    let resp = configuration.client.execute(req).await?;
476
477    let status = resp.status();
478
479    if !status.is_client_error() && !status.is_server_error() {
480        Ok(())
481    } else {
482        let content = resp.text().await?;
483        let entity: Option<ProvidersProviderIdUsersIdDeleteError> =
484            serde_json::from_str(&content).ok();
485        Err(Error::ResponseError(ResponseContent {
486            status,
487            content,
488            entity,
489        }))
490    }
491}
492
493pub async fn providers_provider_id_users_id_delete_post(
494    configuration: &configuration::Configuration,
495    provider_id: uuid::Uuid,
496    id: uuid::Uuid,
497) -> Result<(), Error<ProvidersProviderIdUsersIdDeletePostError>> {
498    // add a prefix to parameters to efficiently prevent name collisions
499    let p_provider_id = provider_id;
500    let p_id = id;
501
502    let uri_str = format!(
503        "{}/providers/{providerId}/users/{id}/delete",
504        configuration.base_path,
505        providerId = crate::apis::urlencode(p_provider_id.to_string()),
506        id = crate::apis::urlencode(p_id.to_string())
507    );
508    let mut req_builder = configuration
509        .client
510        .request(reqwest::Method::POST, &uri_str);
511
512    if let Some(ref user_agent) = configuration.user_agent {
513        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
514    }
515    if let Some(ref token) = configuration.oauth_access_token {
516        req_builder = req_builder.bearer_auth(token.to_owned());
517    };
518
519    let req = req_builder.build()?;
520    let resp = configuration.client.execute(req).await?;
521
522    let status = resp.status();
523
524    if !status.is_client_error() && !status.is_server_error() {
525        Ok(())
526    } else {
527        let content = resp.text().await?;
528        let entity: Option<ProvidersProviderIdUsersIdDeletePostError> =
529            serde_json::from_str(&content).ok();
530        Err(Error::ResponseError(ResponseContent {
531            status,
532            content,
533            entity,
534        }))
535    }
536}
537
538pub async fn providers_provider_id_users_id_get(
539    configuration: &configuration::Configuration,
540    provider_id: uuid::Uuid,
541    id: uuid::Uuid,
542) -> Result<models::ProviderUserResponseModel, Error<ProvidersProviderIdUsersIdGetError>> {
543    // add a prefix to parameters to efficiently prevent name collisions
544    let p_provider_id = provider_id;
545    let p_id = id;
546
547    let uri_str = format!(
548        "{}/providers/{providerId}/users/{id}",
549        configuration.base_path,
550        providerId = crate::apis::urlencode(p_provider_id.to_string()),
551        id = crate::apis::urlencode(p_id.to_string())
552    );
553    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
554
555    if let Some(ref user_agent) = configuration.user_agent {
556        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
557    }
558    if let Some(ref token) = configuration.oauth_access_token {
559        req_builder = req_builder.bearer_auth(token.to_owned());
560    };
561
562    let req = req_builder.build()?;
563    let resp = configuration.client.execute(req).await?;
564
565    let status = resp.status();
566    let content_type = resp
567        .headers()
568        .get("content-type")
569        .and_then(|v| v.to_str().ok())
570        .unwrap_or("application/octet-stream");
571    let content_type = super::ContentType::from(content_type);
572
573    if !status.is_client_error() && !status.is_server_error() {
574        let content = resp.text().await?;
575        match content_type {
576            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
577            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderUserResponseModel`"))),
578            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::ProviderUserResponseModel`")))),
579        }
580    } else {
581        let content = resp.text().await?;
582        let entity: Option<ProvidersProviderIdUsersIdGetError> =
583            serde_json::from_str(&content).ok();
584        Err(Error::ResponseError(ResponseContent {
585            status,
586            content,
587            entity,
588        }))
589    }
590}
591
592pub async fn providers_provider_id_users_id_post(
593    configuration: &configuration::Configuration,
594    provider_id: uuid::Uuid,
595    id: uuid::Uuid,
596    provider_user_update_request_model: Option<models::ProviderUserUpdateRequestModel>,
597) -> Result<(), Error<ProvidersProviderIdUsersIdPostError>> {
598    // add a prefix to parameters to efficiently prevent name collisions
599    let p_provider_id = provider_id;
600    let p_id = id;
601    let p_provider_user_update_request_model = provider_user_update_request_model;
602
603    let uri_str = format!(
604        "{}/providers/{providerId}/users/{id}",
605        configuration.base_path,
606        providerId = crate::apis::urlencode(p_provider_id.to_string()),
607        id = crate::apis::urlencode(p_id.to_string())
608    );
609    let mut req_builder = configuration
610        .client
611        .request(reqwest::Method::POST, &uri_str);
612
613    if let Some(ref user_agent) = configuration.user_agent {
614        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
615    }
616    if let Some(ref token) = configuration.oauth_access_token {
617        req_builder = req_builder.bearer_auth(token.to_owned());
618    };
619    req_builder = req_builder.json(&p_provider_user_update_request_model);
620
621    let req = req_builder.build()?;
622    let resp = configuration.client.execute(req).await?;
623
624    let status = resp.status();
625
626    if !status.is_client_error() && !status.is_server_error() {
627        Ok(())
628    } else {
629        let content = resp.text().await?;
630        let entity: Option<ProvidersProviderIdUsersIdPostError> =
631            serde_json::from_str(&content).ok();
632        Err(Error::ResponseError(ResponseContent {
633            status,
634            content,
635            entity,
636        }))
637    }
638}
639
640pub async fn providers_provider_id_users_id_put(
641    configuration: &configuration::Configuration,
642    provider_id: uuid::Uuid,
643    id: uuid::Uuid,
644    provider_user_update_request_model: Option<models::ProviderUserUpdateRequestModel>,
645) -> Result<(), Error<ProvidersProviderIdUsersIdPutError>> {
646    // add a prefix to parameters to efficiently prevent name collisions
647    let p_provider_id = provider_id;
648    let p_id = id;
649    let p_provider_user_update_request_model = provider_user_update_request_model;
650
651    let uri_str = format!(
652        "{}/providers/{providerId}/users/{id}",
653        configuration.base_path,
654        providerId = crate::apis::urlencode(p_provider_id.to_string()),
655        id = crate::apis::urlencode(p_id.to_string())
656    );
657    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
658
659    if let Some(ref user_agent) = configuration.user_agent {
660        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
661    }
662    if let Some(ref token) = configuration.oauth_access_token {
663        req_builder = req_builder.bearer_auth(token.to_owned());
664    };
665    req_builder = req_builder.json(&p_provider_user_update_request_model);
666
667    let req = req_builder.build()?;
668    let resp = configuration.client.execute(req).await?;
669
670    let status = resp.status();
671
672    if !status.is_client_error() && !status.is_server_error() {
673        Ok(())
674    } else {
675        let content = resp.text().await?;
676        let entity: Option<ProvidersProviderIdUsersIdPutError> =
677            serde_json::from_str(&content).ok();
678        Err(Error::ResponseError(ResponseContent {
679            status,
680            content,
681            entity,
682        }))
683    }
684}
685
686pub async fn providers_provider_id_users_id_reinvite_post(
687    configuration: &configuration::Configuration,
688    provider_id: uuid::Uuid,
689    id: uuid::Uuid,
690) -> Result<(), Error<ProvidersProviderIdUsersIdReinvitePostError>> {
691    // add a prefix to parameters to efficiently prevent name collisions
692    let p_provider_id = provider_id;
693    let p_id = id;
694
695    let uri_str = format!(
696        "{}/providers/{providerId}/users/{id}/reinvite",
697        configuration.base_path,
698        providerId = crate::apis::urlencode(p_provider_id.to_string()),
699        id = crate::apis::urlencode(p_id.to_string())
700    );
701    let mut req_builder = configuration
702        .client
703        .request(reqwest::Method::POST, &uri_str);
704
705    if let Some(ref user_agent) = configuration.user_agent {
706        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
707    }
708    if let Some(ref token) = configuration.oauth_access_token {
709        req_builder = req_builder.bearer_auth(token.to_owned());
710    };
711
712    let req = req_builder.build()?;
713    let resp = configuration.client.execute(req).await?;
714
715    let status = resp.status();
716
717    if !status.is_client_error() && !status.is_server_error() {
718        Ok(())
719    } else {
720        let content = resp.text().await?;
721        let entity: Option<ProvidersProviderIdUsersIdReinvitePostError> =
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 providers_provider_id_users_invite_post(
732    configuration: &configuration::Configuration,
733    provider_id: uuid::Uuid,
734    provider_user_invite_request_model: Option<models::ProviderUserInviteRequestModel>,
735) -> Result<(), Error<ProvidersProviderIdUsersInvitePostError>> {
736    // add a prefix to parameters to efficiently prevent name collisions
737    let p_provider_id = provider_id;
738    let p_provider_user_invite_request_model = provider_user_invite_request_model;
739
740    let uri_str = format!(
741        "{}/providers/{providerId}/users/invite",
742        configuration.base_path,
743        providerId = crate::apis::urlencode(p_provider_id.to_string())
744    );
745    let mut req_builder = configuration
746        .client
747        .request(reqwest::Method::POST, &uri_str);
748
749    if let Some(ref user_agent) = configuration.user_agent {
750        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
751    }
752    if let Some(ref token) = configuration.oauth_access_token {
753        req_builder = req_builder.bearer_auth(token.to_owned());
754    };
755    req_builder = req_builder.json(&p_provider_user_invite_request_model);
756
757    let req = req_builder.build()?;
758    let resp = configuration.client.execute(req).await?;
759
760    let status = resp.status();
761
762    if !status.is_client_error() && !status.is_server_error() {
763        Ok(())
764    } else {
765        let content = resp.text().await?;
766        let entity: Option<ProvidersProviderIdUsersInvitePostError> =
767            serde_json::from_str(&content).ok();
768        Err(Error::ResponseError(ResponseContent {
769            status,
770            content,
771            entity,
772        }))
773    }
774}
775
776pub async fn providers_provider_id_users_public_keys_post(
777    configuration: &configuration::Configuration,
778    provider_id: uuid::Uuid,
779    provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
780) -> Result<
781    models::ProviderUserPublicKeyResponseModelListResponseModel,
782    Error<ProvidersProviderIdUsersPublicKeysPostError>,
783> {
784    // add a prefix to parameters to efficiently prevent name collisions
785    let p_provider_id = provider_id;
786    let p_provider_user_bulk_request_model = provider_user_bulk_request_model;
787
788    let uri_str = format!(
789        "{}/providers/{providerId}/users/public-keys",
790        configuration.base_path,
791        providerId = crate::apis::urlencode(p_provider_id.to_string())
792    );
793    let mut req_builder = configuration
794        .client
795        .request(reqwest::Method::POST, &uri_str);
796
797    if let Some(ref user_agent) = configuration.user_agent {
798        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
799    }
800    if let Some(ref token) = configuration.oauth_access_token {
801        req_builder = req_builder.bearer_auth(token.to_owned());
802    };
803    req_builder = req_builder.json(&p_provider_user_bulk_request_model);
804
805    let req = req_builder.build()?;
806    let resp = configuration.client.execute(req).await?;
807
808    let status = resp.status();
809    let content_type = resp
810        .headers()
811        .get("content-type")
812        .and_then(|v| v.to_str().ok())
813        .unwrap_or("application/octet-stream");
814    let content_type = super::ContentType::from(content_type);
815
816    if !status.is_client_error() && !status.is_server_error() {
817        let content = resp.text().await?;
818        match content_type {
819            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
820            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderUserPublicKeyResponseModelListResponseModel`"))),
821            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::ProviderUserPublicKeyResponseModelListResponseModel`")))),
822        }
823    } else {
824        let content = resp.text().await?;
825        let entity: Option<ProvidersProviderIdUsersPublicKeysPostError> =
826            serde_json::from_str(&content).ok();
827        Err(Error::ResponseError(ResponseContent {
828            status,
829            content,
830            entity,
831        }))
832    }
833}
834
835pub async fn providers_provider_id_users_reinvite_post(
836    configuration: &configuration::Configuration,
837    provider_id: uuid::Uuid,
838    provider_user_bulk_request_model: Option<models::ProviderUserBulkRequestModel>,
839) -> Result<
840    models::ProviderUserBulkResponseModelListResponseModel,
841    Error<ProvidersProviderIdUsersReinvitePostError>,
842> {
843    // add a prefix to parameters to efficiently prevent name collisions
844    let p_provider_id = provider_id;
845    let p_provider_user_bulk_request_model = provider_user_bulk_request_model;
846
847    let uri_str = format!(
848        "{}/providers/{providerId}/users/reinvite",
849        configuration.base_path,
850        providerId = crate::apis::urlencode(p_provider_id.to_string())
851    );
852    let mut req_builder = configuration
853        .client
854        .request(reqwest::Method::POST, &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    req_builder = req_builder.json(&p_provider_user_bulk_request_model);
863
864    let req = req_builder.build()?;
865    let resp = configuration.client.execute(req).await?;
866
867    let status = resp.status();
868    let content_type = resp
869        .headers()
870        .get("content-type")
871        .and_then(|v| v.to_str().ok())
872        .unwrap_or("application/octet-stream");
873    let content_type = super::ContentType::from(content_type);
874
875    if !status.is_client_error() && !status.is_server_error() {
876        let content = resp.text().await?;
877        match content_type {
878            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
879            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderUserBulkResponseModelListResponseModel`"))),
880            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::ProviderUserBulkResponseModelListResponseModel`")))),
881        }
882    } else {
883        let content = resp.text().await?;
884        let entity: Option<ProvidersProviderIdUsersReinvitePostError> =
885            serde_json::from_str(&content).ok();
886        Err(Error::ResponseError(ResponseContent {
887            status,
888            content,
889            entity,
890        }))
891    }
892}
bitwarden_api_api/apis/provider_users_api.rs

bitwarden_api_api/apis/
provider_users_api.rs
