#![cfg_attr(docsrs, feature(doc_cfg))]
//! [`JyveClient`](struct.JyveClient.html) is the main entry point for this library.
//!
//! Library created with [`libninja`](https://www.libninja.com).
#![allow(non_camel_case_types)]
#![allow(unused)]
pub mod model;
pub mod request;
use crate::model::*;
mod serde;
pub struct JyveClient {
    pub client: httpclient::Client,
    authentication: JyveAuthentication,
}
impl JyveClient {
    pub fn from_env() -> Self {
        Self {
            client: httpclient::Client::new().base_url("http://jyve-api:10000/"),
            authentication: JyveAuthentication::from_env(),
        }
    }
}
impl JyveClient {
    pub fn new(url: &str, authentication: JyveAuthentication) -> Self {
        let client = httpclient::Client::new().base_url(url);
        Self { client, authentication }
    }
    pub fn with_authentication(mut self, authentication: JyveAuthentication) -> Self {
        self.authentication = authentication;
        self
    }
    pub(crate) fn authenticate<'a>(&self, mut r: httpclient::RequestBuilder<'a>) -> httpclient::RequestBuilder<'a> {
        match &self.authentication {
            JyveAuthentication::Basic { basic } => {
                r = r.basic_auth(basic);
            }
        }
        r
    }
    pub fn with_middleware<M: httpclient::Middleware + 'static>(mut self, middleware: M) -> Self {
        self.client = self.client.with_middleware(middleware);
        self
    }
    pub fn echo(&self) -> request::EchoRequest {
        request::EchoRequest {
            http_client: self,
            message: None,
        }
    }
    ///Use this endpoint to register devices
    pub fn account_device_register_device(&self) -> request::AccountDeviceRegisterDeviceRequest {
        request::AccountDeviceRegisterDeviceRequest { http_client: self }
    }
    ///Get current user details
    pub fn account_me_list(&self) -> request::AccountMeListRequest {
        request::AccountMeListRequest {
            http_client: self,
            page: None,
            page_size: None,
        }
    }
    ///Update current user profile
    pub fn auth_update_user_profile(&self, data: UpdatedUser) -> request::AuthUpdateUserProfileRequest {
        request::AuthUpdateUserProfileRequest { http_client: self, data }
    }
    /**Refresh User object with lessonly data for that user. Synchronous
    request to Lessonly API. Eg. lessonly ext uid, lessonly uid.
    Invoked on client login.*/
    pub fn account_me_lessonly_refresh_list(&self) -> request::AccountMeLessonlyRefreshListRequest {
        request::AccountMeLessonlyRefreshListRequest {
            http_client: self,
            page: None,
            page_size: None,
        }
    }
    /**Refresh User object with lessonly data for that user in the
    background. Asynchronous request to Lessonly API.
    Eg. lessonly ext uid, lessonly uid.*/
    pub fn account_me_lessonly_refresh_create(&self, data: CurrentUser) -> request::AccountMeLessonlyRefreshCreateRequest {
        request::AccountMeLessonlyRefreshCreateRequest { http_client: self, data }
    }
    pub fn account_onboarding_read(&self) -> request::AccountOnboardingReadRequest {
        request::AccountOnboardingReadRequest { http_client: self }
    }
    pub fn account_onboarding_create(&self) -> request::AccountOnboardingCreateRequest {
        request::AccountOnboardingCreateRequest { http_client: self }
    }
    /**Return the certification and requirements for a Skills Demo that best
    fits the user's chosen job type and brand.*/
    pub fn account_onboarding_certification_requirements(&self) -> request::AccountOnboardingCertificationRequirementsRequest {
        request::AccountOnboardingCertificationRequirementsRequest { http_client: self }
    }
    pub fn account_onboarding_generate_redirect_link(&self) -> request::AccountOnboardingGenerateRedirectLinkRequest {
        request::AccountOnboardingGenerateRedirectLinkRequest { http_client: self }
    }
    pub fn account_onboarding_generate_stripe_onbaording_link(&self) -> request::AccountOnboardingGenerateStripeOnbaordingLinkRequest {
        request::AccountOnboardingGenerateStripeOnbaordingLinkRequest { http_client: self }
    }
    /**Return a list of job types that are within 50 miles of the user's
    postal code, with title, description and demand ('high' or 'medium')
    for each job type.*/
    pub fn account_onboarding_job_types(&self) -> request::AccountOnboardingJobTypesRequest {
        request::AccountOnboardingJobTypesRequest { http_client: self }
    }
    pub fn account_onboarding_run_background_check(&self) -> request::AccountOnboardingRunBackgroundCheckRequest {
        request::AccountOnboardingRunBackgroundCheckRequest { http_client: self }
    }
    ///update user ssn then run background check
    pub fn account_onboarding_update_user_ssn(&self, data: UserSsnUpdate) -> request::AccountOnboardingUpdateUserSsnRequest {
        request::AccountOnboardingUpdateUserSsnRequest { http_client: self, data }
    }
    pub fn account_onboarding_step_complete_step(&self, step_id: &str) -> request::AccountOnboardingStepCompleteStepRequest {
        request::AccountOnboardingStepCompleteStepRequest {
            http_client: self,
            step_id: step_id.to_owned(),
        }
    }
    pub fn account_onboarding_step_rerun_step(&self, step_id: &str) -> request::AccountOnboardingStepRerunStepRequest {
        request::AccountOnboardingStepRerunStepRequest {
            http_client: self,
            step_id: step_id.to_owned(),
        }
    }
    ///Verify if we are available in user location
    pub fn account_onboarding_verify_location_availability(&self, data: LocationAvailability) -> request::AccountOnboardingVerifyLocationAvailabilityRequest {
        request::AccountOnboardingVerifyLocationAvailabilityRequest { http_client: self, data }
    }
    /**Allows a user to opt out of jyve, deactivating them. Also allows
    for the option of opting out of marketing communications*/
    pub fn account_opt_out(&self) -> request::AccountOptOutRequest {
        request::AccountOptOutRequest { http_client: self }
    }
    ///Set a user's password
    pub fn account_password_create(&self, data: PasswordRetype) -> request::AccountPasswordCreateRequest {
        request::AccountPasswordCreateRequest { http_client: self, data }
    }
    ///Send user a password reset email
    pub fn account_password_reset_create(&self, data: PasswordReset) -> request::AccountPasswordResetCreateRequest {
        request::AccountPasswordResetCreateRequest { http_client: self, data }
    }
    ///Used to reset password from link sent to user in password reset email
    pub fn account_password_reset_confirm_create(&self, data: PasswordResetConfirmRetype) -> request::AccountPasswordResetConfirmCreateRequest {
        request::AccountPasswordResetConfirmCreateRequest { http_client: self, data }
    }
    pub fn api_token_auth_create(&self, data: AuthToken) -> request::ApiTokenAuthCreateRequest {
        request::ApiTokenAuthCreateRequest { http_client: self, data }
    }
    pub fn auth_is_valid(&self) -> request::AuthIsValidRequest {
        request::AuthIsValidRequest {
            http_client: self,
            page: None,
            page_size: None,
        }
    }
    ///Login with this endpoint
    pub fn auth_login(&self, data: User) -> request::AuthLoginRequest {
        request::AuthLoginRequest { http_client: self, data }
    }
    ///Send Sms verification to existing User
    pub fn auth_send_mobile_verification(&self, data: RequestCode) -> request::AuthSendMobileVerificationRequest {
        request::AuthSendMobileVerificationRequest { http_client: self, data }
    }
    ///Log User In with SMS CODE
    pub fn auth_verify_mobile(&self, data: VerifyCode) -> request::AuthVerifyMobileRequest {
        request::AuthVerifyMobileRequest { http_client: self, data }
    }
    ///Verify Number, You need to be logged in to do this, This is used to update number
    pub fn auth_verify_only_mobile(&self, data: VerifyCode) -> request::AuthVerifyOnlyMobileRequest {
        request::AuthVerifyOnlyMobileRequest { http_client: self, data }
    }
    ///All Brand Notes ViewSet
    pub fn brand_notes_list(&self) -> request::BrandNotesListRequest {
        request::BrandNotesListRequest {
            http_client: self,
            archived_at: None,
            banners: None,
            brand: None,
            brand_public_id: None,
            brands: None,
            created_at: None,
            deleted: None,
            description: None,
            id: None,
            is_archived: None,
            job: None,
            notes_in_context: None,
            page: None,
            page_size: None,
            source: None,
            started_at: None,
            stores: None,
            title: None,
            updated_at: None,
        }
    }
    ///All Brand Notes ViewSet
    pub fn brand_notes_create(&self, data: BrandNote) -> request::BrandNotesCreateRequest {
        request::BrandNotesCreateRequest { http_client: self, data }
    }
    ///All Brand Notes ViewSet
    pub fn brand_notes_read(&self, id: i64) -> request::BrandNotesReadRequest {
        request::BrandNotesReadRequest { http_client: self, id }
    }
    ///All Brand Notes ViewSet
    pub fn brand_notes_update(&self, data: BrandNote, id: i64) -> request::BrandNotesUpdateRequest {
        request::BrandNotesUpdateRequest { http_client: self, data, id }
    }
    ///Override DRF's default destroy/DELETE and replace with archiving
    pub fn brand_notes_delete(&self, id: i64) -> request::BrandNotesDeleteRequest {
        request::BrandNotesDeleteRequest { http_client: self, id }
    }
    ///All Brand Notes ViewSet
    pub fn brand_notes_partial_update(&self, data: BrandNotePartialUpdate, id: i64) -> request::BrandNotesPartialUpdateRequest {
        request::BrandNotesPartialUpdateRequest { http_client: self, data, id }
    }
    ///Lists brands
    pub fn brands_list(&self) -> request::BrandsListRequest {
        request::BrandsListRequest {
            http_client: self,
            id: None,
            ids: None,
            is_active: None,
            name: None,
            page: None,
            page_size: None,
        }
    }
    pub fn client_dashboard_backstock_available(&self) -> request::ClientDashboardBackstockAvailableRequest {
        request::ClientDashboardBackstockAvailableRequest { http_client: self }
    }
    pub fn client_dashboard_brand_overview(&self) -> request::ClientDashboardBrandOverviewRequest {
        request::ClientDashboardBrandOverviewRequest { http_client: self }
    }
    pub fn client_dashboard_completion_rate(&self) -> request::ClientDashboardCompletionRateRequest {
        request::ClientDashboardCompletionRateRequest { http_client: self }
    }
    pub fn client_dashboard_export_jobs(&self) -> request::ClientDashboardExportJobsRequest {
        request::ClientDashboardExportJobsRequest { http_client: self }
    }
    pub fn client_dashboard_export(&self) -> request::ClientDashboardExportRequest {
        request::ClientDashboardExportRequest { http_client: self }
    }
    pub fn client_dashboard_ratings(&self) -> request::ClientDashboardRatingsRequest {
        request::ClientDashboardRatingsRequest { http_client: self }
    }
    pub fn client_dashboard_mode(&self) -> request::ClientDashboardModeRequest {
        request::ClientDashboardModeRequest { http_client: self }
    }
    pub fn client_dashboard_stocking(&self) -> request::ClientDashboardStockingRequest {
        request::ClientDashboardStockingRequest { http_client: self }
    }
    pub fn client_dashboard_stores_visited(&self) -> request::ClientDashboardStoresVisitedRequest {
        request::ClientDashboardStoresVisitedRequest { http_client: self }
    }
    /**Creates a job request

    __TODO: Add proper error codes to responses__*/
    pub fn contact_us_create(&self, data: ContactUs) -> request::ContactUsCreateRequest {
        request::ContactUsCreateRequest { http_client: self, data }
    }
    pub fn credentials_list(&self) -> request::CredentialsListRequest {
        request::CredentialsListRequest {
            http_client: self,
            archived_at_isnull: None,
            ids: None,
            page: None,
            page_size: None,
            types: None,
            updated_at: None,
            updated_at_gte: None,
        }
    }
    #[doc = "/credentials/fulfilled/ids?=<ids>\nRetrieve list of credentials that a user has fulfilled\nand those specified by ids (even if they haven't been fulfilled)\nonly."]
    pub fn credentials_list_fulfilled(&self) -> request::CredentialsListFulfilledRequest {
        request::CredentialsListFulfilledRequest {
            http_client: self,
            archived_at_isnull: None,
            ids: None,
            page: None,
            page_size: None,
            types: None,
            updated_at: None,
            updated_at_gte: None,
        }
    }
    pub fn credentials_read(&self, id: &str) -> request::CredentialsReadRequest {
        request::CredentialsReadRequest {
            http_client: self,
            id: id.to_owned(),
        }
    }
    #[doc = "/credentials/<id>/fulfilled/"]
    pub fn credentials_detail_fulfilled(&self, id: &str) -> request::CredentialsDetailFulfilledRequest {
        request::CredentialsDetailFulfilledRequest {
            http_client: self,
            id: id.to_owned(),
        }
    }
    ///Deliveries!
    pub fn deliveries_list(&self) -> request::DeliveriesListRequest {
        request::DeliveriesListRequest {
            http_client: self,
            arrival_time_gt: None,
            arrival_time_gte: None,
            arrival_time_lt: None,
            arrival_time_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            has_been_completed: None,
            id: None,
            ids: None,
            ordering: None,
            page: None,
            page_size: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
        }
    }
    ///Deliveries!
    pub fn deliveries_read(&self, id: i64) -> request::DeliveriesReadRequest {
        request::DeliveriesReadRequest { http_client: self, id }
    }
    pub fn geo_jyver_density(&self) -> request::GeoJyverDensityRequest {
        request::GeoJyverDensityRequest { http_client: self }
    }
    pub fn insights_backstock_available(&self) -> request::InsightsBackstockAvailableRequest {
        request::InsightsBackstockAvailableRequest { http_client: self }
    }
    pub fn insights_brand_overview(&self) -> request::InsightsBrandOverviewRequest {
        request::InsightsBrandOverviewRequest { http_client: self }
    }
    pub fn insights_completion_rate(&self) -> request::InsightsCompletionRateRequest {
        request::InsightsCompletionRateRequest { http_client: self }
    }
    pub fn insights_export_jobs(&self) -> request::InsightsExportJobsRequest {
        request::InsightsExportJobsRequest { http_client: self }
    }
    pub fn insights_export(&self) -> request::InsightsExportRequest {
        request::InsightsExportRequest { http_client: self }
    }
    pub fn insights_ratings(&self) -> request::InsightsRatingsRequest {
        request::InsightsRatingsRequest { http_client: self }
    }
    pub fn insights_mode(&self) -> request::InsightsModeRequest {
        request::InsightsModeRequest { http_client: self }
    }
    pub fn insights_stocking(&self) -> request::InsightsStockingRequest {
        request::InsightsStockingRequest { http_client: self }
    }
    pub fn insights_stores_visited(&self) -> request::InsightsStoresVisitedRequest {
        request::InsightsStoresVisitedRequest { http_client: self }
    }
    pub fn job_templates_list(&self) -> request::JobTemplatesListRequest {
        request::JobTemplatesListRequest {
            http_client: self,
            brand_public_id: None,
            is_archived: None,
            page: None,
            page_size: None,
            q: None,
            with_jobs_completed_on_gte: None,
            with_jobs_completed_on_lte: None,
            with_jobs_starting_on_gte: None,
            with_jobs_starting_on_lte: None,
        }
    }
    pub fn job_templates_read(&self, id: i64) -> request::JobTemplatesReadRequest {
        request::JobTemplatesReadRequest { http_client: self, id }
    }
    ///Returns a list of jobs.
    pub fn jobs_list(&self) -> request::JobsListRequest {
        request::JobsListRequest {
            http_client: self,
            brand: None,
            brand_public_id: None,
            client: None,
            client_slug: None,
            clients: None,
            completed_after: None,
            completed_after_gt: None,
            completed_after_gte: None,
            completed_before: None,
            completed_before_lt: None,
            completed_before_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            deliveries: None,
            delivery: None,
            enable_in_merch: None,
            exclude_brands: None,
            exclude_clients: None,
            exclude_initial_demand_source: None,
            has_been_completed: None,
            has_delivery: None,
            id: None,
            ids: None,
            include_jyvealongs: None,
            initial_demand_source: None,
            job_finish_before_gt: None,
            job_finish_before_gte: None,
            job_finish_before_lt: None,
            job_finish_before_lte: None,
            job_start_after_gt: None,
            job_start_after_gte: None,
            job_start_after_lt: None,
            job_start_after_lte: None,
            jobs_completed: None,
            jyver: None,
            jyver_eta_entered: None,
            local_finish_before_gt: None,
            local_finish_before_gte: None,
            local_finish_before_lt: None,
            local_finish_before_lte: None,
            local_start_after_gt: None,
            local_start_after_gte: None,
            local_start_after_lt: None,
            local_start_after_lte: None,
            market_manager: None,
            new_jyver_confirmed_arrival: None,
            ordering: None,
            page: None,
            page_size: None,
            status: None,
            statuses: None,
            store_chain: None,
            store_chains: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
            territory_ids: None,
            type_: None,
            user: None,
        }
    }
    ///All job endpoints
    pub fn jobs_list_downgrade_ja(&self, data: Job) -> request::JobsListDowngradeJaRequest {
        request::JobsListDowngradeJaRequest { http_client: self, data }
    }
    ///Generate jobs for demo
    pub fn jobs_generate_jobs(&self, data: GenerateJobsInput) -> request::JobsGenerateJobsRequest {
        request::JobsGenerateJobsRequest { http_client: self, data }
    }
    ///Returns all jobs with
    pub fn jobs_list_geo(&self) -> request::JobsListGeoRequest {
        request::JobsListGeoRequest {
            http_client: self,
            brand: None,
            brand_public_id: None,
            client: None,
            client_slug: None,
            clients: None,
            completed_after: None,
            completed_after_gt: None,
            completed_after_gte: None,
            completed_before: None,
            completed_before_lt: None,
            completed_before_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            deliveries: None,
            delivery: None,
            enable_in_merch: None,
            exclude_brands: None,
            exclude_clients: None,
            exclude_initial_demand_source: None,
            has_been_completed: None,
            has_delivery: None,
            id: None,
            ids: None,
            include_jyvealongs: None,
            initial_demand_source: None,
            job_finish_before_gt: None,
            job_finish_before_gte: None,
            job_finish_before_lt: None,
            job_finish_before_lte: None,
            job_start_after_gt: None,
            job_start_after_gte: None,
            job_start_after_lt: None,
            job_start_after_lte: None,
            jobs_completed: None,
            jyver: None,
            jyver_eta_entered: None,
            local_finish_before_gt: None,
            local_finish_before_gte: None,
            local_finish_before_lt: None,
            local_finish_before_lte: None,
            local_start_after_gt: None,
            local_start_after_gte: None,
            local_start_after_lt: None,
            local_start_after_lte: None,
            market_manager: None,
            new_jyver_confirmed_arrival: None,
            ordering: None,
            page: None,
            page_size: None,
            status: None,
            statuses: None,
            store_chain: None,
            store_chains: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
            territory_ids: None,
            type_: None,
            user: None,
        }
    }
    ///Makes edits to a job after it has been created.
    pub fn jobs_request_job_changes_new(&self, data: Job) -> request::JobsRequestJobChangesNewRequest {
        request::JobsRequestJobChangesNewRequest { http_client: self, data }
    }
    ///Makes edits to a job after it has been created.
    pub fn jobs_request_job_changes(&self, data: Job) -> request::JobsRequestJobChangesRequest {
        request::JobsRequestJobChangesRequest { http_client: self, data }
    }
    ///All job endpoints
    pub fn jobs_request_jobs_new(&self, data: Job) -> request::JobsRequestJobsNewRequest {
        request::JobsRequestJobsNewRequest { http_client: self, data }
    }
    ///Request a new job at a store.
    pub fn jobs_request_jobs(&self, data: Job) -> request::JobsRequestJobsRequest {
        request::JobsRequestJobsRequest { http_client: self, data }
    }
    /**Returns job stats. Takes all same params as the /jobs/ endpoint (plus
    a few new ones, detailed below)
    ---*/
    pub fn jobs_list_stats(&self) -> request::JobsListStatsRequest {
        request::JobsListStatsRequest {
            http_client: self,
            brand: None,
            brand_public_id: None,
            client: None,
            client_slug: None,
            clients: None,
            completed_after: None,
            completed_after_gt: None,
            completed_after_gte: None,
            completed_before: None,
            completed_before_lt: None,
            completed_before_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            deliveries: None,
            delivery: None,
            enable_in_merch: None,
            exclude_brands: None,
            exclude_clients: None,
            exclude_initial_demand_source: None,
            has_been_completed: None,
            has_delivery: None,
            id: None,
            ids: None,
            include_jyvealongs: None,
            initial_demand_source: None,
            job_finish_before_gt: None,
            job_finish_before_gte: None,
            job_finish_before_lt: None,
            job_finish_before_lte: None,
            job_start_after_gt: None,
            job_start_after_gte: None,
            job_start_after_lt: None,
            job_start_after_lte: None,
            jobs_completed: None,
            jyver: None,
            jyver_eta_entered: None,
            local_finish_before_gt: None,
            local_finish_before_gte: None,
            local_finish_before_lt: None,
            local_finish_before_lte: None,
            local_start_after_gt: None,
            local_start_after_gte: None,
            local_start_after_lt: None,
            local_start_after_lte: None,
            market_manager: None,
            new_jyver_confirmed_arrival: None,
            ordering: None,
            page: None,
            page_size: None,
            status: None,
            statuses: None,
            store_chain: None,
            store_chains: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
            territory_ids: None,
            type_: None,
            user: None,
        }
    }
    ///All job endpoints
    pub fn jobs_list_stats2(&self) -> request::JobsListStats2Request {
        request::JobsListStats2Request {
            http_client: self,
            brand: None,
            brand_public_id: None,
            client: None,
            client_slug: None,
            clients: None,
            completed_after: None,
            completed_after_gt: None,
            completed_after_gte: None,
            completed_before: None,
            completed_before_lt: None,
            completed_before_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            deliveries: None,
            delivery: None,
            enable_in_merch: None,
            exclude_brands: None,
            exclude_clients: None,
            exclude_initial_demand_source: None,
            has_been_completed: None,
            has_delivery: None,
            id: None,
            ids: None,
            include_jyvealongs: None,
            initial_demand_source: None,
            job_finish_before_gt: None,
            job_finish_before_gte: None,
            job_finish_before_lt: None,
            job_finish_before_lte: None,
            job_start_after_gt: None,
            job_start_after_gte: None,
            job_start_after_lt: None,
            job_start_after_lte: None,
            jobs_completed: None,
            jyver: None,
            jyver_eta_entered: None,
            local_finish_before_gt: None,
            local_finish_before_gte: None,
            local_finish_before_lt: None,
            local_finish_before_lte: None,
            local_start_after_gt: None,
            local_start_after_gte: None,
            local_start_after_lt: None,
            local_start_after_lte: None,
            market_manager: None,
            new_jyver_confirmed_arrival: None,
            ordering: None,
            page: None,
            page_size: None,
            status: None,
            statuses: None,
            store_chain: None,
            store_chains: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
            territory_ids: None,
            type_: None,
            user: None,
        }
    }
    ///All job endpoints
    pub fn jobs_list_stats_report(&self) -> request::JobsListStatsReportRequest {
        request::JobsListStatsReportRequest {
            http_client: self,
            brand: None,
            brand_public_id: None,
            client: None,
            client_slug: None,
            clients: None,
            completed_after: None,
            completed_after_gt: None,
            completed_after_gte: None,
            completed_before: None,
            completed_before_lt: None,
            completed_before_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            deliveries: None,
            delivery: None,
            enable_in_merch: None,
            exclude_brands: None,
            exclude_clients: None,
            exclude_initial_demand_source: None,
            has_been_completed: None,
            has_delivery: None,
            id: None,
            ids: None,
            include_jyvealongs: None,
            initial_demand_source: None,
            job_finish_before_gt: None,
            job_finish_before_gte: None,
            job_finish_before_lt: None,
            job_finish_before_lte: None,
            job_start_after_gt: None,
            job_start_after_gte: None,
            job_start_after_lt: None,
            job_start_after_lte: None,
            jobs_completed: None,
            jyver: None,
            jyver_eta_entered: None,
            local_finish_before_gt: None,
            local_finish_before_gte: None,
            local_finish_before_lt: None,
            local_finish_before_lte: None,
            local_start_after_gt: None,
            local_start_after_gte: None,
            local_start_after_lt: None,
            local_start_after_lte: None,
            market_manager: None,
            new_jyver_confirmed_arrival: None,
            ordering: None,
            page: None,
            page_size: None,
            status: None,
            statuses: None,
            store_chain: None,
            store_chains: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
            territory_ids: None,
            type_: None,
            user: None,
        }
    }
    ///List statuses jobs can have
    pub fn jobs_list_status(&self) -> request::JobsListStatusRequest {
        request::JobsListStatusRequest {
            http_client: self,
            brand: None,
            brand_public_id: None,
            client: None,
            client_slug: None,
            clients: None,
            completed_after: None,
            completed_after_gt: None,
            completed_after_gte: None,
            completed_before: None,
            completed_before_lt: None,
            completed_before_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            deliveries: None,
            delivery: None,
            enable_in_merch: None,
            exclude_brands: None,
            exclude_clients: None,
            exclude_initial_demand_source: None,
            has_been_completed: None,
            has_delivery: None,
            id: None,
            ids: None,
            include_jyvealongs: None,
            initial_demand_source: None,
            job_finish_before_gt: None,
            job_finish_before_gte: None,
            job_finish_before_lt: None,
            job_finish_before_lte: None,
            job_start_after_gt: None,
            job_start_after_gte: None,
            job_start_after_lt: None,
            job_start_after_lte: None,
            jobs_completed: None,
            jyver: None,
            jyver_eta_entered: None,
            local_finish_before_gt: None,
            local_finish_before_gte: None,
            local_finish_before_lt: None,
            local_finish_before_lte: None,
            local_start_after_gt: None,
            local_start_after_gte: None,
            local_start_after_lt: None,
            local_start_after_lte: None,
            market_manager: None,
            new_jyver_confirmed_arrival: None,
            ordering: None,
            page: None,
            page_size: None,
            status: None,
            statuses: None,
            store_chain: None,
            store_chains: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
            territory_ids: None,
            type_: None,
            user: None,
        }
    }
    /**Allows a user to atomically swap a job with another job
    by unclaiming and then claiming.

    TODO(@wesleykendall) - Migrate this to the django-action-framework
    once it supports this type of use case.*/
    pub fn jobs_list_swap(&self, data: Job) -> request::JobsListSwapRequest {
        request::JobsListSwapRequest { http_client: self, data }
    }
    ///List types of jobs
    pub fn jobs_list_types(&self) -> request::JobsListTypesRequest {
        request::JobsListTypesRequest {
            http_client: self,
            brand: None,
            brand_public_id: None,
            client: None,
            client_slug: None,
            clients: None,
            completed_after: None,
            completed_after_gt: None,
            completed_after_gte: None,
            completed_before: None,
            completed_before_lt: None,
            completed_before_lte: None,
            date_completed_gt: None,
            date_completed_gte: None,
            date_completed_lt: None,
            date_completed_lte: None,
            deliveries: None,
            delivery: None,
            enable_in_merch: None,
            exclude_brands: None,
            exclude_clients: None,
            exclude_initial_demand_source: None,
            has_been_completed: None,
            has_delivery: None,
            id: None,
            ids: None,
            include_jyvealongs: None,
            initial_demand_source: None,
            job_finish_before_gt: None,
            job_finish_before_gte: None,
            job_finish_before_lt: None,
            job_finish_before_lte: None,
            job_start_after_gt: None,
            job_start_after_gte: None,
            job_start_after_lt: None,
            job_start_after_lte: None,
            jobs_completed: None,
            jyver: None,
            jyver_eta_entered: None,
            local_finish_before_gt: None,
            local_finish_before_gte: None,
            local_finish_before_lt: None,
            local_finish_before_lte: None,
            local_start_after_gt: None,
            local_start_after_gte: None,
            local_start_after_lt: None,
            local_start_after_lte: None,
            market_manager: None,
            new_jyver_confirmed_arrival: None,
            ordering: None,
            page: None,
            page_size: None,
            status: None,
            statuses: None,
            store_chain: None,
            store_chains: None,
            store_groups: None,
            store_location: None,
            store_locations: None,
            territory_ids: None,
            type_: None,
            user: None,
        }
    }
    ///Unreserve jobs in bulk for a single user
    pub fn jobs_list_unreserve(&self, data: Job) -> request::JobsListUnreserveRequest {
        request::JobsListUnreserveRequest { http_client: self, data }
    }
    ///Upgrade jobs in bulk for a single user
    pub fn jobs_list_upgrade_to_ja(&self, data: Job) -> request::JobsListUpgradeToJaRequest {
        request::JobsListUpgradeToJaRequest { http_client: self, data }
    }
    ///Returns a job.
    pub fn jobs_read(&self, id: i64) -> request::JobsReadRequest {
        request::JobsReadRequest { http_client: self, id }
    }
    ///All job endpoints
    pub fn jobs_detail_cancel(&self, data: Job, id: i64) -> request::JobsDetailCancelRequest {
        request::JobsDetailCancelRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_complete(&self, data: Job, id: i64) -> request::JobsDetailCompleteRequest {
        request::JobsDetailCompleteRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_downgrade_from_jyve_along(&self, data: Job, id: i64) -> request::JobsDetailDowngradeFromJyveAlongRequest {
        request::JobsDetailDowngradeFromJyveAlongRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_report_issue(&self, data: Job, id: i64) -> request::JobsDetailReportIssueRequest {
        request::JobsDetailReportIssueRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_claim(&self, data: Job, id: i64) -> request::JobsDetailClaimRequest {
        request::JobsDetailClaimRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_reset(&self, data: Job, id: i64) -> request::JobsDetailResetRequest {
        request::JobsDetailResetRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_self_serve_cancel(&self, data: Job, id: i64) -> request::JobsDetailSelfServeCancelRequest {
        request::JobsDetailSelfServeCancelRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_set_eta(&self, data: Job, id: i64) -> request::JobsDetailSetEtaRequest {
        request::JobsDetailSetEtaRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_start(&self, data: Job, id: i64) -> request::JobsDetailStartRequest {
        request::JobsDetailStartRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_submit_feedback(&self, data: Job, id: i64) -> request::JobsDetailSubmitFeedbackRequest {
        request::JobsDetailSubmitFeedbackRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_unclaim(&self, data: Job, id: i64) -> request::JobsDetailUnclaimRequest {
        request::JobsDetailUnclaimRequest { http_client: self, data, id }
    }
    ///All job endpoints
    pub fn jobs_detail_upgrade_to_jyve_along(&self, data: Job, id: i64) -> request::JobsDetailUpgradeToJyveAlongRequest {
        request::JobsDetailUpgradeToJyveAlongRequest { http_client: self, data, id }
    }
    pub fn jwt_token_create(&self, data: JyveTokenObtainPair) -> request::JwtTokenCreateRequest {
        request::JwtTokenCreateRequest { http_client: self, data }
    }
    /**Deletes httpOnly auth cookies.
    Used as logout view while using AUTH_COOKIE*/
    pub fn jwt_token_delete_create(&self) -> request::JwtTokenDeleteCreateRequest {
        request::JwtTokenDeleteCreateRequest { http_client: self }
    }
    /**Takes a refresh type JSON web token and returns an access type JSON web
    token if the refresh token is valid.*/
    pub fn jwt_token_refresh_create(&self, data: TokenRefresh) -> request::JwtTokenRefreshCreateRequest {
        request::JwtTokenRefreshCreateRequest { http_client: self, data }
    }
    /**Takes a token and indicates if it is valid.  This view provides no
    information about a token's fitness for a particular use.*/
    pub fn jwt_token_verify_create(&self, data: TokenVerify) -> request::JwtTokenVerifyCreateRequest {
        request::JwtTokenVerifyCreateRequest { http_client: self, data }
    }
    pub fn mobile_sms(&self, data: Sms) -> request::MobileSmsRequest {
        request::MobileSmsRequest { http_client: self, data }
    }
    pub fn notifications_list(&self) -> request::NotificationsListRequest {
        request::NotificationsListRequest {
            http_client: self,
            action_was_taken: None,
            created_at_gte: None,
            id: None,
            ordering: None,
            page: None,
            page_size: None,
            should_hide: None,
            updated_at_gte: None,
        }
    }
    /**Bulk acknowledge a list of Notifications.
    request format:
    {
        "notifications": [{
            "id": "288277",
            "should_hide": true/false
        }, {
            "id": "288265"
        }]
    }*/
    pub fn notifications_list_acknowledge(&self, data: Notification) -> request::NotificationsListAcknowledgeRequest {
        request::NotificationsListAcknowledgeRequest { http_client: self, data }
    }
    ///Acknowledge a push notification action
    pub fn notifications_push_notification_acknowledge_action_create(&self) -> request::NotificationsPushNotificationAcknowledgeActionCreateRequest {
        request::NotificationsPushNotificationAcknowledgeActionCreateRequest { http_client: self }
    }
    ///Acknowledge a push notification
    pub fn notifications_push_notification_acknowledged_create(&self) -> request::NotificationsPushNotificationAcknowledgedCreateRequest {
        request::NotificationsPushNotificationAcknowledgedCreateRequest { http_client: self }
    }
    pub fn notifications_read(&self, id: &str) -> request::NotificationsReadRequest {
        request::NotificationsReadRequest {
            http_client: self,
            id: id.to_owned(),
        }
    }
    /**Acknowledge a single Notification and related PushNotification.
    and set the action_taken_at of related pn's to now.
    (previously NotificationActionAcknowledged class)
    request format: /notifications/{pk}/acknowledge-action/
    {
        "push_notification_id": "777777",
        "action": "..."
    }*/
    pub fn notifications_single_acknowledge(&self, data: Notification, id: &str) -> request::NotificationsSingleAcknowledgeRequest {
        request::NotificationsSingleAcknowledgeRequest {
            http_client: self,
            data,
            id: id.to_owned(),
        }
    }
    pub fn payments_list(&self) -> request::PaymentsListRequest {
        request::PaymentsListRequest {
            http_client: self,
            end_lt: None,
            ids: None,
            page: None,
            page_size: None,
            start_gte: None,
            types: None,
        }
    }
    ///Return a list of daily earnings as specified by
    pub fn payments_list_daily_earnings(&self) -> request::PaymentsListDailyEarningsRequest {
        request::PaymentsListDailyEarningsRequest {
            http_client: self,
            end_lt: None,
            ids: None,
            page: None,
            page_size: None,
            start_gte: None,
            types: None,
        }
    }
    /**Return a list of aggregated weekly earnings grouped by fiscal
    week/day.*/
    pub fn payments_list_weekly_earnings(&self) -> request::PaymentsListWeeklyEarningsRequest {
        request::PaymentsListWeeklyEarningsRequest {
            http_client: self,
            end_lt: None,
            ids: None,
            page: None,
            page_size: None,
            start_gte: None,
            types: None,
        }
    }
    pub fn payments_read(&self, id: i64) -> request::PaymentsReadRequest {
        request::PaymentsReadRequest { http_client: self, id }
    }
    ///Simple workaround for retrieving total earnings payout and 'count'.
    pub fn payouts_detail_earnings_count(&self) -> request::PayoutsDetailEarningsCountRequest {
        request::PayoutsDetailEarningsCountRequest {
            http_client: self,
            page: None,
            page_size: None,
        }
    }
    pub fn payouts_list_earnings(&self) -> request::PayoutsListEarningsRequest {
        request::PayoutsListEarningsRequest {
            http_client: self,
            page: None,
            page_size: None,
        }
    }
    pub fn products_list(&self) -> request::ProductsListRequest {
        request::ProductsListRequest {
            http_client: self,
            page: None,
            page_size: None,
        }
    }
    pub fn rating_requests_create(&self, data: RatingRequest) -> request::RatingRequestsCreateRequest {
        request::RatingRequestsCreateRequest { http_client: self, data }
    }
    ///Rates an object or updates an existing rating
    pub fn rating_requests_rate(&self, data: RatingRequest) -> request::RatingRequestsRateRequest {
        request::RatingRequestsRateRequest { http_client: self, data }
    }
    ///Gets a rating object that associated with rating request
    pub fn rating_requests_read(&self, id: i64) -> request::RatingRequestsReadRequest {
        request::RatingRequestsReadRequest { http_client: self, id }
    }
    /**Rate an brand, job, or user or update
    existing rating.*/
    pub fn ratings_create(&self, data: Rating) -> request::RatingsCreateRequest {
        request::RatingsCreateRequest { http_client: self, data }
    }
    ///All ratings endpoints
    pub fn ratings_read(&self, id: i64) -> request::RatingsReadRequest {
        request::RatingsReadRequest { http_client: self, id }
    }
    ///Create a fast-track referral, and return the referral code and URL.
    pub fn referrals_create_fast_track_referral(&self) -> request::ReferralsCreateFastTrackReferralRequest {
        request::ReferralsCreateFastTrackReferralRequest { http_client: self }
    }
    ///Job Endpoints for External Clients
    pub fn retailer_jobs_kroger(&self) -> request::RetailerJobsKrogerRequest {
        request::RetailerJobsKrogerRequest {
            http_client: self,
            page: None,
            page_size: None,
        }
    }
    ///Endpoint method which returns the responses belong to a review.
    pub fn review_responses_list(&self) -> request::ReviewResponsesListRequest {
        request::ReviewResponsesListRequest {
            http_client: self,
            ordering: None,
            page: None,
            page_size: None,
        }
    }
    ///Review response endpoints.
    pub fn review_responses_create(&self, data: ReviewResponse) -> request::ReviewResponsesCreateRequest {
        request::ReviewResponsesCreateRequest { http_client: self, data }
    }
    ///Review response endpoints.
    pub fn review_responses_read(&self, id: i64) -> request::ReviewResponsesReadRequest {
        request::ReviewResponsesReadRequest { http_client: self, id }
    }
    ///Review endpoints.
    pub fn reviews_list(&self) -> request::ReviewsListRequest {
        request::ReviewsListRequest {
            http_client: self,
            created_at_gte: None,
            created_at_lt: None,
            created_at_lte: None,
            escalation_statuses: None,
            escalation_statuses_or_status: None,
            id: None,
            ids: None,
            local_created_at_gte: None,
            local_created_at_lt: None,
            local_responses_created_at_gte: None,
            local_responses_created_at_lt: None,
            object_id: None,
            only_active: None,
            ordering: None,
            page: None,
            page_size: None,
            responses_created_at_gte: None,
            responses_created_at_lt: None,
            responses_created_at_lte: None,
            status: None,
            statuses: None,
        }
    }
    ///Returns all the statuses a review can have.
    pub fn reviews_list_status(&self) -> request::ReviewsListStatusRequest {
        request::ReviewsListStatusRequest {
            http_client: self,
            created_at_gte: None,
            created_at_lt: None,
            created_at_lte: None,
            escalation_statuses: None,
            escalation_statuses_or_status: None,
            id: None,
            ids: None,
            local_created_at_gte: None,
            local_created_at_lt: None,
            local_responses_created_at_gte: None,
            local_responses_created_at_lt: None,
            object_id: None,
            only_active: None,
            ordering: None,
            page: None,
            page_size: None,
            responses_created_at_gte: None,
            responses_created_at_lt: None,
            responses_created_at_lte: None,
            status: None,
            statuses: None,
        }
    }
    ///Review endpoints.
    pub fn reviews_read(&self, id: i64) -> request::ReviewsReadRequest {
        request::ReviewsReadRequest { http_client: self, id }
    }
    ///Adds response to a review.
    pub fn reviews_review_response(&self, data: ReviewResponseAction, id: i64) -> request::ReviewsReviewResponseRequest {
        request::ReviewsReviewResponseRequest { http_client: self, data, id }
    }
    ///Returns mobile constants
    pub fn services_app_vars(&self) -> request::ServicesAppVarsRequest {
        request::ServicesAppVarsRequest { http_client: self }
    }
    ///POST hook from S3 Event Notifications when an image is uploaded
    pub fn services_aws_save_image_url_to_task(&self) -> request::ServicesAwsSaveImageUrlToTaskRequest {
        request::ServicesAwsSaveImageUrlToTaskRequest { http_client: self }
    }
    ///This endpoint returns a presigned url for uploading a file to S3. Used for uploading images to tasks.
    pub fn services_s3_task_image_upload_presigned_url_create(&self, data: S3Url) -> request::ServicesS3TaskImageUploadPresignedUrlCreateRequest {
        request::ServicesS3TaskImageUploadPresignedUrlCreateRequest { http_client: self, data }
    }
    /**Zendesk push notifications hit this endpoint to send out a push
    notification of our own to our users*/
    pub fn services_zendesk_post(&self) -> request::ServicesZendeskPostRequest {
        request::ServicesZendeskPostRequest { http_client: self }
    }
    pub fn store_chains_list(&self) -> request::StoreChainsListRequest {
        request::StoreChainsListRequest {
            http_client: self,
            class_of_trade: None,
            created_at: None,
            deleted: None,
            name: None,
            page: None,
            page_size: None,
            parent_company: None,
            store_locations_jobs_brand_public_id: None,
            updated_at: None,
        }
    }
    ///Endpoint for retrieving StoreGroups, such as regions/areas/etc.
    pub fn store_groups_list(&self) -> request::StoreGroupsListRequest {
        request::StoreGroupsListRequest {
            http_client: self,
            ancestor: None,
            id: None,
            ids: None,
            is_archived: None,
            name: None,
            ordering: None,
            page: None,
            page_size: None,
            parent: None,
            primary_manager: None,
            slug: None,
            source: None,
            type_: None,
        }
    }
    /**request url format:
        '../store_groups/market_lookup/?postal_code=98012'
    postal_code query param is required here.

    Given a postal code, returns most likely StoreGroup area,
    StoreGroup market,and city associations. If no
    likely market/city from our records, return the
    default market and use Google geocode api to get likely city.

    Uses PostalCode model.

    Using list route here because although only one StoreGroup is
    expected, detail_route is for urls with model ids and this is more
    of a filtered set - trying to keep it RESTful.*/
    pub fn store_groups_market_lookup(&self) -> request::StoreGroupsMarketLookupRequest {
        request::StoreGroupsMarketLookupRequest {
            http_client: self,
            ancestor: None,
            id: None,
            ids: None,
            is_archived: None,
            name: None,
            ordering: None,
            page: None,
            page_size: None,
            parent: None,
            primary_manager: None,
            slug: None,
            source: None,
            type_: None,
        }
    }
    ///Endpoint for retrieving StoreGroups, such as regions/areas/etc.
    pub fn store_groups_read(&self, id: i64) -> request::StoreGroupsReadRequest {
        request::StoreGroupsReadRequest { http_client: self, id }
    }
    /**Returns a list of stores.

    All query params that accept times accept 'now', 'midnight',
    'midnight_tomorrow', and datetime str that can be understood
    by arrow.get(datetime_str).*/
    pub fn stores_list(&self) -> request::StoresListRequest {
        request::StoresListRequest {
            http_client: self,
            address: None,
            brand_territory_brand_public_id: None,
            chain_name: None,
            city: None,
            county: None,
            ids: None,
            job_completed_range: None,
            job_ids: None,
            jyver_density_gte: None,
            ordering: None,
            page: None,
            page_size: None,
            postal_code: None,
            primary_self_identity: None,
            q: None,
            state: None,
            store_chain: None,
            store_chains: None,
        }
    }
    ///Filter the available jobs by achievements
    pub fn stores_filters_list_filters_achievements(&self) -> request::StoresFiltersListFiltersAchievementsRequest {
        request::StoresFiltersListFiltersAchievementsRequest {
            http_client: self,
            address: None,
            brand_territory_brand_public_id: None,
            chain_name: None,
            city: None,
            county: None,
            ids: None,
            job_completed_range: None,
            job_ids: None,
            jyver_density_gte: None,
            ordering: None,
            page: None,
            page_size: None,
            postal_code: None,
            primary_self_identity: None,
            q: None,
            state: None,
            store_chain: None,
            store_chains: None,
        }
    }
    ///Filter the available jobs by brands
    pub fn stores_filters_list_filters_brands(&self) -> request::StoresFiltersListFiltersBrandsRequest {
        request::StoresFiltersListFiltersBrandsRequest {
            http_client: self,
            address: None,
            brand_territory_brand_public_id: None,
            chain_name: None,
            city: None,
            county: None,
            ids: None,
            job_completed_range: None,
            job_ids: None,
            jyver_density_gte: None,
            ordering: None,
            page: None,
            page_size: None,
            postal_code: None,
            primary_self_identity: None,
            q: None,
            state: None,
            store_chain: None,
            store_chains: None,
        }
    }
    ///Store stats
    pub fn stores_list_stats(&self) -> request::StoresListStatsRequest {
        request::StoresListStatsRequest {
            http_client: self,
            address: None,
            brand_territory_brand_public_id: None,
            chain_name: None,
            city: None,
            county: None,
            ids: None,
            job_completed_range: None,
            job_ids: None,
            jyver_density_gte: None,
            ordering: None,
            page: None,
            page_size: None,
            postal_code: None,
            primary_self_identity: None,
            q: None,
            state: None,
            store_chain: None,
            store_chains: None,
        }
    }
    ///Returns a single store.
    pub fn stores_read(&self, id: i64) -> request::StoresReadRequest {
        request::StoresReadRequest { http_client: self, id }
    }
    ///Lists tasks
    pub fn tasks_list(&self) -> request::TasksListRequest {
        request::TasksListRequest {
            http_client: self,
            brand: None,
            client: None,
            client_slug: None,
            completed_after: None,
            completed_before: None,
            id: None,
            ids: None,
            job: None,
            job_completed_after: None,
            job_completed_after_gt: None,
            job_completed_after_gte: None,
            job_completed_before: None,
            job_completed_before_lt: None,
            job_completed_before_lte: None,
            jobs: None,
            page: None,
            page_size: None,
            status: None,
            store_chain: None,
            store_chains: None,
            store_location: None,
            store_locations: None,
            type_: None,
            types: None,
            user: None,
        }
    }
    /**Returns task stats. Takes all same params as the /tasks/ endpoint (plus
    a few new ones, detailed below)
    ---*/
    pub fn tasks_list_stats(&self) -> request::TasksListStatsRequest {
        request::TasksListStatsRequest {
            http_client: self,
            brand: None,
            client: None,
            client_slug: None,
            completed_after: None,
            completed_before: None,
            id: None,
            ids: None,
            job: None,
            job_completed_after: None,
            job_completed_after_gt: None,
            job_completed_after_gte: None,
            job_completed_before: None,
            job_completed_before_lt: None,
            job_completed_before_lte: None,
            jobs: None,
            page: None,
            page_size: None,
            status: None,
            store_chain: None,
            store_chains: None,
            store_location: None,
            store_locations: None,
            type_: None,
            types: None,
            user: None,
        }
    }
    ///Gets a task
    pub fn tasks_read(&self, id: i64) -> request::TasksReadRequest {
        request::TasksReadRequest { http_client: self, id }
    }
    ///Completes a Task
    pub fn tasks_detail_complete(&self, data: Task, id: i64) -> request::TasksDetailCompleteRequest {
        request::TasksDetailCompleteRequest { http_client: self, data, id }
    }
    ///All task endpoints
    pub fn tasks_detail_reset(&self, data: Task, id: i64) -> request::TasksDetailResetRequest {
        request::TasksDetailResetRequest { http_client: self, data, id }
    }
    ///TOS endpoints
    pub fn tos_list(&self) -> request::TosListRequest {
        request::TosListRequest {
            http_client: self,
            id: None,
            page: None,
            page_size: None,
            version: None,
        }
    }
    ///TOS endpoints
    pub fn tos_agree(&self, data: Tos) -> request::TosAgreeRequest {
        request::TosAgreeRequest { http_client: self, data }
    }
    ///TOS endpoints
    pub fn tos_current(&self) -> request::TosCurrentRequest {
        request::TosCurrentRequest {
            http_client: self,
            id: None,
            page: None,
            page_size: None,
            version: None,
        }
    }
    ///TOS endpoints
    pub fn tos_read(&self, id: i64) -> request::TosReadRequest {
        request::TosReadRequest { http_client: self, id }
    }
    ///TOS endpoints
    pub fn detail(&self, data: Tos) -> request::DetailRequest {
        request::DetailRequest { http_client: self, data }
    }
    ///All Users Viewset
    pub fn users_list(&self) -> request::UsersListRequest {
        request::UsersListRequest {
            http_client: self,
            email: None,
            first_name: None,
            full_name: None,
            id: None,
            ids: None,
            last_name: None,
            ordering: None,
            page: None,
            page_size: None,
            phone_number: None,
            q: None,
        }
    }
    ///All Users Viewset
    pub fn users_list_jyvers(&self) -> request::UsersListJyversRequest {
        request::UsersListJyversRequest {
            http_client: self,
            email: None,
            first_name: None,
            full_name: None,
            id: None,
            ids: None,
            last_name: None,
            ordering: None,
            page: None,
            page_size: None,
            phone_number: None,
            q: None,
        }
    }
    ///All Users Viewset
    pub fn users_list_market_managers(&self) -> request::UsersListMarketManagersRequest {
        request::UsersListMarketManagersRequest {
            http_client: self,
            email: None,
            first_name: None,
            full_name: None,
            id: None,
            ids: None,
            last_name: None,
            ordering: None,
            page: None,
            page_size: None,
            phone_number: None,
            q: None,
        }
    }
    /**Use this endpoint to verify a variety of different codes.
    Currently, only referral codes are supported.*/
    pub fn verify_code_list(&self) -> request::VerifyCodeListRequest {
        request::VerifyCodeListRequest { http_client: self }
    }
}
pub enum JyveAuthentication {
    Basic { basic: String },
}
impl JyveAuthentication {
    pub fn from_env() -> Self {
        Self::Basic {
            basic: std::env::var("JYVE_BASIC").expect("Environment variable JYVE_BASIC is not set."),
        }
    }
}