box-open-sdk 0.4.1

// Code generated by box-gantry 0.1.0 (spec 3fb3510fe12f2f80) for Box API 2024.0. DO NOT EDIT.

use super::*;

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct MetadataFieldFilterDateRange {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lt: Option<chrono::DateTime<chrono::Utc>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub gt: Option<chrono::DateTime<chrono::Utc>>,
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct MetadataFieldFilterFloatRange {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub lt: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub gt: Option<f64>,
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct MetadataFilter {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub scope: Option<MetadataFilterScope>,
    #[serde(
        rename = "templateKey",
        default,
        skip_serializing_if = "Option::is_none"
    )]
    pub template_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub filters: Option<std::collections::HashMap<String, MetadataFilterValue>>,
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct MetadataFilterValue(pub serde_json::Value);

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct MetadataQuery {
    pub from: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub query_params: Option<std::collections::HashMap<String, serde_json::Value>>,
    pub ancestor_folder_id: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub order_by: Option<Vec<MetadataQueryOrderBy>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marker: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub fields: Option<Vec<String>>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum MetadataQueryResultItem {
    File(FileFull),
    Folder(FolderFull),
    /// An unrecognized discriminator, retained verbatim (open union).
    Unknown(serde_json::Value),
}

impl Default for MetadataQueryResultItem {
    fn default() -> Self {
        Self::Unknown(Default::default())
    }
}

impl serde::Serialize for MetadataQueryResultItem {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::File(inner) => inner.serialize(serializer),
            Self::Folder(inner) => inner.serialize(serializer),
            Self::Unknown(inner) => inner.serialize(serializer),
        }
    }
}

