harbor-api 2.0.0

/*
 * Harbor API
 *
 * These APIs provide services for manipulating Harbor project.
 *
 * The version of the OpenAPI document: 2.0
 * 
 * Generated by: https://openapi-generator.tech
 */


use reqwest;
use serde::{Deserialize, Serialize, de::Error as _};
use crate::{apis::ResponseContent, models};
use super::{Error, configuration, ContentType};

/// struct for passing parameters to the method [`create_user`]
#[derive(Clone, Debug)]
pub struct CreateUserParams {
    /// The new user
    pub user_req: models::UserCreationReq,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`delete_user`]
#[derive(Clone, Debug)]
pub struct DeleteUserParams {
    /// User ID for marking as to be removed.
    pub user_id: i32,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`get_current_user_info`]
#[derive(Clone, Debug)]
pub struct GetCurrentUserInfoParams {
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`get_current_user_permissions`]
#[derive(Clone, Debug)]
pub struct GetCurrentUserPermissionsParams {
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The scope for the permission
    pub scope: Option<String>,
    /// If true, the resources in the response are relative to the scope, eg for resource '/project/1/repository' if relative is 'true' then the resource in response will be 'repository'. 
    pub relative: Option<bool>
}

/// struct for passing parameters to the method [`get_user`]
#[derive(Clone, Debug)]
pub struct GetUserParams {
    pub user_id: i32,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`list_users`]
#[derive(Clone, Debug)]
pub struct ListUsersParams {
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// Query string to query resources. Supported query patterns are \"exact match(k=v)\", \"fuzzy match(k=~v)\", \"range(k=[min~max])\", \"list with union releationship(k={v1 v2 v3})\" and \"list with intersetion relationship(k=(v1 v2 v3))\". The value of range and list can be string(enclosed by \" or '), integer or time(in format \"2020-04-09 02:36:00\"). All of these query patterns should be put in the query string \"q=xxx\" and splitted by \",\". e.g. q=k1=v1,k2=~v2,k3=[min~max]
    pub q: Option<String>,
    /// Sort the resource list in ascending or descending order. e.g. sort by field1 in ascending order and field2 in descending order with \"sort=field1,-field2\"
    pub sort: Option<String>,
    /// The page number
    pub page: Option<i64>,
    /// The size of per page
    pub page_size: Option<i64>
}

/// struct for passing parameters to the method [`search_users`]
#[derive(Clone, Debug)]
pub struct SearchUsersParams {
    /// Username for filtering results.
    pub username: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The page number
    pub page: Option<i64>,
    /// The size of per page
    pub page_size: Option<i64>
}

/// struct for passing parameters to the method [`set_cli_secret`]
#[derive(Clone, Debug)]
pub struct SetCliSecretParams {
    /// User ID
    pub user_id: i32,
    pub secret: models::OidcCliSecretReq,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`set_user_sys_admin`]
#[derive(Clone, Debug)]
pub struct SetUserSysAdminParams {
    pub user_id: i32,
    /// Toggle a user to admin or not.
    pub sysadmin_flag: models::UserSysAdminFlag,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`update_user_password`]
#[derive(Clone, Debug)]
pub struct UpdateUserPasswordParams {
    pub user_id: i32,
    /// Password to be updated, the attribute 'old_password' is optional when the API is called by the system administrator.
    pub password: models::PasswordReq,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`update_user_profile`]
#[derive(Clone, Debug)]
pub struct UpdateUserProfileParams {
    /// Registered user ID
    pub user_id: i32,
    /// Only email, realname and comment can be modified.
    pub profile: models::UserProfile,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}


