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