Skip to main content

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 std::sync::Arc;
12
13use async_trait::async_trait;
14#[cfg(feature = "mockall")]
15use mockall::automock;
16use reqwest;
17use serde::{Deserialize, Serialize, de::Error as _};
18
19use super::{Error, configuration};
20use crate::{
21    apis::{AuthRequired, ContentType, ResponseContent},
22    models,
23};
24
25#[cfg_attr(feature = "mockall", automock)]
26#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
27#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
28pub trait TwoFactorApi: Send + Sync {
29    /// DELETE /two-factor/webauthn
30    async fn delete_web_authn<'a>(
31        &self,
32        two_factor_web_authn_delete_request_model: Option<
33            models::TwoFactorWebAuthnDeleteRequestModel,
34        >,
35    ) -> Result<models::TwoFactorWebAuthnResponseModel, Error>;
36
37    /// DELETE /two-factor/authenticator
38    async fn disable_authenticator<'a>(
39        &self,
40        two_factor_authenticator_disable_request_model: Option<
41            models::TwoFactorAuthenticatorDisableRequestModel,
42        >,
43    ) -> Result<models::TwoFactorProviderResponseModel, Error>;
44
45    /// GET /two-factor
46    async fn get(&self) -> Result<models::TwoFactorProviderResponseModelListResponseModel, Error>;
47
48    /// POST /two-factor/get-authenticator
49    async fn get_authenticator<'a>(
50        &self,
51        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
52    ) -> Result<models::TwoFactorAuthenticatorResponseModel, Error>;
53
54    /// POST /two-factor/get-duo
55    async fn get_duo<'a>(
56        &self,
57        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
58    ) -> Result<models::TwoFactorDuoResponseModel, Error>;
59
60    /// POST /two-factor/get-email
61    async fn get_email<'a>(
62        &self,
63        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
64    ) -> Result<models::TwoFactorEmailResponseModel, Error>;
65
66    /// GET /organizations/{id}/two-factor
67    async fn get_organization<'a>(
68        &self,
69        id: &'a str,
70    ) -> Result<models::TwoFactorProviderResponseModelListResponseModel, Error>;
71
72    /// POST /organizations/{id}/two-factor/get-duo
73    async fn get_organization_duo<'a>(
74        &self,
75        id: &'a str,
76        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
77    ) -> Result<models::TwoFactorDuoResponseModel, Error>;
78
79    /// POST /two-factor/get-recover
80    async fn get_recover<'a>(
81        &self,
82        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
83    ) -> Result<models::TwoFactorRecoverResponseModel, Error>;
84
85    /// POST /two-factor/get-webauthn
86    async fn get_web_authn<'a>(
87        &self,
88        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
89    ) -> Result<models::TwoFactorWebAuthnResponseModel, Error>;
90
91    /// POST /two-factor/get-yubikey
92    async fn get_yubi_key<'a>(
93        &self,
94        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
95    ) -> Result<models::TwoFactorYubiKeyResponseModel, Error>;
96
97    /// PUT /two-factor/authenticator
98    async fn put_authenticator<'a>(
99        &self,
100        update_two_factor_authenticator_request_model: Option<
101            models::UpdateTwoFactorAuthenticatorRequestModel,
102        >,
103    ) -> Result<models::TwoFactorAuthenticatorResponseModel, Error>;
104
105    /// PUT /two-factor/disable
106    async fn put_disable<'a>(
107        &self,
108        two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
109    ) -> Result<models::TwoFactorProviderResponseModel, Error>;
110
111    /// PUT /two-factor/duo
112    async fn put_duo<'a>(
113        &self,
114        update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
115    ) -> Result<models::TwoFactorDuoResponseModel, Error>;
116
117    /// PUT /two-factor/email
118    async fn put_email<'a>(
119        &self,
120        update_two_factor_email_request_model: Option<models::UpdateTwoFactorEmailRequestModel>,
121    ) -> Result<models::TwoFactorEmailResponseModel, Error>;
122
123    /// PUT /organizations/{id}/two-factor/disable
124    async fn put_organization_disable<'a>(
125        &self,
126        id: &'a str,
127        two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
128    ) -> Result<models::TwoFactorProviderResponseModel, Error>;
129
130    /// PUT /organizations/{id}/two-factor/duo
131    async fn put_organization_duo<'a>(
132        &self,
133        id: &'a str,
134        update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
135    ) -> Result<models::TwoFactorDuoResponseModel, Error>;
136
137    /// PUT /two-factor/webauthn
138    async fn put_web_authn<'a>(
139        &self,
140        two_factor_web_authn_request_model: Option<models::TwoFactorWebAuthnRequestModel>,
141    ) -> Result<models::TwoFactorWebAuthnResponseModel, Error>;
142
143    /// PUT /two-factor/yubikey
144    async fn put_yubi_key<'a>(
145        &self,
146        update_two_factor_yubico_otp_request_model: Option<
147            models::UpdateTwoFactorYubicoOtpRequestModel,
148        >,
149    ) -> Result<models::TwoFactorYubiKeyResponseModel, Error>;
150
151    /// POST /two-factor/send-email
152    async fn send_email<'a>(
153        &self,
154        two_factor_email_request_model: Option<models::TwoFactorEmailRequestModel>,
155    ) -> Result<(), Error>;
156
157    /// POST /two-factor/send-email-login
158    async fn send_email_login<'a>(
159        &self,
160        two_factor_email_request_model: Option<models::TwoFactorEmailRequestModel>,
161    ) -> Result<(), Error>;
162}
163
164pub struct TwoFactorApiClient {
165    configuration: Arc<configuration::Configuration>,
166}
167
168impl TwoFactorApiClient {
169    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
170        Self { configuration }
171    }
172}
173
174#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
175#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
176impl TwoFactorApi for TwoFactorApiClient {
177    async fn delete_web_authn<'a>(
178        &self,
179        two_factor_web_authn_delete_request_model: Option<
180            models::TwoFactorWebAuthnDeleteRequestModel,
181        >,
182    ) -> Result<models::TwoFactorWebAuthnResponseModel, Error> {
183        let local_var_configuration = &self.configuration;
184
185        let local_var_client = &local_var_configuration.client;
186
187        let local_var_uri_str =
188            format!("{}/two-factor/webauthn", local_var_configuration.base_path);
189        let mut local_var_req_builder =
190            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
191
192        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
193        local_var_req_builder =
194            local_var_req_builder.json(&two_factor_web_authn_delete_request_model);
195
196        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
197    }
198
199    async fn disable_authenticator<'a>(
200        &self,
201        two_factor_authenticator_disable_request_model: Option<
202            models::TwoFactorAuthenticatorDisableRequestModel,
203        >,
204    ) -> Result<models::TwoFactorProviderResponseModel, Error> {
205        let local_var_configuration = &self.configuration;
206
207        let local_var_client = &local_var_configuration.client;
208
209        let local_var_uri_str = format!(
210            "{}/two-factor/authenticator",
211            local_var_configuration.base_path
212        );
213        let mut local_var_req_builder =
214            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
215
216        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
217        local_var_req_builder =
218            local_var_req_builder.json(&two_factor_authenticator_disable_request_model);
219
220        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
221    }
222
223    async fn get(&self) -> Result<models::TwoFactorProviderResponseModelListResponseModel, Error> {
224        let local_var_configuration = &self.configuration;
225
226        let local_var_client = &local_var_configuration.client;
227
228        let local_var_uri_str = format!("{}/two-factor", local_var_configuration.base_path);
229        let mut local_var_req_builder =
230            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
231
232        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
233
234        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
235    }
236
237    async fn get_authenticator<'a>(
238        &self,
239        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
240    ) -> Result<models::TwoFactorAuthenticatorResponseModel, Error> {
241        let local_var_configuration = &self.configuration;
242
243        let local_var_client = &local_var_configuration.client;
244
245        let local_var_uri_str = format!(
246            "{}/two-factor/get-authenticator",
247            local_var_configuration.base_path
248        );
249        let mut local_var_req_builder =
250            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
251
252        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
253        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
254
255        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
256    }
257
258    async fn get_duo<'a>(
259        &self,
260        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
261    ) -> Result<models::TwoFactorDuoResponseModel, Error> {
262        let local_var_configuration = &self.configuration;
263
264        let local_var_client = &local_var_configuration.client;
265
266        let local_var_uri_str = format!("{}/two-factor/get-duo", local_var_configuration.base_path);
267        let mut local_var_req_builder =
268            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
269
270        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
271        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
272
273        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
274    }
275
276    async fn get_email<'a>(
277        &self,
278        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
279    ) -> Result<models::TwoFactorEmailResponseModel, Error> {
280        let local_var_configuration = &self.configuration;
281
282        let local_var_client = &local_var_configuration.client;
283
284        let local_var_uri_str =
285            format!("{}/two-factor/get-email", local_var_configuration.base_path);
286        let mut local_var_req_builder =
287            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
288
289        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
290        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
291
292        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
293    }
294
295    async fn get_organization<'a>(
296        &self,
297        id: &'a str,
298    ) -> Result<models::TwoFactorProviderResponseModelListResponseModel, Error> {
299        let local_var_configuration = &self.configuration;
300
301        let local_var_client = &local_var_configuration.client;
302
303        let local_var_uri_str = format!(
304            "{}/organizations/{id}/two-factor",
305            local_var_configuration.base_path,
306            id = crate::apis::urlencode(id)
307        );
308        let mut local_var_req_builder =
309            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
310
311        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
312
313        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
314    }
315
316    async fn get_organization_duo<'a>(
317        &self,
318        id: &'a str,
319        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
320    ) -> Result<models::TwoFactorDuoResponseModel, Error> {
321        let local_var_configuration = &self.configuration;
322
323        let local_var_client = &local_var_configuration.client;
324
325        let local_var_uri_str = format!(
326            "{}/organizations/{id}/two-factor/get-duo",
327            local_var_configuration.base_path,
328            id = crate::apis::urlencode(id)
329        );
330        let mut local_var_req_builder =
331            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
332
333        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
334        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
335
336        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
337    }
338
339    async fn get_recover<'a>(
340        &self,
341        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
342    ) -> Result<models::TwoFactorRecoverResponseModel, Error> {
343        let local_var_configuration = &self.configuration;
344
345        let local_var_client = &local_var_configuration.client;
346
347        let local_var_uri_str = format!(
348            "{}/two-factor/get-recover",
349            local_var_configuration.base_path
350        );
351        let mut local_var_req_builder =
352            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
353
354        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
355        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
356
357        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
358    }
359
360    async fn get_web_authn<'a>(
361        &self,
362        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
363    ) -> Result<models::TwoFactorWebAuthnResponseModel, Error> {
364        let local_var_configuration = &self.configuration;
365
366        let local_var_client = &local_var_configuration.client;
367
368        let local_var_uri_str = format!(
369            "{}/two-factor/get-webauthn",
370            local_var_configuration.base_path
371        );
372        let mut local_var_req_builder =
373            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
374
375        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
376        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
377
378        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
379    }
380
381    async fn get_yubi_key<'a>(
382        &self,
383        secret_verification_request_model: Option<models::SecretVerificationRequestModel>,
384    ) -> Result<models::TwoFactorYubiKeyResponseModel, Error> {
385        let local_var_configuration = &self.configuration;
386
387        let local_var_client = &local_var_configuration.client;
388
389        let local_var_uri_str = format!(
390            "{}/two-factor/get-yubikey",
391            local_var_configuration.base_path
392        );
393        let mut local_var_req_builder =
394            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
395
396        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
397        local_var_req_builder = local_var_req_builder.json(&secret_verification_request_model);
398
399        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
400    }
401
402    async fn put_authenticator<'a>(
403        &self,
404        update_two_factor_authenticator_request_model: Option<
405            models::UpdateTwoFactorAuthenticatorRequestModel,
406        >,
407    ) -> Result<models::TwoFactorAuthenticatorResponseModel, Error> {
408        let local_var_configuration = &self.configuration;
409
410        let local_var_client = &local_var_configuration.client;
411
412        let local_var_uri_str = format!(
413            "{}/two-factor/authenticator",
414            local_var_configuration.base_path
415        );
416        let mut local_var_req_builder =
417            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
418
419        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
420        local_var_req_builder =
421            local_var_req_builder.json(&update_two_factor_authenticator_request_model);
422
423        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
424    }
425
426    async fn put_disable<'a>(
427        &self,
428        two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
429    ) -> Result<models::TwoFactorProviderResponseModel, Error> {
430        let local_var_configuration = &self.configuration;
431
432        let local_var_client = &local_var_configuration.client;
433
434        let local_var_uri_str = format!("{}/two-factor/disable", local_var_configuration.base_path);
435        let mut local_var_req_builder =
436            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
437
438        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
439        local_var_req_builder = local_var_req_builder.json(&two_factor_provider_request_model);
440
441        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
442    }
443
444    async fn put_duo<'a>(
445        &self,
446        update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
447    ) -> Result<models::TwoFactorDuoResponseModel, Error> {
448        let local_var_configuration = &self.configuration;
449
450        let local_var_client = &local_var_configuration.client;
451
452        let local_var_uri_str = format!("{}/two-factor/duo", local_var_configuration.base_path);
453        let mut local_var_req_builder =
454            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
455
456        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
457        local_var_req_builder = local_var_req_builder.json(&update_two_factor_duo_request_model);
458
459        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
460    }
461
462    async fn put_email<'a>(
463        &self,
464        update_two_factor_email_request_model: Option<models::UpdateTwoFactorEmailRequestModel>,
465    ) -> Result<models::TwoFactorEmailResponseModel, Error> {
466        let local_var_configuration = &self.configuration;
467
468        let local_var_client = &local_var_configuration.client;
469
470        let local_var_uri_str = format!("{}/two-factor/email", local_var_configuration.base_path);
471        let mut local_var_req_builder =
472            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
473
474        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
475        local_var_req_builder = local_var_req_builder.json(&update_two_factor_email_request_model);
476
477        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
478    }
479
480    async fn put_organization_disable<'a>(
481        &self,
482        id: &'a str,
483        two_factor_provider_request_model: Option<models::TwoFactorProviderRequestModel>,
484    ) -> Result<models::TwoFactorProviderResponseModel, Error> {
485        let local_var_configuration = &self.configuration;
486
487        let local_var_client = &local_var_configuration.client;
488
489        let local_var_uri_str = format!(
490            "{}/organizations/{id}/two-factor/disable",
491            local_var_configuration.base_path,
492            id = crate::apis::urlencode(id)
493        );
494        let mut local_var_req_builder =
495            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
496
497        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
498        local_var_req_builder = local_var_req_builder.json(&two_factor_provider_request_model);
499
500        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
501    }
502
503    async fn put_organization_duo<'a>(
504        &self,
505        id: &'a str,
506        update_two_factor_duo_request_model: Option<models::UpdateTwoFactorDuoRequestModel>,
507    ) -> Result<models::TwoFactorDuoResponseModel, Error> {
508        let local_var_configuration = &self.configuration;
509
510        let local_var_client = &local_var_configuration.client;
511
512        let local_var_uri_str = format!(
513            "{}/organizations/{id}/two-factor/duo",
514            local_var_configuration.base_path,
515            id = crate::apis::urlencode(id)
516        );
517        let mut local_var_req_builder =
518            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
519
520        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
521        local_var_req_builder = local_var_req_builder.json(&update_two_factor_duo_request_model);
522
523        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
524    }
525
526    async fn put_web_authn<'a>(
527        &self,
528        two_factor_web_authn_request_model: Option<models::TwoFactorWebAuthnRequestModel>,
529    ) -> Result<models::TwoFactorWebAuthnResponseModel, Error> {
530        let local_var_configuration = &self.configuration;
531
532        let local_var_client = &local_var_configuration.client;
533
534        let local_var_uri_str =
535            format!("{}/two-factor/webauthn", local_var_configuration.base_path);
536        let mut local_var_req_builder =
537            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
538
539        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
540        local_var_req_builder = local_var_req_builder.json(&two_factor_web_authn_request_model);
541
542        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
543    }
544
545    async fn put_yubi_key<'a>(
546        &self,
547        update_two_factor_yubico_otp_request_model: Option<
548            models::UpdateTwoFactorYubicoOtpRequestModel,
549        >,
550    ) -> Result<models::TwoFactorYubiKeyResponseModel, Error> {
551        let local_var_configuration = &self.configuration;
552
553        let local_var_client = &local_var_configuration.client;
554
555        let local_var_uri_str = format!("{}/two-factor/yubikey", local_var_configuration.base_path);
556        let mut local_var_req_builder =
557            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
558
559        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
560        local_var_req_builder =
561            local_var_req_builder.json(&update_two_factor_yubico_otp_request_model);
562
563        bitwarden_api_base::process_with_json_response(local_var_req_builder).await
564    }
565
566    async fn send_email<'a>(
567        &self,
568        two_factor_email_request_model: Option<models::TwoFactorEmailRequestModel>,
569    ) -> Result<(), Error> {
570        let local_var_configuration = &self.configuration;
571
572        let local_var_client = &local_var_configuration.client;
573
574        let local_var_uri_str = format!(
575            "{}/two-factor/send-email",
576            local_var_configuration.base_path
577        );
578        let mut local_var_req_builder =
579            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
580
581        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
582        local_var_req_builder = local_var_req_builder.json(&two_factor_email_request_model);
583
584        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
585    }
586
587    async fn send_email_login<'a>(
588        &self,
589        two_factor_email_request_model: Option<models::TwoFactorEmailRequestModel>,
590    ) -> Result<(), Error> {
591        let local_var_configuration = &self.configuration;
592
593        let local_var_client = &local_var_configuration.client;
594
595        let local_var_uri_str = format!(
596            "{}/two-factor/send-email-login",
597            local_var_configuration.base_path
598        );
599        let mut local_var_req_builder =
600            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
601
602        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
603        local_var_req_builder = local_var_req_builder.json(&two_factor_email_request_model);
604
605        bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
606    }
607}