immich_api_rs 1.137.3

/*
 * Immich
 *
 * Immich API
 *
 * The version of the OpenAPI document: 1.137.3
 *
 * Generated by: https://openapi-generator.tech
 */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Checks if assets exist by checksums
pub async fn check_bulk_upload(
    configuration: &configuration::Configuration,
    asset_bulk_upload_check_dto: models::AssetBulkUploadCheckDto,
) -> Result<models::AssetBulkUploadCheckResponseDto, Error<CheckBulkUploadError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_asset_bulk_upload_check_dto = asset_bulk_upload_check_dto;

    let uri_str = format!("{}/assets/bulk-upload-check", 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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_asset_bulk_upload_check_dto);

    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::AssetBulkUploadCheckResponseDto`"))),
            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::AssetBulkUploadCheckResponseDto`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CheckBulkUploadError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Checks if multiple assets exist on the server and returns all existing - used by background backup
pub async fn check_existing_assets(
    configuration: &configuration::Configuration,
    check_existing_assets_dto: models::CheckExistingAssetsDto,
) -> Result<models::CheckExistingAssetsResponseDto, Error<CheckExistingAssetsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_check_existing_assets_dto = check_existing_assets_dto;

    let uri_str = format!("{}/assets/exist", 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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_check_existing_assets_dto);

    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::CheckExistingAssetsResponseDto`"))),
            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::CheckExistingAssetsResponseDto`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CheckExistingAssetsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This endpoint requires the `asset.delete` permission.
pub async fn delete_assets(
    configuration: &configuration::Configuration,
    asset_bulk_delete_dto: models::AssetBulkDeleteDto,
) -> Result<(), Error<DeleteAssetsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_asset_bulk_delete_dto = asset_bulk_delete_dto;

    let uri_str = format!("{}/assets", configuration.base_path);
    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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_asset_bulk_delete_dto);

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

