bitwarden_api_api/apis/
two_factor_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::{Deserialize, Serialize};
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method [`organizations_id_two_factor_disable_post`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum OrganizationsIdTwoFactorDisablePostError {
21    UnknownValue(serde_json::Value),
22}
23
24/// struct for typed errors of method [`organizations_id_two_factor_disable_put`]
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum OrganizationsIdTwoFactorDisablePutError {
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`organizations_id_two_factor_duo_post`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum OrganizationsIdTwoFactorDuoPostError {
35    UnknownValue(serde_json::Value),
36}
37
38/// struct for typed errors of method [`organizations_id_two_factor_duo_put`]
39#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum OrganizationsIdTwoFactorDuoPutError {
42    UnknownValue(serde_json::Value),
43}
44
45/// struct for typed errors of method [`organizations_id_two_factor_get`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum OrganizationsIdTwoFactorGetError {
49    UnknownValue(serde_json::Value),
50}
51
52/// struct for typed errors of method [`organizations_id_two_factor_get_duo_post`]
53#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum OrganizationsIdTwoFactorGetDuoPostError {
56    UnknownValue(serde_json::Value),
57}
58
59/// struct for typed errors of method [`two_factor_authenticator_delete`]
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum TwoFactorAuthenticatorDeleteError {
63    UnknownValue(serde_json::Value),
64}
65
66/// struct for typed errors of method [`two_factor_authenticator_post`]
67#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum TwoFactorAuthenticatorPostError {
70    UnknownValue(serde_json::Value),
71}
72
73/// struct for typed errors of method [`two_factor_authenticator_put`]
74#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum TwoFactorAuthenticatorPutError {
77    UnknownValue(serde_json::Value),
78}
79
80/// struct for typed errors of method [`two_factor_device_verification_settings_put`]
81#[derive(Debug, Clone, Serialize, Deserialize)]
82#[serde(untagged)]
83pub enum TwoFactorDeviceVerificationSettingsPutError {
84    UnknownValue(serde_json::Value),
85}
86
87/// struct for typed errors of method [`two_factor_disable_post`]
88#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum TwoFactorDisablePostError {
91    UnknownValue(serde_json::Value),
92}
93
94/// struct for typed errors of method [`two_factor_disable_put`]
95#[derive(Debug, Clone, Serialize, Deserialize)]
96#[serde(untagged)]
97pub enum TwoFactorDisablePutError {
98    UnknownValue(serde_json::Value),
99}
100
101/// struct for typed errors of method [`two_factor_duo_post`]
102#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum TwoFactorDuoPostError {
105    UnknownValue(serde_json::Value),
106}
107
108/// struct for typed errors of method [`two_factor_duo_put`]
109#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(untagged)]
111pub enum TwoFactorDuoPutError {
112    UnknownValue(serde_json::Value),
113}
114
115/// struct for typed errors of method [`two_factor_email_post`]
116#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum TwoFactorEmailPostError {
119    UnknownValue(serde_json::Value),
120}
121
122/// struct for typed errors of method [`two_factor_email_put`]
123#[derive(Debug, Clone, Serialize, Deserialize)]
124#[serde(untagged)]
125pub enum TwoFactorEmailPutError {
126    UnknownValue(serde_json::Value),
127}
128
129/// struct for typed errors of method [`two_factor_get`]
130#[derive(Debug, Clone, Serialize, Deserialize)]
131#[serde(untagged)]
132pub enum TwoFactorGetError {
133    UnknownValue(serde_json::Value),
134}
135
136/// struct for typed errors of method [`two_factor_get_authenticator_post`]
137#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum TwoFactorGetAuthenticatorPostError {
140    UnknownValue(serde_json::Value),
141}
142
143/// struct for typed errors of method [`two_factor_get_device_verification_settings_get`]
144#[derive(Debug, Clone, Serialize, Deserialize)]
145#[serde(untagged)]
146pub enum TwoFactorGetDeviceVerificationSettingsGetError {
147    UnknownValue(serde_json::Value),
148}
149
150/// struct for typed errors of method [`two_factor_get_duo_post`]
151#[derive(Debug, Clone, Serialize, Deserialize)]
152#[serde(untagged)]
153pub enum TwoFactorGetDuoPostError {
154    UnknownValue(serde_json::Value),
155}
156
157/// struct for typed errors of method [`two_factor_get_email_post`]
158#[derive(Debug, Clone, Serialize, Deserialize)]
159#[serde(untagged)]
160pub enum TwoFactorGetEmailPostError {
161    UnknownValue(serde_json::Value),
162}
163
164/// struct for typed errors of method [`two_factor_get_recover_post`]
165#[derive(Debug, Clone, Serialize, Deserialize)]
166#[serde(untagged)]
167pub enum TwoFactorGetRecoverPostError {
168    UnknownValue(serde_json::Value),
169}
170
171/// struct for typed errors of method [`two_factor_get_webauthn_post`]
172#[derive(Debug, Clone, Serialize, Deserialize)]
173#[serde(untagged)]
174pub enum TwoFactorGetWebauthnPostError {
175    UnknownValue(serde_json::Value),
176}
177
178/// struct for typed errors of method [`two_factor_get_yubikey_post`]
179#[derive(Debug, Clone, Serialize, Deserialize)]
180#[serde(untagged)]
181pub enum TwoFactorGetYubikeyPostError {
182    UnknownValue(serde_json::Value),
183}
184
185/// struct for typed errors of method [`two_factor_recover_post`]
186#[derive(Debug, Clone, Serialize, Deserialize)]
187#[serde(untagged)]
188pub enum TwoFactorRecoverPostError {
189    UnknownValue(serde_json::Value),
190}
191
192/// struct for typed errors of method [`two_factor_send_email_login_post`]
193#[derive(Debug, Clone, Serialize, Deserialize)]
194#[serde(untagged)]
195pub enum TwoFactorSendEmailLoginPostError {
196    UnknownValue(serde_json::Value),
197}
198
199/// struct for typed errors of method [`two_factor_send_email_post`]
200#[derive(Debug, Clone, Serialize, Deserialize)]
201#[serde(untagged)]
202pub enum TwoFactorSendEmailPostError {
203    UnknownValue(serde_json::Value),
204}
205
206/// struct for typed errors of method [`two_factor_webauthn_delete`]
207#[derive(Debug, Clone, Serialize, Deserialize)]
208#[serde(untagged)]
209pub enum TwoFactorWebauthnDeleteError {
210    UnknownValue(serde_json::Value),
211}
212
213/// struct for typed errors of method [`two_factor_webauthn_post`]
214#[derive(Debug, Clone, Serialize, Deserialize)]
215#[serde(untagged)]
216pub enum TwoFactorWebauthnPostError {
217    UnknownValue(serde_json::Value),
218}
219
220/// struct for typed errors of method [`two_factor_webauthn_put`]
221#[derive(Debug, Clone, Serialize, Deserialize)]
222#[serde(untagged)]
223pub enum TwoFactorWebauthnPutError {
224    UnknownValue(serde_json::Value),
225}
226
227/// struct for typed errors of method [`two_factor_yubikey_post`]
228#[derive(Debug, Clone, Serialize, Deserialize)]
229#[serde(untagged)]
230pub enum TwoFactorYubikeyPostError {
231    UnknownValue(serde_json::Value),
232}
233
234/// struct for typed errors of method [`two_factor_yubikey_put`]
235#[derive(Debug, Clone, Serialize, Deserialize)]
236#[serde(untagged)]
237pub enum TwoFactorYubikeyPutError {
238    UnknownValue(serde_json::Value),
239}
240
241pub async fn organizations_id_two_factor_disable_post(
242    configuration: &configuration::Configuration,
243    id: &str,
244    two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
245) -> Result<models::TwoFactorProviderResponseModel, Error<OrganizationsIdTwoFactorDisablePostError>>
246{
247    let local_var_configuration = configuration;
248
249    let local_var_client = &local_var_configuration.client;
250
251    let local_var_uri_str = format!(
252        "{}/organizations/{id}/two-factor/disable",
253        local_var_configuration.base_path,
254        id = crate::apis::urlencode(id)
255    );
256    let mut local_var_req_builder =
257        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
258
259    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
260        local_var_req_builder =
261            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
262    }
263    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
264        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
265    };
266    local_var_req_builder = local_var_req_builder.json(&two_factor_provider_request_model);
267
268    let local_var_req = local_var_req_builder.build()?;
269    let local_var_resp = local_var_client.execute(local_var_req).await?;
270
271    let local_var_status = local_var_resp.status();
272    let local_var_content = local_var_resp.text().await?;
273
274    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
275        serde_json::from_str(&local_var_content).map_err(Error::from)
276    } else {
277        let local_var_entity: Option<OrganizationsIdTwoFactorDisablePostError> =
278            serde_json::from_str(&local_var_content).ok();
279        let local_var_error = ResponseContent {
280            status: local_var_status,
281            content: local_var_content,
282            entity: local_var_entity,
283        };
284        Err(Error::ResponseError(local_var_error))
285    }
286}
287
288pub async fn organizations_id_two_factor_disable_put(
289    configuration: &configuration::Configuration,
290    id: &str,
291    two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
292) -> Result<models::TwoFactorProviderResponseModel, Error<OrganizationsIdTwoFactorDisablePutError>>
293{
294    let local_var_configuration = configuration;
295
296    let local_var_client = &local_var_configuration.client;
297
298    let local_var_uri_str = format!(
299        "{}/organizations/{id}/two-factor/disable",
300        local_var_configuration.base_path,
301        id = crate::apis::urlencode(id)
302    );
303    let mut local_var_req_builder =
304        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
305
306    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
307        local_var_req_builder =
308            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
309    }
310    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
311        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
312    };
313    local_var_req_builder = local_var_req_builder.json(&two_factor_provider_request_model);
314
315    let local_var_req = local_var_req_builder.build()?;
316    let local_var_resp = local_var_client.execute(local_var_req).await?;
317
318    let local_var_status = local_var_resp.status();
319    let local_var_content = local_var_resp.text().await?;
320
321    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
322        serde_json::from_str(&local_var_content).map_err(Error::from)
323    } else {
324        let local_var_entity: Option<OrganizationsIdTwoFactorDisablePutError> =
325            serde_json::from_str(&local_var_content).ok();
326        let local_var_error = ResponseContent {
327            status: local_var_status,
328            content: local_var_content,
329            entity: local_var_entity,
330        };
331        Err(Error::ResponseError(local_var_error))
332    }
333}
334
335pub async fn organizations_id_two_factor_duo_post(
336    configuration: &configuration::Configuration,
337    id: &str,
338    update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
339) -> Result<models::TwoFactorDuoResponseModel, Error<OrganizationsIdTwoFactorDuoPostError>> {
340    let local_var_configuration = configuration;
341
342    let local_var_client = &local_var_configuration.client;
343
344    let local_var_uri_str = format!(
345        "{}/organizations/{id}/two-factor/duo",
346        local_var_configuration.base_path,
347        id = crate::apis::urlencode(id)
348    );
349    let mut local_var_req_builder =
350        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
351
352    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
353        local_var_req_builder =
354            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
355    }
356    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
357        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
358    };
359    local_var_req_builder = local_var_req_builder.json(&update_two_factor_duo_request_model);
360
361    let local_var_req = local_var_req_builder.build()?;
362    let local_var_resp = local_var_client.execute(local_var_req).await?;
363
364    let local_var_status = local_var_resp.status();
365    let local_var_content = local_var_resp.text().await?;
366
367    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
368        serde_json::from_str(&local_var_content).map_err(Error::from)
369    } else {
370        let local_var_entity: Option<OrganizationsIdTwoFactorDuoPostError> =
371            serde_json::from_str(&local_var_content).ok();
372        let local_var_error = ResponseContent {
373            status: local_var_status,
374            content: local_var_content,
375            entity: local_var_entity,
376        };
377        Err(Error::ResponseError(local_var_error))
378    }
379}
380
381pub async fn organizations_id_two_factor_duo_put(
382    configuration: &configuration::Configuration,
383    id: &str,
384    update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
385) -> Result<models::TwoFactorDuoResponseModel, Error<OrganizationsIdTwoFactorDuoPutError>> {
386    let local_var_configuration = configuration;
387
388    let local_var_client = &local_var_configuration.client;
389
390    let local_var_uri_str = format!(
391        "{}/organizations/{id}/two-factor/duo",
392        local_var_configuration.base_path,
393        id = crate::apis::urlencode(id)
394    );
395    let mut local_var_req_builder =
396        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
397
398    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
399        local_var_req_builder =
400            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
401    }
402    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
403        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
404    };
405    local_var_req_builder = local_var_req_builder.json(&update_two_factor_duo_request_model);
406
407    let local_var_req = local_var_req_builder.build()?;
408    let local_var_resp = local_var_client.execute(local_var_req).await?;
409
410    let local_var_status = local_var_resp.status();
411    let local_var_content = local_var_resp.text().await?;
412
413    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
414        serde_json::from_str(&local_var_content).map_err(Error::from)
415    } else {
416        let local_var_entity: Option<OrganizationsIdTwoFactorDuoPutError> =
417            serde_json::from_str(&local_var_content).ok();
418        let local_var_error = ResponseContent {
419            status: local_var_status,
420            content: local_var_content,
421            entity: local_var_entity,
422        };
423        Err(Error::ResponseError(local_var_error))
424    }
425}
426
427pub async fn organizations_id_two_factor_get(
428    configuration: &configuration::Configuration,
429    id: &str,
430) -> Result<
431    models::TwoFactorProviderResponseModelListResponseModel,
432    Error<OrganizationsIdTwoFactorGetError>,
433> {
434    let local_var_configuration = configuration;
435
436    let local_var_client = &local_var_configuration.client;
437
438    let local_var_uri_str = format!(
439        "{}/organizations/{id}/two-factor",
440        local_var_configuration.base_path,
441        id = crate::apis::urlencode(id)
442    );
443    let mut local_var_req_builder =
444        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
445
446    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
447        local_var_req_builder =
448            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
449    }
450    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
451        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
452    };
453
454    let local_var_req = local_var_req_builder.build()?;
455    let local_var_resp = local_var_client.execute(local_var_req).await?;
456
457    let local_var_status = local_var_resp.status();
458    let local_var_content = local_var_resp.text().await?;
459
460    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
461        serde_json::from_str(&local_var_content).map_err(Error::from)
462    } else {
463        let local_var_entity: Option<OrganizationsIdTwoFactorGetError> =
464            serde_json::from_str(&local_var_content).ok();
465        let local_var_error = ResponseContent {
466            status: local_var_status,
467            content: local_var_content,
468            entity: local_var_entity,
469        };
470        Err(Error::ResponseError(local_var_error))
471    }
472}
473
474pub async fn organizations_id_two_factor_get_duo_post(
475    configuration: &configuration::Configuration,
476    id: &str,
477    secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
478) -> Result<models::TwoFactorDuoResponseModel, Error<OrganizationsIdTwoFactorGetDuoPostError>> {
479    let local_var_configuration = configuration;
480
481    let local_var_client = &local_var_configuration.client;
482
483    let local_var_uri_str = format!(
484        "{}/organizations/{id}/two-factor/get-duo",
485        local_var_configuration.base_path,
486        id = crate::apis::urlencode(id)
487    );
488    let mut local_var_req_builder =
489        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
490
491    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
492        local_var_req_builder =
493            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
494    }
495    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
496        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
497    };
498    local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
499
500    let local_var_req = local_var_req_builder.build()?;
501    let local_var_resp = local_var_client.execute(local_var_req).await?;
502
503    let local_var_status = local_var_resp.status();
504    let local_var_content = local_var_resp.text().await?;
505
506    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
507        serde_json::from_str(&local_var_content).map_err(Error::from)
508    } else {
509        let local_var_entity: Option<OrganizationsIdTwoFactorGetDuoPostError> =
510            serde_json::from_str(&local_var_content).ok();
511        let local_var_error = ResponseContent {
512            status: local_var_status,
513            content: local_var_content,
514            entity: local_var_entity,
515        };
516        Err(Error::ResponseError(local_var_error))
517    }
518}
519
520pub async fn two_factor_authenticator_delete(
521    configuration: &configuration::Configuration,
522    two_factor_authenticator_disable_request_model: Option<
523        models::TwoFactorAuthenticatorDisableRequestModel,
524    >,
525) -> Result<models::TwoFactorProviderResponseModel, Error<TwoFactorAuthenticatorDeleteError>> {
526    let local_var_configuration = configuration;
527
528    let local_var_client = &local_var_configuration.client;
529
530    let local_var_uri_str = format!(
531        "{}/two-factor/authenticator",
532        local_var_configuration.base_path
533    );
534    let mut local_var_req_builder =
535        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
536
537    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
538        local_var_req_builder =
539            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
540    }
541    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
542        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
543    };
544    local_var_req_builder =
545        local_var_req_builder.json(&two_factor_authenticator_disable_request_model);
546
547    let local_var_req = local_var_req_builder.build()?;
548    let local_var_resp = local_var_client.execute(local_var_req).await?;
549
550    let local_var_status = local_var_resp.status();
551    let local_var_content = local_var_resp.text().await?;
552
553    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
554        serde_json::from_str(&local_var_content).map_err(Error::from)
555    } else {
556        let local_var_entity: Option<TwoFactorAuthenticatorDeleteError> =
557            serde_json::from_str(&local_var_content).ok();
558        let local_var_error = ResponseContent {
559            status: local_var_status,
560            content: local_var_content,
561            entity: local_var_entity,
562        };
563        Err(Error::ResponseError(local_var_error))
564    }
565}
566
567pub async fn two_factor_authenticator_post(
568    configuration: &configuration::Configuration,
569    update_two_factor_authenticator_request_model: Option<
570        models::UpdateTwoFactorAuthenticatorRequestModel,
571    >,
572) -> Result<models::TwoFactorAuthenticatorResponseModel, Error<TwoFactorAuthenticatorPostError>> {
573    let local_var_configuration = configuration;
574
575    let local_var_client = &local_var_configuration.client;
576
577    let local_var_uri_str = format!(
578        "{}/two-factor/authenticator",
579        local_var_configuration.base_path
580    );
581    let mut local_var_req_builder =
582        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
583
584    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
585        local_var_req_builder =
586            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
587    }
588    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
589        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
590    };
591    local_var_req_builder =
592        local_var_req_builder.json(&update_two_factor_authenticator_request_model);
593
594    let local_var_req = local_var_req_builder.build()?;
595    let local_var_resp = local_var_client.execute(local_var_req).await?;
596
597    let local_var_status = local_var_resp.status();
598    let local_var_content = local_var_resp.text().await?;
599
600    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
601        serde_json::from_str(&local_var_content).map_err(Error::from)
602    } else {
603        let local_var_entity: Option<TwoFactorAuthenticatorPostError> =
604            serde_json::from_str(&local_var_content).ok();
605        let local_var_error = ResponseContent {
606            status: local_var_status,
607            content: local_var_content,
608            entity: local_var_entity,
609        };
610        Err(Error::ResponseError(local_var_error))
611    }
612}
613
614pub async fn two_factor_authenticator_put(
615    configuration: &configuration::Configuration,
616    update_two_factor_authenticator_request_model: Option<
617        models::UpdateTwoFactorAuthenticatorRequestModel,
618    >,
619) -> Result<models::TwoFactorAuthenticatorResponseModel, Error<TwoFactorAuthenticatorPutError>> {
620    let local_var_configuration = configuration;
621
622    let local_var_client = &local_var_configuration.client;
623
624    let local_var_uri_str = format!(
625        "{}/two-factor/authenticator",
626        local_var_configuration.base_path
627    );
628    let mut local_var_req_builder =
629        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
630
631    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
632        local_var_req_builder =
633            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
634    }
635    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
636        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
637    };
638    local_var_req_builder =
639        local_var_req_builder.json(&update_two_factor_authenticator_request_model);
640
641    let local_var_req = local_var_req_builder.build()?;
642    let local_var_resp = local_var_client.execute(local_var_req).await?;
643
644    let local_var_status = local_var_resp.status();
645    let local_var_content = local_var_resp.text().await?;
646
647    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
648        serde_json::from_str(&local_var_content).map_err(Error::from)
649    } else {
650        let local_var_entity: Option<TwoFactorAuthenticatorPutError> =
651            serde_json::from_str(&local_var_content).ok();
652        let local_var_error = ResponseContent {
653            status: local_var_status,
654            content: local_var_content,
655            entity: local_var_entity,
656        };
657        Err(Error::ResponseError(local_var_error))
658    }
659}
660
661pub async fn two_factor_device_verification_settings_put(
662    configuration: &configuration::Configuration,
663    device_verification_request_model: Option<models::DeviceVerificationRequestModel>,
664) -> Result<
665    models::DeviceVerificationResponseModel,
666    Error<TwoFactorDeviceVerificationSettingsPutError>,
667> {
668    let local_var_configuration = configuration;
669
670    let local_var_client = &local_var_configuration.client;
671
672    let local_var_uri_str = format!(
673        "{}/two-factor/device-verification-settings",
674        local_var_configuration.base_path
675    );
676    let mut local_var_req_builder =
677        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
678
679    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
680        local_var_req_builder =
681            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
682    }
683    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
684        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
685    };
686    local_var_req_builder = local_var_req_builder.json(&device_verification_request_model);
687
688    let local_var_req = local_var_req_builder.build()?;
689    let local_var_resp = local_var_client.execute(local_var_req).await?;
690
691    let local_var_status = local_var_resp.status();
692    let local_var_content = local_var_resp.text().await?;
693
694    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
695        serde_json::from_str(&local_var_content).map_err(Error::from)
696    } else {
697        let local_var_entity: Option<TwoFactorDeviceVerificationSettingsPutError> =
698            serde_json::from_str(&local_var_content).ok();
699        let local_var_error = ResponseContent {
700            status: local_var_status,
701            content: local_var_content,
702            entity: local_var_entity,
703        };
704        Err(Error::ResponseError(local_var_error))
705    }
706}
707
708pub async fn two_factor_disable_post(
709    configuration: &configuration::Configuration,
710    two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
711) -> Result<models::TwoFactorProviderResponseModel, Error<TwoFactorDisablePostError>> {
712    let local_var_configuration = configuration;
713
714    let local_var_client = &local_var_configuration.client;
715
716    let local_var_uri_str = format!("{}/two-factor/disable", local_var_configuration.base_path);
717    let mut local_var_req_builder =
718        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
719
720    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
721        local_var_req_builder =
722            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
723    }
724    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
725        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
726    };
727    local_var_req_builder = local_var_req_builder.json(&two_factor_provider_request_model);
728
729    let local_var_req = local_var_req_builder.build()?;
730    let local_var_resp = local_var_client.execute(local_var_req).await?;
731
732    let local_var_status = local_var_resp.status();
733    let local_var_content = local_var_resp.text().await?;
734
735    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
736        serde_json::from_str(&local_var_content).map_err(Error::from)
737    } else {
738        let local_var_entity: Option<TwoFactorDisablePostError> =
739            serde_json::from_str(&local_var_content).ok();
740        let local_var_error = ResponseContent {
741            status: local_var_status,
742            content: local_var_content,
743            entity: local_var_entity,
744        };
745        Err(Error::ResponseError(local_var_error))
746    }
747}
748
749pub async fn two_factor_disable_put(
750    configuration: &configuration::Configuration,
751    two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
752) -> Result<models::TwoFactorProviderResponseModel, Error<TwoFactorDisablePutError>> {
753    let local_var_configuration = configuration;
754
755    let local_var_client = &local_var_configuration.client;
756
757    let local_var_uri_str = format!("{}/two-factor/disable", local_var_configuration.base_path);
758    let mut local_var_req_builder =
759        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
760
761    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
762        local_var_req_builder =
763            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
764    }
765    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
766        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
767    };
768    local_var_req_builder = local_var_req_builder.json(&two_factor_provider_request_model);
769
770    let local_var_req = local_var_req_builder.build()?;
771    let local_var_resp = local_var_client.execute(local_var_req).await?;
772
773    let local_var_status = local_var_resp.status();
774    let local_var_content = local_var_resp.text().await?;
775
776    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
777        serde_json::from_str(&local_var_content).map_err(Error::from)
778    } else {
779        let local_var_entity: Option<TwoFactorDisablePutError> =
780            serde_json::from_str(&local_var_content).ok();
781        let local_var_error = ResponseContent {
782            status: local_var_status,
783            content: local_var_content,
784            entity: local_var_entity,
785        };
786        Err(Error::ResponseError(local_var_error))
787    }
788}
789
790pub async fn two_factor_duo_post(
791    configuration: &configuration::Configuration,
792    update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
793) -> Result<models::TwoFactorDuoResponseModel, Error<TwoFactorDuoPostError>> {
794    let local_var_configuration = configuration;
795
796    let local_var_client = &local_var_configuration.client;
797
798    let local_var_uri_str = format!("{}/two-factor/duo", local_var_configuration.base_path);
799    let mut local_var_req_builder =
800        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
801
802    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
803        local_var_req_builder =
804            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
805    }
806    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
807        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
808    };
809    local_var_req_builder = local_var_req_builder.json(&update_two_factor_duo_request_model);
810
811    let local_var_req = local_var_req_builder.build()?;
812    let local_var_resp = local_var_client.execute(local_var_req).await?;
813
814    let local_var_status = local_var_resp.status();
815    let local_var_content = local_var_resp.text().await?;
816
817    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
818        serde_json::from_str(&local_var_content).map_err(Error::from)
819    } else {
820        let local_var_entity: Option<TwoFactorDuoPostError> =
821            serde_json::from_str(&local_var_content).ok();
822        let local_var_error = ResponseContent {
823            status: local_var_status,
824            content: local_var_content,
825            entity: local_var_entity,
826        };
827        Err(Error::ResponseError(local_var_error))
828    }
829}
830
831pub async fn two_factor_duo_put(
832    configuration: &configuration::Configuration,
833    update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
834) -> Result<models::TwoFactorDuoResponseModel, Error<TwoFactorDuoPutError>> {
835    let local_var_configuration = configuration;
836
837    let local_var_client = &local_var_configuration.client;
838
839    let local_var_uri_str = format!("{}/two-factor/duo", local_var_configuration.base_path);
840    let mut local_var_req_builder =
841        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
842
843    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
844        local_var_req_builder =
845            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
846    }
847    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
848        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
849    };
850    local_var_req_builder = local_var_req_builder.json(&update_two_factor_duo_request_model);
851
852    let local_var_req = local_var_req_builder.build()?;
853    let local_var_resp = local_var_client.execute(local_var_req).await?;
854
855    let local_var_status = local_var_resp.status();
856    let local_var_content = local_var_resp.text().await?;
857
858    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
859        serde_json::from_str(&local_var_content).map_err(Error::from)
860    } else {
861        let local_var_entity: Option<TwoFactorDuoPutError> =
862            serde_json::from_str(&local_var_content).ok();
863        let local_var_error = ResponseContent {
864            status: local_var_status,
865            content: local_var_content,
866            entity: local_var_entity,
867        };
868        Err(Error::ResponseError(local_var_error))
869    }
870}
871
872pub async fn two_factor_email_post(
873    configuration: &configuration::Configuration,
874    update_two_factor_email_request_model: Option<models::UpdateTwoFactorEmailRequestModel>,
875) -> Result<models::TwoFactorEmailResponseModel, Error<TwoFactorEmailPostError>> {
876    let local_var_configuration = configuration;
877
878    let local_var_client = &local_var_configuration.client;
879
880    let local_var_uri_str = format!("{}/two-factor/email", local_var_configuration.base_path);
881    let mut local_var_req_builder =
882        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
883
884    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
885        local_var_req_builder =
886            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
887    }
888    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
889        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
890    };
891    local_var_req_builder = local_var_req_builder.json(&update_two_factor_email_request_model);
892
893    let local_var_req = local_var_req_builder.build()?;
894    let local_var_resp = local_var_client.execute(local_var_req).await?;
895
896    let local_var_status = local_var_resp.status();
897    let local_var_content = local_var_resp.text().await?;
898
899    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
900        serde_json::from_str(&local_var_content).map_err(Error::from)
901    } else {
902        let local_var_entity: Option<TwoFactorEmailPostError> =
903            serde_json::from_str(&local_var_content).ok();
904        let local_var_error = ResponseContent {
905            status: local_var_status,
906            content: local_var_content,
907            entity: local_var_entity,
908        };
909        Err(Error::ResponseError(local_var_error))
910    }
911}
912
913pub async fn two_factor_email_put(
914    configuration: &configuration::Configuration,
915    update_two_factor_email_request_model: Option<models::UpdateTwoFactorEmailRequestModel>,
916) -> Result<models::TwoFactorEmailResponseModel, Error<TwoFactorEmailPutError>> {
917    let local_var_configuration = configuration;
918
919    let local_var_client = &local_var_configuration.client;
920
921    let local_var_uri_str = format!("{}/two-factor/email", local_var_configuration.base_path);
922    let mut local_var_req_builder =
923        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
924
925    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
926        local_var_req_builder =
927            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
928    }
929    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
930        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
931    };
932    local_var_req_builder = local_var_req_builder.json(&update_two_factor_email_request_model);
933
934    let local_var_req = local_var_req_builder.build()?;
935    let local_var_resp = local_var_client.execute(local_var_req).await?;
936
937    let local_var_status = local_var_resp.status();
938    let local_var_content = local_var_resp.text().await?;
939
940    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
941        serde_json::from_str(&local_var_content).map_err(Error::from)
942    } else {
943        let local_var_entity: Option<TwoFactorEmailPutError> =
944            serde_json::from_str(&local_var_content).ok();
945        let local_var_error = ResponseContent {
946            status: local_var_status,
947            content: local_var_content,
948            entity: local_var_entity,
949        };
950        Err(Error::ResponseError(local_var_error))
951    }
952}
953
954pub async fn two_factor_get(
955    configuration: &configuration::Configuration,
956) -> Result<models::TwoFactorProviderResponseModelListResponseModel, Error<TwoFactorGetError>> {
957    let local_var_configuration = configuration;
958
959    let local_var_client = &local_var_configuration.client;
960
961    let local_var_uri_str = format!("{}/two-factor", local_var_configuration.base_path);
962    let mut local_var_req_builder =
963        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
964
965    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
966        local_var_req_builder =
967            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
968    }
969    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
970        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
971    };
972
973    let local_var_req = local_var_req_builder.build()?;
974    let local_var_resp = local_var_client.execute(local_var_req).await?;
975
976    let local_var_status = local_var_resp.status();
977    let local_var_content = local_var_resp.text().await?;
978
979    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
980        serde_json::from_str(&local_var_content).map_err(Error::from)
981    } else {
982        let local_var_entity: Option<TwoFactorGetError> =
983            serde_json::from_str(&local_var_content).ok();
984        let local_var_error = ResponseContent {
985            status: local_var_status,
986            content: local_var_content,
987            entity: local_var_entity,
988        };
989        Err(Error::ResponseError(local_var_error))
990    }
991}
992
993pub async fn two_factor_get_authenticator_post(
994    configuration: &configuration::Configuration,
995    secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
996) -> Result<models::TwoFactorAuthenticatorResponseModel, Error<TwoFactorGetAuthenticatorPostError>>
997{
998    let local_var_configuration = configuration;
999
1000    let local_var_client = &local_var_configuration.client;
1001
1002    let local_var_uri_str = format!(
1003        "{}/two-factor/get-authenticator",
1004        local_var_configuration.base_path
1005    );
1006    let mut local_var_req_builder =
1007        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1008
1009    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1010        local_var_req_builder =
1011            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1012    }
1013    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1014        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1015    };
1016    local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1017
1018    let local_var_req = local_var_req_builder.build()?;
1019    let local_var_resp = local_var_client.execute(local_var_req).await?;
1020
1021    let local_var_status = local_var_resp.status();
1022    let local_var_content = local_var_resp.text().await?;
1023
1024    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1025        serde_json::from_str(&local_var_content).map_err(Error::from)
1026    } else {
1027        let local_var_entity: Option<TwoFactorGetAuthenticatorPostError> =
1028            serde_json::from_str(&local_var_content).ok();
1029        let local_var_error = ResponseContent {
1030            status: local_var_status,
1031            content: local_var_content,
1032            entity: local_var_entity,
1033        };
1034        Err(Error::ResponseError(local_var_error))
1035    }
1036}
1037
1038pub async fn two_factor_get_device_verification_settings_get(
1039    configuration: &configuration::Configuration,
1040) -> Result<
1041    models::DeviceVerificationResponseModel,
1042    Error<TwoFactorGetDeviceVerificationSettingsGetError>,
1043> {
1044    let local_var_configuration = configuration;
1045
1046    let local_var_client = &local_var_configuration.client;
1047
1048    let local_var_uri_str = format!(
1049        "{}/two-factor/get-device-verification-settings",
1050        local_var_configuration.base_path
1051    );
1052    let mut local_var_req_builder =
1053        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
1054
1055    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1056        local_var_req_builder =
1057            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1058    }
1059    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1060        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1061    };
1062
1063    let local_var_req = local_var_req_builder.build()?;
1064    let local_var_resp = local_var_client.execute(local_var_req).await?;
1065
1066    let local_var_status = local_var_resp.status();
1067    let local_var_content = local_var_resp.text().await?;
1068
1069    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1070        serde_json::from_str(&local_var_content).map_err(Error::from)
1071    } else {
1072        let local_var_entity: Option<TwoFactorGetDeviceVerificationSettingsGetError> =
1073            serde_json::from_str(&local_var_content).ok();
1074        let local_var_error = ResponseContent {
1075            status: local_var_status,
1076            content: local_var_content,
1077            entity: local_var_entity,
1078        };
1079        Err(Error::ResponseError(local_var_error))
1080    }
1081}
1082
1083pub async fn two_factor_get_duo_post(
1084    configuration: &configuration::Configuration,
1085    secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
1086) -> Result<models::TwoFactorDuoResponseModel, Error<TwoFactorGetDuoPostError>> {
1087    let local_var_configuration = configuration;
1088
1089    let local_var_client = &local_var_configuration.client;
1090
1091    let local_var_uri_str = format!("{}/two-factor/get-duo", local_var_configuration.base_path);
1092    let mut local_var_req_builder =
1093        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1094
1095    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1096        local_var_req_builder =
1097            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1098    }
1099    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1100        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1101    };
1102    local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1103
1104    let local_var_req = local_var_req_builder.build()?;
1105    let local_var_resp = local_var_client.execute(local_var_req).await?;
1106
1107    let local_var_status = local_var_resp.status();
1108    let local_var_content = local_var_resp.text().await?;
1109
1110    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1111        serde_json::from_str(&local_var_content).map_err(Error::from)
1112    } else {
1113        let local_var_entity: Option<TwoFactorGetDuoPostError> =
1114            serde_json::from_str(&local_var_content).ok();
1115        let local_var_error = ResponseContent {
1116            status: local_var_status,
1117            content: local_var_content,
1118            entity: local_var_entity,
1119        };
1120        Err(Error::ResponseError(local_var_error))
1121    }
1122}
1123
1124pub async fn two_factor_get_email_post(
1125    configuration: &configuration::Configuration,
1126    secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
1127) -> Result<models::TwoFactorEmailResponseModel, Error<TwoFactorGetEmailPostError>> {
1128    let local_var_configuration = configuration;
1129
1130    let local_var_client = &local_var_configuration.client;
1131
1132    let local_var_uri_str = format!("{}/two-factor/get-email", local_var_configuration.base_path);
1133    let mut local_var_req_builder =
1134        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1135
1136    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1137        local_var_req_builder =
1138            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1139    }
1140    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1141        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1142    };
1143    local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1144
1145    let local_var_req = local_var_req_builder.build()?;
1146    let local_var_resp = local_var_client.execute(local_var_req).await?;
1147
1148    let local_var_status = local_var_resp.status();
1149    let local_var_content = local_var_resp.text().await?;
1150
1151    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1152        serde_json::from_str(&local_var_content).map_err(Error::from)
1153    } else {
1154        let local_var_entity: Option<TwoFactorGetEmailPostError> =
1155            serde_json::from_str(&local_var_content).ok();
1156        let local_var_error = ResponseContent {
1157            status: local_var_status,
1158            content: local_var_content,
1159            entity: local_var_entity,
1160        };
1161        Err(Error::ResponseError(local_var_error))
1162    }
1163}
1164
1165pub async fn two_factor_get_recover_post(
1166    configuration: &configuration::Configuration,
1167    secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
1168) -> Result<models::TwoFactorRecoverResponseModel, Error<TwoFactorGetRecoverPostError>> {
1169    let local_var_configuration = configuration;
1170
1171    let local_var_client = &local_var_configuration.client;
1172
1173    let local_var_uri_str = format!(
1174        "{}/two-factor/get-recover",
1175        local_var_configuration.base_path
1176    );
1177    let mut local_var_req_builder =
1178        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1179
1180    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1181        local_var_req_builder =
1182            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1183    }
1184    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1185        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1186    };
1187    local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1188
1189    let local_var_req = local_var_req_builder.build()?;
1190    let local_var_resp = local_var_client.execute(local_var_req).await?;
1191
1192    let local_var_status = local_var_resp.status();
1193    let local_var_content = local_var_resp.text().await?;
1194
1195    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1196        serde_json::from_str(&local_var_content).map_err(Error::from)
1197    } else {
1198        let local_var_entity: Option<TwoFactorGetRecoverPostError> =
1199            serde_json::from_str(&local_var_content).ok();
1200        let local_var_error = ResponseContent {
1201            status: local_var_status,
1202            content: local_var_content,
1203            entity: local_var_entity,
1204        };
1205        Err(Error::ResponseError(local_var_error))
1206    }
1207}
1208
1209pub async fn two_factor_get_webauthn_post(
1210    configuration: &configuration::Configuration,
1211    secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
1212) -> Result<models::TwoFactorWebAuthnResponseModel, Error<TwoFactorGetWebauthnPostError>> {
1213    let local_var_configuration = configuration;
1214
1215    let local_var_client = &local_var_configuration.client;
1216
1217    let local_var_uri_str = format!(
1218        "{}/two-factor/get-webauthn",
1219        local_var_configuration.base_path
1220    );
1221    let mut local_var_req_builder =
1222        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1223
1224    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1225        local_var_req_builder =
1226            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1227    }
1228    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1229        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1230    };
1231    local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1232
1233    let local_var_req = local_var_req_builder.build()?;
1234    let local_var_resp = local_var_client.execute(local_var_req).await?;
1235
1236    let local_var_status = local_var_resp.status();
1237    let local_var_content = local_var_resp.text().await?;
1238
1239    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1240        serde_json::from_str(&local_var_content).map_err(Error::from)
1241    } else {
1242        let local_var_entity: Option<TwoFactorGetWebauthnPostError> =
1243            serde_json::from_str(&local_var_content).ok();
1244        let local_var_error = ResponseContent {
1245            status: local_var_status,
1246            content: local_var_content,
1247            entity: local_var_entity,
1248        };
1249        Err(Error::ResponseError(local_var_error))
1250    }
1251}
1252
1253pub async fn two_factor_get_yubikey_post(
1254    configuration: &configuration::Configuration,
1255    secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
1256) -> Result<models::TwoFactorYubiKeyResponseModel, Error<TwoFactorGetYubikeyPostError>> {
1257    let local_var_configuration = configuration;
1258
1259    let local_var_client = &local_var_configuration.client;
1260
1261    let local_var_uri_str = format!(
1262        "{}/two-factor/get-yubikey",
1263        local_var_configuration.base_path
1264    );
1265    let mut local_var_req_builder =
1266        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1267
1268    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1269        local_var_req_builder =
1270            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1271    }
1272    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1273        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1274    };
1275    local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
1276
1277    let local_var_req = local_var_req_builder.build()?;
1278    let local_var_resp = local_var_client.execute(local_var_req).await?;
1279
1280    let local_var_status = local_var_resp.status();
1281    let local_var_content = local_var_resp.text().await?;
1282
1283    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1284        serde_json::from_str(&local_var_content).map_err(Error::from)
1285    } else {
1286        let local_var_entity: Option<TwoFactorGetYubikeyPostError> =
1287            serde_json::from_str(&local_var_content).ok();
1288        let local_var_error = ResponseContent {
1289            status: local_var_status,
1290            content: local_var_content,
1291            entity: local_var_entity,
1292        };
1293        Err(Error::ResponseError(local_var_error))
1294    }
1295}
1296
1297pub async fn two_factor_recover_post(
1298    configuration: &configuration::Configuration,
1299    two_factor_recovery_request_model: Option<models::TwoFactorRecoveryRequestModel>,
1300) -> Result<(), Error<TwoFactorRecoverPostError>> {
1301    let local_var_configuration = configuration;
1302
1303    let local_var_client = &local_var_configuration.client;
1304
1305    let local_var_uri_str = format!("{}/two-factor/recover", local_var_configuration.base_path);
1306    let mut local_var_req_builder =
1307        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1308
1309    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1310        local_var_req_builder =
1311            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1312    }
1313    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1314        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1315    };
1316    local_var_req_builder = local_var_req_builder.json(&two_factor_recovery_request_model);
1317
1318    let local_var_req = local_var_req_builder.build()?;
1319    let local_var_resp = local_var_client.execute(local_var_req).await?;
1320
1321    let local_var_status = local_var_resp.status();
1322    let local_var_content = local_var_resp.text().await?;
1323
1324    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1325        Ok(())
1326    } else {
1327        let local_var_entity: Option<TwoFactorRecoverPostError> =
1328            serde_json::from_str(&local_var_content).ok();
1329        let local_var_error = ResponseContent {
1330            status: local_var_status,
1331            content: local_var_content,
1332            entity: local_var_entity,
1333        };
1334        Err(Error::ResponseError(local_var_error))
1335    }
1336}
1337
1338pub async fn two_factor_send_email_login_post(
1339    configuration: &configuration::Configuration,
1340    two_factor_email_request_model: Option<models::TwoFactorEmailRequestModel>,
1341) -> Result<(), Error<TwoFactorSendEmailLoginPostError>> {
1342    let local_var_configuration = configuration;
1343
1344    let local_var_client = &local_var_configuration.client;
1345
1346    let local_var_uri_str = format!(
1347        "{}/two-factor/send-email-login",
1348        local_var_configuration.base_path
1349    );
1350    let mut local_var_req_builder =
1351        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1352
1353    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1354        local_var_req_builder =
1355            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1356    }
1357    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1358        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1359    };
1360    local_var_req_builder = local_var_req_builder.json(&two_factor_email_request_model);
1361
1362    let local_var_req = local_var_req_builder.build()?;
1363    let local_var_resp = local_var_client.execute(local_var_req).await?;
1364
1365    let local_var_status = local_var_resp.status();
1366    let local_var_content = local_var_resp.text().await?;
1367
1368    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1369        Ok(())
1370    } else {
1371        let local_var_entity: Option<TwoFactorSendEmailLoginPostError> =
1372            serde_json::from_str(&local_var_content).ok();
1373        let local_var_error = ResponseContent {
1374            status: local_var_status,
1375            content: local_var_content,
1376            entity: local_var_entity,
1377        };
1378        Err(Error::ResponseError(local_var_error))
1379    }
1380}
1381
1382pub async fn two_factor_send_email_post(
1383    configuration: &configuration::Configuration,
1384    two_factor_email_request_model: Option<models::TwoFactorEmailRequestModel>,
1385) -> Result<(), Error<TwoFactorSendEmailPostError>> {
1386    let local_var_configuration = configuration;
1387
1388    let local_var_client = &local_var_configuration.client;
1389
1390    let local_var_uri_str = format!(
1391        "{}/two-factor/send-email",
1392        local_var_configuration.base_path
1393    );
1394    let mut local_var_req_builder =
1395        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1396
1397    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1398        local_var_req_builder =
1399            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1400    }
1401    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1402        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1403    };
1404    local_var_req_builder = local_var_req_builder.json(&two_factor_email_request_model);
1405
1406    let local_var_req = local_var_req_builder.build()?;
1407    let local_var_resp = local_var_client.execute(local_var_req).await?;
1408
1409    let local_var_status = local_var_resp.status();
1410    let local_var_content = local_var_resp.text().await?;
1411
1412    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1413        Ok(())
1414    } else {
1415        let local_var_entity: Option<TwoFactorSendEmailPostError> =
1416            serde_json::from_str(&local_var_content).ok();
1417        let local_var_error = ResponseContent {
1418            status: local_var_status,
1419            content: local_var_content,
1420            entity: local_var_entity,
1421        };
1422        Err(Error::ResponseError(local_var_error))
1423    }
1424}
1425
1426pub async fn two_factor_webauthn_delete(
1427    configuration: &configuration::Configuration,
1428    two_factor_web_authn_delete_request_model: Option<models::TwoFactorWebAuthnDeleteRequestModel>,
1429) -> Result<models::TwoFactorWebAuthnResponseModel, Error<TwoFactorWebauthnDeleteError>> {
1430    let local_var_configuration = configuration;
1431
1432    let local_var_client = &local_var_configuration.client;
1433
1434    let local_var_uri_str = format!("{}/two-factor/webauthn", local_var_configuration.base_path);
1435    let mut local_var_req_builder =
1436        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
1437
1438    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1439        local_var_req_builder =
1440            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1441    }
1442    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1443        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1444    };
1445    local_var_req_builder = local_var_req_builder.json(&two_factor_web_authn_delete_request_model);
1446
1447    let local_var_req = local_var_req_builder.build()?;
1448    let local_var_resp = local_var_client.execute(local_var_req).await?;
1449
1450    let local_var_status = local_var_resp.status();
1451    let local_var_content = local_var_resp.text().await?;
1452
1453    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1454        serde_json::from_str(&local_var_content).map_err(Error::from)
1455    } else {
1456        let local_var_entity: Option<TwoFactorWebauthnDeleteError> =
1457            serde_json::from_str(&local_var_content).ok();
1458        let local_var_error = ResponseContent {
1459            status: local_var_status,
1460            content: local_var_content,
1461            entity: local_var_entity,
1462        };
1463        Err(Error::ResponseError(local_var_error))
1464    }
1465}
1466
1467pub async fn two_factor_webauthn_post(
1468    configuration: &configuration::Configuration,
1469    two_factor_web_authn_request_model: Option<models::TwoFactorWebAuthnRequestModel>,
1470) -> Result<models::TwoFactorWebAuthnResponseModel, Error<TwoFactorWebauthnPostError>> {
1471    let local_var_configuration = configuration;
1472
1473    let local_var_client = &local_var_configuration.client;
1474
1475    let local_var_uri_str = format!("{}/two-factor/webauthn", local_var_configuration.base_path);
1476    let mut local_var_req_builder =
1477        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1478
1479    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1480        local_var_req_builder =
1481            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1482    }
1483    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1484        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1485    };
1486    local_var_req_builder = local_var_req_builder.json(&two_factor_web_authn_request_model);
1487
1488    let local_var_req = local_var_req_builder.build()?;
1489    let local_var_resp = local_var_client.execute(local_var_req).await?;
1490
1491    let local_var_status = local_var_resp.status();
1492    let local_var_content = local_var_resp.text().await?;
1493
1494    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1495        serde_json::from_str(&local_var_content).map_err(Error::from)
1496    } else {
1497        let local_var_entity: Option<TwoFactorWebauthnPostError> =
1498            serde_json::from_str(&local_var_content).ok();
1499        let local_var_error = ResponseContent {
1500            status: local_var_status,
1501            content: local_var_content,
1502            entity: local_var_entity,
1503        };
1504        Err(Error::ResponseError(local_var_error))
1505    }
1506}
1507
1508pub async fn two_factor_webauthn_put(
1509    configuration: &configuration::Configuration,
1510    two_factor_web_authn_request_model: Option<models::TwoFactorWebAuthnRequestModel>,
1511) -> Result<models::TwoFactorWebAuthnResponseModel, Error<TwoFactorWebauthnPutError>> {
1512    let local_var_configuration = configuration;
1513
1514    let local_var_client = &local_var_configuration.client;
1515
1516    let local_var_uri_str = format!("{}/two-factor/webauthn", local_var_configuration.base_path);
1517    let mut local_var_req_builder =
1518        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1519
1520    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1521        local_var_req_builder =
1522            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1523    }
1524    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1525        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1526    };
1527    local_var_req_builder = local_var_req_builder.json(&two_factor_web_authn_request_model);
1528
1529    let local_var_req = local_var_req_builder.build()?;
1530    let local_var_resp = local_var_client.execute(local_var_req).await?;
1531
1532    let local_var_status = local_var_resp.status();
1533    let local_var_content = local_var_resp.text().await?;
1534
1535    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1536        serde_json::from_str(&local_var_content).map_err(Error::from)
1537    } else {
1538        let local_var_entity: Option<TwoFactorWebauthnPutError> =
1539            serde_json::from_str(&local_var_content).ok();
1540        let local_var_error = ResponseContent {
1541            status: local_var_status,
1542            content: local_var_content,
1543            entity: local_var_entity,
1544        };
1545        Err(Error::ResponseError(local_var_error))
1546    }
1547}
1548
1549pub async fn two_factor_yubikey_post(
1550    configuration: &configuration::Configuration,
1551    update_two_factor_yubico_otp_request_model: Option<
1552        models::UpdateTwoFactorYubicoOtpRequestModel,
1553    >,
1554) -> Result<models::TwoFactorYubiKeyResponseModel, Error<TwoFactorYubikeyPostError>> {
1555    let local_var_configuration = configuration;
1556
1557    let local_var_client = &local_var_configuration.client;
1558
1559    let local_var_uri_str = format!("{}/two-factor/yubikey", local_var_configuration.base_path);
1560    let mut local_var_req_builder =
1561        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1562
1563    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1564        local_var_req_builder =
1565            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1566    }
1567    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1568        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1569    };
1570    local_var_req_builder = local_var_req_builder.json(&update_two_factor_yubico_otp_request_model);
1571
1572    let local_var_req = local_var_req_builder.build()?;
1573    let local_var_resp = local_var_client.execute(local_var_req).await?;
1574
1575    let local_var_status = local_var_resp.status();
1576    let local_var_content = local_var_resp.text().await?;
1577
1578    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1579        serde_json::from_str(&local_var_content).map_err(Error::from)
1580    } else {
1581        let local_var_entity: Option<TwoFactorYubikeyPostError> =
1582            serde_json::from_str(&local_var_content).ok();
1583        let local_var_error = ResponseContent {
1584            status: local_var_status,
1585            content: local_var_content,
1586            entity: local_var_entity,
1587        };
1588        Err(Error::ResponseError(local_var_error))
1589    }
1590}
1591
1592pub async fn two_factor_yubikey_put(
1593    configuration: &configuration::Configuration,
1594    update_two_factor_yubico_otp_request_model: Option<
1595        models::UpdateTwoFactorYubicoOtpRequestModel,
1596    >,
1597) -> Result<models::TwoFactorYubiKeyResponseModel, Error<TwoFactorYubikeyPutError>> {
1598    let local_var_configuration = configuration;
1599
1600    let local_var_client = &local_var_configuration.client;
1601
1602    let local_var_uri_str = format!("{}/two-factor/yubikey", local_var_configuration.base_path);
1603    let mut local_var_req_builder =
1604        local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
1605
1606    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1607        local_var_req_builder =
1608            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1609    }
1610    if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1611        local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1612    };
1613    local_var_req_builder = local_var_req_builder.json(&update_two_factor_yubico_otp_request_model);
1614
1615    let local_var_req = local_var_req_builder.build()?;
1616    let local_var_resp = local_var_client.execute(local_var_req).await?;
1617
1618    let local_var_status = local_var_resp.status();
1619    let local_var_content = local_var_resp.text().await?;
1620
1621    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1622        serde_json::from_str(&local_var_content).map_err(Error::from)
1623    } else {
1624        let local_var_entity: Option<TwoFactorYubikeyPutError> =
1625            serde_json::from_str(&local_var_content).ok();
1626        let local_var_error = ResponseContent {
1627            status: local_var_status,
1628            content: local_var_content,
1629            entity: local_var_entity,
1630        };
1631        Err(Error::ResponseError(local_var_error))
1632    }
1633}
bitwarden_api_api/apis/two_factor_api.rs

bitwarden_api_api/apis/
two_factor_api.rs
