#![allow(
clippy::too_many_arguments,
clippy::large_enum_variant,
clippy::doc_markdown,
)]
pub type FileRequestId = String;
pub type FileRequestValidationError = Option<String>;
pub fn count(
client: &impl crate::client_trait::UserAuthClient,
) -> crate::Result<Result<CountFileRequestsResult, CountFileRequestsError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/count",
&(),
None)
}
pub fn create(
client: &impl crate::client_trait::UserAuthClient,
arg: &CreateFileRequestArgs,
) -> crate::Result<Result<FileRequest, CreateFileRequestError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/create",
arg,
None)
}
pub fn delete(
client: &impl crate::client_trait::UserAuthClient,
arg: &DeleteFileRequestArgs,
) -> crate::Result<Result<DeleteFileRequestsResult, DeleteFileRequestError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/delete",
arg,
None)
}
pub fn delete_all_closed(
client: &impl crate::client_trait::UserAuthClient,
) -> crate::Result<Result<DeleteAllClosedFileRequestsResult, DeleteAllClosedFileRequestsError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/delete_all_closed",
&(),
None)
}
pub fn get(
client: &impl crate::client_trait::UserAuthClient,
arg: &GetFileRequestArgs,
) -> crate::Result<Result<FileRequest, GetFileRequestError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/get",
arg,
None)
}
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn list_v2(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListFileRequestsArg,
) -> crate::Result<Result<ListFileRequestsV2Result, ListFileRequestsError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/list_v2",
arg,
None)
}
pub fn list(
client: &impl crate::client_trait::UserAuthClient,
) -> crate::Result<Result<ListFileRequestsResult, ListFileRequestsError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/list",
&(),
None)
}
#[cfg(feature = "unstable")]
#[cfg_attr(docsrs, doc(cfg(feature = "unstable")))]
pub fn list_continue(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListFileRequestsContinueArg,
) -> crate::Result<Result<ListFileRequestsV2Result, ListFileRequestsContinueError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/list/continue",
arg,
None)
}
pub fn update(
client: &impl crate::client_trait::UserAuthClient,
arg: &UpdateFileRequestArgs,
) -> crate::Result<Result<FileRequest, UpdateFileRequestError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"file_requests/update",
arg,
None)
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum CountFileRequestsError {
DisabledForTeam,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for CountFileRequestsError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = CountFileRequestsError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a CountFileRequestsError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => CountFileRequestsError::DisabledForTeam,
_ => CountFileRequestsError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other"];
deserializer.deserialize_struct("CountFileRequestsError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for CountFileRequestsError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
CountFileRequestsError::DisabledForTeam => {
let mut s = serializer.serialize_struct("CountFileRequestsError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
CountFileRequestsError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for CountFileRequestsError {
}
impl ::std::fmt::Display for CountFileRequestsError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
CountFileRequestsError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct CountFileRequestsResult {
pub file_request_count: u64,
}
impl CountFileRequestsResult {
pub fn new(file_request_count: u64) -> Self {
CountFileRequestsResult {
file_request_count,
}
}
}
const COUNT_FILE_REQUESTS_RESULT_FIELDS: &[&str] = &["file_request_count"];
impl CountFileRequestsResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<CountFileRequestsResult, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<CountFileRequestsResult>, V::Error> {
let mut field_file_request_count = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"file_request_count" => {
if field_file_request_count.is_some() {
return Err(::serde::de::Error::duplicate_field("file_request_count"));
}
field_file_request_count = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = CountFileRequestsResult {
file_request_count: field_file_request_count.ok_or_else(|| ::serde::de::Error::missing_field("file_request_count"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("file_request_count", &self.file_request_count)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for CountFileRequestsResult {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = CountFileRequestsResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a CountFileRequestsResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
CountFileRequestsResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("CountFileRequestsResult", COUNT_FILE_REQUESTS_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for CountFileRequestsResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("CountFileRequestsResult", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct CreateFileRequestArgs {
pub title: String,
pub destination: crate::files::Path,
pub deadline: Option<FileRequestDeadline>,
pub open: bool,
pub description: Option<String>,
}
impl CreateFileRequestArgs {
pub fn new(title: String, destination: crate::files::Path) -> Self {
CreateFileRequestArgs {
title,
destination,
deadline: None,
open: true,
description: None,
}
}
pub fn with_deadline(mut self, value: FileRequestDeadline) -> Self {
self.deadline = Some(value);
self
}
pub fn with_open(mut self, value: bool) -> Self {
self.open = value;
self
}
pub fn with_description(mut self, value: String) -> Self {
self.description = Some(value);
self
}
}
const CREATE_FILE_REQUEST_ARGS_FIELDS: &[&str] = &["title",
"destination",
"deadline",
"open",
"description"];
impl CreateFileRequestArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<CreateFileRequestArgs, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<CreateFileRequestArgs>, V::Error> {
let mut field_title = None;
let mut field_destination = None;
let mut field_deadline = None;
let mut field_open = None;
let mut field_description = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"title" => {
if field_title.is_some() {
return Err(::serde::de::Error::duplicate_field("title"));
}
field_title = Some(map.next_value()?);
}
"destination" => {
if field_destination.is_some() {
return Err(::serde::de::Error::duplicate_field("destination"));
}
field_destination = Some(map.next_value()?);
}
"deadline" => {
if field_deadline.is_some() {
return Err(::serde::de::Error::duplicate_field("deadline"));
}
field_deadline = Some(map.next_value()?);
}
"open" => {
if field_open.is_some() {
return Err(::serde::de::Error::duplicate_field("open"));
}
field_open = Some(map.next_value()?);
}
"description" => {
if field_description.is_some() {
return Err(::serde::de::Error::duplicate_field("description"));
}
field_description = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = CreateFileRequestArgs {
title: field_title.ok_or_else(|| ::serde::de::Error::missing_field("title"))?,
destination: field_destination.ok_or_else(|| ::serde::de::Error::missing_field("destination"))?,
deadline: field_deadline,
open: field_open.unwrap_or(true),
description: field_description,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("title", &self.title)?;
s.serialize_field("destination", &self.destination)?;
if let Some(val) = &self.deadline {
s.serialize_field("deadline", val)?;
}
s.serialize_field("open", &self.open)?;
if let Some(val) = &self.description {
s.serialize_field("description", val)?;
}
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for CreateFileRequestArgs {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = CreateFileRequestArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a CreateFileRequestArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
CreateFileRequestArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("CreateFileRequestArgs", CREATE_FILE_REQUEST_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for CreateFileRequestArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("CreateFileRequestArgs", 5)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum CreateFileRequestError {
DisabledForTeam,
NotFound,
NotAFolder,
AppLacksAccess,
NoPermission,
EmailUnverified,
ValidationError,
InvalidLocation,
RateLimit,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for CreateFileRequestError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = CreateFileRequestError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a CreateFileRequestError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => CreateFileRequestError::DisabledForTeam,
"not_found" => CreateFileRequestError::NotFound,
"not_a_folder" => CreateFileRequestError::NotAFolder,
"app_lacks_access" => CreateFileRequestError::AppLacksAccess,
"no_permission" => CreateFileRequestError::NoPermission,
"email_unverified" => CreateFileRequestError::EmailUnverified,
"validation_error" => CreateFileRequestError::ValidationError,
"invalid_location" => CreateFileRequestError::InvalidLocation,
"rate_limit" => CreateFileRequestError::RateLimit,
_ => CreateFileRequestError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other",
"not_found",
"not_a_folder",
"app_lacks_access",
"no_permission",
"email_unverified",
"validation_error",
"invalid_location",
"rate_limit"];
deserializer.deserialize_struct("CreateFileRequestError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for CreateFileRequestError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
CreateFileRequestError::DisabledForTeam => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
CreateFileRequestError::NotFound => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "not_found")?;
s.end()
}
CreateFileRequestError::NotAFolder => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "not_a_folder")?;
s.end()
}
CreateFileRequestError::AppLacksAccess => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "app_lacks_access")?;
s.end()
}
CreateFileRequestError::NoPermission => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "no_permission")?;
s.end()
}
CreateFileRequestError::EmailUnverified => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "email_unverified")?;
s.end()
}
CreateFileRequestError::ValidationError => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "validation_error")?;
s.end()
}
CreateFileRequestError::InvalidLocation => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "invalid_location")?;
s.end()
}
CreateFileRequestError::RateLimit => {
let mut s = serializer.serialize_struct("CreateFileRequestError", 1)?;
s.serialize_field(".tag", "rate_limit")?;
s.end()
}
CreateFileRequestError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for CreateFileRequestError {
}
impl ::std::fmt::Display for CreateFileRequestError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
CreateFileRequestError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
CreateFileRequestError::NotFound => f.write_str("This file request ID was not found."),
CreateFileRequestError::NotAFolder => f.write_str("The specified path is not a folder."),
CreateFileRequestError::AppLacksAccess => f.write_str("This file request is not accessible to this app. Apps with the app folder permission can only access file requests in their app folder."),
CreateFileRequestError::NoPermission => f.write_str("This user doesn't have permission to access or modify this file request."),
CreateFileRequestError::ValidationError => f.write_str("There was an error validating the request. For example, the title was invalid, or there were disallowed characters in the destination path."),
CreateFileRequestError::InvalidLocation => f.write_str("File requests are not available on the specified folder."),
CreateFileRequestError::RateLimit => f.write_str("The user has reached the rate limit for creating file requests. The limit is currently 4000 file requests total."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum DeleteAllClosedFileRequestsError {
DisabledForTeam,
NotFound,
NotAFolder,
AppLacksAccess,
NoPermission,
EmailUnverified,
ValidationError,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for DeleteAllClosedFileRequestsError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = DeleteAllClosedFileRequestsError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a DeleteAllClosedFileRequestsError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => DeleteAllClosedFileRequestsError::DisabledForTeam,
"not_found" => DeleteAllClosedFileRequestsError::NotFound,
"not_a_folder" => DeleteAllClosedFileRequestsError::NotAFolder,
"app_lacks_access" => DeleteAllClosedFileRequestsError::AppLacksAccess,
"no_permission" => DeleteAllClosedFileRequestsError::NoPermission,
"email_unverified" => DeleteAllClosedFileRequestsError::EmailUnverified,
"validation_error" => DeleteAllClosedFileRequestsError::ValidationError,
_ => DeleteAllClosedFileRequestsError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other",
"not_found",
"not_a_folder",
"app_lacks_access",
"no_permission",
"email_unverified",
"validation_error"];
deserializer.deserialize_struct("DeleteAllClosedFileRequestsError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for DeleteAllClosedFileRequestsError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
DeleteAllClosedFileRequestsError::DisabledForTeam => {
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
DeleteAllClosedFileRequestsError::NotFound => {
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?;
s.serialize_field(".tag", "not_found")?;
s.end()
}
DeleteAllClosedFileRequestsError::NotAFolder => {
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?;
s.serialize_field(".tag", "not_a_folder")?;
s.end()
}
DeleteAllClosedFileRequestsError::AppLacksAccess => {
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?;
s.serialize_field(".tag", "app_lacks_access")?;
s.end()
}
DeleteAllClosedFileRequestsError::NoPermission => {
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?;
s.serialize_field(".tag", "no_permission")?;
s.end()
}
DeleteAllClosedFileRequestsError::EmailUnverified => {
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?;
s.serialize_field(".tag", "email_unverified")?;
s.end()
}
DeleteAllClosedFileRequestsError::ValidationError => {
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsError", 1)?;
s.serialize_field(".tag", "validation_error")?;
s.end()
}
DeleteAllClosedFileRequestsError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for DeleteAllClosedFileRequestsError {
}
impl ::std::fmt::Display for DeleteAllClosedFileRequestsError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
DeleteAllClosedFileRequestsError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
DeleteAllClosedFileRequestsError::NotFound => f.write_str("This file request ID was not found."),
DeleteAllClosedFileRequestsError::NotAFolder => f.write_str("The specified path is not a folder."),
DeleteAllClosedFileRequestsError::AppLacksAccess => f.write_str("This file request is not accessible to this app. Apps with the app folder permission can only access file requests in their app folder."),
DeleteAllClosedFileRequestsError::NoPermission => f.write_str("This user doesn't have permission to access or modify this file request."),
DeleteAllClosedFileRequestsError::ValidationError => f.write_str("There was an error validating the request. For example, the title was invalid, or there were disallowed characters in the destination path."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct DeleteAllClosedFileRequestsResult {
pub file_requests: Vec<FileRequest>,
}
impl DeleteAllClosedFileRequestsResult {
pub fn new(file_requests: Vec<FileRequest>) -> Self {
DeleteAllClosedFileRequestsResult {
file_requests,
}
}
}
const DELETE_ALL_CLOSED_FILE_REQUESTS_RESULT_FIELDS: &[&str] = &["file_requests"];
impl DeleteAllClosedFileRequestsResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<DeleteAllClosedFileRequestsResult, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<DeleteAllClosedFileRequestsResult>, V::Error> {
let mut field_file_requests = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"file_requests" => {
if field_file_requests.is_some() {
return Err(::serde::de::Error::duplicate_field("file_requests"));
}
field_file_requests = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = DeleteAllClosedFileRequestsResult {
file_requests: field_file_requests.ok_or_else(|| ::serde::de::Error::missing_field("file_requests"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("file_requests", &self.file_requests)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for DeleteAllClosedFileRequestsResult {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = DeleteAllClosedFileRequestsResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a DeleteAllClosedFileRequestsResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
DeleteAllClosedFileRequestsResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("DeleteAllClosedFileRequestsResult", DELETE_ALL_CLOSED_FILE_REQUESTS_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for DeleteAllClosedFileRequestsResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("DeleteAllClosedFileRequestsResult", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct DeleteFileRequestArgs {
pub ids: Vec<FileRequestId>,
}
impl DeleteFileRequestArgs {
pub fn new(ids: Vec<FileRequestId>) -> Self {
DeleteFileRequestArgs {
ids,
}
}
}
const DELETE_FILE_REQUEST_ARGS_FIELDS: &[&str] = &["ids"];
impl DeleteFileRequestArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<DeleteFileRequestArgs, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<DeleteFileRequestArgs>, V::Error> {
let mut field_ids = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"ids" => {
if field_ids.is_some() {
return Err(::serde::de::Error::duplicate_field("ids"));
}
field_ids = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = DeleteFileRequestArgs {
ids: field_ids.ok_or_else(|| ::serde::de::Error::missing_field("ids"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("ids", &self.ids)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for DeleteFileRequestArgs {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = DeleteFileRequestArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a DeleteFileRequestArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
DeleteFileRequestArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("DeleteFileRequestArgs", DELETE_FILE_REQUEST_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for DeleteFileRequestArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("DeleteFileRequestArgs", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum DeleteFileRequestError {
DisabledForTeam,
NotFound,
NotAFolder,
AppLacksAccess,
NoPermission,
EmailUnverified,
ValidationError,
FileRequestOpen,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for DeleteFileRequestError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = DeleteFileRequestError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a DeleteFileRequestError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => DeleteFileRequestError::DisabledForTeam,
"not_found" => DeleteFileRequestError::NotFound,
"not_a_folder" => DeleteFileRequestError::NotAFolder,
"app_lacks_access" => DeleteFileRequestError::AppLacksAccess,
"no_permission" => DeleteFileRequestError::NoPermission,
"email_unverified" => DeleteFileRequestError::EmailUnverified,
"validation_error" => DeleteFileRequestError::ValidationError,
"file_request_open" => DeleteFileRequestError::FileRequestOpen,
_ => DeleteFileRequestError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other",
"not_found",
"not_a_folder",
"app_lacks_access",
"no_permission",
"email_unverified",
"validation_error",
"file_request_open"];
deserializer.deserialize_struct("DeleteFileRequestError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for DeleteFileRequestError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
DeleteFileRequestError::DisabledForTeam => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
DeleteFileRequestError::NotFound => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "not_found")?;
s.end()
}
DeleteFileRequestError::NotAFolder => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "not_a_folder")?;
s.end()
}
DeleteFileRequestError::AppLacksAccess => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "app_lacks_access")?;
s.end()
}
DeleteFileRequestError::NoPermission => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "no_permission")?;
s.end()
}
DeleteFileRequestError::EmailUnverified => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "email_unverified")?;
s.end()
}
DeleteFileRequestError::ValidationError => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "validation_error")?;
s.end()
}
DeleteFileRequestError::FileRequestOpen => {
let mut s = serializer.serialize_struct("DeleteFileRequestError", 1)?;
s.serialize_field(".tag", "file_request_open")?;
s.end()
}
DeleteFileRequestError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for DeleteFileRequestError {
}
impl ::std::fmt::Display for DeleteFileRequestError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
DeleteFileRequestError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
DeleteFileRequestError::NotFound => f.write_str("This file request ID was not found."),
DeleteFileRequestError::NotAFolder => f.write_str("The specified path is not a folder."),
DeleteFileRequestError::AppLacksAccess => f.write_str("This file request is not accessible to this app. Apps with the app folder permission can only access file requests in their app folder."),
DeleteFileRequestError::NoPermission => f.write_str("This user doesn't have permission to access or modify this file request."),
DeleteFileRequestError::ValidationError => f.write_str("There was an error validating the request. For example, the title was invalid, or there were disallowed characters in the destination path."),
DeleteFileRequestError::FileRequestOpen => f.write_str("One or more file requests currently open."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct DeleteFileRequestsResult {
pub file_requests: Vec<FileRequest>,
}
impl DeleteFileRequestsResult {
pub fn new(file_requests: Vec<FileRequest>) -> Self {
DeleteFileRequestsResult {
file_requests,
}
}
}
const DELETE_FILE_REQUESTS_RESULT_FIELDS: &[&str] = &["file_requests"];
impl DeleteFileRequestsResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<DeleteFileRequestsResult, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<DeleteFileRequestsResult>, V::Error> {
let mut field_file_requests = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"file_requests" => {
if field_file_requests.is_some() {
return Err(::serde::de::Error::duplicate_field("file_requests"));
}
field_file_requests = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = DeleteFileRequestsResult {
file_requests: field_file_requests.ok_or_else(|| ::serde::de::Error::missing_field("file_requests"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("file_requests", &self.file_requests)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for DeleteFileRequestsResult {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = DeleteFileRequestsResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a DeleteFileRequestsResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
DeleteFileRequestsResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("DeleteFileRequestsResult", DELETE_FILE_REQUESTS_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for DeleteFileRequestsResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("DeleteFileRequestsResult", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct FileRequest {
pub id: FileRequestId,
pub url: String,
pub title: String,
pub created: crate::common::DropboxTimestamp,
pub is_open: bool,
pub file_count: i64,
pub destination: Option<crate::files::Path>,
pub deadline: Option<FileRequestDeadline>,
pub description: Option<String>,
}
impl FileRequest {
pub fn new(
id: FileRequestId,
url: String,
title: String,
created: crate::common::DropboxTimestamp,
is_open: bool,
file_count: i64,
) -> Self {
FileRequest {
id,
url,
title,
created,
is_open,
file_count,
destination: None,
deadline: None,
description: None,
}
}
pub fn with_destination(mut self, value: crate::files::Path) -> Self {
self.destination = Some(value);
self
}
pub fn with_deadline(mut self, value: FileRequestDeadline) -> Self {
self.deadline = Some(value);
self
}
pub fn with_description(mut self, value: String) -> Self {
self.description = Some(value);
self
}
}
const FILE_REQUEST_FIELDS: &[&str] = &["id",
"url",
"title",
"created",
"is_open",
"file_count",
"destination",
"deadline",
"description"];
impl FileRequest {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<FileRequest, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<FileRequest>, V::Error> {
let mut field_id = None;
let mut field_url = None;
let mut field_title = None;
let mut field_created = None;
let mut field_is_open = None;
let mut field_file_count = None;
let mut field_destination = None;
let mut field_deadline = None;
let mut field_description = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"id" => {
if field_id.is_some() {
return Err(::serde::de::Error::duplicate_field("id"));
}
field_id = Some(map.next_value()?);
}
"url" => {
if field_url.is_some() {
return Err(::serde::de::Error::duplicate_field("url"));
}
field_url = Some(map.next_value()?);
}
"title" => {
if field_title.is_some() {
return Err(::serde::de::Error::duplicate_field("title"));
}
field_title = Some(map.next_value()?);
}
"created" => {
if field_created.is_some() {
return Err(::serde::de::Error::duplicate_field("created"));
}
field_created = Some(map.next_value()?);
}
"is_open" => {
if field_is_open.is_some() {
return Err(::serde::de::Error::duplicate_field("is_open"));
}
field_is_open = Some(map.next_value()?);
}
"file_count" => {
if field_file_count.is_some() {
return Err(::serde::de::Error::duplicate_field("file_count"));
}
field_file_count = Some(map.next_value()?);
}
"destination" => {
if field_destination.is_some() {
return Err(::serde::de::Error::duplicate_field("destination"));
}
field_destination = Some(map.next_value()?);
}
"deadline" => {
if field_deadline.is_some() {
return Err(::serde::de::Error::duplicate_field("deadline"));
}
field_deadline = Some(map.next_value()?);
}
"description" => {
if field_description.is_some() {
return Err(::serde::de::Error::duplicate_field("description"));
}
field_description = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = FileRequest {
id: field_id.ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
url: field_url.ok_or_else(|| ::serde::de::Error::missing_field("url"))?,
title: field_title.ok_or_else(|| ::serde::de::Error::missing_field("title"))?,
created: field_created.ok_or_else(|| ::serde::de::Error::missing_field("created"))?,
is_open: field_is_open.ok_or_else(|| ::serde::de::Error::missing_field("is_open"))?,
file_count: field_file_count.ok_or_else(|| ::serde::de::Error::missing_field("file_count"))?,
destination: field_destination,
deadline: field_deadline,
description: field_description,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("id", &self.id)?;
s.serialize_field("url", &self.url)?;
s.serialize_field("title", &self.title)?;
s.serialize_field("created", &self.created)?;
s.serialize_field("is_open", &self.is_open)?;
s.serialize_field("file_count", &self.file_count)?;
if let Some(val) = &self.destination {
s.serialize_field("destination", val)?;
}
if let Some(val) = &self.deadline {
s.serialize_field("deadline", val)?;
}
if let Some(val) = &self.description {
s.serialize_field("description", val)?;
}
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for FileRequest {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = FileRequest;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a FileRequest struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
FileRequest::internal_deserialize(map)
}
}
deserializer.deserialize_struct("FileRequest", FILE_REQUEST_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for FileRequest {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("FileRequest", 9)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct FileRequestDeadline {
pub deadline: crate::common::DropboxTimestamp,
pub allow_late_uploads: Option<GracePeriod>,
}
impl FileRequestDeadline {
pub fn new(deadline: crate::common::DropboxTimestamp) -> Self {
FileRequestDeadline {
deadline,
allow_late_uploads: None,
}
}
pub fn with_allow_late_uploads(mut self, value: GracePeriod) -> Self {
self.allow_late_uploads = Some(value);
self
}
}
const FILE_REQUEST_DEADLINE_FIELDS: &[&str] = &["deadline",
"allow_late_uploads"];
impl FileRequestDeadline {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<FileRequestDeadline, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<FileRequestDeadline>, V::Error> {
let mut field_deadline = None;
let mut field_allow_late_uploads = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"deadline" => {
if field_deadline.is_some() {
return Err(::serde::de::Error::duplicate_field("deadline"));
}
field_deadline = Some(map.next_value()?);
}
"allow_late_uploads" => {
if field_allow_late_uploads.is_some() {
return Err(::serde::de::Error::duplicate_field("allow_late_uploads"));
}
field_allow_late_uploads = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = FileRequestDeadline {
deadline: field_deadline.ok_or_else(|| ::serde::de::Error::missing_field("deadline"))?,
allow_late_uploads: field_allow_late_uploads,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("deadline", &self.deadline)?;
if let Some(val) = &self.allow_late_uploads {
s.serialize_field("allow_late_uploads", val)?;
}
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for FileRequestDeadline {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = FileRequestDeadline;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a FileRequestDeadline struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
FileRequestDeadline::internal_deserialize(map)
}
}
deserializer.deserialize_struct("FileRequestDeadline", FILE_REQUEST_DEADLINE_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for FileRequestDeadline {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("FileRequestDeadline", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum FileRequestError {
DisabledForTeam,
NotFound,
NotAFolder,
AppLacksAccess,
NoPermission,
EmailUnverified,
ValidationError,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for FileRequestError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = FileRequestError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a FileRequestError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => FileRequestError::DisabledForTeam,
"not_found" => FileRequestError::NotFound,
"not_a_folder" => FileRequestError::NotAFolder,
"app_lacks_access" => FileRequestError::AppLacksAccess,
"no_permission" => FileRequestError::NoPermission,
"email_unverified" => FileRequestError::EmailUnverified,
"validation_error" => FileRequestError::ValidationError,
_ => FileRequestError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other",
"not_found",
"not_a_folder",
"app_lacks_access",
"no_permission",
"email_unverified",
"validation_error"];
deserializer.deserialize_struct("FileRequestError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for FileRequestError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
FileRequestError::DisabledForTeam => {
let mut s = serializer.serialize_struct("FileRequestError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
FileRequestError::NotFound => {
let mut s = serializer.serialize_struct("FileRequestError", 1)?;
s.serialize_field(".tag", "not_found")?;
s.end()
}
FileRequestError::NotAFolder => {
let mut s = serializer.serialize_struct("FileRequestError", 1)?;
s.serialize_field(".tag", "not_a_folder")?;
s.end()
}
FileRequestError::AppLacksAccess => {
let mut s = serializer.serialize_struct("FileRequestError", 1)?;
s.serialize_field(".tag", "app_lacks_access")?;
s.end()
}
FileRequestError::NoPermission => {
let mut s = serializer.serialize_struct("FileRequestError", 1)?;
s.serialize_field(".tag", "no_permission")?;
s.end()
}
FileRequestError::EmailUnverified => {
let mut s = serializer.serialize_struct("FileRequestError", 1)?;
s.serialize_field(".tag", "email_unverified")?;
s.end()
}
FileRequestError::ValidationError => {
let mut s = serializer.serialize_struct("FileRequestError", 1)?;
s.serialize_field(".tag", "validation_error")?;
s.end()
}
FileRequestError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for FileRequestError {
}
impl ::std::fmt::Display for FileRequestError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
FileRequestError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
FileRequestError::NotFound => f.write_str("This file request ID was not found."),
FileRequestError::NotAFolder => f.write_str("The specified path is not a folder."),
FileRequestError::AppLacksAccess => f.write_str("This file request is not accessible to this app. Apps with the app folder permission can only access file requests in their app folder."),
FileRequestError::NoPermission => f.write_str("This user doesn't have permission to access or modify this file request."),
FileRequestError::ValidationError => f.write_str("There was an error validating the request. For example, the title was invalid, or there were disallowed characters in the destination path."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum GeneralFileRequestsError {
DisabledForTeam,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for GeneralFileRequestsError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = GeneralFileRequestsError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a GeneralFileRequestsError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => GeneralFileRequestsError::DisabledForTeam,
_ => GeneralFileRequestsError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other"];
deserializer.deserialize_struct("GeneralFileRequestsError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for GeneralFileRequestsError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
GeneralFileRequestsError::DisabledForTeam => {
let mut s = serializer.serialize_struct("GeneralFileRequestsError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
GeneralFileRequestsError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for GeneralFileRequestsError {
}
impl ::std::fmt::Display for GeneralFileRequestsError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
GeneralFileRequestsError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct GetFileRequestArgs {
pub id: FileRequestId,
}
impl GetFileRequestArgs {
pub fn new(id: FileRequestId) -> Self {
GetFileRequestArgs {
id,
}
}
}
const GET_FILE_REQUEST_ARGS_FIELDS: &[&str] = &["id"];
impl GetFileRequestArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<GetFileRequestArgs, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<GetFileRequestArgs>, V::Error> {
let mut field_id = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"id" => {
if field_id.is_some() {
return Err(::serde::de::Error::duplicate_field("id"));
}
field_id = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = GetFileRequestArgs {
id: field_id.ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("id", &self.id)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for GetFileRequestArgs {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = GetFileRequestArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a GetFileRequestArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
GetFileRequestArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("GetFileRequestArgs", GET_FILE_REQUEST_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for GetFileRequestArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("GetFileRequestArgs", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum GetFileRequestError {
DisabledForTeam,
NotFound,
NotAFolder,
AppLacksAccess,
NoPermission,
EmailUnverified,
ValidationError,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for GetFileRequestError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = GetFileRequestError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a GetFileRequestError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => GetFileRequestError::DisabledForTeam,
"not_found" => GetFileRequestError::NotFound,
"not_a_folder" => GetFileRequestError::NotAFolder,
"app_lacks_access" => GetFileRequestError::AppLacksAccess,
"no_permission" => GetFileRequestError::NoPermission,
"email_unverified" => GetFileRequestError::EmailUnverified,
"validation_error" => GetFileRequestError::ValidationError,
_ => GetFileRequestError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other",
"not_found",
"not_a_folder",
"app_lacks_access",
"no_permission",
"email_unverified",
"validation_error"];
deserializer.deserialize_struct("GetFileRequestError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for GetFileRequestError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
GetFileRequestError::DisabledForTeam => {
let mut s = serializer.serialize_struct("GetFileRequestError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
GetFileRequestError::NotFound => {
let mut s = serializer.serialize_struct("GetFileRequestError", 1)?;
s.serialize_field(".tag", "not_found")?;
s.end()
}
GetFileRequestError::NotAFolder => {
let mut s = serializer.serialize_struct("GetFileRequestError", 1)?;
s.serialize_field(".tag", "not_a_folder")?;
s.end()
}
GetFileRequestError::AppLacksAccess => {
let mut s = serializer.serialize_struct("GetFileRequestError", 1)?;
s.serialize_field(".tag", "app_lacks_access")?;
s.end()
}
GetFileRequestError::NoPermission => {
let mut s = serializer.serialize_struct("GetFileRequestError", 1)?;
s.serialize_field(".tag", "no_permission")?;
s.end()
}
GetFileRequestError::EmailUnverified => {
let mut s = serializer.serialize_struct("GetFileRequestError", 1)?;
s.serialize_field(".tag", "email_unverified")?;
s.end()
}
GetFileRequestError::ValidationError => {
let mut s = serializer.serialize_struct("GetFileRequestError", 1)?;
s.serialize_field(".tag", "validation_error")?;
s.end()
}
GetFileRequestError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for GetFileRequestError {
}
impl ::std::fmt::Display for GetFileRequestError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
GetFileRequestError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
GetFileRequestError::NotFound => f.write_str("This file request ID was not found."),
GetFileRequestError::NotAFolder => f.write_str("The specified path is not a folder."),
GetFileRequestError::AppLacksAccess => f.write_str("This file request is not accessible to this app. Apps with the app folder permission can only access file requests in their app folder."),
GetFileRequestError::NoPermission => f.write_str("This user doesn't have permission to access or modify this file request."),
GetFileRequestError::ValidationError => f.write_str("There was an error validating the request. For example, the title was invalid, or there were disallowed characters in the destination path."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum GracePeriod {
OneDay,
TwoDays,
SevenDays,
ThirtyDays,
Always,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for GracePeriod {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = GracePeriod;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a GracePeriod structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"one_day" => GracePeriod::OneDay,
"two_days" => GracePeriod::TwoDays,
"seven_days" => GracePeriod::SevenDays,
"thirty_days" => GracePeriod::ThirtyDays,
"always" => GracePeriod::Always,
_ => GracePeriod::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["one_day",
"two_days",
"seven_days",
"thirty_days",
"always",
"other"];
deserializer.deserialize_struct("GracePeriod", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for GracePeriod {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
GracePeriod::OneDay => {
let mut s = serializer.serialize_struct("GracePeriod", 1)?;
s.serialize_field(".tag", "one_day")?;
s.end()
}
GracePeriod::TwoDays => {
let mut s = serializer.serialize_struct("GracePeriod", 1)?;
s.serialize_field(".tag", "two_days")?;
s.end()
}
GracePeriod::SevenDays => {
let mut s = serializer.serialize_struct("GracePeriod", 1)?;
s.serialize_field(".tag", "seven_days")?;
s.end()
}
GracePeriod::ThirtyDays => {
let mut s = serializer.serialize_struct("GracePeriod", 1)?;
s.serialize_field(".tag", "thirty_days")?;
s.end()
}
GracePeriod::Always => {
let mut s = serializer.serialize_struct("GracePeriod", 1)?;
s.serialize_field(".tag", "always")?;
s.end()
}
GracePeriod::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct ListFileRequestsArg {
pub limit: u64,
}
impl Default for ListFileRequestsArg {
fn default() -> Self {
ListFileRequestsArg {
limit: 1000,
}
}
}
impl ListFileRequestsArg {
pub fn with_limit(mut self, value: u64) -> Self {
self.limit = value;
self
}
}
const LIST_FILE_REQUESTS_ARG_FIELDS: &[&str] = &["limit"];
impl ListFileRequestsArg {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
) -> Result<ListFileRequestsArg, V::Error> {
let mut field_limit = None;
while let Some(key) = map.next_key::<&str>()? {
match key {
"limit" => {
if field_limit.is_some() {
return Err(::serde::de::Error::duplicate_field("limit"));
}
field_limit = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
let result = ListFileRequestsArg {
limit: field_limit.unwrap_or(1000),
};
Ok(result)
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("limit", &self.limit)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListFileRequestsArg {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = ListFileRequestsArg;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListFileRequestsArg struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListFileRequestsArg::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListFileRequestsArg", LIST_FILE_REQUESTS_ARG_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListFileRequestsArg {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListFileRequestsArg", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct ListFileRequestsContinueArg {
pub cursor: String,
}
impl ListFileRequestsContinueArg {
pub fn new(cursor: String) -> Self {
ListFileRequestsContinueArg {
cursor,
}
}
}
const LIST_FILE_REQUESTS_CONTINUE_ARG_FIELDS: &[&str] = &["cursor"];
impl ListFileRequestsContinueArg {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListFileRequestsContinueArg, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<ListFileRequestsContinueArg>, V::Error> {
let mut field_cursor = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"cursor" => {
if field_cursor.is_some() {
return Err(::serde::de::Error::duplicate_field("cursor"));
}
field_cursor = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = ListFileRequestsContinueArg {
cursor: field_cursor.ok_or_else(|| ::serde::de::Error::missing_field("cursor"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("cursor", &self.cursor)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListFileRequestsContinueArg {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = ListFileRequestsContinueArg;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListFileRequestsContinueArg struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListFileRequestsContinueArg::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListFileRequestsContinueArg", LIST_FILE_REQUESTS_CONTINUE_ARG_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListFileRequestsContinueArg {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListFileRequestsContinueArg", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum ListFileRequestsContinueError {
DisabledForTeam,
InvalidCursor,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ListFileRequestsContinueError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = ListFileRequestsContinueError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListFileRequestsContinueError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => ListFileRequestsContinueError::DisabledForTeam,
"invalid_cursor" => ListFileRequestsContinueError::InvalidCursor,
_ => ListFileRequestsContinueError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other",
"invalid_cursor"];
deserializer.deserialize_struct("ListFileRequestsContinueError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ListFileRequestsContinueError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ListFileRequestsContinueError::DisabledForTeam => {
let mut s = serializer.serialize_struct("ListFileRequestsContinueError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
ListFileRequestsContinueError::InvalidCursor => {
let mut s = serializer.serialize_struct("ListFileRequestsContinueError", 1)?;
s.serialize_field(".tag", "invalid_cursor")?;
s.end()
}
ListFileRequestsContinueError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for ListFileRequestsContinueError {
}
impl ::std::fmt::Display for ListFileRequestsContinueError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
ListFileRequestsContinueError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
ListFileRequestsContinueError::InvalidCursor => f.write_str("The cursor is invalid."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum ListFileRequestsError {
DisabledForTeam,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ListFileRequestsError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = ListFileRequestsError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListFileRequestsError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => ListFileRequestsError::DisabledForTeam,
_ => ListFileRequestsError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other"];
deserializer.deserialize_struct("ListFileRequestsError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ListFileRequestsError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ListFileRequestsError::DisabledForTeam => {
let mut s = serializer.serialize_struct("ListFileRequestsError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
ListFileRequestsError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for ListFileRequestsError {
}
impl ::std::fmt::Display for ListFileRequestsError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
ListFileRequestsError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
_ => write!(f, "{:?}", *self),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct ListFileRequestsResult {
pub file_requests: Vec<FileRequest>,
}
impl ListFileRequestsResult {
pub fn new(file_requests: Vec<FileRequest>) -> Self {
ListFileRequestsResult {
file_requests,
}
}
}
const LIST_FILE_REQUESTS_RESULT_FIELDS: &[&str] = &["file_requests"];
impl ListFileRequestsResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListFileRequestsResult, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<ListFileRequestsResult>, V::Error> {
let mut field_file_requests = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"file_requests" => {
if field_file_requests.is_some() {
return Err(::serde::de::Error::duplicate_field("file_requests"));
}
field_file_requests = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = ListFileRequestsResult {
file_requests: field_file_requests.ok_or_else(|| ::serde::de::Error::missing_field("file_requests"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("file_requests", &self.file_requests)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListFileRequestsResult {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = ListFileRequestsResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListFileRequestsResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListFileRequestsResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListFileRequestsResult", LIST_FILE_REQUESTS_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListFileRequestsResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListFileRequestsResult", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct ListFileRequestsV2Result {
pub file_requests: Vec<FileRequest>,
pub cursor: String,
pub has_more: bool,
}
impl ListFileRequestsV2Result {
pub fn new(file_requests: Vec<FileRequest>, cursor: String, has_more: bool) -> Self {
ListFileRequestsV2Result {
file_requests,
cursor,
has_more,
}
}
}
const LIST_FILE_REQUESTS_V2_RESULT_FIELDS: &[&str] = &["file_requests",
"cursor",
"has_more"];
impl ListFileRequestsV2Result {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListFileRequestsV2Result, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<ListFileRequestsV2Result>, V::Error> {
let mut field_file_requests = None;
let mut field_cursor = None;
let mut field_has_more = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"file_requests" => {
if field_file_requests.is_some() {
return Err(::serde::de::Error::duplicate_field("file_requests"));
}
field_file_requests = Some(map.next_value()?);
}
"cursor" => {
if field_cursor.is_some() {
return Err(::serde::de::Error::duplicate_field("cursor"));
}
field_cursor = Some(map.next_value()?);
}
"has_more" => {
if field_has_more.is_some() {
return Err(::serde::de::Error::duplicate_field("has_more"));
}
field_has_more = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = ListFileRequestsV2Result {
file_requests: field_file_requests.ok_or_else(|| ::serde::de::Error::missing_field("file_requests"))?,
cursor: field_cursor.ok_or_else(|| ::serde::de::Error::missing_field("cursor"))?,
has_more: field_has_more.ok_or_else(|| ::serde::de::Error::missing_field("has_more"))?,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("file_requests", &self.file_requests)?;
s.serialize_field("cursor", &self.cursor)?;
s.serialize_field("has_more", &self.has_more)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListFileRequestsV2Result {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = ListFileRequestsV2Result;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListFileRequestsV2Result struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListFileRequestsV2Result::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListFileRequestsV2Result", LIST_FILE_REQUESTS_V2_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListFileRequestsV2Result {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListFileRequestsV2Result", 3)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct UpdateFileRequestArgs {
pub id: FileRequestId,
pub title: Option<String>,
pub destination: Option<crate::files::Path>,
pub deadline: UpdateFileRequestDeadline,
pub open: Option<bool>,
pub description: Option<String>,
}
impl UpdateFileRequestArgs {
pub fn new(id: FileRequestId) -> Self {
UpdateFileRequestArgs {
id,
title: None,
destination: None,
deadline: UpdateFileRequestDeadline::NoUpdate,
open: None,
description: None,
}
}
pub fn with_title(mut self, value: String) -> Self {
self.title = Some(value);
self
}
pub fn with_destination(mut self, value: crate::files::Path) -> Self {
self.destination = Some(value);
self
}
pub fn with_deadline(mut self, value: UpdateFileRequestDeadline) -> Self {
self.deadline = value;
self
}
pub fn with_open(mut self, value: bool) -> Self {
self.open = Some(value);
self
}
pub fn with_description(mut self, value: String) -> Self {
self.description = Some(value);
self
}
}
const UPDATE_FILE_REQUEST_ARGS_FIELDS: &[&str] = &["id",
"title",
"destination",
"deadline",
"open",
"description"];
impl UpdateFileRequestArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<UpdateFileRequestArgs, V::Error> {
Self::internal_deserialize_opt(map, false).map(Option::unwrap)
}
pub(crate) fn internal_deserialize_opt<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
optional: bool,
) -> Result<Option<UpdateFileRequestArgs>, V::Error> {
let mut field_id = None;
let mut field_title = None;
let mut field_destination = None;
let mut field_deadline = None;
let mut field_open = None;
let mut field_description = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"id" => {
if field_id.is_some() {
return Err(::serde::de::Error::duplicate_field("id"));
}
field_id = Some(map.next_value()?);
}
"title" => {
if field_title.is_some() {
return Err(::serde::de::Error::duplicate_field("title"));
}
field_title = Some(map.next_value()?);
}
"destination" => {
if field_destination.is_some() {
return Err(::serde::de::Error::duplicate_field("destination"));
}
field_destination = Some(map.next_value()?);
}
"deadline" => {
if field_deadline.is_some() {
return Err(::serde::de::Error::duplicate_field("deadline"));
}
field_deadline = Some(map.next_value()?);
}
"open" => {
if field_open.is_some() {
return Err(::serde::de::Error::duplicate_field("open"));
}
field_open = Some(map.next_value()?);
}
"description" => {
if field_description.is_some() {
return Err(::serde::de::Error::duplicate_field("description"));
}
field_description = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = UpdateFileRequestArgs {
id: field_id.ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
title: field_title,
destination: field_destination,
deadline: field_deadline.unwrap_or(UpdateFileRequestDeadline::NoUpdate),
open: field_open,
description: field_description,
};
Ok(Some(result))
}
pub(crate) fn internal_serialize<S: ::serde::ser::Serializer>(
&self,
s: &mut S::SerializeStruct,
) -> Result<(), S::Error> {
use serde::ser::SerializeStruct;
s.serialize_field("id", &self.id)?;
if let Some(val) = &self.title {
s.serialize_field("title", val)?;
}
if let Some(val) = &self.destination {
s.serialize_field("destination", val)?;
}
s.serialize_field("deadline", &self.deadline)?;
if let Some(val) = &self.open {
s.serialize_field("open", val)?;
}
if let Some(val) = &self.description {
s.serialize_field("description", val)?;
}
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for UpdateFileRequestArgs {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{MapAccess, Visitor};
struct StructVisitor;
impl<'de> Visitor<'de> for StructVisitor {
type Value = UpdateFileRequestArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a UpdateFileRequestArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
UpdateFileRequestArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("UpdateFileRequestArgs", UPDATE_FILE_REQUEST_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for UpdateFileRequestArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("UpdateFileRequestArgs", 6)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum UpdateFileRequestDeadline {
NoUpdate,
Update(Option<FileRequestDeadline>),
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for UpdateFileRequestDeadline {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = UpdateFileRequestDeadline;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a UpdateFileRequestDeadline structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"no_update" => UpdateFileRequestDeadline::NoUpdate,
"update" => UpdateFileRequestDeadline::Update(FileRequestDeadline::internal_deserialize_opt(&mut map, true)?),
_ => UpdateFileRequestDeadline::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["no_update",
"update",
"other"];
deserializer.deserialize_struct("UpdateFileRequestDeadline", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for UpdateFileRequestDeadline {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
UpdateFileRequestDeadline::NoUpdate => {
let mut s = serializer.serialize_struct("UpdateFileRequestDeadline", 1)?;
s.serialize_field(".tag", "no_update")?;
s.end()
}
UpdateFileRequestDeadline::Update(ref x) => {
let n = if x.is_some() { 4 } else { 1 };
let mut s = serializer.serialize_struct("UpdateFileRequestDeadline", n)?;
s.serialize_field(".tag", "update")?;
if let Some(ref x) = x {
x.internal_serialize::<S>(&mut s)?;
}
s.end()
}
UpdateFileRequestDeadline::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum UpdateFileRequestError {
DisabledForTeam,
NotFound,
NotAFolder,
AppLacksAccess,
NoPermission,
EmailUnverified,
ValidationError,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for UpdateFileRequestError {
fn deserialize<D: ::serde::de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
use serde::de::{self, MapAccess, Visitor};
struct EnumVisitor;
impl<'de> Visitor<'de> for EnumVisitor {
type Value = UpdateFileRequestError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a UpdateFileRequestError structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled_for_team" => UpdateFileRequestError::DisabledForTeam,
"not_found" => UpdateFileRequestError::NotFound,
"not_a_folder" => UpdateFileRequestError::NotAFolder,
"app_lacks_access" => UpdateFileRequestError::AppLacksAccess,
"no_permission" => UpdateFileRequestError::NoPermission,
"email_unverified" => UpdateFileRequestError::EmailUnverified,
"validation_error" => UpdateFileRequestError::ValidationError,
_ => UpdateFileRequestError::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled_for_team",
"other",
"not_found",
"not_a_folder",
"app_lacks_access",
"no_permission",
"email_unverified",
"validation_error"];
deserializer.deserialize_struct("UpdateFileRequestError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for UpdateFileRequestError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
UpdateFileRequestError::DisabledForTeam => {
let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?;
s.serialize_field(".tag", "disabled_for_team")?;
s.end()
}
UpdateFileRequestError::NotFound => {
let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?;
s.serialize_field(".tag", "not_found")?;
s.end()
}
UpdateFileRequestError::NotAFolder => {
let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?;
s.serialize_field(".tag", "not_a_folder")?;
s.end()
}
UpdateFileRequestError::AppLacksAccess => {
let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?;
s.serialize_field(".tag", "app_lacks_access")?;
s.end()
}
UpdateFileRequestError::NoPermission => {
let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?;
s.serialize_field(".tag", "no_permission")?;
s.end()
}
UpdateFileRequestError::EmailUnverified => {
let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?;
s.serialize_field(".tag", "email_unverified")?;
s.end()
}
UpdateFileRequestError::ValidationError => {
let mut s = serializer.serialize_struct("UpdateFileRequestError", 1)?;
s.serialize_field(".tag", "validation_error")?;
s.end()
}
UpdateFileRequestError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for UpdateFileRequestError {
}
impl ::std::fmt::Display for UpdateFileRequestError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
UpdateFileRequestError::DisabledForTeam => f.write_str("This user's Dropbox Business team doesn't allow file requests."),
UpdateFileRequestError::NotFound => f.write_str("This file request ID was not found."),
UpdateFileRequestError::NotAFolder => f.write_str("The specified path is not a folder."),
UpdateFileRequestError::AppLacksAccess => f.write_str("This file request is not accessible to this app. Apps with the app folder permission can only access file requests in their app folder."),
UpdateFileRequestError::NoPermission => f.write_str("This user doesn't have permission to access or modify this file request."),
UpdateFileRequestError::ValidationError => f.write_str("There was an error validating the request. For example, the title was invalid, or there were disallowed characters in the destination path."),
_ => write!(f, "{:?}", *self),
}
}
}