harbor_api/apis/

artifact_api.rs

/*
 * 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 [`add_label`]
#[derive(Clone, Debug)]
pub struct AddLabelParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: String,
    /// The label that added to the artifact. Only the ID property is needed.
    pub label: models::Label,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`copy_artifact`]
#[derive(Clone, Debug)]
pub struct CopyArtifactParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The artifact from which the new artifact is copied from, the format should be \"project/repository:tag\" or \"project/repository@digest\".
    pub from: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`create_tag`]
#[derive(Clone, Debug)]
pub struct CreateTagParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: String,
    /// The JSON object of tag.
    pub tag: models::Tag,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`delete_artifact`]
#[derive(Clone, Debug)]
pub struct DeleteArtifactParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`delete_tag`]
#[derive(Clone, Debug)]
pub struct DeleteTagParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: String,
    /// The name of the tag
    pub tag_name: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`get_addition`]
#[derive(Clone, Debug)]
pub struct GetAdditionParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: String,
    /// The type of addition.
    pub addition: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}

/// struct for passing parameters to the method [`get_artifact`]
#[derive(Clone, Debug)]
pub struct GetArtifactParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: 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>,
    /// 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 inclued inside the returning artifacts
    pub with_tag: Option<bool>,
    /// Specify whether the labels are inclued inside the returning artifacts
    pub with_label: Option<bool>,
    /// Specify whether the scan overview is inclued inside the returning artifacts
    pub with_scan_overview: Option<bool>,
    /// Specify whether the SBOM overview is included in returning artifact, when this option is true, the SBOM overview will be included in the response
    pub with_sbom_overview: Option<bool>,
    /// Specify whether the accessories are included of the returning artifacts.
    pub with_accessory: Option<bool>,
    /// Specify whether the signature is inclued inside the returning artifacts
    pub with_signature: Option<bool>,
    /// Specify whether the immutable status is inclued inside the tags of the returning artifacts.
    pub with_immutable_status: Option<bool>
}

/// struct for passing parameters to the method [`get_vulnerabilities_addition`]
#[derive(Clone, Debug)]
pub struct GetVulnerabilitiesAdditionParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: String,
    /// An unique ID for the request
    pub x_request_id: Option<String>,
    /// 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>
}

/// struct for passing parameters to the method [`list_accessories`]
#[derive(Clone, Debug)]
pub struct ListAccessoriesParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: 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 [`list_artifacts`]
#[derive(Clone, Debug)]
pub struct ListArtifactsParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_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>,
    /// 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 signature is included inside the tags of the returning artifacts. Only works when setting \"with_tag=true\"
    pub with_signature: 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>
}

/// struct for passing parameters to the method [`list_tags`]
#[derive(Clone, Debug)]
pub struct ListTagsParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: 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>,
    /// Specify whether the signature is included inside the returning tags
    pub with_signature: Option<bool>,
    /// Specify whether the immutable status is included inside the returning tags
    pub with_immutable_status: Option<bool>
}

/// struct for passing parameters to the method [`remove_label`]
#[derive(Clone, Debug)]
pub struct RemoveLabelParams {
    /// The name of the project
    pub project_name: String,
    /// The name of the repository. If it contains slash, encode it twice over with URL encoding. e.g. a/b -> a%2Fb -> a%252Fb
    pub repository_name: String,
    /// The reference of the artifact, can be digest or tag
    pub reference: String,
    /// The ID of the label that removed from the artifact.
    pub label_id: i64,
    /// An unique ID for the request
    pub x_request_id: Option<String>
}


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

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

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

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

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

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

/// struct for typed errors of method [`get_artifact`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetArtifactError {
    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_vulnerabilities_addition`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetVulnerabilitiesAdditionError {
    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_accessories`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListAccessoriesError {
    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_artifacts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListArtifactsError {
    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_tags`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListTagsError {
    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 [`remove_label`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveLabelError {
    Status401(models::Errors),
    Status403(models::Errors),
    Status404(models::Errors),
    Status409(models::Errors),
    Status500(models::Errors),
    UnknownValue(serde_json::Value),
}


/// Add label to the specified artiact.
pub async fn add_label(configuration: &configuration::Configuration, params: AddLabelParams) -> Result<(), Error<AddLabelError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}/labels", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference));
    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.label);

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

/// Copy the artifact specified in the \"from\" parameter to the repository.
pub async fn copy_artifact(configuration: &configuration::Configuration, params: CopyArtifactParams) -> Result<(), Error<CopyArtifactError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("from", &params.from.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<CopyArtifactError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Create a tag for the specified artifact
pub async fn create_tag(configuration: &configuration::Configuration, params: CreateTagParams) -> Result<(), Error<CreateTagError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}/tags", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference));
    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.tag);

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

/// Delete the artifact specified by the reference under the project and repository. The reference can be digest or tag
pub async fn delete_artifact(configuration: &configuration::Configuration, params: DeleteArtifactParams) -> Result<(), Error<DeleteArtifactError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference));
    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<DeleteArtifactError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Delete the tag of the specified artifact
pub async fn delete_tag(configuration: &configuration::Configuration, params: DeleteTagParams) -> Result<(), Error<DeleteTagError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}/tags/{tag_name}", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference), tag_name=crate::apis::urlencode(params.tag_name));
    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<DeleteTagError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get the addition of the artifact specified by the reference under the project and repository.
pub async fn get_addition(configuration: &configuration::Configuration, params: GetAdditionParams) -> Result<String, Error<GetAdditionError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}/additions/{addition}", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference), addition=crate::apis::urlencode(params.addition));
    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 `String`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAdditionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get the artifact specified by the reference under the project and repository. The reference can be digest or tag.
pub async fn get_artifact(configuration: &configuration::Configuration, params: GetArtifactParams) -> Result<models::Artifact, Error<GetArtifactError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference));
    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())]);
    }
    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_accessory {
        req_builder = req_builder.query(&[("with_accessory", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.with_signature {
        req_builder = req_builder.query(&[("with_signature", &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 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_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 `models::Artifact`"))),
            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::Artifact`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetArtifactError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Get the vulnerabilities addition of the artifact specified by the reference under the project and repository.
pub async fn get_vulnerabilities_addition(configuration: &configuration::Configuration, params: GetVulnerabilitiesAdditionParams) -> Result<String, Error<GetVulnerabilitiesAdditionError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}/additions/vulnerabilities", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference));
    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_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 `String`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetVulnerabilitiesAdditionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List accessories of the specific artifact
pub async fn list_accessories(configuration: &configuration::Configuration, params: ListAccessoriesParams) -> Result<Vec<models::Accessory>, Error<ListAccessoriesError>> {

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

/// List artifacts under the specific project and repository. Except the basic properties, the other supported queries in \"q\" includes \"tags=*\" to list only tagged artifacts, \"tags=nil\" to list only untagged artifacts, \"tags=~v\" to list artifacts whose tag fuzzy matches \"v\", \"tags=v\" to list artifact whose tag exactly matches \"v\", \"labels=(id1, id2)\" to list artifacts that both labels with id1 and id2 are added to
pub async fn list_artifacts(configuration: &configuration::Configuration, params: ListArtifactsParams) -> Result<Vec<models::Artifact>, Error<ListArtifactsError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_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 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_signature {
        req_builder = req_builder.query(&[("with_signature", &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 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_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<ListArtifactsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// List tags of the specific artifact
pub async fn list_tags(configuration: &configuration::Configuration, params: ListTagsParams) -> Result<Vec<models::Tag>, Error<ListTagsError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}/tags", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference));
    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_signature {
        req_builder = req_builder.query(&[("with_signature", &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 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::Tag&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::Tag&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListTagsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Remove the label from the specified artiact.
pub async fn remove_label(configuration: &configuration::Configuration, params: RemoveLabelParams) -> Result<(), Error<RemoveLabelError>> {

    let uri_str = format!("{}/projects/{project_name}/repositories/{repository_name}/artifacts/{reference}/labels/{label_id}", configuration.base_path, project_name=crate::apis::urlencode(params.project_name), repository_name=crate::apis::urlencode(params.repository_name), reference=crate::apis::urlencode(params.reference), label_id=params.label_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<RemoveLabelError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}