bitwarden_api_api/apis/
mod.rs

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