vrchatapi 1.20.8-nightly.11

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// Returns the modified InventoryItem object as held by the currently logged in user.
pub async fn consume_own_inventory_item(
    configuration: &configuration::Configuration,
    inventory_item_id: &str,
) -> Result<models::InventoryConsumptionResults, Error<ConsumeOwnInventoryItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_inventory_item_id = inventory_item_id;

    let uri_str = format!(
        "{}/inventory/{inventoryItemId}/consume",
        configuration.base_path,
        inventoryItemId = crate::apis::urlencode(p_path_inventory_item_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());
    }

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

/// Deletes an InventoryItem from the inventory of the currently logged in user.
pub async fn delete_own_inventory_item(
    configuration: &configuration::Configuration,
    inventory_item_id: &str,
) -> Result<models::SuccessFlag, Error<DeleteOwnInventoryItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_inventory_item_id = inventory_item_id;

    let uri_str = format!(
        "{}/inventory/{inventoryItemId}",
        configuration.base_path,
        inventoryItemId = crate::apis::urlencode(p_path_inventory_item_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());
    }

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

/// Returns the modified InventoryItem object as held by the currently logged in user.
pub async fn equip_own_inventory_item(
    configuration: &configuration::Configuration,
    inventory_item_id: &str,
    equip_inventory_item_request: Option<models::EquipInventoryItemRequest>,
) -> Result<models::InventoryItem, Error<EquipOwnInventoryItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_inventory_item_id = inventory_item_id;
    let p_body_equip_inventory_item_request = equip_inventory_item_request;

    let uri_str = format!(
        "{}/inventory/{inventoryItemId}/equip",
        configuration.base_path,
        inventoryItemId = crate::apis::urlencode(p_path_inventory_item_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());
    }
    req_builder = req_builder.json(&p_body_equip_inventory_item_request);

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