/// struct for typed errors of method [`create_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateUserError {
    Status400(models::Errors),
    Status401(models::Errors),
    Status403(),
    Status409(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteUserError {
    Status401(models::Errors),
    Status403(models::Errors),
    Status404(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_current_user_info`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCurrentUserInfoError {
    Status401(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_current_user_permissions`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCurrentUserPermissionsError {
    Status401(),
    Status500(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetUserError {
    Status401(models::Errors),
    Status403(models::Errors),
    Status404(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_users`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListUsersError {
    Status401(models::Errors),
    Status403(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`search_users`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SearchUsersError {
    Status401(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`set_cli_secret`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SetCliSecretError {
    Status400(),
    Status401(models::Errors),
    Status403(models::Errors),
    Status404(models::Errors),
    Status412(),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`set_user_sys_admin`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SetUserSysAdminError {
    Status401(models::Errors),
    Status403(models::Errors),
    Status404(models::Errors),
    Status500(),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_user_password`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateUserPasswordError {
    Status400(),
    Status401(models::Errors),
    Status403(),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_user_profile`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateUserProfileError {
    Status401(models::Errors),
    Status403(models::Errors),
    Status404(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}


/// This API can be used only when the authentication mode is for local DB.  When self registration is disabled.
pub async fn create_user(configuration: &configuration::Configuration, params: CreateUserParams) -> Result<(), Error<CreateUserError>> {

    let uri_str = format!("{}/users", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    req_builder = req_builder.json(&params.user_req);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateUserError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint let administrator of Harbor mark a registered user as removed.It actually won't be deleted from DB. 
pub async fn delete_user(configuration: &configuration::Configuration, params: DeleteUserParams) -> Result<(), Error<DeleteUserError>> {

    let uri_str = format!("{}/users/{user_id}", configuration.base_path, user_id=params.user_id);
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteUserError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_current_user_info(configuration: &configuration::Configuration, params: GetCurrentUserInfoParams) -> Result<models::UserResp, Error<GetCurrentUserInfoError>> {

    let uri_str = format!("{}/users/current", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserResp`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UserResp`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCurrentUserInfoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_current_user_permissions(configuration: &configuration::Configuration, params: GetCurrentUserPermissionsParams) -> Result<Vec<models::Permission>, Error<GetCurrentUserPermissionsError>> {

    let uri_str = format!("{}/users/current/permissions", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = params.scope {
        req_builder = req_builder.query(&[("scope", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.relative {
        req_builder = req_builder.query(&[("relative", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Permission&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Permission&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCurrentUserPermissionsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_user(configuration: &configuration::Configuration, params: GetUserParams) -> Result<models::UserResp, Error<GetUserError>> {

    let uri_str = format!("{}/users/{user_id}", configuration.base_path, user_id=params.user_id);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserResp`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UserResp`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetUserError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_users(configuration: &configuration::Configuration, params: ListUsersParams) -> Result<Vec<models::UserResp>, Error<ListUsersError>> {

    let uri_str = format!("{}/users", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = params.q {
        req_builder = req_builder.query(&[("q", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.page_size {
        req_builder = req_builder.query(&[("page_size", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UserResp&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UserResp&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListUsersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint is to search the users by username.  It's open for all authenticated requests. 
pub async fn search_users(configuration: &configuration::Configuration, params: SearchUsersParams) -> Result<Vec<models::UserSearchRespItem>, Error<SearchUsersError>> {

    let uri_str = format!("{}/users/search", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = params.page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.page_size {
        req_builder = req_builder.query(&[("page_size", &param_value.to_string())]);
    }
    req_builder = req_builder.query(&[("username", &params.username.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UserSearchRespItem&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UserSearchRespItem&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SearchUsersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint let user generate a new CLI secret for himself.  This API only works when auth mode is set to 'OIDC'. Once this API returns with successful status, the old secret will be invalid, as there will be only one CLI secret for a user.
pub async fn set_cli_secret(configuration: &configuration::Configuration, params: SetCliSecretParams) -> Result<(), Error<SetCliSecretError>> {

    let uri_str = format!("{}/users/{user_id}/cli_secret", configuration.base_path, user_id=params.user_id);
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    req_builder = req_builder.json(&params.secret);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<SetCliSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn set_user_sys_admin(configuration: &configuration::Configuration, params: SetUserSysAdminParams) -> Result<(), Error<SetUserSysAdminError>> {

    let uri_str = format!("{}/users/{user_id}/sysadmin", configuration.base_path, user_id=params.user_id);
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    req_builder = req_builder.json(&params.sysadmin_flag);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<SetUserSysAdminError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint is for user to update password. Users with the admin role can change any user's password. Regular users can change only their own password. 
pub async fn update_user_password(configuration: &configuration::Configuration, params: UpdateUserPasswordParams) -> Result<(), Error<UpdateUserPasswordError>> {

    let uri_str = format!("{}/users/{user_id}/password", configuration.base_path, user_id=params.user_id);
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    req_builder = req_builder.json(&params.password);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateUserPasswordError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_user_profile(configuration: &configuration::Configuration, params: UpdateUserProfileParams) -> Result<(), Error<UpdateUserProfileError>> {

    let uri_str = format!("{}/users/{user_id}", configuration.base_path, user_id=params.user_id);
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(param_value) = params.x_request_id {
        req_builder = req_builder.header("X-Request-Id", param_value.to_string());
    }
    if let Some(ref auth_conf) = configuration.basic_auth {
        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
    };
    req_builder = req_builder.json(&params.profile);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateUserProfileError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}