impl<'de> serde::Deserialize<'de> for MetadataQueryResultItem {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(serde_json::Value::as_str)
            .map(str::to_owned);
        match tag.as_deref() {
            Some("file") => Ok(Self::File(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            Some("folder") => Ok(Self::Folder(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            _ => Ok(Self::Unknown(value)),
        }
    }
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct MetadataQueryResults {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<MetadataQueryResultItem>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub next_marker: Option<String>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum SearchResultItem {
    File(FileFull),
    Folder(FolderFull),
    WebLink(WebLink),
    /// An unrecognized discriminator, retained verbatim (open union).
    Unknown(serde_json::Value),
}

impl Default for SearchResultItem {
    fn default() -> Self {
        Self::Unknown(Default::default())
    }
}

impl serde::Serialize for SearchResultItem {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::File(inner) => inner.serialize(serializer),
            Self::Folder(inner) => inner.serialize(serializer),
            Self::WebLink(inner) => inner.serialize(serializer),
            Self::Unknown(inner) => inner.serialize(serializer),
        }
    }
}

impl<'de> serde::Deserialize<'de> for SearchResultItem {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(serde_json::Value::as_str)
            .map(str::to_owned);
        match tag.as_deref() {
            Some("file") => Ok(Self::File(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            Some("folder") => Ok(Self::Folder(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            Some("web_link") => Ok(Self::WebLink(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            _ => Ok(Self::Unknown(value)),
        }
    }
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct SearchResults {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    pub r#type: SearchResultsType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<SearchResultItem>>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum SearchResultsResponse {
    SearchResultsItems(SearchResults),
    SearchResultsWithSharedLinks(SearchResultsWithSharedLinks),
    /// An unrecognized discriminator, retained verbatim (open union).
    Unknown(serde_json::Value),
}

impl Default for SearchResultsResponse {
    fn default() -> Self {
        Self::Unknown(Default::default())
    }
}

impl serde::Serialize for SearchResultsResponse {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::SearchResultsItems(inner) => inner.serialize(serializer),
            Self::SearchResultsWithSharedLinks(inner) => inner.serialize(serializer),
            Self::Unknown(inner) => inner.serialize(serializer),
        }
    }
}

impl<'de> serde::Deserialize<'de> for SearchResultsResponse {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(serde_json::Value::as_str)
            .map(str::to_owned);
        match tag.as_deref() {
            Some("search_results_items") => Ok(Self::SearchResultsItems(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            Some("search_results_with_shared_links") => Ok(Self::SearchResultsWithSharedLinks(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            _ => Ok(Self::Unknown(value)),
        }
    }
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct SearchResultsWithSharedLinks {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub total_count: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    pub r#type: SearchResultsWithSharedLinksType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub entries: Option<Vec<SearchResultWithSharedLink>>,
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct SearchResultWithSharedLink {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub accessible_via_shared_link: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub item: Option<SearchResultWithSharedLinkItem>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

#[derive(Clone, Debug, PartialEq)]
pub enum SearchResultWithSharedLinkItem {
    File(FileFull),
    Folder(FolderFull),
    WebLink(WebLink),
    /// An unrecognized discriminator, retained verbatim (open union).
    Unknown(serde_json::Value),
}

impl Default for SearchResultWithSharedLinkItem {
    fn default() -> Self {
        Self::Unknown(Default::default())
    }
}

impl serde::Serialize for SearchResultWithSharedLinkItem {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        match self {
            Self::File(inner) => inner.serialize(serializer),
            Self::Folder(inner) => inner.serialize(serializer),
            Self::WebLink(inner) => inner.serialize(serializer),
            Self::Unknown(inner) => inner.serialize(serializer),
        }
    }
}

impl<'de> serde::Deserialize<'de> for SearchResultWithSharedLinkItem {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = serde_json::Value::deserialize(deserializer)?;
        let tag = value
            .get("type")
            .and_then(serde_json::Value::as_str)
            .map(str::to_owned);
        match tag.as_deref() {
            Some("file") => Ok(Self::File(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            Some("folder") => Ok(Self::Folder(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            Some("web_link") => Ok(Self::WebLink(
                serde_json::from_value(value).map_err(serde::de::Error::custom)?,
            )),
            _ => Ok(Self::Unknown(value)),
        }
    }
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct MetadataFilterScope(pub String);

impl MetadataFilterScope {
    pub const GLOBAL: &'static str = "global";
    pub const ENTERPRISE: &'static str = "enterprise";
    pub const ENTERPRISE_ENTERPRISE_ID: &'static str = "enterprise_{enterprise_id}";
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct OrderByDirection(pub String);

impl OrderByDirection {
    pub const ASC: &'static str = "ASC";
    pub const DESC: &'static str = "DESC";
    pub const ASC_2: &'static str = "asc";
    pub const DESC_2: &'static str = "desc";
}

#[derive(Clone, Debug, Default, PartialEq, serde::Deserialize, serde::Serialize)]
pub struct MetadataQueryOrderBy {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub field_key: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub direction: Option<OrderByDirection>,
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct SearchResultsType(pub String);

impl SearchResultsType {
    pub const SEARCH_RESULTS_ITEMS: &'static str = "search_results_items";
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct SearchResultsWithSharedLinksType(pub String);

impl SearchResultsWithSharedLinksType {
    pub const SEARCH_RESULTS_WITH_SHARED_LINKS: &'static str = "search_results_with_shared_links";
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct GetScope(pub String);

impl GetScope {
    pub const USER_CONTENT: &'static str = "user_content";
    pub const ENTERPRISE_CONTENT: &'static str = "enterprise_content";
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct GetContentTypes(pub String);

impl GetContentTypes {
    pub const NAME: &'static str = "name";
    pub const DESCRIPTION: &'static str = "description";
    pub const FILE_CONTENT: &'static str = "file_content";
    pub const COMMENTS: &'static str = "comments";
    pub const TAGS: &'static str = "tags";
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct GetType(pub String);

impl GetType {
    pub const FILE: &'static str = "file";
    pub const FOLDER: &'static str = "folder";
    pub const WEB_LINK: &'static str = "web_link";
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct GetTrashContent(pub String);

impl GetTrashContent {
    pub const NON_TRASHED_ONLY: &'static str = "non_trashed_only";
    pub const TRASHED_ONLY: &'static str = "trashed_only";
    pub const ALL_ITEMS: &'static str = "all_items";
}

#[derive(Clone, Debug, Default, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
#[serde(transparent)]
pub struct GetSort(pub String);

impl GetSort {
    pub const MODIFIED_AT: &'static str = "modified_at";
    pub const RELEVANCE: &'static str = "relevance";
}