/// Returns an Inventory object.
pub async fn get_inventory(
    configuration: &configuration::Configuration,
    n: Option<i32>,
    offset: Option<i32>,
    holder_id: Option<&str>,
    equip_slot: Option<models::InventoryEquipSlot>,
    order: Option<&str>,
    tags: Option<&str>,
    types: Option<models::InventoryItemType>,
    flags: Option<models::InventoryFlag>,
    not_types: Option<models::InventoryItemType>,
    not_flags: Option<models::InventoryFlag>,
    archived: Option<bool>,
) -> Result<models::Inventory, Error<GetInventoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_n = n;
    let p_query_offset = offset;
    let p_query_holder_id = holder_id;
    let p_query_equip_slot = equip_slot;
    let p_query_order = order;
    let p_query_tags = tags;
    let p_query_types = types;
    let p_query_flags = flags;
    let p_query_not_types = not_types;
    let p_query_not_flags = not_flags;
    let p_query_archived = archived;

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

    if let Some(ref param_value) = p_query_n {
        req_builder = req_builder.query(&[("n", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_holder_id {
        req_builder = req_builder.query(&[("holderId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_equip_slot {
        req_builder = req_builder.query(&[("equipSlot", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_tags {
        req_builder = req_builder.query(&[("tags", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_types {
        req_builder = req_builder.query(&[("types", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_flags {
        req_builder = req_builder.query(&[("flags", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_not_types {
        req_builder = req_builder.query(&[("notTypes", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_not_flags {
        req_builder = req_builder.query(&[("notFlags", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_archived {
        req_builder = req_builder.query(&[("archived", &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());
    }

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

/// Returns a list of collection names.
pub async fn get_inventory_collections(
    configuration: &configuration::Configuration,
) -> Result<Vec<String>, Error<GetInventoryCollectionsError>> {
    let uri_str = format!("{}/inventory/collections", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

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

/// Returns a list of InventoryDrop objects.
pub async fn get_inventory_drops(
    configuration: &configuration::Configuration,
    active: Option<bool>,
) -> Result<Vec<models::InventoryDrop>, Error<GetInventoryDropsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_active = active;

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

    if let Some(ref param_value) = p_query_active {
        req_builder = req_builder.query(&[("active", &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());
    }

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

/// Returns an InventoryTemplate object.
pub async fn get_inventory_template(
    configuration: &configuration::Configuration,
    inventory_template_id: &str,
) -> Result<models::InventoryTemplate, Error<GetInventoryTemplateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_inventory_template_id = inventory_template_id;

    let uri_str = format!(
        "{}/inventory/template/{inventoryTemplateId}",
        configuration.base_path,
        inventoryTemplateId = crate::apis::urlencode(p_path_inventory_template_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());
    }

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

/// Returns an InventoryItem object held by the currently logged in user.
pub async fn get_own_inventory_item(
    configuration: &configuration::Configuration,
    inventory_item_id: &str,
) -> Result<models::InventoryItem, Error<GetOwnInventoryItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_inventory_item_id = inventory_item_id;

    let uri_str = format!(
        "{}/inventory/{inventoryItemId}",
        configuration.base_path,
        inventoryItemId = crate::apis::urlencode(p_path_inventory_item_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());
    }

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

/// Returns an InventoryItem object held by the given user.
pub async fn get_user_inventory_item(
    configuration: &configuration::Configuration,
    user_id: &str,
    inventory_item_id: &str,
) -> Result<models::InventoryItem, Error<GetUserInventoryItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_user_id = user_id;
    let p_path_inventory_item_id = inventory_item_id;

    let uri_str = format!(
        "{}/user/{userId}/inventory/{inventoryItemId}",
        configuration.base_path,
        userId = crate::apis::urlencode(p_path_user_id),
        inventoryItemId = crate::apis::urlencode(p_path_inventory_item_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());
    }

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

/// Redeem a reward for the currently logged in user.
pub async fn redeem_reward(
    configuration: &configuration::Configuration,
    reward_redemption_request: models::RewardRedemptionRequest,
) -> Result<Vec<models::RewardRedemptionResult>, Error<RedeemRewardError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_reward_redemption_request = reward_redemption_request;

    let uri_str = format!("{}/reward/redeem", 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());
    }
    req_builder = req_builder.json(&p_body_reward_redemption_request);

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

/// Share content directly with other users.
pub async fn share_inventory_item_direct(
    configuration: &configuration::Configuration,
    item_id: &str,
    duration: i32,
    share_inventory_item_direct_request: models::ShareInventoryItemDirectRequest,
) -> Result<models::OkStatus, Error<ShareInventoryItemDirectError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_item_id = item_id;
    let p_query_duration = duration;
    let p_body_share_inventory_item_direct_request = share_inventory_item_direct_request;

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

    req_builder = req_builder.query(&[("itemId", &p_query_item_id.to_string())]);
    req_builder = req_builder.query(&[("duration", &p_query_duration.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_share_inventory_item_direct_request);

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

/// Returns an InventorySpawn object.
pub async fn share_inventory_item_pedestal(
    configuration: &configuration::Configuration,
    item_id: &str,
    duration: i32,
) -> Result<models::InventorySpawn, Error<ShareInventoryItemPedestalError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_item_id = item_id;
    let p_query_duration = duration;

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

    req_builder = req_builder.query(&[("itemId", &p_query_item_id.to_string())]);
    req_builder = req_builder.query(&[("duration", &p_query_duration.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

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

/// Returns an InventorySpawn object.
pub async fn spawn_inventory_item(
    configuration: &configuration::Configuration,
    id: &str,
) -> Result<models::InventorySpawn, Error<SpawnInventoryItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_id = id;

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

    req_builder = req_builder.query(&[("id", &p_query_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

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

/// Unequips the InventoryItem in the given slot of the inventory of the currently logged in user.
pub async fn unequip_own_inventory_slot(
    configuration: &configuration::Configuration,
    inventory_item_id: models::InventoryEquipSlot,
) -> Result<String, Error<UnequipOwnInventorySlotError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_inventory_item_id = inventory_item_id;

    let uri_str = format!(
        "{}/inventory/{inventoryItemId}/equip",
        configuration.base_path,
        inventoryItemId = p_path_inventory_item_id.to_string()
    );
    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());
    }

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

/// Returns the modified InventoryItem object as held by the currently logged in user.
pub async fn update_own_inventory_item(
    configuration: &configuration::Configuration,
    inventory_item_id: &str,
    update_inventory_item_request: Option<models::UpdateInventoryItemRequest>,
) -> Result<models::InventoryItem, Error<UpdateOwnInventoryItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_inventory_item_id = inventory_item_id;
    let p_body_update_inventory_item_request = update_inventory_item_request;

    let uri_str = format!(
        "{}/inventory/{inventoryItemId}",
        configuration.base_path,
        inventoryItemId = crate::apis::urlencode(p_path_inventory_item_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());
    }
    req_builder = req_builder.json(&p_body_update_inventory_item_request);

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