bitwarden_api_api/apis/
organization_billing_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::{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 OrganizationBillingApi: Send + Sync {
29    /// POST /organizations/{organizationId}/billing/change-frequency
30    async fn change_plan_subscription_frequency<'a>(
31        &self,
32        organization_id: uuid::Uuid,
33        change_plan_frequency_request: Option<models::ChangePlanFrequencyRequest>,
34    ) -> Result<(), Error<ChangePlanSubscriptionFrequencyError>>;
35
36    /// GET /organizations/{organizationId}/billing
37    async fn get_billing<'a>(
38        &self,
39        organization_id: uuid::Uuid,
40    ) -> Result<(), Error<GetBillingError>>;
41
42    /// GET /organizations/{organizationId}/billing/history
43    async fn get_history<'a>(
44        &self,
45        organization_id: uuid::Uuid,
46    ) -> Result<(), Error<GetHistoryError>>;
47
48    /// GET /organizations/{organizationId}/billing/invoices
49    async fn get_invoices<'a>(
50        &self,
51        organization_id: uuid::Uuid,
52        status: Option<&'a str>,
53        start_after: Option<&'a str>,
54    ) -> Result<(), Error<GetInvoicesError>>;
55
56    /// GET /organizations/{organizationId}/billing/metadata
57    async fn get_metadata<'a>(
58        &self,
59        organization_id: uuid::Uuid,
60    ) -> Result<(), Error<GetMetadataError>>;
61
62    /// GET /organizations/{organizationId}/billing/payment-method
63    async fn get_payment_method<'a>(
64        &self,
65        organization_id: uuid::Uuid,
66    ) -> Result<(), Error<GetPaymentMethodError>>;
67
68    /// GET /organizations/{organizationId}/billing/tax-information
69    async fn get_tax_information<'a>(
70        &self,
71        organization_id: uuid::Uuid,
72    ) -> Result<(), Error<GetTaxInformationError>>;
73
74    /// GET /organizations/{organizationId}/billing/transactions
75    async fn get_transactions<'a>(
76        &self,
77        organization_id: uuid::Uuid,
78        start_after: Option<String>,
79    ) -> Result<(), Error<GetTransactionsError>>;
80
81    /// POST /organizations/{organizationId}/billing/setup-business-unit
82    async fn setup_business_unit<'a>(
83        &self,
84        organization_id: uuid::Uuid,
85        setup_business_unit_request_body: Option<models::SetupBusinessUnitRequestBody>,
86    ) -> Result<(), Error<SetupBusinessUnitError>>;
87
88    /// PUT /organizations/{organizationId}/billing/payment-method
89    async fn update_payment_method<'a>(
90        &self,
91        organization_id: uuid::Uuid,
92        update_payment_method_request_body: Option<models::UpdatePaymentMethodRequestBody>,
93    ) -> Result<(), Error<UpdatePaymentMethodError>>;
94
95    /// PUT /organizations/{organizationId}/billing/tax-information
96    async fn update_tax_information<'a>(
97        &self,
98        organization_id: uuid::Uuid,
99        tax_information_request_body: Option<models::TaxInformationRequestBody>,
100    ) -> Result<(), Error<UpdateTaxInformationError>>;
101
102    /// POST /organizations/{organizationId}/billing/payment-method/verify-bank-account
103    async fn verify_bank_account<'a>(
104        &self,
105        organization_id: uuid::Uuid,
106        verify_bank_account_request_body: Option<models::VerifyBankAccountRequestBody>,
107    ) -> Result<(), Error<VerifyBankAccountError>>;
108}
109
110pub struct OrganizationBillingApiClient {
111    configuration: Arc<configuration::Configuration>,
112}
113
114impl OrganizationBillingApiClient {
115    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
116        Self { configuration }
117    }
118}
119
120#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
121#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
122impl OrganizationBillingApi for OrganizationBillingApiClient {
123    async fn change_plan_subscription_frequency<'a>(
124        &self,
125        organization_id: uuid::Uuid,
126        change_plan_frequency_request: Option<models::ChangePlanFrequencyRequest>,
127    ) -> Result<(), Error<ChangePlanSubscriptionFrequencyError>> {
128        let local_var_configuration = &self.configuration;
129
130        let local_var_client = &local_var_configuration.client;
131
132        let local_var_uri_str = format!(
133            "{}/organizations/{organizationId}/billing/change-frequency",
134            local_var_configuration.base_path,
135            organizationId = organization_id
136        );
137        let mut local_var_req_builder =
138            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
139
140        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
141            local_var_req_builder = local_var_req_builder
142                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
143        }
144        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
145            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
146        };
147        local_var_req_builder = local_var_req_builder.json(&change_plan_frequency_request);
148
149        let local_var_req = local_var_req_builder.build()?;
150        let local_var_resp = local_var_client.execute(local_var_req).await?;
151
152        let local_var_status = local_var_resp.status();
153        let local_var_content = local_var_resp.text().await?;
154
155        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
156            Ok(())
157        } else {
158            let local_var_entity: Option<ChangePlanSubscriptionFrequencyError> =
159                serde_json::from_str(&local_var_content).ok();
160            let local_var_error = ResponseContent {
161                status: local_var_status,
162                content: local_var_content,
163                entity: local_var_entity,
164            };
165            Err(Error::ResponseError(local_var_error))
166        }
167    }
168
169    async fn get_billing<'a>(
170        &self,
171        organization_id: uuid::Uuid,
172    ) -> Result<(), Error<GetBillingError>> {
173        let local_var_configuration = &self.configuration;
174
175        let local_var_client = &local_var_configuration.client;
176
177        let local_var_uri_str = format!(
178            "{}/organizations/{organizationId}/billing",
179            local_var_configuration.base_path,
180            organizationId = organization_id
181        );
182        let mut local_var_req_builder =
183            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
184
185        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
186            local_var_req_builder = local_var_req_builder
187                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
188        }
189        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
190            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
191        };
192
193        let local_var_req = local_var_req_builder.build()?;
194        let local_var_resp = local_var_client.execute(local_var_req).await?;
195
196        let local_var_status = local_var_resp.status();
197        let local_var_content = local_var_resp.text().await?;
198
199        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
200            Ok(())
201        } else {
202            let local_var_entity: Option<GetBillingError> =
203                serde_json::from_str(&local_var_content).ok();
204            let local_var_error = ResponseContent {
205                status: local_var_status,
206                content: local_var_content,
207                entity: local_var_entity,
208            };
209            Err(Error::ResponseError(local_var_error))
210        }
211    }
212
213    async fn get_history<'a>(
214        &self,
215        organization_id: uuid::Uuid,
216    ) -> Result<(), Error<GetHistoryError>> {
217        let local_var_configuration = &self.configuration;
218
219        let local_var_client = &local_var_configuration.client;
220
221        let local_var_uri_str = format!(
222            "{}/organizations/{organizationId}/billing/history",
223            local_var_configuration.base_path,
224            organizationId = organization_id
225        );
226        let mut local_var_req_builder =
227            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
228
229        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
230            local_var_req_builder = local_var_req_builder
231                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
232        }
233        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
234            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
235        };
236
237        let local_var_req = local_var_req_builder.build()?;
238        let local_var_resp = local_var_client.execute(local_var_req).await?;
239
240        let local_var_status = local_var_resp.status();
241        let local_var_content = local_var_resp.text().await?;
242
243        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
244            Ok(())
245        } else {
246            let local_var_entity: Option<GetHistoryError> =
247                serde_json::from_str(&local_var_content).ok();
248            let local_var_error = ResponseContent {
249                status: local_var_status,
250                content: local_var_content,
251                entity: local_var_entity,
252            };
253            Err(Error::ResponseError(local_var_error))
254        }
255    }
256
257    async fn get_invoices<'a>(
258        &self,
259        organization_id: uuid::Uuid,
260        status: Option<&'a str>,
261        start_after: Option<&'a str>,
262    ) -> Result<(), Error<GetInvoicesError>> {
263        let local_var_configuration = &self.configuration;
264
265        let local_var_client = &local_var_configuration.client;
266
267        let local_var_uri_str = format!(
268            "{}/organizations/{organizationId}/billing/invoices",
269            local_var_configuration.base_path,
270            organizationId = organization_id
271        );
272        let mut local_var_req_builder =
273            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
274
275        if let Some(ref param_value) = status {
276            local_var_req_builder =
277                local_var_req_builder.query(&[("status", &param_value.to_string())]);
278        }
279        if let Some(ref param_value) = start_after {
280            local_var_req_builder =
281                local_var_req_builder.query(&[("startAfter", &param_value.to_string())]);
282        }
283        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
284            local_var_req_builder = local_var_req_builder
285                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
286        }
287        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
288            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
289        };
290
291        let local_var_req = local_var_req_builder.build()?;
292        let local_var_resp = local_var_client.execute(local_var_req).await?;
293
294        let local_var_status = local_var_resp.status();
295        let local_var_content = local_var_resp.text().await?;
296
297        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
298            Ok(())
299        } else {
300            let local_var_entity: Option<GetInvoicesError> =
301                serde_json::from_str(&local_var_content).ok();
302            let local_var_error = ResponseContent {
303                status: local_var_status,
304                content: local_var_content,
305                entity: local_var_entity,
306            };
307            Err(Error::ResponseError(local_var_error))
308        }
309    }
310
311    async fn get_metadata<'a>(
312        &self,
313        organization_id: uuid::Uuid,
314    ) -> Result<(), Error<GetMetadataError>> {
315        let local_var_configuration = &self.configuration;
316
317        let local_var_client = &local_var_configuration.client;
318
319        let local_var_uri_str = format!(
320            "{}/organizations/{organizationId}/billing/metadata",
321            local_var_configuration.base_path,
322            organizationId = organization_id
323        );
324        let mut local_var_req_builder =
325            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
326
327        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
328            local_var_req_builder = local_var_req_builder
329                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
330        }
331        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
332            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
333        };
334
335        let local_var_req = local_var_req_builder.build()?;
336        let local_var_resp = local_var_client.execute(local_var_req).await?;
337
338        let local_var_status = local_var_resp.status();
339        let local_var_content = local_var_resp.text().await?;
340
341        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
342            Ok(())
343        } else {
344            let local_var_entity: Option<GetMetadataError> =
345                serde_json::from_str(&local_var_content).ok();
346            let local_var_error = ResponseContent {
347                status: local_var_status,
348                content: local_var_content,
349                entity: local_var_entity,
350            };
351            Err(Error::ResponseError(local_var_error))
352        }
353    }
354
355    async fn get_payment_method<'a>(
356        &self,
357        organization_id: uuid::Uuid,
358    ) -> Result<(), Error<GetPaymentMethodError>> {
359        let local_var_configuration = &self.configuration;
360
361        let local_var_client = &local_var_configuration.client;
362
363        let local_var_uri_str = format!(
364            "{}/organizations/{organizationId}/billing/payment-method",
365            local_var_configuration.base_path,
366            organizationId = organization_id
367        );
368        let mut local_var_req_builder =
369            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
370
371        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
372            local_var_req_builder = local_var_req_builder
373                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
374        }
375        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
376            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
377        };
378
379        let local_var_req = local_var_req_builder.build()?;
380        let local_var_resp = local_var_client.execute(local_var_req).await?;
381
382        let local_var_status = local_var_resp.status();
383        let local_var_content = local_var_resp.text().await?;
384
385        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
386            Ok(())
387        } else {
388            let local_var_entity: Option<GetPaymentMethodError> =
389                serde_json::from_str(&local_var_content).ok();
390            let local_var_error = ResponseContent {
391                status: local_var_status,
392                content: local_var_content,
393                entity: local_var_entity,
394            };
395            Err(Error::ResponseError(local_var_error))
396        }
397    }
398
399    async fn get_tax_information<'a>(
400        &self,
401        organization_id: uuid::Uuid,
402    ) -> Result<(), Error<GetTaxInformationError>> {
403        let local_var_configuration = &self.configuration;
404
405        let local_var_client = &local_var_configuration.client;
406
407        let local_var_uri_str = format!(
408            "{}/organizations/{organizationId}/billing/tax-information",
409            local_var_configuration.base_path,
410            organizationId = organization_id
411        );
412        let mut local_var_req_builder =
413            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
414
415        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
416            local_var_req_builder = local_var_req_builder
417                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
418        }
419        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
420            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
421        };
422
423        let local_var_req = local_var_req_builder.build()?;
424        let local_var_resp = local_var_client.execute(local_var_req).await?;
425
426        let local_var_status = local_var_resp.status();
427        let local_var_content = local_var_resp.text().await?;
428
429        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
430            Ok(())
431        } else {
432            let local_var_entity: Option<GetTaxInformationError> =
433                serde_json::from_str(&local_var_content).ok();
434            let local_var_error = ResponseContent {
435                status: local_var_status,
436                content: local_var_content,
437                entity: local_var_entity,
438            };
439            Err(Error::ResponseError(local_var_error))
440        }
441    }
442
443    async fn get_transactions<'a>(
444        &self,
445        organization_id: uuid::Uuid,
446        start_after: Option<String>,
447    ) -> Result<(), Error<GetTransactionsError>> {
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!(
453            "{}/organizations/{organizationId}/billing/transactions",
454            local_var_configuration.base_path,
455            organizationId = organization_id
456        );
457        let mut local_var_req_builder =
458            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
459
460        if let Some(ref param_value) = start_after {
461            local_var_req_builder =
462                local_var_req_builder.query(&[("startAfter", &param_value.to_string())]);
463        }
464        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
465            local_var_req_builder = local_var_req_builder
466                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
467        }
468        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
469            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
470        };
471
472        let local_var_req = local_var_req_builder.build()?;
473        let local_var_resp = local_var_client.execute(local_var_req).await?;
474
475        let local_var_status = local_var_resp.status();
476        let local_var_content = local_var_resp.text().await?;
477
478        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
479            Ok(())
480        } else {
481            let local_var_entity: Option<GetTransactionsError> =
482                serde_json::from_str(&local_var_content).ok();
483            let local_var_error = ResponseContent {
484                status: local_var_status,
485                content: local_var_content,
486                entity: local_var_entity,
487            };
488            Err(Error::ResponseError(local_var_error))
489        }
490    }
491
492    async fn setup_business_unit<'a>(
493        &self,
494        organization_id: uuid::Uuid,
495        setup_business_unit_request_body: Option<models::SetupBusinessUnitRequestBody>,
496    ) -> Result<(), Error<SetupBusinessUnitError>> {
497        let local_var_configuration = &self.configuration;
498
499        let local_var_client = &local_var_configuration.client;
500
501        let local_var_uri_str = format!(
502            "{}/organizations/{organizationId}/billing/setup-business-unit",
503            local_var_configuration.base_path,
504            organizationId = organization_id
505        );
506        let mut local_var_req_builder =
507            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
508
509        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
510            local_var_req_builder = local_var_req_builder
511                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
512        }
513        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
514            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
515        };
516        local_var_req_builder = local_var_req_builder.json(&setup_business_unit_request_body);
517
518        let local_var_req = local_var_req_builder.build()?;
519        let local_var_resp = local_var_client.execute(local_var_req).await?;
520
521        let local_var_status = local_var_resp.status();
522        let local_var_content = local_var_resp.text().await?;
523
524        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
525            Ok(())
526        } else {
527            let local_var_entity: Option<SetupBusinessUnitError> =
528                serde_json::from_str(&local_var_content).ok();
529            let local_var_error = ResponseContent {
530                status: local_var_status,
531                content: local_var_content,
532                entity: local_var_entity,
533            };
534            Err(Error::ResponseError(local_var_error))
535        }
536    }
537
538    async fn update_payment_method<'a>(
539        &self,
540        organization_id: uuid::Uuid,
541        update_payment_method_request_body: Option<models::UpdatePaymentMethodRequestBody>,
542    ) -> Result<(), Error<UpdatePaymentMethodError>> {
543        let local_var_configuration = &self.configuration;
544
545        let local_var_client = &local_var_configuration.client;
546
547        let local_var_uri_str = format!(
548            "{}/organizations/{organizationId}/billing/payment-method",
549            local_var_configuration.base_path,
550            organizationId = organization_id
551        );
552        let mut local_var_req_builder =
553            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
554
555        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
556            local_var_req_builder = local_var_req_builder
557                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
558        }
559        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
560            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
561        };
562        local_var_req_builder = local_var_req_builder.json(&update_payment_method_request_body);
563
564        let local_var_req = local_var_req_builder.build()?;
565        let local_var_resp = local_var_client.execute(local_var_req).await?;
566
567        let local_var_status = local_var_resp.status();
568        let local_var_content = local_var_resp.text().await?;
569
570        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
571            Ok(())
572        } else {
573            let local_var_entity: Option<UpdatePaymentMethodError> =
574                serde_json::from_str(&local_var_content).ok();
575            let local_var_error = ResponseContent {
576                status: local_var_status,
577                content: local_var_content,
578                entity: local_var_entity,
579            };
580            Err(Error::ResponseError(local_var_error))
581        }
582    }
583
584    async fn update_tax_information<'a>(
585        &self,
586        organization_id: uuid::Uuid,
587        tax_information_request_body: Option<models::TaxInformationRequestBody>,
588    ) -> Result<(), Error<UpdateTaxInformationError>> {
589        let local_var_configuration = &self.configuration;
590
591        let local_var_client = &local_var_configuration.client;
592
593        let local_var_uri_str = format!(
594            "{}/organizations/{organizationId}/billing/tax-information",
595            local_var_configuration.base_path,
596            organizationId = organization_id
597        );
598        let mut local_var_req_builder =
599            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
600
601        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
602            local_var_req_builder = local_var_req_builder
603                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
604        }
605        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
606            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
607        };
608        local_var_req_builder = local_var_req_builder.json(&tax_information_request_body);
609
610        let local_var_req = local_var_req_builder.build()?;
611        let local_var_resp = local_var_client.execute(local_var_req).await?;
612
613        let local_var_status = local_var_resp.status();
614        let local_var_content = local_var_resp.text().await?;
615
616        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
617            Ok(())
618        } else {
619            let local_var_entity: Option<UpdateTaxInformationError> =
620                serde_json::from_str(&local_var_content).ok();
621            let local_var_error = ResponseContent {
622                status: local_var_status,
623                content: local_var_content,
624                entity: local_var_entity,
625            };
626            Err(Error::ResponseError(local_var_error))
627        }
628    }
629
630    async fn verify_bank_account<'a>(
631        &self,
632        organization_id: uuid::Uuid,
633        verify_bank_account_request_body: Option<models::VerifyBankAccountRequestBody>,
634    ) -> Result<(), Error<VerifyBankAccountError>> {
635        let local_var_configuration = &self.configuration;
636
637        let local_var_client = &local_var_configuration.client;
638
639        let local_var_uri_str = format!(
640            "{}/organizations/{organizationId}/billing/payment-method/verify-bank-account",
641            local_var_configuration.base_path,
642            organizationId = organization_id
643        );
644        let mut local_var_req_builder =
645            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
646
647        if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
648            local_var_req_builder = local_var_req_builder
649                .header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
650        }
651        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
652            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
653        };
654        local_var_req_builder = local_var_req_builder.json(&verify_bank_account_request_body);
655
656        let local_var_req = local_var_req_builder.build()?;
657        let local_var_resp = local_var_client.execute(local_var_req).await?;
658
659        let local_var_status = local_var_resp.status();
660        let local_var_content = local_var_resp.text().await?;
661
662        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
663            Ok(())
664        } else {
665            let local_var_entity: Option<VerifyBankAccountError> =
666                serde_json::from_str(&local_var_content).ok();
667            let local_var_error = ResponseContent {
668                status: local_var_status,
669                content: local_var_content,
670                entity: local_var_entity,
671            };
672            Err(Error::ResponseError(local_var_error))
673        }
674    }
675}
676
677/// struct for typed errors of method [`OrganizationBillingApi::change_plan_subscription_frequency`]
678#[derive(Debug, Clone, Serialize, Deserialize)]
679#[serde(untagged)]
680pub enum ChangePlanSubscriptionFrequencyError {
681    UnknownValue(serde_json::Value),
682}
683/// struct for typed errors of method [`OrganizationBillingApi::get_billing`]
684#[derive(Debug, Clone, Serialize, Deserialize)]
685#[serde(untagged)]
686pub enum GetBillingError {
687    UnknownValue(serde_json::Value),
688}
689/// struct for typed errors of method [`OrganizationBillingApi::get_history`]
690#[derive(Debug, Clone, Serialize, Deserialize)]
691#[serde(untagged)]
692pub enum GetHistoryError {
693    UnknownValue(serde_json::Value),
694}
695/// struct for typed errors of method [`OrganizationBillingApi::get_invoices`]
696#[derive(Debug, Clone, Serialize, Deserialize)]
697#[serde(untagged)]
698pub enum GetInvoicesError {
699    UnknownValue(serde_json::Value),
700}
701/// struct for typed errors of method [`OrganizationBillingApi::get_metadata`]
702#[derive(Debug, Clone, Serialize, Deserialize)]
703#[serde(untagged)]
704pub enum GetMetadataError {
705    UnknownValue(serde_json::Value),
706}
707/// struct for typed errors of method [`OrganizationBillingApi::get_payment_method`]
708#[derive(Debug, Clone, Serialize, Deserialize)]
709#[serde(untagged)]
710pub enum GetPaymentMethodError {
711    UnknownValue(serde_json::Value),
712}
713/// struct for typed errors of method [`OrganizationBillingApi::get_tax_information`]
714#[derive(Debug, Clone, Serialize, Deserialize)]
715#[serde(untagged)]
716pub enum GetTaxInformationError {
717    UnknownValue(serde_json::Value),
718}
719/// struct for typed errors of method [`OrganizationBillingApi::get_transactions`]
720#[derive(Debug, Clone, Serialize, Deserialize)]
721#[serde(untagged)]
722pub enum GetTransactionsError {
723    UnknownValue(serde_json::Value),
724}
725/// struct for typed errors of method [`OrganizationBillingApi::setup_business_unit`]
726#[derive(Debug, Clone, Serialize, Deserialize)]
727#[serde(untagged)]
728pub enum SetupBusinessUnitError {
729    UnknownValue(serde_json::Value),
730}
731/// struct for typed errors of method [`OrganizationBillingApi::update_payment_method`]
732#[derive(Debug, Clone, Serialize, Deserialize)]
733#[serde(untagged)]
734pub enum UpdatePaymentMethodError {
735    UnknownValue(serde_json::Value),
736}
737/// struct for typed errors of method [`OrganizationBillingApi::update_tax_information`]
738#[derive(Debug, Clone, Serialize, Deserialize)]
739#[serde(untagged)]
740pub enum UpdateTaxInformationError {
741    UnknownValue(serde_json::Value),
742}
743/// struct for typed errors of method [`OrganizationBillingApi::verify_bank_account`]
744#[derive(Debug, Clone, Serialize, Deserialize)]
745#[serde(untagged)]
746pub enum VerifyBankAccountError {
747    UnknownValue(serde_json::Value),
748}