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 SelfHostedOrganizationBillingVNextApi: Send + Sync {
29 async fn get_metadata<'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 use_my_items: Option<bool>,
96 ) -> Result<(), Error<GetMetadataError>>;
97}
98
99pub struct SelfHostedOrganizationBillingVNextApiClient {
100 configuration: Arc<configuration::Configuration>,
101}
102
103impl SelfHostedOrganizationBillingVNextApiClient {
104 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
105 Self { configuration }
106 }
107}
108
109#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
110#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
111impl SelfHostedOrganizationBillingVNextApi for SelfHostedOrganizationBillingVNextApiClient {
112 async fn get_metadata<'a>(
113 &self,
114 organization_id: &'a str,
115 id: Option<uuid::Uuid>,
116 identifier: Option<&'a str>,
117 name: Option<&'a str>,
118 business_name: Option<&'a str>,
119 business_address1: Option<&'a str>,
120 business_address2: Option<&'a str>,
121 business_address3: Option<&'a str>,
122 business_country: Option<&'a str>,
123 business_tax_number: Option<&'a str>,
124 billing_email: Option<&'a str>,
125 plan: Option<&'a str>,
126 plan_type: Option<models::PlanType>,
127 seats: Option<i32>,
128 max_collections: Option<i32>,
129 use_policies: Option<bool>,
130 use_sso: Option<bool>,
131 use_key_connector: Option<bool>,
132 use_scim: Option<bool>,
133 use_groups: Option<bool>,
134 use_directory: Option<bool>,
135 use_events: Option<bool>,
136 use_totp: Option<bool>,
137 use2fa: Option<bool>,
138 use_api: Option<bool>,
139 use_reset_password: Option<bool>,
140 use_secrets_manager: Option<bool>,
141 self_host: Option<bool>,
142 users_get_premium: Option<bool>,
143 use_custom_permissions: Option<bool>,
144 storage: Option<i64>,
145 max_storage_gb: Option<i32>,
146 gateway: Option<models::GatewayType>,
147 gateway_customer_id: Option<&'a str>,
148 gateway_subscription_id: Option<&'a str>,
149 reference_data: Option<&'a str>,
150 enabled: Option<bool>,
151 license_key: Option<&'a str>,
152 public_key: Option<&'a str>,
153 private_key: Option<&'a str>,
154 two_factor_providers: Option<&'a str>,
155 expiration_date: Option<String>,
156 creation_date: Option<String>,
157 revision_date: Option<String>,
158 max_autoscale_seats: Option<i32>,
159 owners_notified_of_autoscaling: Option<String>,
160 status: Option<models::OrganizationStatusType>,
161 use_password_manager: Option<bool>,
162 sm_seats: Option<i32>,
163 sm_service_accounts: Option<i32>,
164 max_autoscale_sm_seats: Option<i32>,
165 max_autoscale_sm_service_accounts: Option<i32>,
166 limit_collection_creation: Option<bool>,
167 limit_collection_deletion: Option<bool>,
168 allow_admin_access_to_all_collection_items: Option<bool>,
169 limit_item_deletion: Option<bool>,
170 use_risk_insights: Option<bool>,
171 use_organization_domains: Option<bool>,
172 use_admin_sponsored_families: Option<bool>,
173 sync_seats: Option<bool>,
174 use_automatic_user_confirmation: Option<bool>,
175 use_disable_sm_ads_for_users: Option<bool>,
176 use_phishing_blocker: Option<bool>,
177 use_my_items: Option<bool>,
178 ) -> Result<(), Error<GetMetadataError>> {
179 let local_var_configuration = &self.configuration;
180
181 let local_var_client = &local_var_configuration.client;
182
183 let local_var_uri_str = format!(
184 "{}/organizations/{organizationId}/billing/vnext/self-host/metadata",
185 local_var_configuration.base_path,
186 organizationId = crate::apis::urlencode(organization_id)
187 );
188 let mut local_var_req_builder =
189 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
190
191 if let Some(ref param_value) = id {
192 local_var_req_builder =
193 local_var_req_builder.query(&[("id", ¶m_value.to_string())]);
194 }
195 if let Some(ref param_value) = identifier {
196 local_var_req_builder =
197 local_var_req_builder.query(&[("identifier", ¶m_value.to_string())]);
198 }
199 if let Some(ref param_value) = name {
200 local_var_req_builder =
201 local_var_req_builder.query(&[("name", ¶m_value.to_string())]);
202 }
203 if let Some(ref param_value) = business_name {
204 local_var_req_builder =
205 local_var_req_builder.query(&[("businessName", ¶m_value.to_string())]);
206 }
207 if let Some(ref param_value) = business_address1 {
208 local_var_req_builder =
209 local_var_req_builder.query(&[("businessAddress1", ¶m_value.to_string())]);
210 }
211 if let Some(ref param_value) = business_address2 {
212 local_var_req_builder =
213 local_var_req_builder.query(&[("businessAddress2", ¶m_value.to_string())]);
214 }
215 if let Some(ref param_value) = business_address3 {
216 local_var_req_builder =
217 local_var_req_builder.query(&[("businessAddress3", ¶m_value.to_string())]);
218 }
219 if let Some(ref param_value) = business_country {
220 local_var_req_builder =
221 local_var_req_builder.query(&[("businessCountry", ¶m_value.to_string())]);
222 }
223 if let Some(ref param_value) = business_tax_number {
224 local_var_req_builder =
225 local_var_req_builder.query(&[("businessTaxNumber", ¶m_value.to_string())]);
226 }
227 if let Some(ref param_value) = billing_email {
228 local_var_req_builder =
229 local_var_req_builder.query(&[("billingEmail", ¶m_value.to_string())]);
230 }
231 if let Some(ref param_value) = plan {
232 local_var_req_builder =
233 local_var_req_builder.query(&[("plan", ¶m_value.to_string())]);
234 }
235 if let Some(ref param_value) = plan_type {
236 local_var_req_builder =
237 local_var_req_builder.query(&[("planType", ¶m_value.to_string())]);
238 }
239 if let Some(ref param_value) = seats {
240 local_var_req_builder =
241 local_var_req_builder.query(&[("seats", ¶m_value.to_string())]);
242 }
243 if let Some(ref param_value) = max_collections {
244 local_var_req_builder =
245 local_var_req_builder.query(&[("maxCollections", ¶m_value.to_string())]);
246 }
247 if let Some(ref param_value) = use_policies {
248 local_var_req_builder =
249 local_var_req_builder.query(&[("usePolicies", ¶m_value.to_string())]);
250 }
251 if let Some(ref param_value) = use_sso {
252 local_var_req_builder =
253 local_var_req_builder.query(&[("useSso", ¶m_value.to_string())]);
254 }
255 if let Some(ref param_value) = use_key_connector {
256 local_var_req_builder =
257 local_var_req_builder.query(&[("useKeyConnector", ¶m_value.to_string())]);
258 }
259 if let Some(ref param_value) = use_scim {
260 local_var_req_builder =
261 local_var_req_builder.query(&[("useScim", ¶m_value.to_string())]);
262 }
263 if let Some(ref param_value) = use_groups {
264 local_var_req_builder =
265 local_var_req_builder.query(&[("useGroups", ¶m_value.to_string())]);
266 }
267 if let Some(ref param_value) = use_directory {
268 local_var_req_builder =
269 local_var_req_builder.query(&[("useDirectory", ¶m_value.to_string())]);
270 }
271 if let Some(ref param_value) = use_events {
272 local_var_req_builder =
273 local_var_req_builder.query(&[("useEvents", ¶m_value.to_string())]);
274 }
275 if let Some(ref param_value) = use_totp {
276 local_var_req_builder =
277 local_var_req_builder.query(&[("useTotp", ¶m_value.to_string())]);
278 }
279 if let Some(ref param_value) = use2fa {
280 local_var_req_builder =
281 local_var_req_builder.query(&[("use2fa", ¶m_value.to_string())]);
282 }
283 if let Some(ref param_value) = use_api {
284 local_var_req_builder =
285 local_var_req_builder.query(&[("useApi", ¶m_value.to_string())]);
286 }
287 if let Some(ref param_value) = use_reset_password {
288 local_var_req_builder =
289 local_var_req_builder.query(&[("useResetPassword", ¶m_value.to_string())]);
290 }
291 if let Some(ref param_value) = use_secrets_manager {
292 local_var_req_builder =
293 local_var_req_builder.query(&[("useSecretsManager", ¶m_value.to_string())]);
294 }
295 if let Some(ref param_value) = self_host {
296 local_var_req_builder =
297 local_var_req_builder.query(&[("selfHost", ¶m_value.to_string())]);
298 }
299 if let Some(ref param_value) = users_get_premium {
300 local_var_req_builder =
301 local_var_req_builder.query(&[("usersGetPremium", ¶m_value.to_string())]);
302 }
303 if let Some(ref param_value) = use_custom_permissions {
304 local_var_req_builder =
305 local_var_req_builder.query(&[("useCustomPermissions", ¶m_value.to_string())]);
306 }
307 if let Some(ref param_value) = storage {
308 local_var_req_builder =
309 local_var_req_builder.query(&[("storage", ¶m_value.to_string())]);
310 }
311 if let Some(ref param_value) = max_storage_gb {
312 local_var_req_builder =
313 local_var_req_builder.query(&[("maxStorageGb", ¶m_value.to_string())]);
314 }
315 if let Some(ref param_value) = gateway {
316 local_var_req_builder =
317 local_var_req_builder.query(&[("gateway", ¶m_value.to_string())]);
318 }
319 if let Some(ref param_value) = gateway_customer_id {
320 local_var_req_builder =
321 local_var_req_builder.query(&[("gatewayCustomerId", ¶m_value.to_string())]);
322 }
323 if let Some(ref param_value) = gateway_subscription_id {
324 local_var_req_builder =
325 local_var_req_builder.query(&[("gatewaySubscriptionId", ¶m_value.to_string())]);
326 }
327 if let Some(ref param_value) = reference_data {
328 local_var_req_builder =
329 local_var_req_builder.query(&[("referenceData", ¶m_value.to_string())]);
330 }
331 if let Some(ref param_value) = enabled {
332 local_var_req_builder =
333 local_var_req_builder.query(&[("enabled", ¶m_value.to_string())]);
334 }
335 if let Some(ref param_value) = license_key {
336 local_var_req_builder =
337 local_var_req_builder.query(&[("licenseKey", ¶m_value.to_string())]);
338 }
339 if let Some(ref param_value) = public_key {
340 local_var_req_builder =
341 local_var_req_builder.query(&[("publicKey", ¶m_value.to_string())]);
342 }
343 if let Some(ref param_value) = private_key {
344 local_var_req_builder =
345 local_var_req_builder.query(&[("privateKey", ¶m_value.to_string())]);
346 }
347 if let Some(ref param_value) = two_factor_providers {
348 local_var_req_builder =
349 local_var_req_builder.query(&[("twoFactorProviders", ¶m_value.to_string())]);
350 }
351 if let Some(ref param_value) = expiration_date {
352 local_var_req_builder =
353 local_var_req_builder.query(&[("expirationDate", ¶m_value.to_string())]);
354 }
355 if let Some(ref param_value) = creation_date {
356 local_var_req_builder =
357 local_var_req_builder.query(&[("creationDate", ¶m_value.to_string())]);
358 }
359 if let Some(ref param_value) = revision_date {
360 local_var_req_builder =
361 local_var_req_builder.query(&[("revisionDate", ¶m_value.to_string())]);
362 }
363 if let Some(ref param_value) = max_autoscale_seats {
364 local_var_req_builder =
365 local_var_req_builder.query(&[("maxAutoscaleSeats", ¶m_value.to_string())]);
366 }
367 if let Some(ref param_value) = owners_notified_of_autoscaling {
368 local_var_req_builder = local_var_req_builder
369 .query(&[("ownersNotifiedOfAutoscaling", ¶m_value.to_string())]);
370 }
371 if let Some(ref param_value) = status {
372 local_var_req_builder =
373 local_var_req_builder.query(&[("status", ¶m_value.to_string())]);
374 }
375 if let Some(ref param_value) = use_password_manager {
376 local_var_req_builder =
377 local_var_req_builder.query(&[("usePasswordManager", ¶m_value.to_string())]);
378 }
379 if let Some(ref param_value) = sm_seats {
380 local_var_req_builder =
381 local_var_req_builder.query(&[("smSeats", ¶m_value.to_string())]);
382 }
383 if let Some(ref param_value) = sm_service_accounts {
384 local_var_req_builder =
385 local_var_req_builder.query(&[("smServiceAccounts", ¶m_value.to_string())]);
386 }
387 if let Some(ref param_value) = max_autoscale_sm_seats {
388 local_var_req_builder =
389 local_var_req_builder.query(&[("maxAutoscaleSmSeats", ¶m_value.to_string())]);
390 }
391 if let Some(ref param_value) = max_autoscale_sm_service_accounts {
392 local_var_req_builder = local_var_req_builder
393 .query(&[("maxAutoscaleSmServiceAccounts", ¶m_value.to_string())]);
394 }
395 if let Some(ref param_value) = limit_collection_creation {
396 local_var_req_builder = local_var_req_builder
397 .query(&[("limitCollectionCreation", ¶m_value.to_string())]);
398 }
399 if let Some(ref param_value) = limit_collection_deletion {
400 local_var_req_builder = local_var_req_builder
401 .query(&[("limitCollectionDeletion", ¶m_value.to_string())]);
402 }
403 if let Some(ref param_value) = allow_admin_access_to_all_collection_items {
404 local_var_req_builder = local_var_req_builder.query(&[(
405 "allowAdminAccessToAllCollectionItems",
406 ¶m_value.to_string(),
407 )]);
408 }
409 if let Some(ref param_value) = limit_item_deletion {
410 local_var_req_builder =
411 local_var_req_builder.query(&[("limitItemDeletion", ¶m_value.to_string())]);
412 }
413 if let Some(ref param_value) = use_risk_insights {
414 local_var_req_builder =
415 local_var_req_builder.query(&[("useRiskInsights", ¶m_value.to_string())]);
416 }
417 if let Some(ref param_value) = use_organization_domains {
418 local_var_req_builder = local_var_req_builder
419 .query(&[("useOrganizationDomains", ¶m_value.to_string())]);
420 }
421 if let Some(ref param_value) = use_admin_sponsored_families {
422 local_var_req_builder = local_var_req_builder
423 .query(&[("useAdminSponsoredFamilies", ¶m_value.to_string())]);
424 }
425 if let Some(ref param_value) = sync_seats {
426 local_var_req_builder =
427 local_var_req_builder.query(&[("syncSeats", ¶m_value.to_string())]);
428 }
429 if let Some(ref param_value) = use_automatic_user_confirmation {
430 local_var_req_builder = local_var_req_builder
431 .query(&[("useAutomaticUserConfirmation", ¶m_value.to_string())]);
432 }
433 if let Some(ref param_value) = use_disable_sm_ads_for_users {
434 local_var_req_builder = local_var_req_builder
435 .query(&[("useDisableSmAdsForUsers", ¶m_value.to_string())]);
436 }
437 if let Some(ref param_value) = use_phishing_blocker {
438 local_var_req_builder =
439 local_var_req_builder.query(&[("usePhishingBlocker", ¶m_value.to_string())]);
440 }
441 if let Some(ref param_value) = use_my_items {
442 local_var_req_builder =
443 local_var_req_builder.query(&[("useMyItems", ¶m_value.to_string())]);
444 }
445 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
446
447 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
448 }
449}
450
451#[derive(Debug, Clone, Serialize, Deserialize)]
453#[serde(untagged)]
454pub enum GetMetadataError {
455 UnknownValue(serde_json::Value),
456}