/// This endpoint requires the `asset.download` permission.
pub async fn download_asset(
    configuration: &configuration::Configuration,
    id: &str,
    key: Option<&str>,
    slug: Option<&str>,
) -> Result<reqwest::Response, Error<DownloadAssetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_id = id;
    let p_key = key;
    let p_slug = slug;

    let uri_str = format!(
        "{}/assets/{id}/original",
        configuration.base_path,
        id = crate::apis::urlencode(p_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_key {
        req_builder = req_builder.query(&[("key", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_slug {
        req_builder = req_builder.query(&[("slug", &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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.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(resp)
    } else {
        let content = resp.text().await?;
        let entity: Option<DownloadAssetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Get all asset of a device that are in the database, ID only.
pub async fn get_all_user_assets_by_device_id(
    configuration: &configuration::Configuration,
    device_id: &str,
) -> Result<Vec<String>, Error<GetAllUserAssetsByDeviceIdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_device_id = device_id;

    let uri_str = format!(
        "{}/assets/device/{deviceId}",
        configuration.base_path,
        deviceId = crate::apis::urlencode(p_device_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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.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;String&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;String&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAllUserAssetsByDeviceIdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This endpoint requires the `asset.read` permission.
pub async fn get_asset_info(
    configuration: &configuration::Configuration,
    id: &str,
    key: Option<&str>,
    slug: Option<&str>,
) -> Result<models::AssetResponseDto, Error<GetAssetInfoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_id = id;
    let p_key = key;
    let p_slug = slug;

    let uri_str = format!(
        "{}/assets/{id}",
        configuration.base_path,
        id = crate::apis::urlencode(p_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_key {
        req_builder = req_builder.query(&[("key", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_slug {
        req_builder = req_builder.query(&[("slug", &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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.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::AssetResponseDto`"))),
            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::AssetResponseDto`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAssetInfoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This endpoint requires the `asset.statistics` permission.
pub async fn get_asset_statistics(
    configuration: &configuration::Configuration,
    is_favorite: Option<bool>,
    is_trashed: Option<bool>,
    visibility: Option<models::AssetVisibility>,
) -> Result<models::AssetStatsResponseDto, Error<GetAssetStatisticsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_is_favorite = is_favorite;
    let p_is_trashed = is_trashed;
    let p_visibility = visibility;

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

    if let Some(ref param_value) = p_is_favorite {
        req_builder = req_builder.query(&[("isFavorite", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_is_trashed {
        req_builder = req_builder.query(&[("isTrashed", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_visibility {
        req_builder = req_builder.query(&[("visibility", &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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.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::AssetStatsResponseDto`"))),
            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::AssetStatsResponseDto`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAssetStatisticsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This property was deprecated in v1.116.0. This endpoint requires the `asset.read` permission.
pub async fn get_random(
    configuration: &configuration::Configuration,
    count: Option<f64>,
) -> Result<Vec<models::AssetResponseDto>, Error<GetRandomError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_count = count;

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

    if let Some(ref param_value) = p_count {
        req_builder = req_builder.query(&[("count", &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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.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::AssetResponseDto&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::AssetResponseDto&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRandomError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This endpoint requires the `asset.view` permission.
pub async fn play_asset_video(
    configuration: &configuration::Configuration,
    id: &str,
    key: Option<&str>,
    slug: Option<&str>,
) -> Result<reqwest::Response, Error<PlayAssetVideoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_id = id;
    let p_key = key;
    let p_slug = slug;

    let uri_str = format!(
        "{}/assets/{id}/video/playback",
        configuration.base_path,
        id = crate::apis::urlencode(p_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_key {
        req_builder = req_builder.query(&[("key", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_slug {
        req_builder = req_builder.query(&[("slug", &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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.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(resp)
    } else {
        let content = resp.text().await?;
        let entity: Option<PlayAssetVideoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Replace the asset with new file, without changing its id. This endpoint requires the `asset.replace` permission.
pub async fn replace_asset(
    configuration: &configuration::Configuration,
    id: &str,
    asset_data: std::path::PathBuf,
    device_asset_id: &str,
    device_id: &str,
    file_created_at: String,
    file_modified_at: String,
    key: Option<&str>,
    slug: Option<&str>,
    duration: Option<&str>,
    filename: Option<&str>,
) -> Result<models::AssetMediaResponseDto, Error<ReplaceAssetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_id = id;
    let p_asset_data = asset_data;
    let p_device_asset_id = device_asset_id;
    let p_device_id = device_id;
    let p_file_created_at = file_created_at;
    let p_file_modified_at = file_modified_at;
    let p_key = key;
    let p_slug = slug;
    let p_duration = duration;
    let p_filename = filename;

    let uri_str = format!(
        "{}/assets/{id}/original",
        configuration.base_path,
        id = crate::apis::urlencode(p_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    if let Some(ref param_value) = p_key {
        req_builder = req_builder.query(&[("key", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_slug {
        req_builder = req_builder.query(&[("slug", &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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    let mut multipart_form = reqwest::multipart::Form::new();
    // TODO: support file upload for 'assetData' parameter
    multipart_form = multipart_form.text("deviceAssetId", p_device_asset_id.to_string());
    multipart_form = multipart_form.text("deviceId", p_device_id.to_string());
    if let Some(param_value) = p_duration {
        multipart_form = multipart_form.text("duration", param_value.to_string());
    }
    multipart_form = multipart_form.text("fileCreatedAt", p_file_created_at.to_string());
    multipart_form = multipart_form.text("fileModifiedAt", p_file_modified_at.to_string());
    if let Some(param_value) = p_filename {
        multipart_form = multipart_form.text("filename", param_value.to_string());
    }
    req_builder = req_builder.multipart(multipart_form);

    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::AssetMediaResponseDto`"))),
            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::AssetMediaResponseDto`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ReplaceAssetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn run_asset_jobs(
    configuration: &configuration::Configuration,
    asset_jobs_dto: models::AssetJobsDto,
) -> Result<(), Error<RunAssetJobsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_asset_jobs_dto = asset_jobs_dto;

    let uri_str = format!("{}/assets/jobs", 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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_asset_jobs_dto);

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

/// This endpoint requires the `asset.update` permission.
pub async fn update_asset(
    configuration: &configuration::Configuration,
    id: &str,
    update_asset_dto: models::UpdateAssetDto,
) -> Result<models::AssetResponseDto, Error<UpdateAssetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_id = id;
    let p_update_asset_dto = update_asset_dto;

    let uri_str = format!(
        "{}/assets/{id}",
        configuration.base_path,
        id = crate::apis::urlencode(p_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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_update_asset_dto);

    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::AssetResponseDto`"))),
            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::AssetResponseDto`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAssetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This endpoint requires the `asset.update` permission.
pub async fn update_assets(
    configuration: &configuration::Configuration,
    asset_bulk_update_dto: models::AssetBulkUpdateDto,
) -> Result<(), Error<UpdateAssetsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_asset_bulk_update_dto = asset_bulk_update_dto;

    let uri_str = format!("{}/assets", configuration.base_path);
    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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_asset_bulk_update_dto);

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

/// This endpoint requires the `asset.upload` permission.
pub async fn upload_asset(
    configuration: &configuration::Configuration,
    asset_data: std::path::PathBuf,
    device_asset_id: &str,
    device_id: &str,
    file_created_at: String,
    file_modified_at: String,
    key: Option<&str>,
    slug: Option<&str>,
    x_immich_checksum: Option<&str>,
    duration: Option<&str>,
    filename: Option<&str>,
    is_favorite: Option<bool>,
    live_photo_video_id: Option<&str>,
    sidecar_data: Option<std::path::PathBuf>,
    visibility: Option<models::AssetVisibility>,
) -> Result<models::AssetMediaResponseDto, Error<UploadAssetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_asset_data = asset_data;
    let p_device_asset_id = device_asset_id;
    let p_device_id = device_id;
    let p_file_created_at = file_created_at;
    let p_file_modified_at = file_modified_at;
    let p_key = key;
    let p_slug = slug;
    let p_x_immich_checksum = x_immich_checksum;
    let p_duration = duration;
    let p_filename = filename;
    let p_is_favorite = is_favorite;
    let p_live_photo_video_id = live_photo_video_id;
    let p_sidecar_data = sidecar_data;
    let p_visibility = visibility;

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

    if let Some(ref param_value) = p_key {
        req_builder = req_builder.query(&[("key", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_slug {
        req_builder = req_builder.query(&[("slug", &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) = p_x_immich_checksum {
        req_builder = req_builder.header("x-immich-checksum", param_value.to_string());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    let mut multipart_form = reqwest::multipart::Form::new();
    // TODO: support file upload for 'assetData' parameter
    multipart_form = multipart_form.text("deviceAssetId", p_device_asset_id.to_string());
    multipart_form = multipart_form.text("deviceId", p_device_id.to_string());
    if let Some(param_value) = p_duration {
        multipart_form = multipart_form.text("duration", param_value.to_string());
    }
    multipart_form = multipart_form.text("fileCreatedAt", p_file_created_at.to_string());
    multipart_form = multipart_form.text("fileModifiedAt", p_file_modified_at.to_string());
    if let Some(param_value) = p_filename {
        multipart_form = multipart_form.text("filename", param_value.to_string());
    }
    if let Some(param_value) = p_is_favorite {
        multipart_form = multipart_form.text("isFavorite", param_value.to_string());
    }
    if let Some(param_value) = p_live_photo_video_id {
        multipart_form = multipart_form.text("livePhotoVideoId", param_value.to_string());
    }
    // TODO: support file upload for 'sidecarData' parameter
    if let Some(param_value) = p_visibility {
        multipart_form = multipart_form.text("visibility", param_value.to_string());
    }
    req_builder = req_builder.multipart(multipart_form);

    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::AssetMediaResponseDto`"))),
            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::AssetMediaResponseDto`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UploadAssetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// This endpoint requires the `asset.view` permission.
pub async fn view_asset(
    configuration: &configuration::Configuration,
    id: &str,
    key: Option<&str>,
    size: Option<models::AssetMediaSize>,
    slug: Option<&str>,
) -> Result<reqwest::Response, Error<ViewAssetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_id = id;
    let p_key = key;
    let p_size = size;
    let p_slug = slug;

    let uri_str = format!(
        "{}/assets/{id}/thumbnail",
        configuration.base_path,
        id = crate::apis::urlencode(p_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_key {
        req_builder = req_builder.query(&[("key", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_size {
        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_slug {
        req_builder = req_builder.query(&[("slug", &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(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    if let Some(ref token) = configuration.bearer_access_token {
        req_builder = req_builder.bearer_auth(token.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(resp)
    } else {
        let content = resp.text().await?;
        let entity: Option<ViewAssetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}