1use 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 PreviewInvoiceApi: Send + Sync {
29 async fn preview_organization_subscription_plan_change_tax<'a>(
31 &self,
32 organization_id: &'a str,
33 id: Option<uuid::Uuid>,
34 identifier: Option<&'a str>,
35 name: Option<&'a str>,
36 business_name: Option<&'a str>,
37 business_address1: Option<&'a str>,
38 business_address2: Option<&'a str>,
39 business_address3: Option<&'a str>,
40 business_country: Option<&'a str>,
41 business_tax_number: Option<&'a str>,
42 billing_email: Option<&'a str>,
43 plan: Option<&'a str>,
44 plan_type: Option<models::PlanType>,
45 seats: Option<i32>,
46 max_collections: Option<i32>,
47 use_policies: Option<bool>,
48 use_sso: Option<bool>,
49 use_key_connector: Option<bool>,
50 use_scim: Option<bool>,
51 use_groups: Option<bool>,
52 use_directory: Option<bool>,
53 use_events: Option<bool>,
54 use_totp: Option<bool>,
55 use2fa: Option<bool>,
56 use_api: Option<bool>,
57 use_reset_password: Option<bool>,
58 use_secrets_manager: Option<bool>,
59 self_host: Option<bool>,
60 users_get_premium: Option<bool>,
61 use_custom_permissions: Option<bool>,
62 storage: Option<i64>,
63 max_storage_gb: Option<i32>,
64 gateway: Option<models::GatewayType>,
65 gateway_customer_id: Option<&'a str>,
66 gateway_subscription_id: Option<&'a str>,
67 reference_data: Option<&'a str>,
68 enabled: Option<bool>,
69 license_key: Option<&'a str>,
70 public_key: Option<&'a str>,
71 private_key: Option<&'a str>,
72 two_factor_providers: Option<&'a str>,
73 expiration_date: Option<String>,
74 creation_date: Option<String>,
75 revision_date: Option<String>,
76 max_autoscale_seats: Option<i32>,
77 owners_notified_of_autoscaling: Option<String>,
78 status: Option<models::OrganizationStatusType>,
79 use_password_manager: Option<bool>,
80 sm_seats: Option<i32>,
81 sm_service_accounts: Option<i32>,
82 max_autoscale_sm_seats: Option<i32>,
83 max_autoscale_sm_service_accounts: Option<i32>,
84 limit_collection_creation: Option<bool>,
85 limit_collection_deletion: Option<bool>,
86 allow_admin_access_to_all_collection_items: Option<bool>,
87 limit_item_deletion: Option<bool>,
88 use_risk_insights: Option<bool>,
89 use_organization_domains: Option<bool>,
90 use_admin_sponsored_families: Option<bool>,
91 sync_seats: Option<bool>,
92 use_automatic_user_confirmation: Option<bool>,
93 use_disable_sm_ads_for_users: Option<bool>,
94 use_phishing_blocker: Option<bool>,
95 preview_organization_subscription_plan_change_tax_request: Option<
96 models::PreviewOrganizationSubscriptionPlanChangeTaxRequest,
97 >,
98 ) -> Result<(), Error<PreviewOrganizationSubscriptionPlanChangeTaxError>>;
99
100 async fn preview_organization_subscription_purchase_tax<'a>(
102 &self,
103 preview_organization_subscription_purchase_tax_request: Option<
104 models::PreviewOrganizationSubscriptionPurchaseTaxRequest,
105 >,
106 ) -> Result<(), Error<PreviewOrganizationSubscriptionPurchaseTaxError>>;
107
108 async fn preview_organization_subscription_update_tax<'a>(
110 &self,
111 organization_id: &'a str,
112 id: Option<uuid::Uuid>,
113 identifier: Option<&'a str>,
114 name: Option<&'a str>,
115 business_name: Option<&'a str>,
116 business_address1: Option<&'a str>,
117 business_address2: Option<&'a str>,
118 business_address3: Option<&'a str>,
119 business_country: Option<&'a str>,
120 business_tax_number: Option<&'a str>,
121 billing_email: Option<&'a str>,
122 plan: Option<&'a str>,
123 plan_type: Option<models::PlanType>,
124 seats: Option<i32>,
125 max_collections: Option<i32>,
126 use_policies: Option<bool>,
127 use_sso: Option<bool>,
128 use_key_connector: Option<bool>,
129 use_scim: Option<bool>,
130 use_groups: Option<bool>,
131 use_directory: Option<bool>,
132 use_events: Option<bool>,
133 use_totp: Option<bool>,
134 use2fa: Option<bool>,
135 use_api: Option<bool>,
136 use_reset_password: Option<bool>,
137 use_secrets_manager: Option<bool>,
138 self_host: Option<bool>,
139 users_get_premium: Option<bool>,
140 use_custom_permissions: Option<bool>,
141 storage: Option<i64>,
142 max_storage_gb: Option<i32>,
143 gateway: Option<models::GatewayType>,
144 gateway_customer_id: Option<&'a str>,
145 gateway_subscription_id: Option<&'a str>,
146 reference_data: Option<&'a str>,
147 enabled: Option<bool>,
148 license_key: Option<&'a str>,
149 public_key: Option<&'a str>,
150 private_key: Option<&'a str>,
151 two_factor_providers: Option<&'a str>,
152 expiration_date: Option<String>,
153 creation_date: Option<String>,
154 revision_date: Option<String>,
155 max_autoscale_seats: Option<i32>,
156 owners_notified_of_autoscaling: Option<String>,
157 status: Option<models::OrganizationStatusType>,
158 use_password_manager: Option<bool>,
159 sm_seats: Option<i32>,
160 sm_service_accounts: Option<i32>,
161 max_autoscale_sm_seats: Option<i32>,
162 max_autoscale_sm_service_accounts: Option<i32>,
163 limit_collection_creation: Option<bool>,
164 limit_collection_deletion: Option<bool>,
165 allow_admin_access_to_all_collection_items: Option<bool>,
166 limit_item_deletion: Option<bool>,
167 use_risk_insights: Option<bool>,
168 use_organization_domains: Option<bool>,
169 use_admin_sponsored_families: Option<bool>,
170 sync_seats: Option<bool>,
171 use_automatic_user_confirmation: Option<bool>,
172 use_disable_sm_ads_for_users: Option<bool>,
173 use_phishing_blocker: Option<bool>,
174 preview_organization_subscription_update_tax_request: Option<
175 models::PreviewOrganizationSubscriptionUpdateTaxRequest,
176 >,
177 ) -> Result<(), Error<PreviewOrganizationSubscriptionUpdateTaxError>>;
178
179 async fn preview_premium_subscription_purchase_tax<'a>(
181 &self,
182 preview_premium_subscription_purchase_tax_request: Option<
183 models::PreviewPremiumSubscriptionPurchaseTaxRequest,
184 >,
185 ) -> Result<(), Error<PreviewPremiumSubscriptionPurchaseTaxError>>;
186
187 async fn preview_premium_upgrade_proration<'a>(
189 &self,
190 email: &'a str,
191 security_stamp: &'a str,
192 api_key: &'a str,
193 id: Option<uuid::Uuid>,
194 name: Option<&'a str>,
195 email_verified: Option<bool>,
196 master_password: Option<&'a str>,
197 master_password_hint: Option<&'a str>,
198 culture: Option<&'a str>,
199 two_factor_providers: Option<&'a str>,
200 two_factor_recovery_code: Option<&'a str>,
201 equivalent_domains: Option<&'a str>,
202 excluded_global_equivalent_domains: Option<&'a str>,
203 account_revision_date: Option<String>,
204 key: Option<&'a str>,
205 public_key: Option<&'a str>,
206 private_key: Option<&'a str>,
207 signed_public_key: Option<&'a str>,
208 security_version: Option<i32>,
209 security_state: Option<&'a str>,
210 premium: Option<bool>,
211 premium_expiration_date: Option<String>,
212 renewal_reminder_date: Option<String>,
213 storage: Option<i64>,
214 max_storage_gb: Option<i32>,
215 gateway: Option<models::GatewayType>,
216 gateway_customer_id: Option<&'a str>,
217 gateway_subscription_id: Option<&'a str>,
218 reference_data: Option<&'a str>,
219 license_key: Option<&'a str>,
220 kdf: Option<models::KdfType>,
221 kdf_iterations: Option<i32>,
222 kdf_memory: Option<i32>,
223 kdf_parallelism: Option<i32>,
224 creation_date: Option<String>,
225 revision_date: Option<String>,
226 force_password_reset: Option<bool>,
227 uses_key_connector: Option<bool>,
228 failed_login_count: Option<i32>,
229 last_failed_login_date: Option<String>,
230 avatar_color: Option<&'a str>,
231 last_password_change_date: Option<String>,
232 last_kdf_change_date: Option<String>,
233 last_key_rotation_date: Option<String>,
234 last_email_change_date: Option<String>,
235 verify_devices: Option<bool>,
236 preview_premium_upgrade_proration_request: Option<
237 models::PreviewPremiumUpgradeProrationRequest,
238 >,
239 ) -> Result<(), Error<PreviewPremiumUpgradeProrationError>>;
240}
241
242pub struct PreviewInvoiceApiClient {
243 configuration: Arc<configuration::Configuration>,
244}
245
246impl PreviewInvoiceApiClient {
247 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
248 Self { configuration }
249 }
250}
251
252#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
253#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
254impl PreviewInvoiceApi for PreviewInvoiceApiClient {
255 async fn preview_organization_subscription_plan_change_tax<'a>(
256 &self,
257 organization_id: &'a str,
258 id: Option<uuid::Uuid>,
259 identifier: Option<&'a str>,
260 name: Option<&'a str>,
261 business_name: Option<&'a str>,
262 business_address1: Option<&'a str>,
263 business_address2: Option<&'a str>,
264 business_address3: Option<&'a str>,
265 business_country: Option<&'a str>,
266 business_tax_number: Option<&'a str>,
267 billing_email: Option<&'a str>,
268 plan: Option<&'a str>,
269 plan_type: Option<models::PlanType>,
270 seats: Option<i32>,
271 max_collections: Option<i32>,
272 use_policies: Option<bool>,
273 use_sso: Option<bool>,
274 use_key_connector: Option<bool>,
275 use_scim: Option<bool>,
276 use_groups: Option<bool>,
277 use_directory: Option<bool>,
278 use_events: Option<bool>,
279 use_totp: Option<bool>,
280 use2fa: Option<bool>,
281 use_api: Option<bool>,
282 use_reset_password: Option<bool>,
283 use_secrets_manager: Option<bool>,
284 self_host: Option<bool>,
285 users_get_premium: Option<bool>,
286 use_custom_permissions: Option<bool>,
287 storage: Option<i64>,
288 max_storage_gb: Option<i32>,
289 gateway: Option<models::GatewayType>,
290 gateway_customer_id: Option<&'a str>,
291 gateway_subscription_id: Option<&'a str>,
292 reference_data: Option<&'a str>,
293 enabled: Option<bool>,
294 license_key: Option<&'a str>,
295 public_key: Option<&'a str>,
296 private_key: Option<&'a str>,
297 two_factor_providers: Option<&'a str>,
298 expiration_date: Option<String>,
299 creation_date: Option<String>,
300 revision_date: Option<String>,
301 max_autoscale_seats: Option<i32>,
302 owners_notified_of_autoscaling: Option<String>,
303 status: Option<models::OrganizationStatusType>,
304 use_password_manager: Option<bool>,
305 sm_seats: Option<i32>,
306 sm_service_accounts: Option<i32>,
307 max_autoscale_sm_seats: Option<i32>,
308 max_autoscale_sm_service_accounts: Option<i32>,
309 limit_collection_creation: Option<bool>,
310 limit_collection_deletion: Option<bool>,
311 allow_admin_access_to_all_collection_items: Option<bool>,
312 limit_item_deletion: Option<bool>,
313 use_risk_insights: Option<bool>,
314 use_organization_domains: Option<bool>,
315 use_admin_sponsored_families: Option<bool>,
316 sync_seats: Option<bool>,
317 use_automatic_user_confirmation: Option<bool>,
318 use_disable_sm_ads_for_users: Option<bool>,
319 use_phishing_blocker: Option<bool>,
320 preview_organization_subscription_plan_change_tax_request: Option<
321 models::PreviewOrganizationSubscriptionPlanChangeTaxRequest,
322 >,
323 ) -> Result<(), Error<PreviewOrganizationSubscriptionPlanChangeTaxError>> {
324 let local_var_configuration = &self.configuration;
325
326 let local_var_client = &local_var_configuration.client;
327
328 let local_var_uri_str = format!(
329 "{}/billing/preview-invoice/organizations/{organizationId}/subscription/plan-change",
330 local_var_configuration.base_path,
331 organizationId = crate::apis::urlencode(organization_id)
332 );
333 let mut local_var_req_builder =
334 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
335
336 if let Some(ref param_value) = id {
337 local_var_req_builder =
338 local_var_req_builder.query(&[("id", ¶m_value.to_string())]);
339 }
340 if let Some(ref param_value) = identifier {
341 local_var_req_builder =
342 local_var_req_builder.query(&[("identifier", ¶m_value.to_string())]);
343 }
344 if let Some(ref param_value) = name {
345 local_var_req_builder =
346 local_var_req_builder.query(&[("name", ¶m_value.to_string())]);
347 }
348 if let Some(ref param_value) = business_name {
349 local_var_req_builder =
350 local_var_req_builder.query(&[("businessName", ¶m_value.to_string())]);
351 }
352 if let Some(ref param_value) = business_address1 {
353 local_var_req_builder =
354 local_var_req_builder.query(&[("businessAddress1", ¶m_value.to_string())]);
355 }
356 if let Some(ref param_value) = business_address2 {
357 local_var_req_builder =
358 local_var_req_builder.query(&[("businessAddress2", ¶m_value.to_string())]);
359 }
360 if let Some(ref param_value) = business_address3 {
361 local_var_req_builder =
362 local_var_req_builder.query(&[("businessAddress3", ¶m_value.to_string())]);
363 }
364 if let Some(ref param_value) = business_country {
365 local_var_req_builder =
366 local_var_req_builder.query(&[("businessCountry", ¶m_value.to_string())]);
367 }
368 if let Some(ref param_value) = business_tax_number {
369 local_var_req_builder =
370 local_var_req_builder.query(&[("businessTaxNumber", ¶m_value.to_string())]);
371 }
372 if let Some(ref param_value) = billing_email {
373 local_var_req_builder =
374 local_var_req_builder.query(&[("billingEmail", ¶m_value.to_string())]);
375 }
376 if let Some(ref param_value) = plan {
377 local_var_req_builder =
378 local_var_req_builder.query(&[("plan", ¶m_value.to_string())]);
379 }
380 if let Some(ref param_value) = plan_type {
381 local_var_req_builder =
382 local_var_req_builder.query(&[("planType", ¶m_value.to_string())]);
383 }
384 if let Some(ref param_value) = seats {
385 local_var_req_builder =
386 local_var_req_builder.query(&[("seats", ¶m_value.to_string())]);
387 }
388 if let Some(ref param_value) = max_collections {
389 local_var_req_builder =
390 local_var_req_builder.query(&[("maxCollections", ¶m_value.to_string())]);
391 }
392 if let Some(ref param_value) = use_policies {
393 local_var_req_builder =
394 local_var_req_builder.query(&[("usePolicies", ¶m_value.to_string())]);
395 }
396 if let Some(ref param_value) = use_sso {
397 local_var_req_builder =
398 local_var_req_builder.query(&[("useSso", ¶m_value.to_string())]);
399 }
400 if let Some(ref param_value) = use_key_connector {
401 local_var_req_builder =
402 local_var_req_builder.query(&[("useKeyConnector", ¶m_value.to_string())]);
403 }
404 if let Some(ref param_value) = use_scim {
405 local_var_req_builder =
406 local_var_req_builder.query(&[("useScim", ¶m_value.to_string())]);
407 }
408 if let Some(ref param_value) = use_groups {
409 local_var_req_builder =
410 local_var_req_builder.query(&[("useGroups", ¶m_value.to_string())]);
411 }
412 if let Some(ref param_value) = use_directory {
413 local_var_req_builder =
414 local_var_req_builder.query(&[("useDirectory", ¶m_value.to_string())]);
415 }
416 if let Some(ref param_value) = use_events {
417 local_var_req_builder =
418 local_var_req_builder.query(&[("useEvents", ¶m_value.to_string())]);
419 }
420 if let Some(ref param_value) = use_totp {
421 local_var_req_builder =
422 local_var_req_builder.query(&[("useTotp", ¶m_value.to_string())]);
423 }
424 if let Some(ref param_value) = use2fa {
425 local_var_req_builder =
426 local_var_req_builder.query(&[("use2fa", ¶m_value.to_string())]);
427 }
428 if let Some(ref param_value) = use_api {
429 local_var_req_builder =
430 local_var_req_builder.query(&[("useApi", ¶m_value.to_string())]);
431 }
432 if let Some(ref param_value) = use_reset_password {
433 local_var_req_builder =
434 local_var_req_builder.query(&[("useResetPassword", ¶m_value.to_string())]);
435 }
436 if let Some(ref param_value) = use_secrets_manager {
437 local_var_req_builder =
438 local_var_req_builder.query(&[("useSecretsManager", ¶m_value.to_string())]);
439 }
440 if let Some(ref param_value) = self_host {
441 local_var_req_builder =
442 local_var_req_builder.query(&[("selfHost", ¶m_value.to_string())]);
443 }
444 if let Some(ref param_value) = users_get_premium {
445 local_var_req_builder =
446 local_var_req_builder.query(&[("usersGetPremium", ¶m_value.to_string())]);
447 }
448 if let Some(ref param_value) = use_custom_permissions {
449 local_var_req_builder =
450 local_var_req_builder.query(&[("useCustomPermissions", ¶m_value.to_string())]);
451 }
452 if let Some(ref param_value) = storage {
453 local_var_req_builder =
454 local_var_req_builder.query(&[("storage", ¶m_value.to_string())]);
455 }
456 if let Some(ref param_value) = max_storage_gb {
457 local_var_req_builder =
458 local_var_req_builder.query(&[("maxStorageGb", ¶m_value.to_string())]);
459 }
460 if let Some(ref param_value) = gateway {
461 local_var_req_builder =
462 local_var_req_builder.query(&[("gateway", ¶m_value.to_string())]);
463 }
464 if let Some(ref param_value) = gateway_customer_id {
465 local_var_req_builder =
466 local_var_req_builder.query(&[("gatewayCustomerId", ¶m_value.to_string())]);
467 }
468 if let Some(ref param_value) = gateway_subscription_id {
469 local_var_req_builder =
470 local_var_req_builder.query(&[("gatewaySubscriptionId", ¶m_value.to_string())]);
471 }
472 if let Some(ref param_value) = reference_data {
473 local_var_req_builder =
474 local_var_req_builder.query(&[("referenceData", ¶m_value.to_string())]);
475 }
476 if let Some(ref param_value) = enabled {
477 local_var_req_builder =
478 local_var_req_builder.query(&[("enabled", ¶m_value.to_string())]);
479 }
480 if let Some(ref param_value) = license_key {
481 local_var_req_builder =
482 local_var_req_builder.query(&[("licenseKey", ¶m_value.to_string())]);
483 }
484 if let Some(ref param_value) = public_key {
485 local_var_req_builder =
486 local_var_req_builder.query(&[("publicKey", ¶m_value.to_string())]);
487 }
488 if let Some(ref param_value) = private_key {
489 local_var_req_builder =
490 local_var_req_builder.query(&[("privateKey", ¶m_value.to_string())]);
491 }
492 if let Some(ref param_value) = two_factor_providers {
493 local_var_req_builder =
494 local_var_req_builder.query(&[("twoFactorProviders", ¶m_value.to_string())]);
495 }
496 if let Some(ref param_value) = expiration_date {
497 local_var_req_builder =
498 local_var_req_builder.query(&[("expirationDate", ¶m_value.to_string())]);
499 }
500 if let Some(ref param_value) = creation_date {
501 local_var_req_builder =
502 local_var_req_builder.query(&[("creationDate", ¶m_value.to_string())]);
503 }
504 if let Some(ref param_value) = revision_date {
505 local_var_req_builder =
506 local_var_req_builder.query(&[("revisionDate", ¶m_value.to_string())]);
507 }
508 if let Some(ref param_value) = max_autoscale_seats {
509 local_var_req_builder =
510 local_var_req_builder.query(&[("maxAutoscaleSeats", ¶m_value.to_string())]);
511 }
512 if let Some(ref param_value) = owners_notified_of_autoscaling {
513 local_var_req_builder = local_var_req_builder
514 .query(&[("ownersNotifiedOfAutoscaling", ¶m_value.to_string())]);
515 }
516 if let Some(ref param_value) = status {
517 local_var_req_builder =
518 local_var_req_builder.query(&[("status", ¶m_value.to_string())]);
519 }
520 if let Some(ref param_value) = use_password_manager {
521 local_var_req_builder =
522 local_var_req_builder.query(&[("usePasswordManager", ¶m_value.to_string())]);
523 }
524 if let Some(ref param_value) = sm_seats {
525 local_var_req_builder =
526 local_var_req_builder.query(&[("smSeats", ¶m_value.to_string())]);
527 }
528 if let Some(ref param_value) = sm_service_accounts {
529 local_var_req_builder =
530 local_var_req_builder.query(&[("smServiceAccounts", ¶m_value.to_string())]);
531 }
532 if let Some(ref param_value) = max_autoscale_sm_seats {
533 local_var_req_builder =
534 local_var_req_builder.query(&[("maxAutoscaleSmSeats", ¶m_value.to_string())]);
535 }
536 if let Some(ref param_value) = max_autoscale_sm_service_accounts {
537 local_var_req_builder = local_var_req_builder
538 .query(&[("maxAutoscaleSmServiceAccounts", ¶m_value.to_string())]);
539 }
540 if let Some(ref param_value) = limit_collection_creation {
541 local_var_req_builder = local_var_req_builder
542 .query(&[("limitCollectionCreation", ¶m_value.to_string())]);
543 }
544 if let Some(ref param_value) = limit_collection_deletion {
545 local_var_req_builder = local_var_req_builder
546 .query(&[("limitCollectionDeletion", ¶m_value.to_string())]);
547 }
548 if let Some(ref param_value) = allow_admin_access_to_all_collection_items {
549 local_var_req_builder = local_var_req_builder.query(&[(
550 "allowAdminAccessToAllCollectionItems",
551 ¶m_value.to_string(),
552 )]);
553 }
554 if let Some(ref param_value) = limit_item_deletion {
555 local_var_req_builder =
556 local_var_req_builder.query(&[("limitItemDeletion", ¶m_value.to_string())]);
557 }
558 if let Some(ref param_value) = use_risk_insights {
559 local_var_req_builder =
560 local_var_req_builder.query(&[("useRiskInsights", ¶m_value.to_string())]);
561 }
562 if let Some(ref param_value) = use_organization_domains {
563 local_var_req_builder = local_var_req_builder
564 .query(&[("useOrganizationDomains", ¶m_value.to_string())]);
565 }
566 if let Some(ref param_value) = use_admin_sponsored_families {
567 local_var_req_builder = local_var_req_builder
568 .query(&[("useAdminSponsoredFamilies", ¶m_value.to_string())]);
569 }
570 if let Some(ref param_value) = sync_seats {
571 local_var_req_builder =
572 local_var_req_builder.query(&[("syncSeats", ¶m_value.to_string())]);
573 }
574 if let Some(ref param_value) = use_automatic_user_confirmation {
575 local_var_req_builder = local_var_req_builder
576 .query(&[("useAutomaticUserConfirmation", ¶m_value.to_string())]);
577 }
578 if let Some(ref param_value) = use_disable_sm_ads_for_users {
579 local_var_req_builder = local_var_req_builder
580 .query(&[("useDisableSmAdsForUsers", ¶m_value.to_string())]);
581 }
582 if let Some(ref param_value) = use_phishing_blocker {
583 local_var_req_builder =
584 local_var_req_builder.query(&[("usePhishingBlocker", ¶m_value.to_string())]);
585 }
586 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
587 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
588 };
589 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
590 local_var_req_builder =
591 local_var_req_builder.json(&preview_organization_subscription_plan_change_tax_request);
592
593 let local_var_req = local_var_req_builder.build()?;
594 let local_var_resp = local_var_client.execute(local_var_req).await?;
595
596 let local_var_status = local_var_resp.status();
597 let local_var_content = local_var_resp.text().await?;
598
599 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
600 Ok(())
601 } else {
602 let local_var_entity: Option<PreviewOrganizationSubscriptionPlanChangeTaxError> =
603 serde_json::from_str(&local_var_content).ok();
604 let local_var_error = ResponseContent {
605 status: local_var_status,
606 content: local_var_content,
607 entity: local_var_entity,
608 };
609 Err(Error::ResponseError(local_var_error))
610 }
611 }
612
613 async fn preview_organization_subscription_purchase_tax<'a>(
614 &self,
615 preview_organization_subscription_purchase_tax_request: Option<
616 models::PreviewOrganizationSubscriptionPurchaseTaxRequest,
617 >,
618 ) -> Result<(), Error<PreviewOrganizationSubscriptionPurchaseTaxError>> {
619 let local_var_configuration = &self.configuration;
620
621 let local_var_client = &local_var_configuration.client;
622
623 let local_var_uri_str = format!(
624 "{}/billing/preview-invoice/organizations/subscriptions/purchase",
625 local_var_configuration.base_path
626 );
627 let mut local_var_req_builder =
628 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
629
630 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
631 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
632 };
633 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
634 local_var_req_builder =
635 local_var_req_builder.json(&preview_organization_subscription_purchase_tax_request);
636
637 let local_var_req = local_var_req_builder.build()?;
638 let local_var_resp = local_var_client.execute(local_var_req).await?;
639
640 let local_var_status = local_var_resp.status();
641 let local_var_content = local_var_resp.text().await?;
642
643 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
644 Ok(())
645 } else {
646 let local_var_entity: Option<PreviewOrganizationSubscriptionPurchaseTaxError> =
647 serde_json::from_str(&local_var_content).ok();
648 let local_var_error = ResponseContent {
649 status: local_var_status,
650 content: local_var_content,
651 entity: local_var_entity,
652 };
653 Err(Error::ResponseError(local_var_error))
654 }
655 }
656
657 async fn preview_organization_subscription_update_tax<'a>(
658 &self,
659 organization_id: &'a str,
660 id: Option<uuid::Uuid>,
661 identifier: Option<&'a str>,
662 name: Option<&'a str>,
663 business_name: Option<&'a str>,
664 business_address1: Option<&'a str>,
665 business_address2: Option<&'a str>,
666 business_address3: Option<&'a str>,
667 business_country: Option<&'a str>,
668 business_tax_number: Option<&'a str>,
669 billing_email: Option<&'a str>,
670 plan: Option<&'a str>,
671 plan_type: Option<models::PlanType>,
672 seats: Option<i32>,
673 max_collections: Option<i32>,
674 use_policies: Option<bool>,
675 use_sso: Option<bool>,
676 use_key_connector: Option<bool>,
677 use_scim: Option<bool>,
678 use_groups: Option<bool>,
679 use_directory: Option<bool>,
680 use_events: Option<bool>,
681 use_totp: Option<bool>,
682 use2fa: Option<bool>,
683 use_api: Option<bool>,
684 use_reset_password: Option<bool>,
685 use_secrets_manager: Option<bool>,
686 self_host: Option<bool>,
687 users_get_premium: Option<bool>,
688 use_custom_permissions: Option<bool>,
689 storage: Option<i64>,
690 max_storage_gb: Option<i32>,
691 gateway: Option<models::GatewayType>,
692 gateway_customer_id: Option<&'a str>,
693 gateway_subscription_id: Option<&'a str>,
694 reference_data: Option<&'a str>,
695 enabled: Option<bool>,
696 license_key: Option<&'a str>,
697 public_key: Option<&'a str>,
698 private_key: Option<&'a str>,
699 two_factor_providers: Option<&'a str>,
700 expiration_date: Option<String>,
701 creation_date: Option<String>,
702 revision_date: Option<String>,
703 max_autoscale_seats: Option<i32>,
704 owners_notified_of_autoscaling: Option<String>,
705 status: Option<models::OrganizationStatusType>,
706 use_password_manager: Option<bool>,
707 sm_seats: Option<i32>,
708 sm_service_accounts: Option<i32>,
709 max_autoscale_sm_seats: Option<i32>,
710 max_autoscale_sm_service_accounts: Option<i32>,
711 limit_collection_creation: Option<bool>,
712 limit_collection_deletion: Option<bool>,
713 allow_admin_access_to_all_collection_items: Option<bool>,
714 limit_item_deletion: Option<bool>,
715 use_risk_insights: Option<bool>,
716 use_organization_domains: Option<bool>,
717 use_admin_sponsored_families: Option<bool>,
718 sync_seats: Option<bool>,
719 use_automatic_user_confirmation: Option<bool>,
720 use_disable_sm_ads_for_users: Option<bool>,
721 use_phishing_blocker: Option<bool>,
722 preview_organization_subscription_update_tax_request: Option<
723 models::PreviewOrganizationSubscriptionUpdateTaxRequest,
724 >,
725 ) -> Result<(), Error<PreviewOrganizationSubscriptionUpdateTaxError>> {
726 let local_var_configuration = &self.configuration;
727
728 let local_var_client = &local_var_configuration.client;
729
730 let local_var_uri_str = format!(
731 "{}/billing/preview-invoice/organizations/{organizationId}/subscription/update",
732 local_var_configuration.base_path,
733 organizationId = crate::apis::urlencode(organization_id)
734 );
735 let mut local_var_req_builder =
736 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
737
738 if let Some(ref param_value) = id {
739 local_var_req_builder =
740 local_var_req_builder.query(&[("id", ¶m_value.to_string())]);
741 }
742 if let Some(ref param_value) = identifier {
743 local_var_req_builder =
744 local_var_req_builder.query(&[("identifier", ¶m_value.to_string())]);
745 }
746 if let Some(ref param_value) = name {
747 local_var_req_builder =
748 local_var_req_builder.query(&[("name", ¶m_value.to_string())]);
749 }
750 if let Some(ref param_value) = business_name {
751 local_var_req_builder =
752 local_var_req_builder.query(&[("businessName", ¶m_value.to_string())]);
753 }
754 if let Some(ref param_value) = business_address1 {
755 local_var_req_builder =
756 local_var_req_builder.query(&[("businessAddress1", ¶m_value.to_string())]);
757 }
758 if let Some(ref param_value) = business_address2 {
759 local_var_req_builder =
760 local_var_req_builder.query(&[("businessAddress2", ¶m_value.to_string())]);
761 }
762 if let Some(ref param_value) = business_address3 {
763 local_var_req_builder =
764 local_var_req_builder.query(&[("businessAddress3", ¶m_value.to_string())]);
765 }
766 if let Some(ref param_value) = business_country {
767 local_var_req_builder =
768 local_var_req_builder.query(&[("businessCountry", ¶m_value.to_string())]);
769 }
770 if let Some(ref param_value) = business_tax_number {
771 local_var_req_builder =
772 local_var_req_builder.query(&[("businessTaxNumber", ¶m_value.to_string())]);
773 }
774 if let Some(ref param_value) = billing_email {
775 local_var_req_builder =
776 local_var_req_builder.query(&[("billingEmail", ¶m_value.to_string())]);
777 }
778 if let Some(ref param_value) = plan {
779 local_var_req_builder =
780 local_var_req_builder.query(&[("plan", ¶m_value.to_string())]);
781 }
782 if let Some(ref param_value) = plan_type {
783 local_var_req_builder =
784 local_var_req_builder.query(&[("planType", ¶m_value.to_string())]);
785 }
786 if let Some(ref param_value) = seats {
787 local_var_req_builder =
788 local_var_req_builder.query(&[("seats", ¶m_value.to_string())]);
789 }
790 if let Some(ref param_value) = max_collections {
791 local_var_req_builder =
792 local_var_req_builder.query(&[("maxCollections", ¶m_value.to_string())]);
793 }
794 if let Some(ref param_value) = use_policies {
795 local_var_req_builder =
796 local_var_req_builder.query(&[("usePolicies", ¶m_value.to_string())]);
797 }
798 if let Some(ref param_value) = use_sso {
799 local_var_req_builder =
800 local_var_req_builder.query(&[("useSso", ¶m_value.to_string())]);
801 }
802 if let Some(ref param_value) = use_key_connector {
803 local_var_req_builder =
804 local_var_req_builder.query(&[("useKeyConnector", ¶m_value.to_string())]);
805 }
806 if let Some(ref param_value) = use_scim {
807 local_var_req_builder =
808 local_var_req_builder.query(&[("useScim", ¶m_value.to_string())]);
809 }
810 if let Some(ref param_value) = use_groups {
811 local_var_req_builder =
812 local_var_req_builder.query(&[("useGroups", ¶m_value.to_string())]);
813 }
814 if let Some(ref param_value) = use_directory {
815 local_var_req_builder =
816 local_var_req_builder.query(&[("useDirectory", ¶m_value.to_string())]);
817 }
818 if let Some(ref param_value) = use_events {
819 local_var_req_builder =
820 local_var_req_builder.query(&[("useEvents", ¶m_value.to_string())]);
821 }
822 if let Some(ref param_value) = use_totp {
823 local_var_req_builder =
824 local_var_req_builder.query(&[("useTotp", ¶m_value.to_string())]);
825 }
826 if let Some(ref param_value) = use2fa {
827 local_var_req_builder =
828 local_var_req_builder.query(&[("use2fa", ¶m_value.to_string())]);
829 }
830 if let Some(ref param_value) = use_api {
831 local_var_req_builder =
832 local_var_req_builder.query(&[("useApi", ¶m_value.to_string())]);
833 }
834 if let Some(ref param_value) = use_reset_password {
835 local_var_req_builder =
836 local_var_req_builder.query(&[("useResetPassword", ¶m_value.to_string())]);
837 }
838 if let Some(ref param_value) = use_secrets_manager {
839 local_var_req_builder =
840 local_var_req_builder.query(&[("useSecretsManager", ¶m_value.to_string())]);
841 }
842 if let Some(ref param_value) = self_host {
843 local_var_req_builder =
844 local_var_req_builder.query(&[("selfHost", ¶m_value.to_string())]);
845 }
846 if let Some(ref param_value) = users_get_premium {
847 local_var_req_builder =
848 local_var_req_builder.query(&[("usersGetPremium", ¶m_value.to_string())]);
849 }
850 if let Some(ref param_value) = use_custom_permissions {
851 local_var_req_builder =
852 local_var_req_builder.query(&[("useCustomPermissions", ¶m_value.to_string())]);
853 }
854 if let Some(ref param_value) = storage {
855 local_var_req_builder =
856 local_var_req_builder.query(&[("storage", ¶m_value.to_string())]);
857 }
858 if let Some(ref param_value) = max_storage_gb {
859 local_var_req_builder =
860 local_var_req_builder.query(&[("maxStorageGb", ¶m_value.to_string())]);
861 }
862 if let Some(ref param_value) = gateway {
863 local_var_req_builder =
864 local_var_req_builder.query(&[("gateway", ¶m_value.to_string())]);
865 }
866 if let Some(ref param_value) = gateway_customer_id {
867 local_var_req_builder =
868 local_var_req_builder.query(&[("gatewayCustomerId", ¶m_value.to_string())]);
869 }
870 if let Some(ref param_value) = gateway_subscription_id {
871 local_var_req_builder =
872 local_var_req_builder.query(&[("gatewaySubscriptionId", ¶m_value.to_string())]);
873 }
874 if let Some(ref param_value) = reference_data {
875 local_var_req_builder =
876 local_var_req_builder.query(&[("referenceData", ¶m_value.to_string())]);
877 }
878 if let Some(ref param_value) = enabled {
879 local_var_req_builder =
880 local_var_req_builder.query(&[("enabled", ¶m_value.to_string())]);
881 }
882 if let Some(ref param_value) = license_key {
883 local_var_req_builder =
884 local_var_req_builder.query(&[("licenseKey", ¶m_value.to_string())]);
885 }
886 if let Some(ref param_value) = public_key {
887 local_var_req_builder =
888 local_var_req_builder.query(&[("publicKey", ¶m_value.to_string())]);
889 }
890 if let Some(ref param_value) = private_key {
891 local_var_req_builder =
892 local_var_req_builder.query(&[("privateKey", ¶m_value.to_string())]);
893 }
894 if let Some(ref param_value) = two_factor_providers {
895 local_var_req_builder =
896 local_var_req_builder.query(&[("twoFactorProviders", ¶m_value.to_string())]);
897 }
898 if let Some(ref param_value) = expiration_date {
899 local_var_req_builder =
900 local_var_req_builder.query(&[("expirationDate", ¶m_value.to_string())]);
901 }
902 if let Some(ref param_value) = creation_date {
903 local_var_req_builder =
904 local_var_req_builder.query(&[("creationDate", ¶m_value.to_string())]);
905 }
906 if let Some(ref param_value) = revision_date {
907 local_var_req_builder =
908 local_var_req_builder.query(&[("revisionDate", ¶m_value.to_string())]);
909 }
910 if let Some(ref param_value) = max_autoscale_seats {
911 local_var_req_builder =
912 local_var_req_builder.query(&[("maxAutoscaleSeats", ¶m_value.to_string())]);
913 }
914 if let Some(ref param_value) = owners_notified_of_autoscaling {
915 local_var_req_builder = local_var_req_builder
916 .query(&[("ownersNotifiedOfAutoscaling", ¶m_value.to_string())]);
917 }
918 if let Some(ref param_value) = status {
919 local_var_req_builder =
920 local_var_req_builder.query(&[("status", ¶m_value.to_string())]);
921 }
922 if let Some(ref param_value) = use_password_manager {
923 local_var_req_builder =
924 local_var_req_builder.query(&[("usePasswordManager", ¶m_value.to_string())]);
925 }
926 if let Some(ref param_value) = sm_seats {
927 local_var_req_builder =
928 local_var_req_builder.query(&[("smSeats", ¶m_value.to_string())]);
929 }
930 if let Some(ref param_value) = sm_service_accounts {
931 local_var_req_builder =
932 local_var_req_builder.query(&[("smServiceAccounts", ¶m_value.to_string())]);
933 }
934 if let Some(ref param_value) = max_autoscale_sm_seats {
935 local_var_req_builder =
936 local_var_req_builder.query(&[("maxAutoscaleSmSeats", ¶m_value.to_string())]);
937 }
938 if let Some(ref param_value) = max_autoscale_sm_service_accounts {
939 local_var_req_builder = local_var_req_builder
940 .query(&[("maxAutoscaleSmServiceAccounts", ¶m_value.to_string())]);
941 }
942 if let Some(ref param_value) = limit_collection_creation {
943 local_var_req_builder = local_var_req_builder
944 .query(&[("limitCollectionCreation", ¶m_value.to_string())]);
945 }
946 if let Some(ref param_value) = limit_collection_deletion {
947 local_var_req_builder = local_var_req_builder
948 .query(&[("limitCollectionDeletion", ¶m_value.to_string())]);
949 }
950 if let Some(ref param_value) = allow_admin_access_to_all_collection_items {
951 local_var_req_builder = local_var_req_builder.query(&[(
952 "allowAdminAccessToAllCollectionItems",
953 ¶m_value.to_string(),
954 )]);
955 }
956 if let Some(ref param_value) = limit_item_deletion {
957 local_var_req_builder =
958 local_var_req_builder.query(&[("limitItemDeletion", ¶m_value.to_string())]);
959 }
960 if let Some(ref param_value) = use_risk_insights {
961 local_var_req_builder =
962 local_var_req_builder.query(&[("useRiskInsights", ¶m_value.to_string())]);
963 }
964 if let Some(ref param_value) = use_organization_domains {
965 local_var_req_builder = local_var_req_builder
966 .query(&[("useOrganizationDomains", ¶m_value.to_string())]);
967 }
968 if let Some(ref param_value) = use_admin_sponsored_families {
969 local_var_req_builder = local_var_req_builder
970 .query(&[("useAdminSponsoredFamilies", ¶m_value.to_string())]);
971 }
972 if let Some(ref param_value) = sync_seats {
973 local_var_req_builder =
974 local_var_req_builder.query(&[("syncSeats", ¶m_value.to_string())]);
975 }
976 if let Some(ref param_value) = use_automatic_user_confirmation {
977 local_var_req_builder = local_var_req_builder
978 .query(&[("useAutomaticUserConfirmation", ¶m_value.to_string())]);
979 }
980 if let Some(ref param_value) = use_disable_sm_ads_for_users {
981 local_var_req_builder = local_var_req_builder
982 .query(&[("useDisableSmAdsForUsers", ¶m_value.to_string())]);
983 }
984 if let Some(ref param_value) = use_phishing_blocker {
985 local_var_req_builder =
986 local_var_req_builder.query(&[("usePhishingBlocker", ¶m_value.to_string())]);
987 }
988 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
989 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
990 };
991 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
992 local_var_req_builder =
993 local_var_req_builder.json(&preview_organization_subscription_update_tax_request);
994
995 let local_var_req = local_var_req_builder.build()?;
996 let local_var_resp = local_var_client.execute(local_var_req).await?;
997
998 let local_var_status = local_var_resp.status();
999 let local_var_content = local_var_resp.text().await?;
1000
1001 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1002 Ok(())
1003 } else {
1004 let local_var_entity: Option<PreviewOrganizationSubscriptionUpdateTaxError> =
1005 serde_json::from_str(&local_var_content).ok();
1006 let local_var_error = ResponseContent {
1007 status: local_var_status,
1008 content: local_var_content,
1009 entity: local_var_entity,
1010 };
1011 Err(Error::ResponseError(local_var_error))
1012 }
1013 }
1014
1015 async fn preview_premium_subscription_purchase_tax<'a>(
1016 &self,
1017 preview_premium_subscription_purchase_tax_request: Option<
1018 models::PreviewPremiumSubscriptionPurchaseTaxRequest,
1019 >,
1020 ) -> Result<(), Error<PreviewPremiumSubscriptionPurchaseTaxError>> {
1021 let local_var_configuration = &self.configuration;
1022
1023 let local_var_client = &local_var_configuration.client;
1024
1025 let local_var_uri_str = format!(
1026 "{}/billing/preview-invoice/premium/subscriptions/purchase",
1027 local_var_configuration.base_path
1028 );
1029 let mut local_var_req_builder =
1030 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1031
1032 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1033 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1034 };
1035 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1036 local_var_req_builder =
1037 local_var_req_builder.json(&preview_premium_subscription_purchase_tax_request);
1038
1039 let local_var_req = local_var_req_builder.build()?;
1040 let local_var_resp = local_var_client.execute(local_var_req).await?;
1041
1042 let local_var_status = local_var_resp.status();
1043 let local_var_content = local_var_resp.text().await?;
1044
1045 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1046 Ok(())
1047 } else {
1048 let local_var_entity: Option<PreviewPremiumSubscriptionPurchaseTaxError> =
1049 serde_json::from_str(&local_var_content).ok();
1050 let local_var_error = ResponseContent {
1051 status: local_var_status,
1052 content: local_var_content,
1053 entity: local_var_entity,
1054 };
1055 Err(Error::ResponseError(local_var_error))
1056 }
1057 }
1058
1059 async fn preview_premium_upgrade_proration<'a>(
1060 &self,
1061 email: &'a str,
1062 security_stamp: &'a str,
1063 api_key: &'a str,
1064 id: Option<uuid::Uuid>,
1065 name: Option<&'a str>,
1066 email_verified: Option<bool>,
1067 master_password: Option<&'a str>,
1068 master_password_hint: Option<&'a str>,
1069 culture: Option<&'a str>,
1070 two_factor_providers: Option<&'a str>,
1071 two_factor_recovery_code: Option<&'a str>,
1072 equivalent_domains: Option<&'a str>,
1073 excluded_global_equivalent_domains: Option<&'a str>,
1074 account_revision_date: Option<String>,
1075 key: Option<&'a str>,
1076 public_key: Option<&'a str>,
1077 private_key: Option<&'a str>,
1078 signed_public_key: Option<&'a str>,
1079 security_version: Option<i32>,
1080 security_state: Option<&'a str>,
1081 premium: Option<bool>,
1082 premium_expiration_date: Option<String>,
1083 renewal_reminder_date: Option<String>,
1084 storage: Option<i64>,
1085 max_storage_gb: Option<i32>,
1086 gateway: Option<models::GatewayType>,
1087 gateway_customer_id: Option<&'a str>,
1088 gateway_subscription_id: Option<&'a str>,
1089 reference_data: Option<&'a str>,
1090 license_key: Option<&'a str>,
1091 kdf: Option<models::KdfType>,
1092 kdf_iterations: Option<i32>,
1093 kdf_memory: Option<i32>,
1094 kdf_parallelism: Option<i32>,
1095 creation_date: Option<String>,
1096 revision_date: Option<String>,
1097 force_password_reset: Option<bool>,
1098 uses_key_connector: Option<bool>,
1099 failed_login_count: Option<i32>,
1100 last_failed_login_date: Option<String>,
1101 avatar_color: Option<&'a str>,
1102 last_password_change_date: Option<String>,
1103 last_kdf_change_date: Option<String>,
1104 last_key_rotation_date: Option<String>,
1105 last_email_change_date: Option<String>,
1106 verify_devices: Option<bool>,
1107 preview_premium_upgrade_proration_request: Option<
1108 models::PreviewPremiumUpgradeProrationRequest,
1109 >,
1110 ) -> Result<(), Error<PreviewPremiumUpgradeProrationError>> {
1111 let local_var_configuration = &self.configuration;
1112
1113 let local_var_client = &local_var_configuration.client;
1114
1115 let local_var_uri_str = format!(
1116 "{}/billing/preview-invoice/premium/subscriptions/upgrade",
1117 local_var_configuration.base_path
1118 );
1119 let mut local_var_req_builder =
1120 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1121
1122 if let Some(ref param_value) = id {
1123 local_var_req_builder =
1124 local_var_req_builder.query(&[("id", ¶m_value.to_string())]);
1125 }
1126 if let Some(ref param_value) = name {
1127 local_var_req_builder =
1128 local_var_req_builder.query(&[("name", ¶m_value.to_string())]);
1129 }
1130 local_var_req_builder = local_var_req_builder.query(&[("email", &email.to_string())]);
1131 if let Some(ref param_value) = email_verified {
1132 local_var_req_builder =
1133 local_var_req_builder.query(&[("emailVerified", ¶m_value.to_string())]);
1134 }
1135 if let Some(ref param_value) = master_password {
1136 local_var_req_builder =
1137 local_var_req_builder.query(&[("masterPassword", ¶m_value.to_string())]);
1138 }
1139 if let Some(ref param_value) = master_password_hint {
1140 local_var_req_builder =
1141 local_var_req_builder.query(&[("masterPasswordHint", ¶m_value.to_string())]);
1142 }
1143 if let Some(ref param_value) = culture {
1144 local_var_req_builder =
1145 local_var_req_builder.query(&[("culture", ¶m_value.to_string())]);
1146 }
1147 local_var_req_builder =
1148 local_var_req_builder.query(&[("securityStamp", &security_stamp.to_string())]);
1149 if let Some(ref param_value) = two_factor_providers {
1150 local_var_req_builder =
1151 local_var_req_builder.query(&[("twoFactorProviders", ¶m_value.to_string())]);
1152 }
1153 if let Some(ref param_value) = two_factor_recovery_code {
1154 local_var_req_builder =
1155 local_var_req_builder.query(&[("twoFactorRecoveryCode", ¶m_value.to_string())]);
1156 }
1157 if let Some(ref param_value) = equivalent_domains {
1158 local_var_req_builder =
1159 local_var_req_builder.query(&[("equivalentDomains", ¶m_value.to_string())]);
1160 }
1161 if let Some(ref param_value) = excluded_global_equivalent_domains {
1162 local_var_req_builder = local_var_req_builder
1163 .query(&[("excludedGlobalEquivalentDomains", ¶m_value.to_string())]);
1164 }
1165 if let Some(ref param_value) = account_revision_date {
1166 local_var_req_builder =
1167 local_var_req_builder.query(&[("accountRevisionDate", ¶m_value.to_string())]);
1168 }
1169 if let Some(ref param_value) = key {
1170 local_var_req_builder =
1171 local_var_req_builder.query(&[("key", ¶m_value.to_string())]);
1172 }
1173 if let Some(ref param_value) = public_key {
1174 local_var_req_builder =
1175 local_var_req_builder.query(&[("publicKey", ¶m_value.to_string())]);
1176 }
1177 if let Some(ref param_value) = private_key {
1178 local_var_req_builder =
1179 local_var_req_builder.query(&[("privateKey", ¶m_value.to_string())]);
1180 }
1181 if let Some(ref param_value) = signed_public_key {
1182 local_var_req_builder =
1183 local_var_req_builder.query(&[("signedPublicKey", ¶m_value.to_string())]);
1184 }
1185 if let Some(ref param_value) = security_version {
1186 local_var_req_builder =
1187 local_var_req_builder.query(&[("securityVersion", ¶m_value.to_string())]);
1188 }
1189 if let Some(ref param_value) = security_state {
1190 local_var_req_builder =
1191 local_var_req_builder.query(&[("securityState", ¶m_value.to_string())]);
1192 }
1193 if let Some(ref param_value) = premium {
1194 local_var_req_builder =
1195 local_var_req_builder.query(&[("premium", ¶m_value.to_string())]);
1196 }
1197 if let Some(ref param_value) = premium_expiration_date {
1198 local_var_req_builder =
1199 local_var_req_builder.query(&[("premiumExpirationDate", ¶m_value.to_string())]);
1200 }
1201 if let Some(ref param_value) = renewal_reminder_date {
1202 local_var_req_builder =
1203 local_var_req_builder.query(&[("renewalReminderDate", ¶m_value.to_string())]);
1204 }
1205 if let Some(ref param_value) = storage {
1206 local_var_req_builder =
1207 local_var_req_builder.query(&[("storage", ¶m_value.to_string())]);
1208 }
1209 if let Some(ref param_value) = max_storage_gb {
1210 local_var_req_builder =
1211 local_var_req_builder.query(&[("maxStorageGb", ¶m_value.to_string())]);
1212 }
1213 if let Some(ref param_value) = gateway {
1214 local_var_req_builder =
1215 local_var_req_builder.query(&[("gateway", ¶m_value.to_string())]);
1216 }
1217 if let Some(ref param_value) = gateway_customer_id {
1218 local_var_req_builder =
1219 local_var_req_builder.query(&[("gatewayCustomerId", ¶m_value.to_string())]);
1220 }
1221 if let Some(ref param_value) = gateway_subscription_id {
1222 local_var_req_builder =
1223 local_var_req_builder.query(&[("gatewaySubscriptionId", ¶m_value.to_string())]);
1224 }
1225 if let Some(ref param_value) = reference_data {
1226 local_var_req_builder =
1227 local_var_req_builder.query(&[("referenceData", ¶m_value.to_string())]);
1228 }
1229 if let Some(ref param_value) = license_key {
1230 local_var_req_builder =
1231 local_var_req_builder.query(&[("licenseKey", ¶m_value.to_string())]);
1232 }
1233 local_var_req_builder = local_var_req_builder.query(&[("apiKey", &api_key.to_string())]);
1234 if let Some(ref param_value) = kdf {
1235 local_var_req_builder =
1236 local_var_req_builder.query(&[("kdf", ¶m_value.to_string())]);
1237 }
1238 if let Some(ref param_value) = kdf_iterations {
1239 local_var_req_builder =
1240 local_var_req_builder.query(&[("kdfIterations", ¶m_value.to_string())]);
1241 }
1242 if let Some(ref param_value) = kdf_memory {
1243 local_var_req_builder =
1244 local_var_req_builder.query(&[("kdfMemory", ¶m_value.to_string())]);
1245 }
1246 if let Some(ref param_value) = kdf_parallelism {
1247 local_var_req_builder =
1248 local_var_req_builder.query(&[("kdfParallelism", ¶m_value.to_string())]);
1249 }
1250 if let Some(ref param_value) = creation_date {
1251 local_var_req_builder =
1252 local_var_req_builder.query(&[("creationDate", ¶m_value.to_string())]);
1253 }
1254 if let Some(ref param_value) = revision_date {
1255 local_var_req_builder =
1256 local_var_req_builder.query(&[("revisionDate", ¶m_value.to_string())]);
1257 }
1258 if let Some(ref param_value) = force_password_reset {
1259 local_var_req_builder =
1260 local_var_req_builder.query(&[("forcePasswordReset", ¶m_value.to_string())]);
1261 }
1262 if let Some(ref param_value) = uses_key_connector {
1263 local_var_req_builder =
1264 local_var_req_builder.query(&[("usesKeyConnector", ¶m_value.to_string())]);
1265 }
1266 if let Some(ref param_value) = failed_login_count {
1267 local_var_req_builder =
1268 local_var_req_builder.query(&[("failedLoginCount", ¶m_value.to_string())]);
1269 }
1270 if let Some(ref param_value) = last_failed_login_date {
1271 local_var_req_builder =
1272 local_var_req_builder.query(&[("lastFailedLoginDate", ¶m_value.to_string())]);
1273 }
1274 if let Some(ref param_value) = avatar_color {
1275 local_var_req_builder =
1276 local_var_req_builder.query(&[("avatarColor", ¶m_value.to_string())]);
1277 }
1278 if let Some(ref param_value) = last_password_change_date {
1279 local_var_req_builder = local_var_req_builder
1280 .query(&[("lastPasswordChangeDate", ¶m_value.to_string())]);
1281 }
1282 if let Some(ref param_value) = last_kdf_change_date {
1283 local_var_req_builder =
1284 local_var_req_builder.query(&[("lastKdfChangeDate", ¶m_value.to_string())]);
1285 }
1286 if let Some(ref param_value) = last_key_rotation_date {
1287 local_var_req_builder =
1288 local_var_req_builder.query(&[("lastKeyRotationDate", ¶m_value.to_string())]);
1289 }
1290 if let Some(ref param_value) = last_email_change_date {
1291 local_var_req_builder =
1292 local_var_req_builder.query(&[("lastEmailChangeDate", ¶m_value.to_string())]);
1293 }
1294 if let Some(ref param_value) = verify_devices {
1295 local_var_req_builder =
1296 local_var_req_builder.query(&[("verifyDevices", ¶m_value.to_string())]);
1297 }
1298 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
1299 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
1300 };
1301 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
1302 local_var_req_builder =
1303 local_var_req_builder.json(&preview_premium_upgrade_proration_request);
1304
1305 let local_var_req = local_var_req_builder.build()?;
1306 let local_var_resp = local_var_client.execute(local_var_req).await?;
1307
1308 let local_var_status = local_var_resp.status();
1309 let local_var_content = local_var_resp.text().await?;
1310
1311 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1312 Ok(())
1313 } else {
1314 let local_var_entity: Option<PreviewPremiumUpgradeProrationError> =
1315 serde_json::from_str(&local_var_content).ok();
1316 let local_var_error = ResponseContent {
1317 status: local_var_status,
1318 content: local_var_content,
1319 entity: local_var_entity,
1320 };
1321 Err(Error::ResponseError(local_var_error))
1322 }
1323 }
1324}
1325
1326#[derive(Debug, Clone, Serialize, Deserialize)]
1329#[serde(untagged)]
1330pub enum PreviewOrganizationSubscriptionPlanChangeTaxError {
1331 UnknownValue(serde_json::Value),
1332}
1333#[derive(Debug, Clone, Serialize, Deserialize)]
1336#[serde(untagged)]
1337pub enum PreviewOrganizationSubscriptionPurchaseTaxError {
1338 UnknownValue(serde_json::Value),
1339}
1340#[derive(Debug, Clone, Serialize, Deserialize)]
1343#[serde(untagged)]
1344pub enum PreviewOrganizationSubscriptionUpdateTaxError {
1345 UnknownValue(serde_json::Value),
1346}
1347#[derive(Debug, Clone, Serialize, Deserialize)]
1350#[serde(untagged)]
1351pub enum PreviewPremiumSubscriptionPurchaseTaxError {
1352 UnknownValue(serde_json::Value),
1353}
1354#[derive(Debug, Clone, Serialize, Deserialize)]
1356#[serde(untagged)]
1357pub enum PreviewPremiumUpgradeProrationError {
1358 UnknownValue(serde_json::Value),
1359}