1use std::{error, fmt};
2
3#[derive(Debug, Clone)]
4pub struct ResponseContent<T> {
5 pub status: reqwest::StatusCode,
6 pub content: String,
7 pub entity: Option<T>,
8}
9
10#[derive(Debug)]
11pub enum Error<T> {
12 Reqwest(reqwest::Error),
13 Serde(serde_json::Error),
14 Io(std::io::Error),
15 ResponseError(ResponseContent<T>),
16}
17
18impl<T> fmt::Display for Error<T> {
19 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
20 let (module, e) = match self {
21 Error::Reqwest(e) => ("reqwest", e.to_string()),
22 Error::Serde(e) => ("serde", e.to_string()),
23 Error::Io(e) => ("IO", e.to_string()),
24 Error::ResponseError(e) => ("response", format!("status code {}", e.status)),
25 };
26 write!(f, "error in {}: {}", module, e)
27 }
28}
29
30impl<T: fmt::Debug> error::Error for Error<T> {
31 fn source(&self) -> Option<&(dyn error::Error + 'static)> {
32 Some(match self {
33 Error::Reqwest(e) => e,
34 Error::Serde(e) => e,
35 Error::Io(e) => e,
36 Error::ResponseError(_) => return None,
37 })
38 }
39}
40
41impl<T> From<reqwest::Error> for Error<T> {
42 fn from(e: reqwest::Error) -> Self {
43 Error::Reqwest(e)
44 }
45}
46
47impl<T> From<serde_json::Error> for Error<T> {
48 fn from(e: serde_json::Error) -> Self {
49 Error::Serde(e)
50 }
51}
52
53impl<T> From<std::io::Error> for Error<T> {
54 fn from(e: std::io::Error) -> Self {
55 Error::Io(e)
56 }
57}
58
59pub fn urlencode<T: AsRef<str>>(s: T) -> String {
60 ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect()
61}
62
63pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> {
64 if let serde_json::Value::Object(object) = value {
65 let mut params = vec![];
66
67 for (key, value) in object {
68 match value {
69 serde_json::Value::Object(_) => params.append(&mut parse_deep_object(
70 &format!("{}[{}]", prefix, key),
71 value,
72 )),
73 serde_json::Value::Array(array) => {
74 for (i, value) in array.iter().enumerate() {
75 params.append(&mut parse_deep_object(
76 &format!("{}[{}][{}]", prefix, key, i),
77 value,
78 ));
79 }
80 }
81 serde_json::Value::String(s) => {
82 params.push((format!("{}[{}]", prefix, key), s.clone()))
83 }
84 _ => params.push((format!("{}[{}]", prefix, key), value.to_string())),
85 }
86 }
87
88 return params;
89 }
90
91 unimplemented!("Only objects are supported with style=deepObject")
92}
93
94#[allow(dead_code)]
97enum ContentType {
98 Json,
99 Text,
100 Unsupported(String),
101}
102
103impl From<&str> for ContentType {
104 fn from(content_type: &str) -> Self {
105 if content_type.starts_with("application") && content_type.contains("json") {
106 return Self::Json;
107 } else if content_type.starts_with("text/plain") {
108 return Self::Text;
109 } else {
110 return Self::Unsupported(content_type.to_string());
111 }
112 }
113}
114
115pub mod access_policies_api;
116pub mod account_billing_v_next_api;
117pub mod accounts_api;
118pub mod accounts_billing_api;
119pub mod accounts_key_management_api;
120pub mod auth_requests_api;
121pub mod ciphers_api;
122pub mod collections_api;
123pub mod config_api;
124pub mod counts_api;
125pub mod devices_api;
126pub mod emergency_access_api;
127pub mod events_api;
128pub mod folders_api;
129pub mod groups_api;
130pub mod hibp_api;
131pub mod import_ciphers_api;
132pub mod info_api;
133pub mod installations_api;
134pub mod licenses_api;
135pub mod notifications_api;
136pub mod organization_auth_requests_api;
137pub mod organization_billing_api;
138pub mod organization_billing_v_next_api;
139pub mod organization_connections_api;
140pub mod organization_domain_api;
141pub mod organization_export_api;
142pub mod organization_integration_api;
143pub mod organization_integration_configuration_api;
144pub mod organization_reports_api;
145pub mod organization_sponsorships_api;
146pub mod organization_users_api;
147pub mod organizations_api;
148pub mod plans_api;
149pub mod policies_api;
150pub mod projects_api;
151pub mod provider_billing_api;
152pub mod provider_billing_v_next_api;
153pub mod provider_clients_api;
154pub mod provider_organizations_api;
155pub mod provider_users_api;
156pub mod providers_api;
157pub mod push_api;
158pub mod reports_api;
159pub mod request_sm_access_api;
160pub mod secret_versions_api;
161pub mod secrets_api;
162pub mod secrets_manager_events_api;
163pub mod secrets_manager_porting_api;
164pub mod security_task_api;
165pub mod self_hosted_account_billing_v_next_api;
166pub mod self_hosted_organization_billing_v_next_api;
167pub mod self_hosted_organization_licenses_api;
168pub mod self_hosted_organization_sponsorships_api;
169pub mod sends_api;
170pub mod service_accounts_api;
171pub mod settings_api;
172pub mod slack_integration_api;
173pub mod stripe_api;
174pub mod sync_api;
175pub mod tax_api;
176pub mod teams_integration_api;
177pub mod trash_api;
178pub mod two_factor_api;
179pub mod users_api;
180pub mod web_authn_api;
181
182pub mod configuration;
183
184use std::sync::Arc;
185
186#[allow(clippy::large_enum_variant, private_interfaces)]
187pub enum ApiClient {
188 Real(ApiClientReal),
189 #[cfg(feature = "mockall")]
190 Mock(ApiClientMock),
191}
192
193struct ApiClientReal {
194 access_policies_api: access_policies_api::AccessPoliciesApiClient,
195 account_billing_v_next_api: account_billing_v_next_api::AccountBillingVNextApiClient,
196 accounts_api: accounts_api::AccountsApiClient,
197 accounts_billing_api: accounts_billing_api::AccountsBillingApiClient,
198 accounts_key_management_api: accounts_key_management_api::AccountsKeyManagementApiClient,
199 auth_requests_api: auth_requests_api::AuthRequestsApiClient,
200 ciphers_api: ciphers_api::CiphersApiClient,
201 collections_api: collections_api::CollectionsApiClient,
202 config_api: config_api::ConfigApiClient,
203 counts_api: counts_api::CountsApiClient,
204 devices_api: devices_api::DevicesApiClient,
205 emergency_access_api: emergency_access_api::EmergencyAccessApiClient,
206 events_api: events_api::EventsApiClient,
207 folders_api: folders_api::FoldersApiClient,
208 groups_api: groups_api::GroupsApiClient,
209 hibp_api: hibp_api::HibpApiClient,
210 import_ciphers_api: import_ciphers_api::ImportCiphersApiClient,
211 info_api: info_api::InfoApiClient,
212 installations_api: installations_api::InstallationsApiClient,
213 licenses_api: licenses_api::LicensesApiClient,
214 notifications_api: notifications_api::NotificationsApiClient,
215 organization_auth_requests_api:
216 organization_auth_requests_api::OrganizationAuthRequestsApiClient,
217 organization_billing_api: organization_billing_api::OrganizationBillingApiClient,
218 organization_billing_v_next_api:
219 organization_billing_v_next_api::OrganizationBillingVNextApiClient,
220 organization_connections_api: organization_connections_api::OrganizationConnectionsApiClient,
221 organization_domain_api: organization_domain_api::OrganizationDomainApiClient,
222 organization_export_api: organization_export_api::OrganizationExportApiClient,
223 organization_integration_api: organization_integration_api::OrganizationIntegrationApiClient,
224 organization_integration_configuration_api:
225 organization_integration_configuration_api::OrganizationIntegrationConfigurationApiClient,
226 organization_reports_api: organization_reports_api::OrganizationReportsApiClient,
227 organization_sponsorships_api: organization_sponsorships_api::OrganizationSponsorshipsApiClient,
228 organization_users_api: organization_users_api::OrganizationUsersApiClient,
229 organizations_api: organizations_api::OrganizationsApiClient,
230 plans_api: plans_api::PlansApiClient,
231 policies_api: policies_api::PoliciesApiClient,
232 projects_api: projects_api::ProjectsApiClient,
233 provider_billing_api: provider_billing_api::ProviderBillingApiClient,
234 provider_billing_v_next_api: provider_billing_v_next_api::ProviderBillingVNextApiClient,
235 provider_clients_api: provider_clients_api::ProviderClientsApiClient,
236 provider_organizations_api: provider_organizations_api::ProviderOrganizationsApiClient,
237 provider_users_api: provider_users_api::ProviderUsersApiClient,
238 providers_api: providers_api::ProvidersApiClient,
239 push_api: push_api::PushApiClient,
240 reports_api: reports_api::ReportsApiClient,
241 request_sm_access_api: request_sm_access_api::RequestSmAccessApiClient,
242 secret_versions_api: secret_versions_api::SecretVersionsApiClient,
243 secrets_api: secrets_api::SecretsApiClient,
244 secrets_manager_events_api: secrets_manager_events_api::SecretsManagerEventsApiClient,
245 secrets_manager_porting_api: secrets_manager_porting_api::SecretsManagerPortingApiClient,
246 security_task_api: security_task_api::SecurityTaskApiClient,
247 self_hosted_account_billing_v_next_api:
248 self_hosted_account_billing_v_next_api::SelfHostedAccountBillingVNextApiClient,
249 self_hosted_organization_billing_v_next_api:
250 self_hosted_organization_billing_v_next_api::SelfHostedOrganizationBillingVNextApiClient,
251 self_hosted_organization_licenses_api:
252 self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApiClient,
253 self_hosted_organization_sponsorships_api:
254 self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApiClient,
255 sends_api: sends_api::SendsApiClient,
256 service_accounts_api: service_accounts_api::ServiceAccountsApiClient,
257 settings_api: settings_api::SettingsApiClient,
258 slack_integration_api: slack_integration_api::SlackIntegrationApiClient,
259 stripe_api: stripe_api::StripeApiClient,
260 sync_api: sync_api::SyncApiClient,
261 tax_api: tax_api::TaxApiClient,
262 teams_integration_api: teams_integration_api::TeamsIntegrationApiClient,
263 trash_api: trash_api::TrashApiClient,
264 two_factor_api: two_factor_api::TwoFactorApiClient,
265 users_api: users_api::UsersApiClient,
266 web_authn_api: web_authn_api::WebAuthnApiClient,
267}
268
269#[cfg(feature = "mockall")]
270pub struct ApiClientMock {
271 pub access_policies_api: access_policies_api::MockAccessPoliciesApi,
272 pub account_billing_v_next_api: account_billing_v_next_api::MockAccountBillingVNextApi,
273 pub accounts_api: accounts_api::MockAccountsApi,
274 pub accounts_billing_api: accounts_billing_api::MockAccountsBillingApi,
275 pub accounts_key_management_api: accounts_key_management_api::MockAccountsKeyManagementApi,
276 pub auth_requests_api: auth_requests_api::MockAuthRequestsApi,
277 pub ciphers_api: ciphers_api::MockCiphersApi,
278 pub collections_api: collections_api::MockCollectionsApi,
279 pub config_api: config_api::MockConfigApi,
280 pub counts_api: counts_api::MockCountsApi,
281 pub devices_api: devices_api::MockDevicesApi,
282 pub emergency_access_api: emergency_access_api::MockEmergencyAccessApi,
283 pub events_api: events_api::MockEventsApi,
284 pub folders_api: folders_api::MockFoldersApi,
285 pub groups_api: groups_api::MockGroupsApi,
286 pub hibp_api: hibp_api::MockHibpApi,
287 pub import_ciphers_api: import_ciphers_api::MockImportCiphersApi,
288 pub info_api: info_api::MockInfoApi,
289 pub installations_api: installations_api::MockInstallationsApi,
290 pub licenses_api: licenses_api::MockLicensesApi,
291 pub notifications_api: notifications_api::MockNotificationsApi,
292 pub organization_auth_requests_api:
293 organization_auth_requests_api::MockOrganizationAuthRequestsApi,
294 pub organization_billing_api: organization_billing_api::MockOrganizationBillingApi,
295 pub organization_billing_v_next_api:
296 organization_billing_v_next_api::MockOrganizationBillingVNextApi,
297 pub organization_connections_api: organization_connections_api::MockOrganizationConnectionsApi,
298 pub organization_domain_api: organization_domain_api::MockOrganizationDomainApi,
299 pub organization_export_api: organization_export_api::MockOrganizationExportApi,
300 pub organization_integration_api: organization_integration_api::MockOrganizationIntegrationApi,
301 pub organization_integration_configuration_api:
302 organization_integration_configuration_api::MockOrganizationIntegrationConfigurationApi,
303 pub organization_reports_api: organization_reports_api::MockOrganizationReportsApi,
304 pub organization_sponsorships_api:
305 organization_sponsorships_api::MockOrganizationSponsorshipsApi,
306 pub organization_users_api: organization_users_api::MockOrganizationUsersApi,
307 pub organizations_api: organizations_api::MockOrganizationsApi,
308 pub plans_api: plans_api::MockPlansApi,
309 pub policies_api: policies_api::MockPoliciesApi,
310 pub projects_api: projects_api::MockProjectsApi,
311 pub provider_billing_api: provider_billing_api::MockProviderBillingApi,
312 pub provider_billing_v_next_api: provider_billing_v_next_api::MockProviderBillingVNextApi,
313 pub provider_clients_api: provider_clients_api::MockProviderClientsApi,
314 pub provider_organizations_api: provider_organizations_api::MockProviderOrganizationsApi,
315 pub provider_users_api: provider_users_api::MockProviderUsersApi,
316 pub providers_api: providers_api::MockProvidersApi,
317 pub push_api: push_api::MockPushApi,
318 pub reports_api: reports_api::MockReportsApi,
319 pub request_sm_access_api: request_sm_access_api::MockRequestSmAccessApi,
320 pub secret_versions_api: secret_versions_api::MockSecretVersionsApi,
321 pub secrets_api: secrets_api::MockSecretsApi,
322 pub secrets_manager_events_api: secrets_manager_events_api::MockSecretsManagerEventsApi,
323 pub secrets_manager_porting_api: secrets_manager_porting_api::MockSecretsManagerPortingApi,
324 pub security_task_api: security_task_api::MockSecurityTaskApi,
325 pub self_hosted_account_billing_v_next_api:
326 self_hosted_account_billing_v_next_api::MockSelfHostedAccountBillingVNextApi,
327 pub self_hosted_organization_billing_v_next_api:
328 self_hosted_organization_billing_v_next_api::MockSelfHostedOrganizationBillingVNextApi,
329 pub self_hosted_organization_licenses_api:
330 self_hosted_organization_licenses_api::MockSelfHostedOrganizationLicensesApi,
331 pub self_hosted_organization_sponsorships_api:
332 self_hosted_organization_sponsorships_api::MockSelfHostedOrganizationSponsorshipsApi,
333 pub sends_api: sends_api::MockSendsApi,
334 pub service_accounts_api: service_accounts_api::MockServiceAccountsApi,
335 pub settings_api: settings_api::MockSettingsApi,
336 pub slack_integration_api: slack_integration_api::MockSlackIntegrationApi,
337 pub stripe_api: stripe_api::MockStripeApi,
338 pub sync_api: sync_api::MockSyncApi,
339 pub tax_api: tax_api::MockTaxApi,
340 pub teams_integration_api: teams_integration_api::MockTeamsIntegrationApi,
341 pub trash_api: trash_api::MockTrashApi,
342 pub two_factor_api: two_factor_api::MockTwoFactorApi,
343 pub users_api: users_api::MockUsersApi,
344 pub web_authn_api: web_authn_api::MockWebAuthnApi,
345}
346
347impl ApiClient {
348 pub fn new(configuration: &Arc<configuration::Configuration>) -> Self {
349 Self::Real(ApiClientReal {
350 access_policies_api: access_policies_api::AccessPoliciesApiClient::new(configuration.clone()),
351 account_billing_v_next_api: account_billing_v_next_api::AccountBillingVNextApiClient::new(configuration.clone()),
352 accounts_api: accounts_api::AccountsApiClient::new(configuration.clone()),
353 accounts_billing_api: accounts_billing_api::AccountsBillingApiClient::new(configuration.clone()),
354 accounts_key_management_api: accounts_key_management_api::AccountsKeyManagementApiClient::new(configuration.clone()),
355 auth_requests_api: auth_requests_api::AuthRequestsApiClient::new(configuration.clone()),
356 ciphers_api: ciphers_api::CiphersApiClient::new(configuration.clone()),
357 collections_api: collections_api::CollectionsApiClient::new(configuration.clone()),
358 config_api: config_api::ConfigApiClient::new(configuration.clone()),
359 counts_api: counts_api::CountsApiClient::new(configuration.clone()),
360 devices_api: devices_api::DevicesApiClient::new(configuration.clone()),
361 emergency_access_api: emergency_access_api::EmergencyAccessApiClient::new(configuration.clone()),
362 events_api: events_api::EventsApiClient::new(configuration.clone()),
363 folders_api: folders_api::FoldersApiClient::new(configuration.clone()),
364 groups_api: groups_api::GroupsApiClient::new(configuration.clone()),
365 hibp_api: hibp_api::HibpApiClient::new(configuration.clone()),
366 import_ciphers_api: import_ciphers_api::ImportCiphersApiClient::new(configuration.clone()),
367 info_api: info_api::InfoApiClient::new(configuration.clone()),
368 installations_api: installations_api::InstallationsApiClient::new(configuration.clone()),
369 licenses_api: licenses_api::LicensesApiClient::new(configuration.clone()),
370 notifications_api: notifications_api::NotificationsApiClient::new(configuration.clone()),
371 organization_auth_requests_api: organization_auth_requests_api::OrganizationAuthRequestsApiClient::new(configuration.clone()),
372 organization_billing_api: organization_billing_api::OrganizationBillingApiClient::new(configuration.clone()),
373 organization_billing_v_next_api: organization_billing_v_next_api::OrganizationBillingVNextApiClient::new(configuration.clone()),
374 organization_connections_api: organization_connections_api::OrganizationConnectionsApiClient::new(configuration.clone()),
375 organization_domain_api: organization_domain_api::OrganizationDomainApiClient::new(configuration.clone()),
376 organization_export_api: organization_export_api::OrganizationExportApiClient::new(configuration.clone()),
377 organization_integration_api: organization_integration_api::OrganizationIntegrationApiClient::new(configuration.clone()),
378 organization_integration_configuration_api: organization_integration_configuration_api::OrganizationIntegrationConfigurationApiClient::new(configuration.clone()),
379 organization_reports_api: organization_reports_api::OrganizationReportsApiClient::new(configuration.clone()),
380 organization_sponsorships_api: organization_sponsorships_api::OrganizationSponsorshipsApiClient::new(configuration.clone()),
381 organization_users_api: organization_users_api::OrganizationUsersApiClient::new(configuration.clone()),
382 organizations_api: organizations_api::OrganizationsApiClient::new(configuration.clone()),
383 plans_api: plans_api::PlansApiClient::new(configuration.clone()),
384 policies_api: policies_api::PoliciesApiClient::new(configuration.clone()),
385 projects_api: projects_api::ProjectsApiClient::new(configuration.clone()),
386 provider_billing_api: provider_billing_api::ProviderBillingApiClient::new(configuration.clone()),
387 provider_billing_v_next_api: provider_billing_v_next_api::ProviderBillingVNextApiClient::new(configuration.clone()),
388 provider_clients_api: provider_clients_api::ProviderClientsApiClient::new(configuration.clone()),
389 provider_organizations_api: provider_organizations_api::ProviderOrganizationsApiClient::new(configuration.clone()),
390 provider_users_api: provider_users_api::ProviderUsersApiClient::new(configuration.clone()),
391 providers_api: providers_api::ProvidersApiClient::new(configuration.clone()),
392 push_api: push_api::PushApiClient::new(configuration.clone()),
393 reports_api: reports_api::ReportsApiClient::new(configuration.clone()),
394 request_sm_access_api: request_sm_access_api::RequestSmAccessApiClient::new(configuration.clone()),
395 secret_versions_api: secret_versions_api::SecretVersionsApiClient::new(configuration.clone()),
396 secrets_api: secrets_api::SecretsApiClient::new(configuration.clone()),
397 secrets_manager_events_api: secrets_manager_events_api::SecretsManagerEventsApiClient::new(configuration.clone()),
398 secrets_manager_porting_api: secrets_manager_porting_api::SecretsManagerPortingApiClient::new(configuration.clone()),
399 security_task_api: security_task_api::SecurityTaskApiClient::new(configuration.clone()),
400 self_hosted_account_billing_v_next_api: self_hosted_account_billing_v_next_api::SelfHostedAccountBillingVNextApiClient::new(configuration.clone()),
401 self_hosted_organization_billing_v_next_api: self_hosted_organization_billing_v_next_api::SelfHostedOrganizationBillingVNextApiClient::new(configuration.clone()),
402 self_hosted_organization_licenses_api: self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApiClient::new(configuration.clone()),
403 self_hosted_organization_sponsorships_api: self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApiClient::new(configuration.clone()),
404 sends_api: sends_api::SendsApiClient::new(configuration.clone()),
405 service_accounts_api: service_accounts_api::ServiceAccountsApiClient::new(configuration.clone()),
406 settings_api: settings_api::SettingsApiClient::new(configuration.clone()),
407 slack_integration_api: slack_integration_api::SlackIntegrationApiClient::new(configuration.clone()),
408 stripe_api: stripe_api::StripeApiClient::new(configuration.clone()),
409 sync_api: sync_api::SyncApiClient::new(configuration.clone()),
410 tax_api: tax_api::TaxApiClient::new(configuration.clone()),
411 teams_integration_api: teams_integration_api::TeamsIntegrationApiClient::new(configuration.clone()),
412 trash_api: trash_api::TrashApiClient::new(configuration.clone()),
413 two_factor_api: two_factor_api::TwoFactorApiClient::new(configuration.clone()),
414 users_api: users_api::UsersApiClient::new(configuration.clone()),
415 web_authn_api: web_authn_api::WebAuthnApiClient::new(configuration.clone()),
416 })
417 }
418
419 #[cfg(feature = "mockall")]
420 pub fn new_mocked(func: impl FnOnce(&mut ApiClientMock)) -> Self {
421 let mut mock = ApiClientMock {
422 access_policies_api: access_policies_api::MockAccessPoliciesApi::new(),
423 account_billing_v_next_api: account_billing_v_next_api::MockAccountBillingVNextApi::new(),
424 accounts_api: accounts_api::MockAccountsApi::new(),
425 accounts_billing_api: accounts_billing_api::MockAccountsBillingApi::new(),
426 accounts_key_management_api: accounts_key_management_api::MockAccountsKeyManagementApi::new(),
427 auth_requests_api: auth_requests_api::MockAuthRequestsApi::new(),
428 ciphers_api: ciphers_api::MockCiphersApi::new(),
429 collections_api: collections_api::MockCollectionsApi::new(),
430 config_api: config_api::MockConfigApi::new(),
431 counts_api: counts_api::MockCountsApi::new(),
432 devices_api: devices_api::MockDevicesApi::new(),
433 emergency_access_api: emergency_access_api::MockEmergencyAccessApi::new(),
434 events_api: events_api::MockEventsApi::new(),
435 folders_api: folders_api::MockFoldersApi::new(),
436 groups_api: groups_api::MockGroupsApi::new(),
437 hibp_api: hibp_api::MockHibpApi::new(),
438 import_ciphers_api: import_ciphers_api::MockImportCiphersApi::new(),
439 info_api: info_api::MockInfoApi::new(),
440 installations_api: installations_api::MockInstallationsApi::new(),
441 licenses_api: licenses_api::MockLicensesApi::new(),
442 notifications_api: notifications_api::MockNotificationsApi::new(),
443 organization_auth_requests_api: organization_auth_requests_api::MockOrganizationAuthRequestsApi::new(),
444 organization_billing_api: organization_billing_api::MockOrganizationBillingApi::new(),
445 organization_billing_v_next_api: organization_billing_v_next_api::MockOrganizationBillingVNextApi::new(),
446 organization_connections_api: organization_connections_api::MockOrganizationConnectionsApi::new(),
447 organization_domain_api: organization_domain_api::MockOrganizationDomainApi::new(),
448 organization_export_api: organization_export_api::MockOrganizationExportApi::new(),
449 organization_integration_api: organization_integration_api::MockOrganizationIntegrationApi::new(),
450 organization_integration_configuration_api: organization_integration_configuration_api::MockOrganizationIntegrationConfigurationApi::new(),
451 organization_reports_api: organization_reports_api::MockOrganizationReportsApi::new(),
452 organization_sponsorships_api: organization_sponsorships_api::MockOrganizationSponsorshipsApi::new(),
453 organization_users_api: organization_users_api::MockOrganizationUsersApi::new(),
454 organizations_api: organizations_api::MockOrganizationsApi::new(),
455 plans_api: plans_api::MockPlansApi::new(),
456 policies_api: policies_api::MockPoliciesApi::new(),
457 projects_api: projects_api::MockProjectsApi::new(),
458 provider_billing_api: provider_billing_api::MockProviderBillingApi::new(),
459 provider_billing_v_next_api: provider_billing_v_next_api::MockProviderBillingVNextApi::new(),
460 provider_clients_api: provider_clients_api::MockProviderClientsApi::new(),
461 provider_organizations_api: provider_organizations_api::MockProviderOrganizationsApi::new(),
462 provider_users_api: provider_users_api::MockProviderUsersApi::new(),
463 providers_api: providers_api::MockProvidersApi::new(),
464 push_api: push_api::MockPushApi::new(),
465 reports_api: reports_api::MockReportsApi::new(),
466 request_sm_access_api: request_sm_access_api::MockRequestSmAccessApi::new(),
467 secret_versions_api: secret_versions_api::MockSecretVersionsApi::new(),
468 secrets_api: secrets_api::MockSecretsApi::new(),
469 secrets_manager_events_api: secrets_manager_events_api::MockSecretsManagerEventsApi::new(),
470 secrets_manager_porting_api: secrets_manager_porting_api::MockSecretsManagerPortingApi::new(),
471 security_task_api: security_task_api::MockSecurityTaskApi::new(),
472 self_hosted_account_billing_v_next_api: self_hosted_account_billing_v_next_api::MockSelfHostedAccountBillingVNextApi::new(),
473 self_hosted_organization_billing_v_next_api: self_hosted_organization_billing_v_next_api::MockSelfHostedOrganizationBillingVNextApi::new(),
474 self_hosted_organization_licenses_api: self_hosted_organization_licenses_api::MockSelfHostedOrganizationLicensesApi::new(),
475 self_hosted_organization_sponsorships_api: self_hosted_organization_sponsorships_api::MockSelfHostedOrganizationSponsorshipsApi::new(),
476 sends_api: sends_api::MockSendsApi::new(),
477 service_accounts_api: service_accounts_api::MockServiceAccountsApi::new(),
478 settings_api: settings_api::MockSettingsApi::new(),
479 slack_integration_api: slack_integration_api::MockSlackIntegrationApi::new(),
480 stripe_api: stripe_api::MockStripeApi::new(),
481 sync_api: sync_api::MockSyncApi::new(),
482 tax_api: tax_api::MockTaxApi::new(),
483 teams_integration_api: teams_integration_api::MockTeamsIntegrationApi::new(),
484 trash_api: trash_api::MockTrashApi::new(),
485 two_factor_api: two_factor_api::MockTwoFactorApi::new(),
486 users_api: users_api::MockUsersApi::new(),
487 web_authn_api: web_authn_api::MockWebAuthnApi::new(),
488 };
489 func(&mut mock);
490 Self::Mock(mock)
491 }
492}
493
494impl ApiClient {
495 pub fn access_policies_api(&self) -> &dyn access_policies_api::AccessPoliciesApi {
496 match self {
497 ApiClient::Real(real) => &real.access_policies_api,
498 #[cfg(feature = "mockall")]
499 ApiClient::Mock(mock) => &mock.access_policies_api,
500 }
501 }
502 pub fn account_billing_v_next_api(
503 &self,
504 ) -> &dyn account_billing_v_next_api::AccountBillingVNextApi {
505 match self {
506 ApiClient::Real(real) => &real.account_billing_v_next_api,
507 #[cfg(feature = "mockall")]
508 ApiClient::Mock(mock) => &mock.account_billing_v_next_api,
509 }
510 }
511 pub fn accounts_api(&self) -> &dyn accounts_api::AccountsApi {
512 match self {
513 ApiClient::Real(real) => &real.accounts_api,
514 #[cfg(feature = "mockall")]
515 ApiClient::Mock(mock) => &mock.accounts_api,
516 }
517 }
518 pub fn accounts_billing_api(&self) -> &dyn accounts_billing_api::AccountsBillingApi {
519 match self {
520 ApiClient::Real(real) => &real.accounts_billing_api,
521 #[cfg(feature = "mockall")]
522 ApiClient::Mock(mock) => &mock.accounts_billing_api,
523 }
524 }
525 pub fn accounts_key_management_api(
526 &self,
527 ) -> &dyn accounts_key_management_api::AccountsKeyManagementApi {
528 match self {
529 ApiClient::Real(real) => &real.accounts_key_management_api,
530 #[cfg(feature = "mockall")]
531 ApiClient::Mock(mock) => &mock.accounts_key_management_api,
532 }
533 }
534 pub fn auth_requests_api(&self) -> &dyn auth_requests_api::AuthRequestsApi {
535 match self {
536 ApiClient::Real(real) => &real.auth_requests_api,
537 #[cfg(feature = "mockall")]
538 ApiClient::Mock(mock) => &mock.auth_requests_api,
539 }
540 }
541 pub fn ciphers_api(&self) -> &dyn ciphers_api::CiphersApi {
542 match self {
543 ApiClient::Real(real) => &real.ciphers_api,
544 #[cfg(feature = "mockall")]
545 ApiClient::Mock(mock) => &mock.ciphers_api,
546 }
547 }
548 pub fn collections_api(&self) -> &dyn collections_api::CollectionsApi {
549 match self {
550 ApiClient::Real(real) => &real.collections_api,
551 #[cfg(feature = "mockall")]
552 ApiClient::Mock(mock) => &mock.collections_api,
553 }
554 }
555 pub fn config_api(&self) -> &dyn config_api::ConfigApi {
556 match self {
557 ApiClient::Real(real) => &real.config_api,
558 #[cfg(feature = "mockall")]
559 ApiClient::Mock(mock) => &mock.config_api,
560 }
561 }
562 pub fn counts_api(&self) -> &dyn counts_api::CountsApi {
563 match self {
564 ApiClient::Real(real) => &real.counts_api,
565 #[cfg(feature = "mockall")]
566 ApiClient::Mock(mock) => &mock.counts_api,
567 }
568 }
569 pub fn devices_api(&self) -> &dyn devices_api::DevicesApi {
570 match self {
571 ApiClient::Real(real) => &real.devices_api,
572 #[cfg(feature = "mockall")]
573 ApiClient::Mock(mock) => &mock.devices_api,
574 }
575 }
576 pub fn emergency_access_api(&self) -> &dyn emergency_access_api::EmergencyAccessApi {
577 match self {
578 ApiClient::Real(real) => &real.emergency_access_api,
579 #[cfg(feature = "mockall")]
580 ApiClient::Mock(mock) => &mock.emergency_access_api,
581 }
582 }
583 pub fn events_api(&self) -> &dyn events_api::EventsApi {
584 match self {
585 ApiClient::Real(real) => &real.events_api,
586 #[cfg(feature = "mockall")]
587 ApiClient::Mock(mock) => &mock.events_api,
588 }
589 }
590 pub fn folders_api(&self) -> &dyn folders_api::FoldersApi {
591 match self {
592 ApiClient::Real(real) => &real.folders_api,
593 #[cfg(feature = "mockall")]
594 ApiClient::Mock(mock) => &mock.folders_api,
595 }
596 }
597 pub fn groups_api(&self) -> &dyn groups_api::GroupsApi {
598 match self {
599 ApiClient::Real(real) => &real.groups_api,
600 #[cfg(feature = "mockall")]
601 ApiClient::Mock(mock) => &mock.groups_api,
602 }
603 }
604 pub fn hibp_api(&self) -> &dyn hibp_api::HibpApi {
605 match self {
606 ApiClient::Real(real) => &real.hibp_api,
607 #[cfg(feature = "mockall")]
608 ApiClient::Mock(mock) => &mock.hibp_api,
609 }
610 }
611 pub fn import_ciphers_api(&self) -> &dyn import_ciphers_api::ImportCiphersApi {
612 match self {
613 ApiClient::Real(real) => &real.import_ciphers_api,
614 #[cfg(feature = "mockall")]
615 ApiClient::Mock(mock) => &mock.import_ciphers_api,
616 }
617 }
618 pub fn info_api(&self) -> &dyn info_api::InfoApi {
619 match self {
620 ApiClient::Real(real) => &real.info_api,
621 #[cfg(feature = "mockall")]
622 ApiClient::Mock(mock) => &mock.info_api,
623 }
624 }
625 pub fn installations_api(&self) -> &dyn installations_api::InstallationsApi {
626 match self {
627 ApiClient::Real(real) => &real.installations_api,
628 #[cfg(feature = "mockall")]
629 ApiClient::Mock(mock) => &mock.installations_api,
630 }
631 }
632 pub fn licenses_api(&self) -> &dyn licenses_api::LicensesApi {
633 match self {
634 ApiClient::Real(real) => &real.licenses_api,
635 #[cfg(feature = "mockall")]
636 ApiClient::Mock(mock) => &mock.licenses_api,
637 }
638 }
639 pub fn notifications_api(&self) -> &dyn notifications_api::NotificationsApi {
640 match self {
641 ApiClient::Real(real) => &real.notifications_api,
642 #[cfg(feature = "mockall")]
643 ApiClient::Mock(mock) => &mock.notifications_api,
644 }
645 }
646 pub fn organization_auth_requests_api(
647 &self,
648 ) -> &dyn organization_auth_requests_api::OrganizationAuthRequestsApi {
649 match self {
650 ApiClient::Real(real) => &real.organization_auth_requests_api,
651 #[cfg(feature = "mockall")]
652 ApiClient::Mock(mock) => &mock.organization_auth_requests_api,
653 }
654 }
655 pub fn organization_billing_api(
656 &self,
657 ) -> &dyn organization_billing_api::OrganizationBillingApi {
658 match self {
659 ApiClient::Real(real) => &real.organization_billing_api,
660 #[cfg(feature = "mockall")]
661 ApiClient::Mock(mock) => &mock.organization_billing_api,
662 }
663 }
664 pub fn organization_billing_v_next_api(
665 &self,
666 ) -> &dyn organization_billing_v_next_api::OrganizationBillingVNextApi {
667 match self {
668 ApiClient::Real(real) => &real.organization_billing_v_next_api,
669 #[cfg(feature = "mockall")]
670 ApiClient::Mock(mock) => &mock.organization_billing_v_next_api,
671 }
672 }
673 pub fn organization_connections_api(
674 &self,
675 ) -> &dyn organization_connections_api::OrganizationConnectionsApi {
676 match self {
677 ApiClient::Real(real) => &real.organization_connections_api,
678 #[cfg(feature = "mockall")]
679 ApiClient::Mock(mock) => &mock.organization_connections_api,
680 }
681 }
682 pub fn organization_domain_api(&self) -> &dyn organization_domain_api::OrganizationDomainApi {
683 match self {
684 ApiClient::Real(real) => &real.organization_domain_api,
685 #[cfg(feature = "mockall")]
686 ApiClient::Mock(mock) => &mock.organization_domain_api,
687 }
688 }
689 pub fn organization_export_api(&self) -> &dyn organization_export_api::OrganizationExportApi {
690 match self {
691 ApiClient::Real(real) => &real.organization_export_api,
692 #[cfg(feature = "mockall")]
693 ApiClient::Mock(mock) => &mock.organization_export_api,
694 }
695 }
696 pub fn organization_integration_api(
697 &self,
698 ) -> &dyn organization_integration_api::OrganizationIntegrationApi {
699 match self {
700 ApiClient::Real(real) => &real.organization_integration_api,
701 #[cfg(feature = "mockall")]
702 ApiClient::Mock(mock) => &mock.organization_integration_api,
703 }
704 }
705 pub fn organization_integration_configuration_api(
706 &self,
707 ) -> &dyn organization_integration_configuration_api::OrganizationIntegrationConfigurationApi
708 {
709 match self {
710 ApiClient::Real(real) => &real.organization_integration_configuration_api,
711 #[cfg(feature = "mockall")]
712 ApiClient::Mock(mock) => &mock.organization_integration_configuration_api,
713 }
714 }
715 pub fn organization_reports_api(
716 &self,
717 ) -> &dyn organization_reports_api::OrganizationReportsApi {
718 match self {
719 ApiClient::Real(real) => &real.organization_reports_api,
720 #[cfg(feature = "mockall")]
721 ApiClient::Mock(mock) => &mock.organization_reports_api,
722 }
723 }
724 pub fn organization_sponsorships_api(
725 &self,
726 ) -> &dyn organization_sponsorships_api::OrganizationSponsorshipsApi {
727 match self {
728 ApiClient::Real(real) => &real.organization_sponsorships_api,
729 #[cfg(feature = "mockall")]
730 ApiClient::Mock(mock) => &mock.organization_sponsorships_api,
731 }
732 }
733 pub fn organization_users_api(&self) -> &dyn organization_users_api::OrganizationUsersApi {
734 match self {
735 ApiClient::Real(real) => &real.organization_users_api,
736 #[cfg(feature = "mockall")]
737 ApiClient::Mock(mock) => &mock.organization_users_api,
738 }
739 }
740 pub fn organizations_api(&self) -> &dyn organizations_api::OrganizationsApi {
741 match self {
742 ApiClient::Real(real) => &real.organizations_api,
743 #[cfg(feature = "mockall")]
744 ApiClient::Mock(mock) => &mock.organizations_api,
745 }
746 }
747 pub fn plans_api(&self) -> &dyn plans_api::PlansApi {
748 match self {
749 ApiClient::Real(real) => &real.plans_api,
750 #[cfg(feature = "mockall")]
751 ApiClient::Mock(mock) => &mock.plans_api,
752 }
753 }
754 pub fn policies_api(&self) -> &dyn policies_api::PoliciesApi {
755 match self {
756 ApiClient::Real(real) => &real.policies_api,
757 #[cfg(feature = "mockall")]
758 ApiClient::Mock(mock) => &mock.policies_api,
759 }
760 }
761 pub fn projects_api(&self) -> &dyn projects_api::ProjectsApi {
762 match self {
763 ApiClient::Real(real) => &real.projects_api,
764 #[cfg(feature = "mockall")]
765 ApiClient::Mock(mock) => &mock.projects_api,
766 }
767 }
768 pub fn provider_billing_api(&self) -> &dyn provider_billing_api::ProviderBillingApi {
769 match self {
770 ApiClient::Real(real) => &real.provider_billing_api,
771 #[cfg(feature = "mockall")]
772 ApiClient::Mock(mock) => &mock.provider_billing_api,
773 }
774 }
775 pub fn provider_billing_v_next_api(
776 &self,
777 ) -> &dyn provider_billing_v_next_api::ProviderBillingVNextApi {
778 match self {
779 ApiClient::Real(real) => &real.provider_billing_v_next_api,
780 #[cfg(feature = "mockall")]
781 ApiClient::Mock(mock) => &mock.provider_billing_v_next_api,
782 }
783 }
784 pub fn provider_clients_api(&self) -> &dyn provider_clients_api::ProviderClientsApi {
785 match self {
786 ApiClient::Real(real) => &real.provider_clients_api,
787 #[cfg(feature = "mockall")]
788 ApiClient::Mock(mock) => &mock.provider_clients_api,
789 }
790 }
791 pub fn provider_organizations_api(
792 &self,
793 ) -> &dyn provider_organizations_api::ProviderOrganizationsApi {
794 match self {
795 ApiClient::Real(real) => &real.provider_organizations_api,
796 #[cfg(feature = "mockall")]
797 ApiClient::Mock(mock) => &mock.provider_organizations_api,
798 }
799 }
800 pub fn provider_users_api(&self) -> &dyn provider_users_api::ProviderUsersApi {
801 match self {
802 ApiClient::Real(real) => &real.provider_users_api,
803 #[cfg(feature = "mockall")]
804 ApiClient::Mock(mock) => &mock.provider_users_api,
805 }
806 }
807 pub fn providers_api(&self) -> &dyn providers_api::ProvidersApi {
808 match self {
809 ApiClient::Real(real) => &real.providers_api,
810 #[cfg(feature = "mockall")]
811 ApiClient::Mock(mock) => &mock.providers_api,
812 }
813 }
814 pub fn push_api(&self) -> &dyn push_api::PushApi {
815 match self {
816 ApiClient::Real(real) => &real.push_api,
817 #[cfg(feature = "mockall")]
818 ApiClient::Mock(mock) => &mock.push_api,
819 }
820 }
821 pub fn reports_api(&self) -> &dyn reports_api::ReportsApi {
822 match self {
823 ApiClient::Real(real) => &real.reports_api,
824 #[cfg(feature = "mockall")]
825 ApiClient::Mock(mock) => &mock.reports_api,
826 }
827 }
828 pub fn request_sm_access_api(&self) -> &dyn request_sm_access_api::RequestSmAccessApi {
829 match self {
830 ApiClient::Real(real) => &real.request_sm_access_api,
831 #[cfg(feature = "mockall")]
832 ApiClient::Mock(mock) => &mock.request_sm_access_api,
833 }
834 }
835 pub fn secret_versions_api(&self) -> &dyn secret_versions_api::SecretVersionsApi {
836 match self {
837 ApiClient::Real(real) => &real.secret_versions_api,
838 #[cfg(feature = "mockall")]
839 ApiClient::Mock(mock) => &mock.secret_versions_api,
840 }
841 }
842 pub fn secrets_api(&self) -> &dyn secrets_api::SecretsApi {
843 match self {
844 ApiClient::Real(real) => &real.secrets_api,
845 #[cfg(feature = "mockall")]
846 ApiClient::Mock(mock) => &mock.secrets_api,
847 }
848 }
849 pub fn secrets_manager_events_api(
850 &self,
851 ) -> &dyn secrets_manager_events_api::SecretsManagerEventsApi {
852 match self {
853 ApiClient::Real(real) => &real.secrets_manager_events_api,
854 #[cfg(feature = "mockall")]
855 ApiClient::Mock(mock) => &mock.secrets_manager_events_api,
856 }
857 }
858 pub fn secrets_manager_porting_api(
859 &self,
860 ) -> &dyn secrets_manager_porting_api::SecretsManagerPortingApi {
861 match self {
862 ApiClient::Real(real) => &real.secrets_manager_porting_api,
863 #[cfg(feature = "mockall")]
864 ApiClient::Mock(mock) => &mock.secrets_manager_porting_api,
865 }
866 }
867 pub fn security_task_api(&self) -> &dyn security_task_api::SecurityTaskApi {
868 match self {
869 ApiClient::Real(real) => &real.security_task_api,
870 #[cfg(feature = "mockall")]
871 ApiClient::Mock(mock) => &mock.security_task_api,
872 }
873 }
874 pub fn self_hosted_account_billing_v_next_api(
875 &self,
876 ) -> &dyn self_hosted_account_billing_v_next_api::SelfHostedAccountBillingVNextApi {
877 match self {
878 ApiClient::Real(real) => &real.self_hosted_account_billing_v_next_api,
879 #[cfg(feature = "mockall")]
880 ApiClient::Mock(mock) => &mock.self_hosted_account_billing_v_next_api,
881 }
882 }
883 pub fn self_hosted_organization_billing_v_next_api(
884 &self,
885 ) -> &dyn self_hosted_organization_billing_v_next_api::SelfHostedOrganizationBillingVNextApi
886 {
887 match self {
888 ApiClient::Real(real) => &real.self_hosted_organization_billing_v_next_api,
889 #[cfg(feature = "mockall")]
890 ApiClient::Mock(mock) => &mock.self_hosted_organization_billing_v_next_api,
891 }
892 }
893 pub fn self_hosted_organization_licenses_api(
894 &self,
895 ) -> &dyn self_hosted_organization_licenses_api::SelfHostedOrganizationLicensesApi {
896 match self {
897 ApiClient::Real(real) => &real.self_hosted_organization_licenses_api,
898 #[cfg(feature = "mockall")]
899 ApiClient::Mock(mock) => &mock.self_hosted_organization_licenses_api,
900 }
901 }
902 pub fn self_hosted_organization_sponsorships_api(
903 &self,
904 ) -> &dyn self_hosted_organization_sponsorships_api::SelfHostedOrganizationSponsorshipsApi {
905 match self {
906 ApiClient::Real(real) => &real.self_hosted_organization_sponsorships_api,
907 #[cfg(feature = "mockall")]
908 ApiClient::Mock(mock) => &mock.self_hosted_organization_sponsorships_api,
909 }
910 }
911 pub fn sends_api(&self) -> &dyn sends_api::SendsApi {
912 match self {
913 ApiClient::Real(real) => &real.sends_api,
914 #[cfg(feature = "mockall")]
915 ApiClient::Mock(mock) => &mock.sends_api,
916 }
917 }
918 pub fn service_accounts_api(&self) -> &dyn service_accounts_api::ServiceAccountsApi {
919 match self {
920 ApiClient::Real(real) => &real.service_accounts_api,
921 #[cfg(feature = "mockall")]
922 ApiClient::Mock(mock) => &mock.service_accounts_api,
923 }
924 }
925 pub fn settings_api(&self) -> &dyn settings_api::SettingsApi {
926 match self {
927 ApiClient::Real(real) => &real.settings_api,
928 #[cfg(feature = "mockall")]
929 ApiClient::Mock(mock) => &mock.settings_api,
930 }
931 }
932 pub fn slack_integration_api(&self) -> &dyn slack_integration_api::SlackIntegrationApi {
933 match self {
934 ApiClient::Real(real) => &real.slack_integration_api,
935 #[cfg(feature = "mockall")]
936 ApiClient::Mock(mock) => &mock.slack_integration_api,
937 }
938 }
939 pub fn stripe_api(&self) -> &dyn stripe_api::StripeApi {
940 match self {
941 ApiClient::Real(real) => &real.stripe_api,
942 #[cfg(feature = "mockall")]
943 ApiClient::Mock(mock) => &mock.stripe_api,
944 }
945 }
946 pub fn sync_api(&self) -> &dyn sync_api::SyncApi {
947 match self {
948 ApiClient::Real(real) => &real.sync_api,
949 #[cfg(feature = "mockall")]
950 ApiClient::Mock(mock) => &mock.sync_api,
951 }
952 }
953 pub fn tax_api(&self) -> &dyn tax_api::TaxApi {
954 match self {
955 ApiClient::Real(real) => &real.tax_api,
956 #[cfg(feature = "mockall")]
957 ApiClient::Mock(mock) => &mock.tax_api,
958 }
959 }
960 pub fn teams_integration_api(&self) -> &dyn teams_integration_api::TeamsIntegrationApi {
961 match self {
962 ApiClient::Real(real) => &real.teams_integration_api,
963 #[cfg(feature = "mockall")]
964 ApiClient::Mock(mock) => &mock.teams_integration_api,
965 }
966 }
967 pub fn trash_api(&self) -> &dyn trash_api::TrashApi {
968 match self {
969 ApiClient::Real(real) => &real.trash_api,
970 #[cfg(feature = "mockall")]
971 ApiClient::Mock(mock) => &mock.trash_api,
972 }
973 }
974 pub fn two_factor_api(&self) -> &dyn two_factor_api::TwoFactorApi {
975 match self {
976 ApiClient::Real(real) => &real.two_factor_api,
977 #[cfg(feature = "mockall")]
978 ApiClient::Mock(mock) => &mock.two_factor_api,
979 }
980 }
981 pub fn users_api(&self) -> &dyn users_api::UsersApi {
982 match self {
983 ApiClient::Real(real) => &real.users_api,
984 #[cfg(feature = "mockall")]
985 ApiClient::Mock(mock) => &mock.users_api,
986 }
987 }
988 pub fn web_authn_api(&self) -> &dyn web_authn_api::WebAuthnApi {
989 match self {
990 ApiClient::Real(real) => &real.web_authn_api,
991 #[cfg(feature = "mockall")]
992 ApiClient::Mock(mock) => &mock.web_authn_api,
993 }
994 }
995}