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_project`]
#[derive(Clone, Debug)]
pub struct CreateProjectParams {
    /// New created project.
    pub project: models::ProjectReq,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether to return the name of the resource in Location. When X-Resource-Name-In-Location is true, the Location will return the name of the resource.
    pub x_resource_name_in_location: Option<bool>
}

/// struct for passing parameters to the method [`delete_project`]
#[derive(Clone, Debug)]
pub struct DeleteProjectParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>
}

/// struct for passing parameters to the method [`get_logs`]
#[derive(Clone, Debug)]
pub struct GetLogsParams {
    /// The name of the project
    pub project_name: String,
    /// 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 [`get_project`]
#[derive(Clone, Debug)]
pub struct GetProjectParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>
}

/// struct for passing parameters to the method [`get_project_deletable`]
#[derive(Clone, Debug)]
pub struct GetProjectDeletableParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>
}

/// struct for passing parameters to the method [`get_project_summary`]
#[derive(Clone, Debug)]
pub struct GetProjectSummaryParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>
}

/// struct for passing parameters to the method [`get_scanner_of_project`]
#[derive(Clone, Debug)]
pub struct GetScannerOfProjectParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>
}

/// struct for passing parameters to the method [`head_project`]
#[derive(Clone, Debug)]
pub struct HeadProjectParams {
    /// Project name for checking exists.
    pub project_name: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`list_artifacts_of_project`]
#[derive(Clone, Debug)]
pub struct ListArtifactsOfProjectParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>,
    /// 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>,
    /// A comma-separated lists of MIME types for the scan report or scan summary. The first mime type will be used when the report found for it. Currently the mime type supports 'application/vnd.scanner.adapter.vuln.report.harbor+json; version=1.0' and 'application/vnd.security.vulnerability.report; version=1.1'
    pub x_accept_vulnerabilities: Option<String>,
    /// Specify whether the tags are included inside the returning artifacts
    pub with_tag: Option<bool>,
    /// Specify whether the labels are included inside the returning artifacts
    pub with_label: Option<bool>,
    /// Specify whether the scan overview is included inside the returning artifacts
    pub with_scan_overview: Option<bool>,
    /// Specify whether the SBOM overview is included in returning artifacts, when this option is true, the SBOM overview will be included in the response
    pub with_sbom_overview: Option<bool>,
    /// Specify whether the immutable status is included inside the tags of the returning artifacts. Only works when setting \"with_immutable_status=true\"
    pub with_immutable_status: Option<bool>,
    /// Specify whether the accessories are included of the returning artifacts. Only works when setting \"with_accessory=true\"
    pub with_accessory: Option<bool>,
    /// Specify whether only the latest pushed artifact of each repository is included inside the returning artifacts. Only works when either artifact_type or media_type is included in the query.
    pub latest_in_repository: Option<bool>
}

/// struct for passing parameters to the method [`list_projects`]
#[derive(Clone, Debug)]
pub struct ListProjectsParams {
    /// 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>,
    /// The page number
    pub page: Option<i64>,
    /// The size of per page
    pub page_size: Option<i64>,
    /// 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 name of project.
    pub name: Option<String>,
    /// The project is public or private.
    pub public: Option<bool>,
    /// The name of project owner.
    pub owner: Option<String>,
    /// Bool value indicating whether return detailed information of the project
    pub with_detail: Option<bool>
}

/// struct for passing parameters to the method [`list_scanner_candidates_of_project`]
#[derive(Clone, Debug)]
pub struct ListScannerCandidatesOfProjectParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>,
    /// 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 [`set_scanner_of_project`]
#[derive(Clone, Debug)]
pub struct SetScannerOfProjectParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    pub payload: models::ProjectScanner,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>
}

/// struct for passing parameters to the method [`update_project`]
#[derive(Clone, Debug)]
pub struct UpdateProjectParams {
    /// The name or id of the project
    pub project_name_or_id: String,
    /// Updates of project.
    pub project: models::ProjectReq,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// The flag to indicate whether the parameter which supports both name and id in the path is the name of the resource. When the X-Is-Resource-Name is false and the parameter can be converted to an integer, the parameter will be as an id, otherwise, it will be as a name.
    pub x_is_resource_name: Option<bool>
}


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

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

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

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

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

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

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

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

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

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

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

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

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


/// This endpoint is for user to create a new project.
pub async fn create_project(configuration: &configuration::Configuration, params: CreateProjectParams) -> Result<(), Error<CreateProjectError>> {

    let uri_str = format!("{}/projects", 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(param_value) = params.x_resource_name_in_location {
        req_builder = req_builder.header("X-Resource-Name-In-Location", 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.project);

    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<CreateProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint is aimed to delete project by project ID.
pub async fn delete_project(configuration: &configuration::Configuration, params: DeleteProjectParams) -> Result<(), Error<DeleteProjectError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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<DeleteProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get recent logs of the projects
pub async fn get_logs(configuration: &configuration::Configuration, params: GetLogsParams) -> Result<Vec<models::AuditLog>, Error<GetLogsError>> {

    let uri_str = format!("{}/projects/{project_name}/logs", configuration.base_path, project_name=crate::apis::urlencode(params.project_name));
    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::AuditLog&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::AuditLog&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetLogsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint returns specific project information by project ID.
pub async fn get_project(configuration: &configuration::Configuration, params: GetProjectParams) -> Result<models::Project, Error<GetProjectError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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::Project`"))),
            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::Project`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get the deletable status of the project
pub async fn get_project_deletable(configuration: &configuration::Configuration, params: GetProjectDeletableParams) -> Result<models::ProjectDeletable, Error<GetProjectDeletableError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}/_deletable", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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::ProjectDeletable`"))),
            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::ProjectDeletable`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetProjectDeletableError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get summary of the project.
pub async fn get_project_summary(configuration: &configuration::Configuration, params: GetProjectSummaryParams) -> Result<models::ProjectSummary, Error<GetProjectSummaryError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}/summary", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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::ProjectSummary`"))),
            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::ProjectSummary`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetProjectSummaryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get the scanner registration of the specified project. If no scanner registration is configured for the specified project, the system default scanner registration will be returned.
pub async fn get_scanner_of_project(configuration: &configuration::Configuration, params: GetScannerOfProjectParams) -> Result<models::ScannerRegistration, Error<GetScannerOfProjectError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}/scanner", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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::ScannerRegistration`"))),
            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::ScannerRegistration`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetScannerOfProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint is used to check if the project name provided already exist.
pub async fn head_project(configuration: &configuration::Configuration, params: HeadProjectParams) -> Result<(), Error<HeadProjectError>> {

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

    req_builder = req_builder.query(&[("project_name", &params.project_name.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();

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

/// List artifacts of the specified project
pub async fn list_artifacts_of_project(configuration: &configuration::Configuration, params: ListArtifactsOfProjectParams) -> Result<Vec<models::Artifact>, Error<ListArtifactsOfProjectError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}/artifacts", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_id));
    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 param_value) = params.with_tag {
        req_builder = req_builder.query(&[("with_tag", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.with_label {
        req_builder = req_builder.query(&[("with_label", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.with_scan_overview {
        req_builder = req_builder.query(&[("with_scan_overview", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.with_sbom_overview {
        req_builder = req_builder.query(&[("with_sbom_overview", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.with_immutable_status {
        req_builder = req_builder.query(&[("with_immutable_status", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.with_accessory {
        req_builder = req_builder.query(&[("with_accessory", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.latest_in_repository {
        req_builder = req_builder.query(&[("latest_in_repository", &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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", param_value.to_string());
    }
    if let Some(param_value) = params.x_accept_vulnerabilities {
        req_builder = req_builder.header("X-Accept-Vulnerabilities", 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::Artifact&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::Artifact&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListArtifactsOfProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint returns projects created by Harbor.
pub async fn list_projects(configuration: &configuration::Configuration, params: ListProjectsParams) -> Result<Vec<models::Project>, Error<ListProjectsError>> {

    let uri_str = format!("{}/projects", 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.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 param_value) = params.sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.name {
        req_builder = req_builder.query(&[("name", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.public {
        req_builder = req_builder.query(&[("public", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.owner {
        req_builder = req_builder.query(&[("owner", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.with_detail {
        req_builder = req_builder.query(&[("with_detail", &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::Project&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::Project&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListProjectsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Retrieve the system configured scanner registrations as candidates of setting project level scanner.
pub async fn list_scanner_candidates_of_project(configuration: &configuration::Configuration, params: ListScannerCandidatesOfProjectParams) -> Result<Vec<models::ScannerRegistration>, Error<ListScannerCandidatesOfProjectError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}/scanner/candidates", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_id));
    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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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::ScannerRegistration&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::ScannerRegistration&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListScannerCandidatesOfProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Set one of the system configured scanner registration as the indepndent scanner of the specified project.
pub async fn set_scanner_of_project(configuration: &configuration::Configuration, params: SetScannerOfProjectParams) -> Result<(), Error<SetScannerOfProjectError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}/scanner", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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.payload);

    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<SetScannerOfProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// This endpoint is aimed to update the properties of a project.
pub async fn update_project(configuration: &configuration::Configuration, params: UpdateProjectParams) -> Result<(), Error<UpdateProjectError>> {

    let uri_str = format!("{}/projects/{project_name_or_id}", configuration.base_path, project_name_or_id=crate::apis::urlencode(params.project_name_or_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(param_value) = params.x_is_resource_name {
        req_builder = req_builder.header("X-Is-Resource-Name", 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.project);

    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<UpdateProjectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}