#![allow(
clippy::too_many_arguments,
clippy::large_enum_variant,
clippy::doc_markdown,
)]
pub type PaperDocId = String;
pub fn docs_archive(
client: &impl crate::client_trait::UserAuthClient,
arg: &RefPaperDoc,
) -> crate::Result<Result<(), DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/archive",
arg,
None)
}
pub fn docs_create(
client: &impl crate::client_trait::UserAuthClient,
arg: &PaperDocCreateArgs,
body: &[u8],
) -> crate::Result<Result<PaperDocCreateUpdateResult, PaperDocCreateError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Upload,
"paper/docs/create",
arg,
Some(body))
}
pub fn docs_download(
client: &impl crate::client_trait::UserAuthClient,
arg: &PaperDocExport,
range_start: Option<u64>,
range_end: Option<u64>,
) -> crate::Result<Result<crate::client_trait::HttpRequestResult<PaperDocExportResult>, DocLookupError>> {
crate::client_helpers::request_with_body(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Download,
"paper/docs/download",
arg,
None,
range_start,
range_end)
}
pub fn docs_folder_users_list(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListUsersOnFolderArgs,
) -> crate::Result<Result<ListUsersOnFolderResponse, DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/folder_users/list",
arg,
None)
}
pub fn docs_folder_users_list_continue(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListUsersOnFolderContinueArgs,
) -> crate::Result<Result<ListUsersOnFolderResponse, ListUsersCursorError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/folder_users/list/continue",
arg,
None)
}
pub fn docs_get_folder_info(
client: &impl crate::client_trait::UserAuthClient,
arg: &RefPaperDoc,
) -> crate::Result<Result<FoldersContainingPaperDoc, DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/get_folder_info",
arg,
None)
}
pub fn docs_list(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListPaperDocsArgs,
) -> crate::Result<Result<ListPaperDocsResponse, ()>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/list",
arg,
None)
}
pub fn docs_list_continue(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListPaperDocsContinueArgs,
) -> crate::Result<Result<ListPaperDocsResponse, ListDocsCursorError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/list/continue",
arg,
None)
}
pub fn docs_permanently_delete(
client: &impl crate::client_trait::UserAuthClient,
arg: &RefPaperDoc,
) -> crate::Result<Result<(), DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/permanently_delete",
arg,
None)
}
pub fn docs_sharing_policy_get(
client: &impl crate::client_trait::UserAuthClient,
arg: &RefPaperDoc,
) -> crate::Result<Result<SharingPolicy, DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/sharing_policy/get",
arg,
None)
}
pub fn docs_sharing_policy_set(
client: &impl crate::client_trait::UserAuthClient,
arg: &PaperDocSharingPolicy,
) -> crate::Result<Result<(), DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/sharing_policy/set",
arg,
None)
}
pub fn docs_update(
client: &impl crate::client_trait::UserAuthClient,
arg: &PaperDocUpdateArgs,
body: &[u8],
) -> crate::Result<Result<PaperDocCreateUpdateResult, PaperDocUpdateError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Upload,
"paper/docs/update",
arg,
Some(body))
}
pub fn docs_users_add(
client: &impl crate::client_trait::UserAuthClient,
arg: &AddPaperDocUser,
) -> crate::Result<Result<Vec<AddPaperDocUserMemberResult>, DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/users/add",
arg,
None)
}
pub fn docs_users_list(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListUsersOnPaperDocArgs,
) -> crate::Result<Result<ListUsersOnPaperDocResponse, DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/users/list",
arg,
None)
}
pub fn docs_users_list_continue(
client: &impl crate::client_trait::UserAuthClient,
arg: &ListUsersOnPaperDocContinueArgs,
) -> crate::Result<Result<ListUsersOnPaperDocResponse, ListUsersCursorError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/users/list/continue",
arg,
None)
}
pub fn docs_users_remove(
client: &impl crate::client_trait::UserAuthClient,
arg: &RemovePaperDocUser,
) -> crate::Result<Result<(), DocLookupError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/docs/users/remove",
arg,
None)
}
pub fn folders_create(
client: &impl crate::client_trait::UserAuthClient,
arg: &PaperFolderCreateArg,
) -> crate::Result<Result<PaperFolderCreateResult, PaperFolderCreateError>> {
crate::client_helpers::request(
client,
crate::client_trait::Endpoint::Api,
crate::client_trait::Style::Rpc,
"paper/folders/create",
arg,
None)
}
#[derive(Debug)]
pub struct AddMember {
pub member: super::sharing::MemberSelector,
pub permission_level: PaperDocPermissionLevel,
}
impl AddMember {
pub fn new(member: super::sharing::MemberSelector) -> Self {
AddMember {
member,
permission_level: PaperDocPermissionLevel::Edit,
}
}
pub fn with_permission_level(mut self, value: PaperDocPermissionLevel) -> Self {
self.permission_level = value;
self
}
}
const ADD_MEMBER_FIELDS: &[&str] = &["member",
"permission_level"];
impl AddMember {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<AddMember, 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<AddMember>, V::Error> {
let mut field_member = None;
let mut field_permission_level = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"member" => {
if field_member.is_some() {
return Err(::serde::de::Error::duplicate_field("member"));
}
field_member = Some(map.next_value()?);
}
"permission_level" => {
if field_permission_level.is_some() {
return Err(::serde::de::Error::duplicate_field("permission_level"));
}
field_permission_level = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = AddMember {
member: field_member.ok_or_else(|| ::serde::de::Error::missing_field("member"))?,
permission_level: field_permission_level.unwrap_or(PaperDocPermissionLevel::Edit),
};
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("member", &self.member)?;
s.serialize_field("permission_level", &self.permission_level)
}
}
impl<'de> ::serde::de::Deserialize<'de> for AddMember {
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 = AddMember;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a AddMember struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
AddMember::internal_deserialize(map)
}
}
deserializer.deserialize_struct("AddMember", ADD_MEMBER_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for AddMember {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("AddMember", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct AddPaperDocUser {
pub doc_id: PaperDocId,
pub members: Vec<AddMember>,
pub custom_message: Option<String>,
pub quiet: bool,
}
impl AddPaperDocUser {
pub fn new(doc_id: PaperDocId, members: Vec<AddMember>) -> Self {
AddPaperDocUser {
doc_id,
members,
custom_message: None,
quiet: false,
}
}
pub fn with_custom_message(mut self, value: Option<String>) -> Self {
self.custom_message = value;
self
}
pub fn with_quiet(mut self, value: bool) -> Self {
self.quiet = value;
self
}
}
const ADD_PAPER_DOC_USER_FIELDS: &[&str] = &["doc_id",
"members",
"custom_message",
"quiet"];
impl AddPaperDocUser {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<AddPaperDocUser, 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<AddPaperDocUser>, V::Error> {
let mut field_doc_id = None;
let mut field_members = None;
let mut field_custom_message = None;
let mut field_quiet = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"members" => {
if field_members.is_some() {
return Err(::serde::de::Error::duplicate_field("members"));
}
field_members = Some(map.next_value()?);
}
"custom_message" => {
if field_custom_message.is_some() {
return Err(::serde::de::Error::duplicate_field("custom_message"));
}
field_custom_message = Some(map.next_value()?);
}
"quiet" => {
if field_quiet.is_some() {
return Err(::serde::de::Error::duplicate_field("quiet"));
}
field_quiet = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = AddPaperDocUser {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
members: field_members.ok_or_else(|| ::serde::de::Error::missing_field("members"))?,
custom_message: field_custom_message,
quiet: field_quiet.unwrap_or(false),
};
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("doc_id", &self.doc_id)?;
s.serialize_field("members", &self.members)?;
s.serialize_field("custom_message", &self.custom_message)?;
s.serialize_field("quiet", &self.quiet)
}
}
impl<'de> ::serde::de::Deserialize<'de> for AddPaperDocUser {
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 = AddPaperDocUser;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a AddPaperDocUser struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
AddPaperDocUser::internal_deserialize(map)
}
}
deserializer.deserialize_struct("AddPaperDocUser", ADD_PAPER_DOC_USER_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for AddPaperDocUser {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("AddPaperDocUser", 4)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct AddPaperDocUserMemberResult {
pub member: super::sharing::MemberSelector,
pub result: AddPaperDocUserResult,
}
impl AddPaperDocUserMemberResult {
pub fn new(member: super::sharing::MemberSelector, result: AddPaperDocUserResult) -> Self {
AddPaperDocUserMemberResult {
member,
result,
}
}
}
const ADD_PAPER_DOC_USER_MEMBER_RESULT_FIELDS: &[&str] = &["member",
"result"];
impl AddPaperDocUserMemberResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<AddPaperDocUserMemberResult, 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<AddPaperDocUserMemberResult>, V::Error> {
let mut field_member = None;
let mut field_result = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"member" => {
if field_member.is_some() {
return Err(::serde::de::Error::duplicate_field("member"));
}
field_member = Some(map.next_value()?);
}
"result" => {
if field_result.is_some() {
return Err(::serde::de::Error::duplicate_field("result"));
}
field_result = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = AddPaperDocUserMemberResult {
member: field_member.ok_or_else(|| ::serde::de::Error::missing_field("member"))?,
result: field_result.ok_or_else(|| ::serde::de::Error::missing_field("result"))?,
};
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("member", &self.member)?;
s.serialize_field("result", &self.result)
}
}
impl<'de> ::serde::de::Deserialize<'de> for AddPaperDocUserMemberResult {
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 = AddPaperDocUserMemberResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a AddPaperDocUserMemberResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
AddPaperDocUserMemberResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("AddPaperDocUserMemberResult", ADD_PAPER_DOC_USER_MEMBER_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for AddPaperDocUserMemberResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("AddPaperDocUserMemberResult", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum AddPaperDocUserResult {
Success,
UnknownError,
SharingOutsideTeamDisabled,
DailyLimitReached,
UserIsOwner,
FailedUserDataRetrieval,
PermissionAlreadyGranted,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for AddPaperDocUserResult {
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 = AddPaperDocUserResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a AddPaperDocUserResult 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"))
};
match tag {
"success" => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::Success)
}
"unknown_error" => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::UnknownError)
}
"sharing_outside_team_disabled" => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::SharingOutsideTeamDisabled)
}
"daily_limit_reached" => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::DailyLimitReached)
}
"user_is_owner" => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::UserIsOwner)
}
"failed_user_data_retrieval" => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::FailedUserDataRetrieval)
}
"permission_already_granted" => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::PermissionAlreadyGranted)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(AddPaperDocUserResult::Other)
}
}
}
}
const VARIANTS: &[&str] = &["success",
"unknown_error",
"sharing_outside_team_disabled",
"daily_limit_reached",
"user_is_owner",
"failed_user_data_retrieval",
"permission_already_granted",
"other"];
deserializer.deserialize_struct("AddPaperDocUserResult", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for AddPaperDocUserResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
AddPaperDocUserResult::Success => {
let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?;
s.serialize_field(".tag", "success")?;
s.end()
}
AddPaperDocUserResult::UnknownError => {
let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?;
s.serialize_field(".tag", "unknown_error")?;
s.end()
}
AddPaperDocUserResult::SharingOutsideTeamDisabled => {
let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?;
s.serialize_field(".tag", "sharing_outside_team_disabled")?;
s.end()
}
AddPaperDocUserResult::DailyLimitReached => {
let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?;
s.serialize_field(".tag", "daily_limit_reached")?;
s.end()
}
AddPaperDocUserResult::UserIsOwner => {
let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?;
s.serialize_field(".tag", "user_is_owner")?;
s.end()
}
AddPaperDocUserResult::FailedUserDataRetrieval => {
let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?;
s.serialize_field(".tag", "failed_user_data_retrieval")?;
s.end()
}
AddPaperDocUserResult::PermissionAlreadyGranted => {
let mut s = serializer.serialize_struct("AddPaperDocUserResult", 1)?;
s.serialize_field(".tag", "permission_already_granted")?;
s.end()
}
AddPaperDocUserResult::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub struct Cursor {
pub value: String,
pub expiration: Option<super::common::DropboxTimestamp>,
}
impl Cursor {
pub fn new(value: String) -> Self {
Cursor {
value,
expiration: None,
}
}
pub fn with_expiration(mut self, value: Option<super::common::DropboxTimestamp>) -> Self {
self.expiration = value;
self
}
}
const CURSOR_FIELDS: &[&str] = &["value",
"expiration"];
impl Cursor {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<Cursor, 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<Cursor>, V::Error> {
let mut field_value = None;
let mut field_expiration = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"value" => {
if field_value.is_some() {
return Err(::serde::de::Error::duplicate_field("value"));
}
field_value = Some(map.next_value()?);
}
"expiration" => {
if field_expiration.is_some() {
return Err(::serde::de::Error::duplicate_field("expiration"));
}
field_expiration = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = Cursor {
value: field_value.ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
expiration: field_expiration,
};
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("value", &self.value)?;
s.serialize_field("expiration", &self.expiration)
}
}
impl<'de> ::serde::de::Deserialize<'de> for Cursor {
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 = Cursor;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a Cursor struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
Cursor::internal_deserialize(map)
}
}
deserializer.deserialize_struct("Cursor", CURSOR_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for Cursor {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("Cursor", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum DocLookupError {
InsufficientPermissions,
DocNotFound,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for DocLookupError {
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 = DocLookupError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a DocLookupError 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"))
};
match tag {
"insufficient_permissions" => {
crate::eat_json_fields(&mut map)?;
Ok(DocLookupError::InsufficientPermissions)
}
"doc_not_found" => {
crate::eat_json_fields(&mut map)?;
Ok(DocLookupError::DocNotFound)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(DocLookupError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["insufficient_permissions",
"other",
"doc_not_found"];
deserializer.deserialize_struct("DocLookupError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for DocLookupError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
DocLookupError::InsufficientPermissions => {
let mut s = serializer.serialize_struct("DocLookupError", 1)?;
s.serialize_field(".tag", "insufficient_permissions")?;
s.end()
}
DocLookupError::DocNotFound => {
let mut s = serializer.serialize_struct("DocLookupError", 1)?;
s.serialize_field(".tag", "doc_not_found")?;
s.end()
}
DocLookupError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for DocLookupError {
fn description(&self) -> &str {
"DocLookupError"
}
}
impl ::std::fmt::Display for DocLookupError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub enum DocSubscriptionLevel {
Default,
Ignore,
Every,
NoEmail,
}
impl<'de> ::serde::de::Deserialize<'de> for DocSubscriptionLevel {
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 = DocSubscriptionLevel;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a DocSubscriptionLevel 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"))
};
match tag {
"default" => {
crate::eat_json_fields(&mut map)?;
Ok(DocSubscriptionLevel::Default)
}
"ignore" => {
crate::eat_json_fields(&mut map)?;
Ok(DocSubscriptionLevel::Ignore)
}
"every" => {
crate::eat_json_fields(&mut map)?;
Ok(DocSubscriptionLevel::Every)
}
"no_email" => {
crate::eat_json_fields(&mut map)?;
Ok(DocSubscriptionLevel::NoEmail)
}
_ => Err(de::Error::unknown_variant(tag, VARIANTS))
}
}
}
const VARIANTS: &[&str] = &["default",
"ignore",
"every",
"no_email"];
deserializer.deserialize_struct("DocSubscriptionLevel", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for DocSubscriptionLevel {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
DocSubscriptionLevel::Default => {
let mut s = serializer.serialize_struct("DocSubscriptionLevel", 1)?;
s.serialize_field(".tag", "default")?;
s.end()
}
DocSubscriptionLevel::Ignore => {
let mut s = serializer.serialize_struct("DocSubscriptionLevel", 1)?;
s.serialize_field(".tag", "ignore")?;
s.end()
}
DocSubscriptionLevel::Every => {
let mut s = serializer.serialize_struct("DocSubscriptionLevel", 1)?;
s.serialize_field(".tag", "every")?;
s.end()
}
DocSubscriptionLevel::NoEmail => {
let mut s = serializer.serialize_struct("DocSubscriptionLevel", 1)?;
s.serialize_field(".tag", "no_email")?;
s.end()
}
}
}
}
#[derive(Debug)]
pub enum ExportFormat {
Html,
Markdown,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ExportFormat {
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 = ExportFormat;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ExportFormat 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"))
};
match tag {
"html" => {
crate::eat_json_fields(&mut map)?;
Ok(ExportFormat::Html)
}
"markdown" => {
crate::eat_json_fields(&mut map)?;
Ok(ExportFormat::Markdown)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(ExportFormat::Other)
}
}
}
}
const VARIANTS: &[&str] = &["html",
"markdown",
"other"];
deserializer.deserialize_struct("ExportFormat", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ExportFormat {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ExportFormat::Html => {
let mut s = serializer.serialize_struct("ExportFormat", 1)?;
s.serialize_field(".tag", "html")?;
s.end()
}
ExportFormat::Markdown => {
let mut s = serializer.serialize_struct("ExportFormat", 1)?;
s.serialize_field(".tag", "markdown")?;
s.end()
}
ExportFormat::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub struct Folder {
pub id: String,
pub name: String,
}
impl Folder {
pub fn new(id: String, name: String) -> Self {
Folder {
id,
name,
}
}
}
const FOLDER_FIELDS: &[&str] = &["id",
"name"];
impl Folder {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<Folder, 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<Folder>, V::Error> {
let mut field_id = None;
let mut field_name = 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()?);
}
"name" => {
if field_name.is_some() {
return Err(::serde::de::Error::duplicate_field("name"));
}
field_name = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = Folder {
id: field_id.ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
name: field_name.ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
};
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("name", &self.name)
}
}
impl<'de> ::serde::de::Deserialize<'de> for Folder {
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 = Folder;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a Folder struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
Folder::internal_deserialize(map)
}
}
deserializer.deserialize_struct("Folder", FOLDER_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for Folder {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("Folder", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum FolderSharingPolicyType {
Team,
InviteOnly,
}
impl<'de> ::serde::de::Deserialize<'de> for FolderSharingPolicyType {
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 = FolderSharingPolicyType;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a FolderSharingPolicyType 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"))
};
match tag {
"team" => {
crate::eat_json_fields(&mut map)?;
Ok(FolderSharingPolicyType::Team)
}
"invite_only" => {
crate::eat_json_fields(&mut map)?;
Ok(FolderSharingPolicyType::InviteOnly)
}
_ => Err(de::Error::unknown_variant(tag, VARIANTS))
}
}
}
const VARIANTS: &[&str] = &["team",
"invite_only"];
deserializer.deserialize_struct("FolderSharingPolicyType", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for FolderSharingPolicyType {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
FolderSharingPolicyType::Team => {
let mut s = serializer.serialize_struct("FolderSharingPolicyType", 1)?;
s.serialize_field(".tag", "team")?;
s.end()
}
FolderSharingPolicyType::InviteOnly => {
let mut s = serializer.serialize_struct("FolderSharingPolicyType", 1)?;
s.serialize_field(".tag", "invite_only")?;
s.end()
}
}
}
}
#[derive(Debug)]
pub enum FolderSubscriptionLevel {
None,
ActivityOnly,
DailyEmails,
WeeklyEmails,
}
impl<'de> ::serde::de::Deserialize<'de> for FolderSubscriptionLevel {
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 = FolderSubscriptionLevel;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a FolderSubscriptionLevel 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"))
};
match tag {
"none" => {
crate::eat_json_fields(&mut map)?;
Ok(FolderSubscriptionLevel::None)
}
"activity_only" => {
crate::eat_json_fields(&mut map)?;
Ok(FolderSubscriptionLevel::ActivityOnly)
}
"daily_emails" => {
crate::eat_json_fields(&mut map)?;
Ok(FolderSubscriptionLevel::DailyEmails)
}
"weekly_emails" => {
crate::eat_json_fields(&mut map)?;
Ok(FolderSubscriptionLevel::WeeklyEmails)
}
_ => Err(de::Error::unknown_variant(tag, VARIANTS))
}
}
}
const VARIANTS: &[&str] = &["none",
"activity_only",
"daily_emails",
"weekly_emails"];
deserializer.deserialize_struct("FolderSubscriptionLevel", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for FolderSubscriptionLevel {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
FolderSubscriptionLevel::None => {
let mut s = serializer.serialize_struct("FolderSubscriptionLevel", 1)?;
s.serialize_field(".tag", "none")?;
s.end()
}
FolderSubscriptionLevel::ActivityOnly => {
let mut s = serializer.serialize_struct("FolderSubscriptionLevel", 1)?;
s.serialize_field(".tag", "activity_only")?;
s.end()
}
FolderSubscriptionLevel::DailyEmails => {
let mut s = serializer.serialize_struct("FolderSubscriptionLevel", 1)?;
s.serialize_field(".tag", "daily_emails")?;
s.end()
}
FolderSubscriptionLevel::WeeklyEmails => {
let mut s = serializer.serialize_struct("FolderSubscriptionLevel", 1)?;
s.serialize_field(".tag", "weekly_emails")?;
s.end()
}
}
}
}
#[derive(Debug)]
pub struct FoldersContainingPaperDoc {
pub folder_sharing_policy_type: Option<FolderSharingPolicyType>,
pub folders: Option<Vec<Folder>>,
}
impl Default for FoldersContainingPaperDoc {
fn default() -> Self {
FoldersContainingPaperDoc {
folder_sharing_policy_type: None,
folders: None,
}
}
}
const FOLDERS_CONTAINING_PAPER_DOC_FIELDS: &[&str] = &["folder_sharing_policy_type",
"folders"];
impl FoldersContainingPaperDoc {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
) -> Result<FoldersContainingPaperDoc, V::Error> {
let mut field_folder_sharing_policy_type = None;
let mut field_folders = None;
while let Some(key) = map.next_key::<&str>()? {
match key {
"folder_sharing_policy_type" => {
if field_folder_sharing_policy_type.is_some() {
return Err(::serde::de::Error::duplicate_field("folder_sharing_policy_type"));
}
field_folder_sharing_policy_type = Some(map.next_value()?);
}
"folders" => {
if field_folders.is_some() {
return Err(::serde::de::Error::duplicate_field("folders"));
}
field_folders = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
let result = FoldersContainingPaperDoc {
folder_sharing_policy_type: field_folder_sharing_policy_type,
folders: field_folders,
};
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("folder_sharing_policy_type", &self.folder_sharing_policy_type)?;
s.serialize_field("folders", &self.folders)
}
}
impl<'de> ::serde::de::Deserialize<'de> for FoldersContainingPaperDoc {
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 = FoldersContainingPaperDoc;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a FoldersContainingPaperDoc struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
FoldersContainingPaperDoc::internal_deserialize(map)
}
}
deserializer.deserialize_struct("FoldersContainingPaperDoc", FOLDERS_CONTAINING_PAPER_DOC_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for FoldersContainingPaperDoc {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("FoldersContainingPaperDoc", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum ImportFormat {
Html,
Markdown,
PlainText,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ImportFormat {
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 = ImportFormat;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ImportFormat 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"))
};
match tag {
"html" => {
crate::eat_json_fields(&mut map)?;
Ok(ImportFormat::Html)
}
"markdown" => {
crate::eat_json_fields(&mut map)?;
Ok(ImportFormat::Markdown)
}
"plain_text" => {
crate::eat_json_fields(&mut map)?;
Ok(ImportFormat::PlainText)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(ImportFormat::Other)
}
}
}
}
const VARIANTS: &[&str] = &["html",
"markdown",
"plain_text",
"other"];
deserializer.deserialize_struct("ImportFormat", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ImportFormat {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ImportFormat::Html => {
let mut s = serializer.serialize_struct("ImportFormat", 1)?;
s.serialize_field(".tag", "html")?;
s.end()
}
ImportFormat::Markdown => {
let mut s = serializer.serialize_struct("ImportFormat", 1)?;
s.serialize_field(".tag", "markdown")?;
s.end()
}
ImportFormat::PlainText => {
let mut s = serializer.serialize_struct("ImportFormat", 1)?;
s.serialize_field(".tag", "plain_text")?;
s.end()
}
ImportFormat::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub struct InviteeInfoWithPermissionLevel {
pub invitee: super::sharing::InviteeInfo,
pub permission_level: PaperDocPermissionLevel,
}
impl InviteeInfoWithPermissionLevel {
pub fn new(
invitee: super::sharing::InviteeInfo,
permission_level: PaperDocPermissionLevel,
) -> Self {
InviteeInfoWithPermissionLevel {
invitee,
permission_level,
}
}
}
const INVITEE_INFO_WITH_PERMISSION_LEVEL_FIELDS: &[&str] = &["invitee",
"permission_level"];
impl InviteeInfoWithPermissionLevel {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<InviteeInfoWithPermissionLevel, 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<InviteeInfoWithPermissionLevel>, V::Error> {
let mut field_invitee = None;
let mut field_permission_level = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"invitee" => {
if field_invitee.is_some() {
return Err(::serde::de::Error::duplicate_field("invitee"));
}
field_invitee = Some(map.next_value()?);
}
"permission_level" => {
if field_permission_level.is_some() {
return Err(::serde::de::Error::duplicate_field("permission_level"));
}
field_permission_level = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = InviteeInfoWithPermissionLevel {
invitee: field_invitee.ok_or_else(|| ::serde::de::Error::missing_field("invitee"))?,
permission_level: field_permission_level.ok_or_else(|| ::serde::de::Error::missing_field("permission_level"))?,
};
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("invitee", &self.invitee)?;
s.serialize_field("permission_level", &self.permission_level)
}
}
impl<'de> ::serde::de::Deserialize<'de> for InviteeInfoWithPermissionLevel {
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 = InviteeInfoWithPermissionLevel;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a InviteeInfoWithPermissionLevel struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
InviteeInfoWithPermissionLevel::internal_deserialize(map)
}
}
deserializer.deserialize_struct("InviteeInfoWithPermissionLevel", INVITEE_INFO_WITH_PERMISSION_LEVEL_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for InviteeInfoWithPermissionLevel {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("InviteeInfoWithPermissionLevel", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum ListDocsCursorError {
CursorError(PaperApiCursorError),
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ListDocsCursorError {
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 = ListDocsCursorError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListDocsCursorError 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"))
};
match tag {
"cursor_error" => {
match map.next_key()? {
Some("cursor_error") => Ok(ListDocsCursorError::CursorError(map.next_value()?)),
None => Err(de::Error::missing_field("cursor_error")),
_ => Err(de::Error::unknown_field(tag, VARIANTS))
}
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(ListDocsCursorError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["cursor_error",
"other"];
deserializer.deserialize_struct("ListDocsCursorError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ListDocsCursorError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ListDocsCursorError::CursorError(ref x) => {
let mut s = serializer.serialize_struct("ListDocsCursorError", 2)?;
s.serialize_field(".tag", "cursor_error")?;
s.serialize_field("cursor_error", x)?;
s.end()
}
ListDocsCursorError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for ListDocsCursorError {
fn description(&self) -> &str {
"ListDocsCursorError"
}
}
impl ::std::fmt::Display for ListDocsCursorError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub struct ListPaperDocsArgs {
pub filter_by: ListPaperDocsFilterBy,
pub sort_by: ListPaperDocsSortBy,
pub sort_order: ListPaperDocsSortOrder,
pub limit: i32,
}
impl Default for ListPaperDocsArgs {
fn default() -> Self {
ListPaperDocsArgs {
filter_by: ListPaperDocsFilterBy::DocsAccessed,
sort_by: ListPaperDocsSortBy::Accessed,
sort_order: ListPaperDocsSortOrder::Ascending,
limit: 1000,
}
}
}
const LIST_PAPER_DOCS_ARGS_FIELDS: &[&str] = &["filter_by",
"sort_by",
"sort_order",
"limit"];
impl ListPaperDocsArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
) -> Result<ListPaperDocsArgs, V::Error> {
let mut field_filter_by = None;
let mut field_sort_by = None;
let mut field_sort_order = None;
let mut field_limit = None;
while let Some(key) = map.next_key::<&str>()? {
match key {
"filter_by" => {
if field_filter_by.is_some() {
return Err(::serde::de::Error::duplicate_field("filter_by"));
}
field_filter_by = Some(map.next_value()?);
}
"sort_by" => {
if field_sort_by.is_some() {
return Err(::serde::de::Error::duplicate_field("sort_by"));
}
field_sort_by = Some(map.next_value()?);
}
"sort_order" => {
if field_sort_order.is_some() {
return Err(::serde::de::Error::duplicate_field("sort_order"));
}
field_sort_order = Some(map.next_value()?);
}
"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 = ListPaperDocsArgs {
filter_by: field_filter_by.unwrap_or(ListPaperDocsFilterBy::DocsAccessed),
sort_by: field_sort_by.unwrap_or(ListPaperDocsSortBy::Accessed),
sort_order: field_sort_order.unwrap_or(ListPaperDocsSortOrder::Ascending),
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("filter_by", &self.filter_by)?;
s.serialize_field("sort_by", &self.sort_by)?;
s.serialize_field("sort_order", &self.sort_order)?;
s.serialize_field("limit", &self.limit)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListPaperDocsArgs {
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 = ListPaperDocsArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListPaperDocsArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListPaperDocsArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListPaperDocsArgs", LIST_PAPER_DOCS_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListPaperDocsArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListPaperDocsArgs", 4)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct ListPaperDocsContinueArgs {
pub cursor: String,
}
impl ListPaperDocsContinueArgs {
pub fn new(cursor: String) -> Self {
ListPaperDocsContinueArgs {
cursor,
}
}
}
const LIST_PAPER_DOCS_CONTINUE_ARGS_FIELDS: &[&str] = &["cursor"];
impl ListPaperDocsContinueArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListPaperDocsContinueArgs, 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<ListPaperDocsContinueArgs>, 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 = ListPaperDocsContinueArgs {
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)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListPaperDocsContinueArgs {
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 = ListPaperDocsContinueArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListPaperDocsContinueArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListPaperDocsContinueArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListPaperDocsContinueArgs", LIST_PAPER_DOCS_CONTINUE_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListPaperDocsContinueArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListPaperDocsContinueArgs", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum ListPaperDocsFilterBy {
DocsAccessed,
DocsCreated,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ListPaperDocsFilterBy {
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 = ListPaperDocsFilterBy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListPaperDocsFilterBy 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"))
};
match tag {
"docs_accessed" => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsFilterBy::DocsAccessed)
}
"docs_created" => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsFilterBy::DocsCreated)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsFilterBy::Other)
}
}
}
}
const VARIANTS: &[&str] = &["docs_accessed",
"docs_created",
"other"];
deserializer.deserialize_struct("ListPaperDocsFilterBy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ListPaperDocsFilterBy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ListPaperDocsFilterBy::DocsAccessed => {
let mut s = serializer.serialize_struct("ListPaperDocsFilterBy", 1)?;
s.serialize_field(".tag", "docs_accessed")?;
s.end()
}
ListPaperDocsFilterBy::DocsCreated => {
let mut s = serializer.serialize_struct("ListPaperDocsFilterBy", 1)?;
s.serialize_field(".tag", "docs_created")?;
s.end()
}
ListPaperDocsFilterBy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub struct ListPaperDocsResponse {
pub doc_ids: Vec<PaperDocId>,
pub cursor: Cursor,
pub has_more: bool,
}
impl ListPaperDocsResponse {
pub fn new(doc_ids: Vec<PaperDocId>, cursor: Cursor, has_more: bool) -> Self {
ListPaperDocsResponse {
doc_ids,
cursor,
has_more,
}
}
}
const LIST_PAPER_DOCS_RESPONSE_FIELDS: &[&str] = &["doc_ids",
"cursor",
"has_more"];
impl ListPaperDocsResponse {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListPaperDocsResponse, 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<ListPaperDocsResponse>, V::Error> {
let mut field_doc_ids = 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 {
"doc_ids" => {
if field_doc_ids.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_ids"));
}
field_doc_ids = 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 = ListPaperDocsResponse {
doc_ids: field_doc_ids.ok_or_else(|| ::serde::de::Error::missing_field("doc_ids"))?,
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("doc_ids", &self.doc_ids)?;
s.serialize_field("cursor", &self.cursor)?;
s.serialize_field("has_more", &self.has_more)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListPaperDocsResponse {
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 = ListPaperDocsResponse;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListPaperDocsResponse struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListPaperDocsResponse::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListPaperDocsResponse", LIST_PAPER_DOCS_RESPONSE_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListPaperDocsResponse {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListPaperDocsResponse", 3)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum ListPaperDocsSortBy {
Accessed,
Modified,
Created,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ListPaperDocsSortBy {
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 = ListPaperDocsSortBy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListPaperDocsSortBy 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"))
};
match tag {
"accessed" => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsSortBy::Accessed)
}
"modified" => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsSortBy::Modified)
}
"created" => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsSortBy::Created)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsSortBy::Other)
}
}
}
}
const VARIANTS: &[&str] = &["accessed",
"modified",
"created",
"other"];
deserializer.deserialize_struct("ListPaperDocsSortBy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ListPaperDocsSortBy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ListPaperDocsSortBy::Accessed => {
let mut s = serializer.serialize_struct("ListPaperDocsSortBy", 1)?;
s.serialize_field(".tag", "accessed")?;
s.end()
}
ListPaperDocsSortBy::Modified => {
let mut s = serializer.serialize_struct("ListPaperDocsSortBy", 1)?;
s.serialize_field(".tag", "modified")?;
s.end()
}
ListPaperDocsSortBy::Created => {
let mut s = serializer.serialize_struct("ListPaperDocsSortBy", 1)?;
s.serialize_field(".tag", "created")?;
s.end()
}
ListPaperDocsSortBy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub enum ListPaperDocsSortOrder {
Ascending,
Descending,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ListPaperDocsSortOrder {
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 = ListPaperDocsSortOrder;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListPaperDocsSortOrder 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"))
};
match tag {
"ascending" => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsSortOrder::Ascending)
}
"descending" => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsSortOrder::Descending)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(ListPaperDocsSortOrder::Other)
}
}
}
}
const VARIANTS: &[&str] = &["ascending",
"descending",
"other"];
deserializer.deserialize_struct("ListPaperDocsSortOrder", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ListPaperDocsSortOrder {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ListPaperDocsSortOrder::Ascending => {
let mut s = serializer.serialize_struct("ListPaperDocsSortOrder", 1)?;
s.serialize_field(".tag", "ascending")?;
s.end()
}
ListPaperDocsSortOrder::Descending => {
let mut s = serializer.serialize_struct("ListPaperDocsSortOrder", 1)?;
s.serialize_field(".tag", "descending")?;
s.end()
}
ListPaperDocsSortOrder::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub enum ListUsersCursorError {
InsufficientPermissions,
DocNotFound,
CursorError(PaperApiCursorError),
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ListUsersCursorError {
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 = ListUsersCursorError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListUsersCursorError 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"))
};
match tag {
"insufficient_permissions" => {
crate::eat_json_fields(&mut map)?;
Ok(ListUsersCursorError::InsufficientPermissions)
}
"doc_not_found" => {
crate::eat_json_fields(&mut map)?;
Ok(ListUsersCursorError::DocNotFound)
}
"cursor_error" => {
match map.next_key()? {
Some("cursor_error") => Ok(ListUsersCursorError::CursorError(map.next_value()?)),
None => Err(de::Error::missing_field("cursor_error")),
_ => Err(de::Error::unknown_field(tag, VARIANTS))
}
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(ListUsersCursorError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["insufficient_permissions",
"other",
"doc_not_found",
"cursor_error"];
deserializer.deserialize_struct("ListUsersCursorError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ListUsersCursorError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ListUsersCursorError::InsufficientPermissions => {
let mut s = serializer.serialize_struct("ListUsersCursorError", 1)?;
s.serialize_field(".tag", "insufficient_permissions")?;
s.end()
}
ListUsersCursorError::DocNotFound => {
let mut s = serializer.serialize_struct("ListUsersCursorError", 1)?;
s.serialize_field(".tag", "doc_not_found")?;
s.end()
}
ListUsersCursorError::CursorError(ref x) => {
let mut s = serializer.serialize_struct("ListUsersCursorError", 2)?;
s.serialize_field(".tag", "cursor_error")?;
s.serialize_field("cursor_error", x)?;
s.end()
}
ListUsersCursorError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for ListUsersCursorError {
fn description(&self) -> &str {
"ListUsersCursorError"
}
}
impl ::std::fmt::Display for ListUsersCursorError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub struct ListUsersOnFolderArgs {
pub doc_id: PaperDocId,
pub limit: i32,
}
impl ListUsersOnFolderArgs {
pub fn new(doc_id: PaperDocId) -> Self {
ListUsersOnFolderArgs {
doc_id,
limit: 1000,
}
}
pub fn with_limit(mut self, value: i32) -> Self {
self.limit = value;
self
}
}
const LIST_USERS_ON_FOLDER_ARGS_FIELDS: &[&str] = &["doc_id",
"limit"];
impl ListUsersOnFolderArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListUsersOnFolderArgs, 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<ListUsersOnFolderArgs>, V::Error> {
let mut field_doc_id = None;
let mut field_limit = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"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>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = ListUsersOnFolderArgs {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
limit: field_limit.unwrap_or(1000),
};
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("doc_id", &self.doc_id)?;
s.serialize_field("limit", &self.limit)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListUsersOnFolderArgs {
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 = ListUsersOnFolderArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListUsersOnFolderArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListUsersOnFolderArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListUsersOnFolderArgs", LIST_USERS_ON_FOLDER_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListUsersOnFolderArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListUsersOnFolderArgs", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct ListUsersOnFolderContinueArgs {
pub doc_id: PaperDocId,
pub cursor: String,
}
impl ListUsersOnFolderContinueArgs {
pub fn new(doc_id: PaperDocId, cursor: String) -> Self {
ListUsersOnFolderContinueArgs {
doc_id,
cursor,
}
}
}
const LIST_USERS_ON_FOLDER_CONTINUE_ARGS_FIELDS: &[&str] = &["doc_id",
"cursor"];
impl ListUsersOnFolderContinueArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListUsersOnFolderContinueArgs, 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<ListUsersOnFolderContinueArgs>, V::Error> {
let mut field_doc_id = None;
let mut field_cursor = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"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 = ListUsersOnFolderContinueArgs {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
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("doc_id", &self.doc_id)?;
s.serialize_field("cursor", &self.cursor)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListUsersOnFolderContinueArgs {
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 = ListUsersOnFolderContinueArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListUsersOnFolderContinueArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListUsersOnFolderContinueArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListUsersOnFolderContinueArgs", LIST_USERS_ON_FOLDER_CONTINUE_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListUsersOnFolderContinueArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListUsersOnFolderContinueArgs", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct ListUsersOnFolderResponse {
pub invitees: Vec<super::sharing::InviteeInfo>,
pub users: Vec<super::sharing::UserInfo>,
pub cursor: Cursor,
pub has_more: bool,
}
impl ListUsersOnFolderResponse {
pub fn new(
invitees: Vec<super::sharing::InviteeInfo>,
users: Vec<super::sharing::UserInfo>,
cursor: Cursor,
has_more: bool,
) -> Self {
ListUsersOnFolderResponse {
invitees,
users,
cursor,
has_more,
}
}
}
const LIST_USERS_ON_FOLDER_RESPONSE_FIELDS: &[&str] = &["invitees",
"users",
"cursor",
"has_more"];
impl ListUsersOnFolderResponse {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListUsersOnFolderResponse, 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<ListUsersOnFolderResponse>, V::Error> {
let mut field_invitees = None;
let mut field_users = 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 {
"invitees" => {
if field_invitees.is_some() {
return Err(::serde::de::Error::duplicate_field("invitees"));
}
field_invitees = Some(map.next_value()?);
}
"users" => {
if field_users.is_some() {
return Err(::serde::de::Error::duplicate_field("users"));
}
field_users = 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 = ListUsersOnFolderResponse {
invitees: field_invitees.ok_or_else(|| ::serde::de::Error::missing_field("invitees"))?,
users: field_users.ok_or_else(|| ::serde::de::Error::missing_field("users"))?,
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("invitees", &self.invitees)?;
s.serialize_field("users", &self.users)?;
s.serialize_field("cursor", &self.cursor)?;
s.serialize_field("has_more", &self.has_more)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListUsersOnFolderResponse {
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 = ListUsersOnFolderResponse;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListUsersOnFolderResponse struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListUsersOnFolderResponse::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListUsersOnFolderResponse", LIST_USERS_ON_FOLDER_RESPONSE_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListUsersOnFolderResponse {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListUsersOnFolderResponse", 4)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct ListUsersOnPaperDocArgs {
pub doc_id: PaperDocId,
pub limit: i32,
pub filter_by: UserOnPaperDocFilter,
}
impl ListUsersOnPaperDocArgs {
pub fn new(doc_id: PaperDocId) -> Self {
ListUsersOnPaperDocArgs {
doc_id,
limit: 1000,
filter_by: UserOnPaperDocFilter::Shared,
}
}
pub fn with_limit(mut self, value: i32) -> Self {
self.limit = value;
self
}
pub fn with_filter_by(mut self, value: UserOnPaperDocFilter) -> Self {
self.filter_by = value;
self
}
}
const LIST_USERS_ON_PAPER_DOC_ARGS_FIELDS: &[&str] = &["doc_id",
"limit",
"filter_by"];
impl ListUsersOnPaperDocArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListUsersOnPaperDocArgs, 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<ListUsersOnPaperDocArgs>, V::Error> {
let mut field_doc_id = None;
let mut field_limit = None;
let mut field_filter_by = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"limit" => {
if field_limit.is_some() {
return Err(::serde::de::Error::duplicate_field("limit"));
}
field_limit = Some(map.next_value()?);
}
"filter_by" => {
if field_filter_by.is_some() {
return Err(::serde::de::Error::duplicate_field("filter_by"));
}
field_filter_by = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = ListUsersOnPaperDocArgs {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
limit: field_limit.unwrap_or(1000),
filter_by: field_filter_by.unwrap_or(UserOnPaperDocFilter::Shared),
};
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("doc_id", &self.doc_id)?;
s.serialize_field("limit", &self.limit)?;
s.serialize_field("filter_by", &self.filter_by)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListUsersOnPaperDocArgs {
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 = ListUsersOnPaperDocArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListUsersOnPaperDocArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListUsersOnPaperDocArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListUsersOnPaperDocArgs", LIST_USERS_ON_PAPER_DOC_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListUsersOnPaperDocArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListUsersOnPaperDocArgs", 3)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct ListUsersOnPaperDocContinueArgs {
pub doc_id: PaperDocId,
pub cursor: String,
}
impl ListUsersOnPaperDocContinueArgs {
pub fn new(doc_id: PaperDocId, cursor: String) -> Self {
ListUsersOnPaperDocContinueArgs {
doc_id,
cursor,
}
}
}
const LIST_USERS_ON_PAPER_DOC_CONTINUE_ARGS_FIELDS: &[&str] = &["doc_id",
"cursor"];
impl ListUsersOnPaperDocContinueArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListUsersOnPaperDocContinueArgs, 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<ListUsersOnPaperDocContinueArgs>, V::Error> {
let mut field_doc_id = None;
let mut field_cursor = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"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 = ListUsersOnPaperDocContinueArgs {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
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("doc_id", &self.doc_id)?;
s.serialize_field("cursor", &self.cursor)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListUsersOnPaperDocContinueArgs {
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 = ListUsersOnPaperDocContinueArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListUsersOnPaperDocContinueArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListUsersOnPaperDocContinueArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListUsersOnPaperDocContinueArgs", LIST_USERS_ON_PAPER_DOC_CONTINUE_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListUsersOnPaperDocContinueArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListUsersOnPaperDocContinueArgs", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct ListUsersOnPaperDocResponse {
pub invitees: Vec<InviteeInfoWithPermissionLevel>,
pub users: Vec<UserInfoWithPermissionLevel>,
pub doc_owner: super::sharing::UserInfo,
pub cursor: Cursor,
pub has_more: bool,
}
impl ListUsersOnPaperDocResponse {
pub fn new(
invitees: Vec<InviteeInfoWithPermissionLevel>,
users: Vec<UserInfoWithPermissionLevel>,
doc_owner: super::sharing::UserInfo,
cursor: Cursor,
has_more: bool,
) -> Self {
ListUsersOnPaperDocResponse {
invitees,
users,
doc_owner,
cursor,
has_more,
}
}
}
const LIST_USERS_ON_PAPER_DOC_RESPONSE_FIELDS: &[&str] = &["invitees",
"users",
"doc_owner",
"cursor",
"has_more"];
impl ListUsersOnPaperDocResponse {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<ListUsersOnPaperDocResponse, 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<ListUsersOnPaperDocResponse>, V::Error> {
let mut field_invitees = None;
let mut field_users = None;
let mut field_doc_owner = 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 {
"invitees" => {
if field_invitees.is_some() {
return Err(::serde::de::Error::duplicate_field("invitees"));
}
field_invitees = Some(map.next_value()?);
}
"users" => {
if field_users.is_some() {
return Err(::serde::de::Error::duplicate_field("users"));
}
field_users = Some(map.next_value()?);
}
"doc_owner" => {
if field_doc_owner.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_owner"));
}
field_doc_owner = 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 = ListUsersOnPaperDocResponse {
invitees: field_invitees.ok_or_else(|| ::serde::de::Error::missing_field("invitees"))?,
users: field_users.ok_or_else(|| ::serde::de::Error::missing_field("users"))?,
doc_owner: field_doc_owner.ok_or_else(|| ::serde::de::Error::missing_field("doc_owner"))?,
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("invitees", &self.invitees)?;
s.serialize_field("users", &self.users)?;
s.serialize_field("doc_owner", &self.doc_owner)?;
s.serialize_field("cursor", &self.cursor)?;
s.serialize_field("has_more", &self.has_more)
}
}
impl<'de> ::serde::de::Deserialize<'de> for ListUsersOnPaperDocResponse {
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 = ListUsersOnPaperDocResponse;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ListUsersOnPaperDocResponse struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
ListUsersOnPaperDocResponse::internal_deserialize(map)
}
}
deserializer.deserialize_struct("ListUsersOnPaperDocResponse", LIST_USERS_ON_PAPER_DOC_RESPONSE_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for ListUsersOnPaperDocResponse {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("ListUsersOnPaperDocResponse", 5)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum PaperApiBaseError {
InsufficientPermissions,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperApiBaseError {
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 = PaperApiBaseError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperApiBaseError 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"))
};
match tag {
"insufficient_permissions" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperApiBaseError::InsufficientPermissions)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(PaperApiBaseError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["insufficient_permissions",
"other"];
deserializer.deserialize_struct("PaperApiBaseError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperApiBaseError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperApiBaseError::InsufficientPermissions => {
let mut s = serializer.serialize_struct("PaperApiBaseError", 1)?;
s.serialize_field(".tag", "insufficient_permissions")?;
s.end()
}
PaperApiBaseError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for PaperApiBaseError {
fn description(&self) -> &str {
"PaperApiBaseError"
}
}
impl ::std::fmt::Display for PaperApiBaseError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub enum PaperApiCursorError {
ExpiredCursor,
InvalidCursor,
WrongUserInCursor,
Reset,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperApiCursorError {
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 = PaperApiCursorError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperApiCursorError 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"))
};
match tag {
"expired_cursor" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperApiCursorError::ExpiredCursor)
}
"invalid_cursor" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperApiCursorError::InvalidCursor)
}
"wrong_user_in_cursor" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperApiCursorError::WrongUserInCursor)
}
"reset" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperApiCursorError::Reset)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(PaperApiCursorError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["expired_cursor",
"invalid_cursor",
"wrong_user_in_cursor",
"reset",
"other"];
deserializer.deserialize_struct("PaperApiCursorError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperApiCursorError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperApiCursorError::ExpiredCursor => {
let mut s = serializer.serialize_struct("PaperApiCursorError", 1)?;
s.serialize_field(".tag", "expired_cursor")?;
s.end()
}
PaperApiCursorError::InvalidCursor => {
let mut s = serializer.serialize_struct("PaperApiCursorError", 1)?;
s.serialize_field(".tag", "invalid_cursor")?;
s.end()
}
PaperApiCursorError::WrongUserInCursor => {
let mut s = serializer.serialize_struct("PaperApiCursorError", 1)?;
s.serialize_field(".tag", "wrong_user_in_cursor")?;
s.end()
}
PaperApiCursorError::Reset => {
let mut s = serializer.serialize_struct("PaperApiCursorError", 1)?;
s.serialize_field(".tag", "reset")?;
s.end()
}
PaperApiCursorError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for PaperApiCursorError {
fn description(&self) -> &str {
"PaperApiCursorError"
}
}
impl ::std::fmt::Display for PaperApiCursorError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub struct PaperDocCreateArgs {
pub import_format: ImportFormat,
pub parent_folder_id: Option<String>,
}
impl PaperDocCreateArgs {
pub fn new(import_format: ImportFormat) -> Self {
PaperDocCreateArgs {
import_format,
parent_folder_id: None,
}
}
pub fn with_parent_folder_id(mut self, value: Option<String>) -> Self {
self.parent_folder_id = value;
self
}
}
const PAPER_DOC_CREATE_ARGS_FIELDS: &[&str] = &["import_format",
"parent_folder_id"];
impl PaperDocCreateArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperDocCreateArgs, 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<PaperDocCreateArgs>, V::Error> {
let mut field_import_format = None;
let mut field_parent_folder_id = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"import_format" => {
if field_import_format.is_some() {
return Err(::serde::de::Error::duplicate_field("import_format"));
}
field_import_format = Some(map.next_value()?);
}
"parent_folder_id" => {
if field_parent_folder_id.is_some() {
return Err(::serde::de::Error::duplicate_field("parent_folder_id"));
}
field_parent_folder_id = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperDocCreateArgs {
import_format: field_import_format.ok_or_else(|| ::serde::de::Error::missing_field("import_format"))?,
parent_folder_id: field_parent_folder_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("import_format", &self.import_format)?;
s.serialize_field("parent_folder_id", &self.parent_folder_id)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocCreateArgs {
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 = PaperDocCreateArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocCreateArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperDocCreateArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperDocCreateArgs", PAPER_DOC_CREATE_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocCreateArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperDocCreateArgs", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum PaperDocCreateError {
InsufficientPermissions,
ContentMalformed,
FolderNotFound,
DocLengthExceeded,
ImageSizeExceeded,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocCreateError {
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 = PaperDocCreateError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocCreateError 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"))
};
match tag {
"insufficient_permissions" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocCreateError::InsufficientPermissions)
}
"content_malformed" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocCreateError::ContentMalformed)
}
"folder_not_found" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocCreateError::FolderNotFound)
}
"doc_length_exceeded" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocCreateError::DocLengthExceeded)
}
"image_size_exceeded" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocCreateError::ImageSizeExceeded)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocCreateError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["insufficient_permissions",
"other",
"content_malformed",
"folder_not_found",
"doc_length_exceeded",
"image_size_exceeded"];
deserializer.deserialize_struct("PaperDocCreateError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocCreateError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperDocCreateError::InsufficientPermissions => {
let mut s = serializer.serialize_struct("PaperDocCreateError", 1)?;
s.serialize_field(".tag", "insufficient_permissions")?;
s.end()
}
PaperDocCreateError::ContentMalformed => {
let mut s = serializer.serialize_struct("PaperDocCreateError", 1)?;
s.serialize_field(".tag", "content_malformed")?;
s.end()
}
PaperDocCreateError::FolderNotFound => {
let mut s = serializer.serialize_struct("PaperDocCreateError", 1)?;
s.serialize_field(".tag", "folder_not_found")?;
s.end()
}
PaperDocCreateError::DocLengthExceeded => {
let mut s = serializer.serialize_struct("PaperDocCreateError", 1)?;
s.serialize_field(".tag", "doc_length_exceeded")?;
s.end()
}
PaperDocCreateError::ImageSizeExceeded => {
let mut s = serializer.serialize_struct("PaperDocCreateError", 1)?;
s.serialize_field(".tag", "image_size_exceeded")?;
s.end()
}
PaperDocCreateError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for PaperDocCreateError {
fn description(&self) -> &str {
"PaperDocCreateError"
}
}
impl ::std::fmt::Display for PaperDocCreateError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub struct PaperDocCreateUpdateResult {
pub doc_id: String,
pub revision: i64,
pub title: String,
}
impl PaperDocCreateUpdateResult {
pub fn new(doc_id: String, revision: i64, title: String) -> Self {
PaperDocCreateUpdateResult {
doc_id,
revision,
title,
}
}
}
const PAPER_DOC_CREATE_UPDATE_RESULT_FIELDS: &[&str] = &["doc_id",
"revision",
"title"];
impl PaperDocCreateUpdateResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperDocCreateUpdateResult, 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<PaperDocCreateUpdateResult>, V::Error> {
let mut field_doc_id = None;
let mut field_revision = None;
let mut field_title = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"revision" => {
if field_revision.is_some() {
return Err(::serde::de::Error::duplicate_field("revision"));
}
field_revision = Some(map.next_value()?);
}
"title" => {
if field_title.is_some() {
return Err(::serde::de::Error::duplicate_field("title"));
}
field_title = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperDocCreateUpdateResult {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
revision: field_revision.ok_or_else(|| ::serde::de::Error::missing_field("revision"))?,
title: field_title.ok_or_else(|| ::serde::de::Error::missing_field("title"))?,
};
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("doc_id", &self.doc_id)?;
s.serialize_field("revision", &self.revision)?;
s.serialize_field("title", &self.title)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocCreateUpdateResult {
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 = PaperDocCreateUpdateResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocCreateUpdateResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperDocCreateUpdateResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperDocCreateUpdateResult", PAPER_DOC_CREATE_UPDATE_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocCreateUpdateResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperDocCreateUpdateResult", 3)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct PaperDocExport {
pub doc_id: PaperDocId,
pub export_format: ExportFormat,
}
impl PaperDocExport {
pub fn new(doc_id: PaperDocId, export_format: ExportFormat) -> Self {
PaperDocExport {
doc_id,
export_format,
}
}
}
const PAPER_DOC_EXPORT_FIELDS: &[&str] = &["doc_id",
"export_format"];
impl PaperDocExport {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperDocExport, 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<PaperDocExport>, V::Error> {
let mut field_doc_id = None;
let mut field_export_format = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"export_format" => {
if field_export_format.is_some() {
return Err(::serde::de::Error::duplicate_field("export_format"));
}
field_export_format = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperDocExport {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
export_format: field_export_format.ok_or_else(|| ::serde::de::Error::missing_field("export_format"))?,
};
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("doc_id", &self.doc_id)?;
s.serialize_field("export_format", &self.export_format)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocExport {
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 = PaperDocExport;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocExport struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperDocExport::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperDocExport", PAPER_DOC_EXPORT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocExport {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperDocExport", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct PaperDocExportResult {
pub owner: String,
pub title: String,
pub revision: i64,
pub mime_type: String,
}
impl PaperDocExportResult {
pub fn new(owner: String, title: String, revision: i64, mime_type: String) -> Self {
PaperDocExportResult {
owner,
title,
revision,
mime_type,
}
}
}
const PAPER_DOC_EXPORT_RESULT_FIELDS: &[&str] = &["owner",
"title",
"revision",
"mime_type"];
impl PaperDocExportResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperDocExportResult, 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<PaperDocExportResult>, V::Error> {
let mut field_owner = None;
let mut field_title = None;
let mut field_revision = None;
let mut field_mime_type = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"owner" => {
if field_owner.is_some() {
return Err(::serde::de::Error::duplicate_field("owner"));
}
field_owner = Some(map.next_value()?);
}
"title" => {
if field_title.is_some() {
return Err(::serde::de::Error::duplicate_field("title"));
}
field_title = Some(map.next_value()?);
}
"revision" => {
if field_revision.is_some() {
return Err(::serde::de::Error::duplicate_field("revision"));
}
field_revision = Some(map.next_value()?);
}
"mime_type" => {
if field_mime_type.is_some() {
return Err(::serde::de::Error::duplicate_field("mime_type"));
}
field_mime_type = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperDocExportResult {
owner: field_owner.ok_or_else(|| ::serde::de::Error::missing_field("owner"))?,
title: field_title.ok_or_else(|| ::serde::de::Error::missing_field("title"))?,
revision: field_revision.ok_or_else(|| ::serde::de::Error::missing_field("revision"))?,
mime_type: field_mime_type.ok_or_else(|| ::serde::de::Error::missing_field("mime_type"))?,
};
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("owner", &self.owner)?;
s.serialize_field("title", &self.title)?;
s.serialize_field("revision", &self.revision)?;
s.serialize_field("mime_type", &self.mime_type)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocExportResult {
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 = PaperDocExportResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocExportResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperDocExportResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperDocExportResult", PAPER_DOC_EXPORT_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocExportResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperDocExportResult", 4)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum PaperDocPermissionLevel {
Edit,
ViewAndComment,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocPermissionLevel {
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 = PaperDocPermissionLevel;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocPermissionLevel 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"))
};
match tag {
"edit" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocPermissionLevel::Edit)
}
"view_and_comment" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocPermissionLevel::ViewAndComment)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocPermissionLevel::Other)
}
}
}
}
const VARIANTS: &[&str] = &["edit",
"view_and_comment",
"other"];
deserializer.deserialize_struct("PaperDocPermissionLevel", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocPermissionLevel {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperDocPermissionLevel::Edit => {
let mut s = serializer.serialize_struct("PaperDocPermissionLevel", 1)?;
s.serialize_field(".tag", "edit")?;
s.end()
}
PaperDocPermissionLevel::ViewAndComment => {
let mut s = serializer.serialize_struct("PaperDocPermissionLevel", 1)?;
s.serialize_field(".tag", "view_and_comment")?;
s.end()
}
PaperDocPermissionLevel::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub struct PaperDocSharingPolicy {
pub doc_id: PaperDocId,
pub sharing_policy: SharingPolicy,
}
impl PaperDocSharingPolicy {
pub fn new(doc_id: PaperDocId, sharing_policy: SharingPolicy) -> Self {
PaperDocSharingPolicy {
doc_id,
sharing_policy,
}
}
}
const PAPER_DOC_SHARING_POLICY_FIELDS: &[&str] = &["doc_id",
"sharing_policy"];
impl PaperDocSharingPolicy {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperDocSharingPolicy, 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<PaperDocSharingPolicy>, V::Error> {
let mut field_doc_id = None;
let mut field_sharing_policy = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"sharing_policy" => {
if field_sharing_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("sharing_policy"));
}
field_sharing_policy = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperDocSharingPolicy {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
sharing_policy: field_sharing_policy.ok_or_else(|| ::serde::de::Error::missing_field("sharing_policy"))?,
};
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("doc_id", &self.doc_id)?;
s.serialize_field("sharing_policy", &self.sharing_policy)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocSharingPolicy {
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 = PaperDocSharingPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocSharingPolicy struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperDocSharingPolicy::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperDocSharingPolicy", PAPER_DOC_SHARING_POLICY_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocSharingPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperDocSharingPolicy", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct PaperDocUpdateArgs {
pub doc_id: PaperDocId,
pub doc_update_policy: PaperDocUpdatePolicy,
pub revision: i64,
pub import_format: ImportFormat,
}
impl PaperDocUpdateArgs {
pub fn new(
doc_id: PaperDocId,
doc_update_policy: PaperDocUpdatePolicy,
revision: i64,
import_format: ImportFormat,
) -> Self {
PaperDocUpdateArgs {
doc_id,
doc_update_policy,
revision,
import_format,
}
}
}
const PAPER_DOC_UPDATE_ARGS_FIELDS: &[&str] = &["doc_id",
"doc_update_policy",
"revision",
"import_format"];
impl PaperDocUpdateArgs {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperDocUpdateArgs, 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<PaperDocUpdateArgs>, V::Error> {
let mut field_doc_id = None;
let mut field_doc_update_policy = None;
let mut field_revision = None;
let mut field_import_format = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"doc_update_policy" => {
if field_doc_update_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_update_policy"));
}
field_doc_update_policy = Some(map.next_value()?);
}
"revision" => {
if field_revision.is_some() {
return Err(::serde::de::Error::duplicate_field("revision"));
}
field_revision = Some(map.next_value()?);
}
"import_format" => {
if field_import_format.is_some() {
return Err(::serde::de::Error::duplicate_field("import_format"));
}
field_import_format = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperDocUpdateArgs {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
doc_update_policy: field_doc_update_policy.ok_or_else(|| ::serde::de::Error::missing_field("doc_update_policy"))?,
revision: field_revision.ok_or_else(|| ::serde::de::Error::missing_field("revision"))?,
import_format: field_import_format.ok_or_else(|| ::serde::de::Error::missing_field("import_format"))?,
};
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("doc_id", &self.doc_id)?;
s.serialize_field("doc_update_policy", &self.doc_update_policy)?;
s.serialize_field("revision", &self.revision)?;
s.serialize_field("import_format", &self.import_format)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocUpdateArgs {
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 = PaperDocUpdateArgs;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocUpdateArgs struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperDocUpdateArgs::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperDocUpdateArgs", PAPER_DOC_UPDATE_ARGS_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocUpdateArgs {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperDocUpdateArgs", 4)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum PaperDocUpdateError {
InsufficientPermissions,
DocNotFound,
ContentMalformed,
RevisionMismatch,
DocLengthExceeded,
ImageSizeExceeded,
DocArchived,
DocDeleted,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocUpdateError {
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 = PaperDocUpdateError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocUpdateError 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"))
};
match tag {
"insufficient_permissions" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::InsufficientPermissions)
}
"doc_not_found" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::DocNotFound)
}
"content_malformed" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::ContentMalformed)
}
"revision_mismatch" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::RevisionMismatch)
}
"doc_length_exceeded" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::DocLengthExceeded)
}
"image_size_exceeded" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::ImageSizeExceeded)
}
"doc_archived" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::DocArchived)
}
"doc_deleted" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::DocDeleted)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdateError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["insufficient_permissions",
"other",
"doc_not_found",
"content_malformed",
"revision_mismatch",
"doc_length_exceeded",
"image_size_exceeded",
"doc_archived",
"doc_deleted"];
deserializer.deserialize_struct("PaperDocUpdateError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocUpdateError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperDocUpdateError::InsufficientPermissions => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "insufficient_permissions")?;
s.end()
}
PaperDocUpdateError::DocNotFound => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "doc_not_found")?;
s.end()
}
PaperDocUpdateError::ContentMalformed => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "content_malformed")?;
s.end()
}
PaperDocUpdateError::RevisionMismatch => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "revision_mismatch")?;
s.end()
}
PaperDocUpdateError::DocLengthExceeded => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "doc_length_exceeded")?;
s.end()
}
PaperDocUpdateError::ImageSizeExceeded => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "image_size_exceeded")?;
s.end()
}
PaperDocUpdateError::DocArchived => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "doc_archived")?;
s.end()
}
PaperDocUpdateError::DocDeleted => {
let mut s = serializer.serialize_struct("PaperDocUpdateError", 1)?;
s.serialize_field(".tag", "doc_deleted")?;
s.end()
}
PaperDocUpdateError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for PaperDocUpdateError {
fn description(&self) -> &str {
"PaperDocUpdateError"
}
}
impl ::std::fmt::Display for PaperDocUpdateError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub enum PaperDocUpdatePolicy {
Append,
Prepend,
OverwriteAll,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDocUpdatePolicy {
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 = PaperDocUpdatePolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDocUpdatePolicy 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"))
};
match tag {
"append" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdatePolicy::Append)
}
"prepend" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdatePolicy::Prepend)
}
"overwrite_all" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdatePolicy::OverwriteAll)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(PaperDocUpdatePolicy::Other)
}
}
}
}
const VARIANTS: &[&str] = &["append",
"prepend",
"overwrite_all",
"other"];
deserializer.deserialize_struct("PaperDocUpdatePolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperDocUpdatePolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperDocUpdatePolicy::Append => {
let mut s = serializer.serialize_struct("PaperDocUpdatePolicy", 1)?;
s.serialize_field(".tag", "append")?;
s.end()
}
PaperDocUpdatePolicy::Prepend => {
let mut s = serializer.serialize_struct("PaperDocUpdatePolicy", 1)?;
s.serialize_field(".tag", "prepend")?;
s.end()
}
PaperDocUpdatePolicy::OverwriteAll => {
let mut s = serializer.serialize_struct("PaperDocUpdatePolicy", 1)?;
s.serialize_field(".tag", "overwrite_all")?;
s.end()
}
PaperDocUpdatePolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug)]
pub struct PaperFolderCreateArg {
pub name: String,
pub parent_folder_id: Option<String>,
pub is_team_folder: Option<bool>,
}
impl PaperFolderCreateArg {
pub fn new(name: String) -> Self {
PaperFolderCreateArg {
name,
parent_folder_id: None,
is_team_folder: None,
}
}
pub fn with_parent_folder_id(mut self, value: Option<String>) -> Self {
self.parent_folder_id = value;
self
}
pub fn with_is_team_folder(mut self, value: Option<bool>) -> Self {
self.is_team_folder = value;
self
}
}
const PAPER_FOLDER_CREATE_ARG_FIELDS: &[&str] = &["name",
"parent_folder_id",
"is_team_folder"];
impl PaperFolderCreateArg {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperFolderCreateArg, 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<PaperFolderCreateArg>, V::Error> {
let mut field_name = None;
let mut field_parent_folder_id = None;
let mut field_is_team_folder = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"name" => {
if field_name.is_some() {
return Err(::serde::de::Error::duplicate_field("name"));
}
field_name = Some(map.next_value()?);
}
"parent_folder_id" => {
if field_parent_folder_id.is_some() {
return Err(::serde::de::Error::duplicate_field("parent_folder_id"));
}
field_parent_folder_id = Some(map.next_value()?);
}
"is_team_folder" => {
if field_is_team_folder.is_some() {
return Err(::serde::de::Error::duplicate_field("is_team_folder"));
}
field_is_team_folder = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperFolderCreateArg {
name: field_name.ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
parent_folder_id: field_parent_folder_id,
is_team_folder: field_is_team_folder,
};
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("name", &self.name)?;
s.serialize_field("parent_folder_id", &self.parent_folder_id)?;
s.serialize_field("is_team_folder", &self.is_team_folder)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperFolderCreateArg {
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 = PaperFolderCreateArg;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperFolderCreateArg struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperFolderCreateArg::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperFolderCreateArg", PAPER_FOLDER_CREATE_ARG_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperFolderCreateArg {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperFolderCreateArg", 3)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum PaperFolderCreateError {
InsufficientPermissions,
FolderNotFound,
InvalidFolderId,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperFolderCreateError {
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 = PaperFolderCreateError;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperFolderCreateError 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"))
};
match tag {
"insufficient_permissions" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperFolderCreateError::InsufficientPermissions)
}
"folder_not_found" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperFolderCreateError::FolderNotFound)
}
"invalid_folder_id" => {
crate::eat_json_fields(&mut map)?;
Ok(PaperFolderCreateError::InvalidFolderId)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(PaperFolderCreateError::Other)
}
}
}
}
const VARIANTS: &[&str] = &["insufficient_permissions",
"other",
"folder_not_found",
"invalid_folder_id"];
deserializer.deserialize_struct("PaperFolderCreateError", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperFolderCreateError {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperFolderCreateError::InsufficientPermissions => {
let mut s = serializer.serialize_struct("PaperFolderCreateError", 1)?;
s.serialize_field(".tag", "insufficient_permissions")?;
s.end()
}
PaperFolderCreateError::FolderNotFound => {
let mut s = serializer.serialize_struct("PaperFolderCreateError", 1)?;
s.serialize_field(".tag", "folder_not_found")?;
s.end()
}
PaperFolderCreateError::InvalidFolderId => {
let mut s = serializer.serialize_struct("PaperFolderCreateError", 1)?;
s.serialize_field(".tag", "invalid_folder_id")?;
s.end()
}
PaperFolderCreateError::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
impl ::std::error::Error for PaperFolderCreateError {
fn description(&self) -> &str {
"PaperFolderCreateError"
}
}
impl ::std::fmt::Display for PaperFolderCreateError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
write!(f, "{:?}", *self)
}
}
#[derive(Debug)]
pub struct PaperFolderCreateResult {
pub folder_id: String,
}
impl PaperFolderCreateResult {
pub fn new(folder_id: String) -> Self {
PaperFolderCreateResult {
folder_id,
}
}
}
const PAPER_FOLDER_CREATE_RESULT_FIELDS: &[&str] = &["folder_id"];
impl PaperFolderCreateResult {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<PaperFolderCreateResult, 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<PaperFolderCreateResult>, V::Error> {
let mut field_folder_id = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"folder_id" => {
if field_folder_id.is_some() {
return Err(::serde::de::Error::duplicate_field("folder_id"));
}
field_folder_id = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = PaperFolderCreateResult {
folder_id: field_folder_id.ok_or_else(|| ::serde::de::Error::missing_field("folder_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("folder_id", &self.folder_id)
}
}
impl<'de> ::serde::de::Deserialize<'de> for PaperFolderCreateResult {
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 = PaperFolderCreateResult;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperFolderCreateResult struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
PaperFolderCreateResult::internal_deserialize(map)
}
}
deserializer.deserialize_struct("PaperFolderCreateResult", PAPER_FOLDER_CREATE_RESULT_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for PaperFolderCreateResult {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("PaperFolderCreateResult", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct RefPaperDoc {
pub doc_id: PaperDocId,
}
impl RefPaperDoc {
pub fn new(doc_id: PaperDocId) -> Self {
RefPaperDoc {
doc_id,
}
}
}
const REF_PAPER_DOC_FIELDS: &[&str] = &["doc_id"];
impl RefPaperDoc {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<RefPaperDoc, 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<RefPaperDoc>, V::Error> {
let mut field_doc_id = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = RefPaperDoc {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_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("doc_id", &self.doc_id)
}
}
impl<'de> ::serde::de::Deserialize<'de> for RefPaperDoc {
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 = RefPaperDoc;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a RefPaperDoc struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
RefPaperDoc::internal_deserialize(map)
}
}
deserializer.deserialize_struct("RefPaperDoc", REF_PAPER_DOC_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for RefPaperDoc {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("RefPaperDoc", 1)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct RemovePaperDocUser {
pub doc_id: PaperDocId,
pub member: super::sharing::MemberSelector,
}
impl RemovePaperDocUser {
pub fn new(doc_id: PaperDocId, member: super::sharing::MemberSelector) -> Self {
RemovePaperDocUser {
doc_id,
member,
}
}
}
const REMOVE_PAPER_DOC_USER_FIELDS: &[&str] = &["doc_id",
"member"];
impl RemovePaperDocUser {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<RemovePaperDocUser, 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<RemovePaperDocUser>, V::Error> {
let mut field_doc_id = None;
let mut field_member = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"doc_id" => {
if field_doc_id.is_some() {
return Err(::serde::de::Error::duplicate_field("doc_id"));
}
field_doc_id = Some(map.next_value()?);
}
"member" => {
if field_member.is_some() {
return Err(::serde::de::Error::duplicate_field("member"));
}
field_member = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = RemovePaperDocUser {
doc_id: field_doc_id.ok_or_else(|| ::serde::de::Error::missing_field("doc_id"))?,
member: field_member.ok_or_else(|| ::serde::de::Error::missing_field("member"))?,
};
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("doc_id", &self.doc_id)?;
s.serialize_field("member", &self.member)
}
}
impl<'de> ::serde::de::Deserialize<'de> for RemovePaperDocUser {
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 = RemovePaperDocUser;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a RemovePaperDocUser struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
RemovePaperDocUser::internal_deserialize(map)
}
}
deserializer.deserialize_struct("RemovePaperDocUser", REMOVE_PAPER_DOC_USER_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for RemovePaperDocUser {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("RemovePaperDocUser", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub struct SharingPolicy {
pub public_sharing_policy: Option<SharingPublicPolicyType>,
pub team_sharing_policy: Option<SharingTeamPolicyType>,
}
impl Default for SharingPolicy {
fn default() -> Self {
SharingPolicy {
public_sharing_policy: None,
team_sharing_policy: None,
}
}
}
const SHARING_POLICY_FIELDS: &[&str] = &["public_sharing_policy",
"team_sharing_policy"];
impl SharingPolicy {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
mut map: V,
) -> Result<SharingPolicy, V::Error> {
let mut field_public_sharing_policy = None;
let mut field_team_sharing_policy = None;
while let Some(key) = map.next_key::<&str>()? {
match key {
"public_sharing_policy" => {
if field_public_sharing_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("public_sharing_policy"));
}
field_public_sharing_policy = Some(map.next_value()?);
}
"team_sharing_policy" => {
if field_team_sharing_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("team_sharing_policy"));
}
field_team_sharing_policy = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
let result = SharingPolicy {
public_sharing_policy: field_public_sharing_policy,
team_sharing_policy: field_team_sharing_policy,
};
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("public_sharing_policy", &self.public_sharing_policy)?;
s.serialize_field("team_sharing_policy", &self.team_sharing_policy)
}
}
impl<'de> ::serde::de::Deserialize<'de> for SharingPolicy {
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 = SharingPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SharingPolicy struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
SharingPolicy::internal_deserialize(map)
}
}
deserializer.deserialize_struct("SharingPolicy", SHARING_POLICY_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for SharingPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("SharingPolicy", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum SharingPublicPolicyType {
PeopleWithLinkCanEdit,
PeopleWithLinkCanViewAndComment,
InviteOnly,
Disabled,
}
impl<'de> ::serde::de::Deserialize<'de> for SharingPublicPolicyType {
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 = SharingPublicPolicyType;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SharingPublicPolicyType 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"))
};
match tag {
"people_with_link_can_edit" => {
crate::eat_json_fields(&mut map)?;
Ok(SharingPublicPolicyType::PeopleWithLinkCanEdit)
}
"people_with_link_can_view_and_comment" => {
crate::eat_json_fields(&mut map)?;
Ok(SharingPublicPolicyType::PeopleWithLinkCanViewAndComment)
}
"invite_only" => {
crate::eat_json_fields(&mut map)?;
Ok(SharingPublicPolicyType::InviteOnly)
}
"disabled" => {
crate::eat_json_fields(&mut map)?;
Ok(SharingPublicPolicyType::Disabled)
}
_ => Err(de::Error::unknown_variant(tag, VARIANTS))
}
}
}
const VARIANTS: &[&str] = &["people_with_link_can_edit",
"people_with_link_can_view_and_comment",
"invite_only",
"disabled"];
deserializer.deserialize_struct("SharingPublicPolicyType", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SharingPublicPolicyType {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SharingPublicPolicyType::PeopleWithLinkCanEdit => {
let mut s = serializer.serialize_struct("SharingPublicPolicyType", 1)?;
s.serialize_field(".tag", "people_with_link_can_edit")?;
s.end()
}
SharingPublicPolicyType::PeopleWithLinkCanViewAndComment => {
let mut s = serializer.serialize_struct("SharingPublicPolicyType", 1)?;
s.serialize_field(".tag", "people_with_link_can_view_and_comment")?;
s.end()
}
SharingPublicPolicyType::InviteOnly => {
let mut s = serializer.serialize_struct("SharingPublicPolicyType", 1)?;
s.serialize_field(".tag", "invite_only")?;
s.end()
}
SharingPublicPolicyType::Disabled => {
let mut s = serializer.serialize_struct("SharingPublicPolicyType", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
}
}
}
#[derive(Debug)]
pub enum SharingTeamPolicyType {
PeopleWithLinkCanEdit,
PeopleWithLinkCanViewAndComment,
InviteOnly,
}
impl<'de> ::serde::de::Deserialize<'de> for SharingTeamPolicyType {
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 = SharingTeamPolicyType;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SharingTeamPolicyType 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"))
};
match tag {
"people_with_link_can_edit" => {
crate::eat_json_fields(&mut map)?;
Ok(SharingTeamPolicyType::PeopleWithLinkCanEdit)
}
"people_with_link_can_view_and_comment" => {
crate::eat_json_fields(&mut map)?;
Ok(SharingTeamPolicyType::PeopleWithLinkCanViewAndComment)
}
"invite_only" => {
crate::eat_json_fields(&mut map)?;
Ok(SharingTeamPolicyType::InviteOnly)
}
_ => Err(de::Error::unknown_variant(tag, VARIANTS))
}
}
}
const VARIANTS: &[&str] = &["people_with_link_can_edit",
"people_with_link_can_view_and_comment",
"invite_only"];
deserializer.deserialize_struct("SharingTeamPolicyType", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SharingTeamPolicyType {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SharingTeamPolicyType::PeopleWithLinkCanEdit => {
let mut s = serializer.serialize_struct("SharingTeamPolicyType", 1)?;
s.serialize_field(".tag", "people_with_link_can_edit")?;
s.end()
}
SharingTeamPolicyType::PeopleWithLinkCanViewAndComment => {
let mut s = serializer.serialize_struct("SharingTeamPolicyType", 1)?;
s.serialize_field(".tag", "people_with_link_can_view_and_comment")?;
s.end()
}
SharingTeamPolicyType::InviteOnly => {
let mut s = serializer.serialize_struct("SharingTeamPolicyType", 1)?;
s.serialize_field(".tag", "invite_only")?;
s.end()
}
}
}
}
#[derive(Debug)]
pub struct UserInfoWithPermissionLevel {
pub user: super::sharing::UserInfo,
pub permission_level: PaperDocPermissionLevel,
}
impl UserInfoWithPermissionLevel {
pub fn new(user: super::sharing::UserInfo, permission_level: PaperDocPermissionLevel) -> Self {
UserInfoWithPermissionLevel {
user,
permission_level,
}
}
}
const USER_INFO_WITH_PERMISSION_LEVEL_FIELDS: &[&str] = &["user",
"permission_level"];
impl UserInfoWithPermissionLevel {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<UserInfoWithPermissionLevel, 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<UserInfoWithPermissionLevel>, V::Error> {
let mut field_user = None;
let mut field_permission_level = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"user" => {
if field_user.is_some() {
return Err(::serde::de::Error::duplicate_field("user"));
}
field_user = Some(map.next_value()?);
}
"permission_level" => {
if field_permission_level.is_some() {
return Err(::serde::de::Error::duplicate_field("permission_level"));
}
field_permission_level = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = UserInfoWithPermissionLevel {
user: field_user.ok_or_else(|| ::serde::de::Error::missing_field("user"))?,
permission_level: field_permission_level.ok_or_else(|| ::serde::de::Error::missing_field("permission_level"))?,
};
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("user", &self.user)?;
s.serialize_field("permission_level", &self.permission_level)
}
}
impl<'de> ::serde::de::Deserialize<'de> for UserInfoWithPermissionLevel {
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 = UserInfoWithPermissionLevel;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a UserInfoWithPermissionLevel struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
UserInfoWithPermissionLevel::internal_deserialize(map)
}
}
deserializer.deserialize_struct("UserInfoWithPermissionLevel", USER_INFO_WITH_PERMISSION_LEVEL_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for UserInfoWithPermissionLevel {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("UserInfoWithPermissionLevel", 2)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug)]
pub enum UserOnPaperDocFilter {
Visited,
Shared,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for UserOnPaperDocFilter {
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 = UserOnPaperDocFilter;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a UserOnPaperDocFilter 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"))
};
match tag {
"visited" => {
crate::eat_json_fields(&mut map)?;
Ok(UserOnPaperDocFilter::Visited)
}
"shared" => {
crate::eat_json_fields(&mut map)?;
Ok(UserOnPaperDocFilter::Shared)
}
_ => {
crate::eat_json_fields(&mut map)?;
Ok(UserOnPaperDocFilter::Other)
}
}
}
}
const VARIANTS: &[&str] = &["visited",
"shared",
"other"];
deserializer.deserialize_struct("UserOnPaperDocFilter", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for UserOnPaperDocFilter {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
UserOnPaperDocFilter::Visited => {
let mut s = serializer.serialize_struct("UserOnPaperDocFilter", 1)?;
s.serialize_field(".tag", "visited")?;
s.end()
}
UserOnPaperDocFilter::Shared => {
let mut s = serializer.serialize_struct("UserOnPaperDocFilter", 1)?;
s.serialize_field(".tag", "shared")?;
s.end()
}
UserOnPaperDocFilter::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}