#![allow(
clippy::too_many_arguments,
clippy::large_enum_variant,
clippy::doc_markdown,
)]
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum CameraUploadsPolicyState {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for CameraUploadsPolicyState {
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 = CameraUploadsPolicyState;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a CameraUploadsPolicyState structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => CameraUploadsPolicyState::Disabled,
"enabled" => CameraUploadsPolicyState::Enabled,
_ => CameraUploadsPolicyState::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("CameraUploadsPolicyState", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for CameraUploadsPolicyState {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
CameraUploadsPolicyState::Disabled => {
let mut s = serializer.serialize_struct("CameraUploadsPolicyState", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
CameraUploadsPolicyState::Enabled => {
let mut s = serializer.serialize_struct("CameraUploadsPolicyState", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
CameraUploadsPolicyState::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum ComputerBackupPolicyState {
Disabled,
Enabled,
Default,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ComputerBackupPolicyState {
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 = ComputerBackupPolicyState;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ComputerBackupPolicyState structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => ComputerBackupPolicyState::Disabled,
"enabled" => ComputerBackupPolicyState::Enabled,
"default" => ComputerBackupPolicyState::Default,
_ => ComputerBackupPolicyState::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"default",
"other"];
deserializer.deserialize_struct("ComputerBackupPolicyState", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ComputerBackupPolicyState {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ComputerBackupPolicyState::Disabled => {
let mut s = serializer.serialize_struct("ComputerBackupPolicyState", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
ComputerBackupPolicyState::Enabled => {
let mut s = serializer.serialize_struct("ComputerBackupPolicyState", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
ComputerBackupPolicyState::Default => {
let mut s = serializer.serialize_struct("ComputerBackupPolicyState", 1)?;
s.serialize_field(".tag", "default")?;
s.end()
}
ComputerBackupPolicyState::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum EmmState {
Disabled,
Optional,
Required,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for EmmState {
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 = EmmState;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a EmmState structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => EmmState::Disabled,
"optional" => EmmState::Optional,
"required" => EmmState::Required,
_ => EmmState::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"optional",
"required",
"other"];
deserializer.deserialize_struct("EmmState", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for EmmState {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
EmmState::Disabled => {
let mut s = serializer.serialize_struct("EmmState", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
EmmState::Optional => {
let mut s = serializer.serialize_struct("EmmState", 1)?;
s.serialize_field(".tag", "optional")?;
s.end()
}
EmmState::Required => {
let mut s = serializer.serialize_struct("EmmState", 1)?;
s.serialize_field(".tag", "required")?;
s.end()
}
EmmState::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum ExternalDriveBackupPolicyState {
Disabled,
Enabled,
Default,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ExternalDriveBackupPolicyState {
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 = ExternalDriveBackupPolicyState;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ExternalDriveBackupPolicyState structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => ExternalDriveBackupPolicyState::Disabled,
"enabled" => ExternalDriveBackupPolicyState::Enabled,
"default" => ExternalDriveBackupPolicyState::Default,
_ => ExternalDriveBackupPolicyState::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"default",
"other"];
deserializer.deserialize_struct("ExternalDriveBackupPolicyState", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ExternalDriveBackupPolicyState {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ExternalDriveBackupPolicyState::Disabled => {
let mut s = serializer.serialize_struct("ExternalDriveBackupPolicyState", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
ExternalDriveBackupPolicyState::Enabled => {
let mut s = serializer.serialize_struct("ExternalDriveBackupPolicyState", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
ExternalDriveBackupPolicyState::Default => {
let mut s = serializer.serialize_struct("ExternalDriveBackupPolicyState", 1)?;
s.serialize_field(".tag", "default")?;
s.end()
}
ExternalDriveBackupPolicyState::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum FileLockingPolicyState {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for FileLockingPolicyState {
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 = FileLockingPolicyState;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a FileLockingPolicyState structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => FileLockingPolicyState::Disabled,
"enabled" => FileLockingPolicyState::Enabled,
_ => FileLockingPolicyState::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("FileLockingPolicyState", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for FileLockingPolicyState {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
FileLockingPolicyState::Disabled => {
let mut s = serializer.serialize_struct("FileLockingPolicyState", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
FileLockingPolicyState::Enabled => {
let mut s = serializer.serialize_struct("FileLockingPolicyState", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
FileLockingPolicyState::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum GroupCreation {
AdminsAndMembers,
AdminsOnly,
}
impl<'de> ::serde::de::Deserialize<'de> for GroupCreation {
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 = GroupCreation;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a GroupCreation structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"admins_and_members" => GroupCreation::AdminsAndMembers,
"admins_only" => GroupCreation::AdminsOnly,
_ => return Err(de::Error::unknown_variant(tag, VARIANTS))
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["admins_and_members",
"admins_only"];
deserializer.deserialize_struct("GroupCreation", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for GroupCreation {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
GroupCreation::AdminsAndMembers => {
let mut s = serializer.serialize_struct("GroupCreation", 1)?;
s.serialize_field(".tag", "admins_and_members")?;
s.end()
}
GroupCreation::AdminsOnly => {
let mut s = serializer.serialize_struct("GroupCreation", 1)?;
s.serialize_field(".tag", "admins_only")?;
s.end()
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum OfficeAddInPolicy {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for OfficeAddInPolicy {
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 = OfficeAddInPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a OfficeAddInPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => OfficeAddInPolicy::Disabled,
"enabled" => OfficeAddInPolicy::Enabled,
_ => OfficeAddInPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("OfficeAddInPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for OfficeAddInPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
OfficeAddInPolicy::Disabled => {
let mut s = serializer.serialize_struct("OfficeAddInPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
OfficeAddInPolicy::Enabled => {
let mut s = serializer.serialize_struct("OfficeAddInPolicy", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
OfficeAddInPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum PaperDefaultFolderPolicy {
EveryoneInTeam,
InviteOnly,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDefaultFolderPolicy {
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 = PaperDefaultFolderPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDefaultFolderPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"everyone_in_team" => PaperDefaultFolderPolicy::EveryoneInTeam,
"invite_only" => PaperDefaultFolderPolicy::InviteOnly,
_ => PaperDefaultFolderPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["everyone_in_team",
"invite_only",
"other"];
deserializer.deserialize_struct("PaperDefaultFolderPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperDefaultFolderPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperDefaultFolderPolicy::EveryoneInTeam => {
let mut s = serializer.serialize_struct("PaperDefaultFolderPolicy", 1)?;
s.serialize_field(".tag", "everyone_in_team")?;
s.end()
}
PaperDefaultFolderPolicy::InviteOnly => {
let mut s = serializer.serialize_struct("PaperDefaultFolderPolicy", 1)?;
s.serialize_field(".tag", "invite_only")?;
s.end()
}
PaperDefaultFolderPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum PaperDeploymentPolicy {
Full,
Partial,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDeploymentPolicy {
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 = PaperDeploymentPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDeploymentPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"full" => PaperDeploymentPolicy::Full,
"partial" => PaperDeploymentPolicy::Partial,
_ => PaperDeploymentPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["full",
"partial",
"other"];
deserializer.deserialize_struct("PaperDeploymentPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperDeploymentPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperDeploymentPolicy::Full => {
let mut s = serializer.serialize_struct("PaperDeploymentPolicy", 1)?;
s.serialize_field(".tag", "full")?;
s.end()
}
PaperDeploymentPolicy::Partial => {
let mut s = serializer.serialize_struct("PaperDeploymentPolicy", 1)?;
s.serialize_field(".tag", "partial")?;
s.end()
}
PaperDeploymentPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum PaperDesktopPolicy {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperDesktopPolicy {
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 = PaperDesktopPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperDesktopPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => PaperDesktopPolicy::Disabled,
"enabled" => PaperDesktopPolicy::Enabled,
_ => PaperDesktopPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("PaperDesktopPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperDesktopPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperDesktopPolicy::Disabled => {
let mut s = serializer.serialize_struct("PaperDesktopPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
PaperDesktopPolicy::Enabled => {
let mut s = serializer.serialize_struct("PaperDesktopPolicy", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
PaperDesktopPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum PaperEnabledPolicy {
Disabled,
Enabled,
Unspecified,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PaperEnabledPolicy {
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 = PaperEnabledPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PaperEnabledPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => PaperEnabledPolicy::Disabled,
"enabled" => PaperEnabledPolicy::Enabled,
"unspecified" => PaperEnabledPolicy::Unspecified,
_ => PaperEnabledPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"unspecified",
"other"];
deserializer.deserialize_struct("PaperEnabledPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PaperEnabledPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PaperEnabledPolicy::Disabled => {
let mut s = serializer.serialize_struct("PaperEnabledPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
PaperEnabledPolicy::Enabled => {
let mut s = serializer.serialize_struct("PaperEnabledPolicy", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
PaperEnabledPolicy::Unspecified => {
let mut s = serializer.serialize_struct("PaperEnabledPolicy", 1)?;
s.serialize_field(".tag", "unspecified")?;
s.end()
}
PaperEnabledPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum PasswordControlMode {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PasswordControlMode {
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 = PasswordControlMode;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PasswordControlMode structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => PasswordControlMode::Disabled,
"enabled" => PasswordControlMode::Enabled,
_ => PasswordControlMode::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("PasswordControlMode", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PasswordControlMode {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PasswordControlMode::Disabled => {
let mut s = serializer.serialize_struct("PasswordControlMode", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
PasswordControlMode::Enabled => {
let mut s = serializer.serialize_struct("PasswordControlMode", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
PasswordControlMode::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum PasswordStrengthPolicy {
MinimalRequirements,
ModeratePassword,
StrongPassword,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for PasswordStrengthPolicy {
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 = PasswordStrengthPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a PasswordStrengthPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"minimal_requirements" => PasswordStrengthPolicy::MinimalRequirements,
"moderate_password" => PasswordStrengthPolicy::ModeratePassword,
"strong_password" => PasswordStrengthPolicy::StrongPassword,
_ => PasswordStrengthPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["minimal_requirements",
"moderate_password",
"strong_password",
"other"];
deserializer.deserialize_struct("PasswordStrengthPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for PasswordStrengthPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
PasswordStrengthPolicy::MinimalRequirements => {
let mut s = serializer.serialize_struct("PasswordStrengthPolicy", 1)?;
s.serialize_field(".tag", "minimal_requirements")?;
s.end()
}
PasswordStrengthPolicy::ModeratePassword => {
let mut s = serializer.serialize_struct("PasswordStrengthPolicy", 1)?;
s.serialize_field(".tag", "moderate_password")?;
s.end()
}
PasswordStrengthPolicy::StrongPassword => {
let mut s = serializer.serialize_struct("PasswordStrengthPolicy", 1)?;
s.serialize_field(".tag", "strong_password")?;
s.end()
}
PasswordStrengthPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RolloutMethod {
UnlinkAll,
UnlinkMostInactive,
AddMemberToExceptions,
}
impl<'de> ::serde::de::Deserialize<'de> for RolloutMethod {
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 = RolloutMethod;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a RolloutMethod structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"unlink_all" => RolloutMethod::UnlinkAll,
"unlink_most_inactive" => RolloutMethod::UnlinkMostInactive,
"add_member_to_exceptions" => RolloutMethod::AddMemberToExceptions,
_ => return Err(de::Error::unknown_variant(tag, VARIANTS))
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["unlink_all",
"unlink_most_inactive",
"add_member_to_exceptions"];
deserializer.deserialize_struct("RolloutMethod", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for RolloutMethod {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
RolloutMethod::UnlinkAll => {
let mut s = serializer.serialize_struct("RolloutMethod", 1)?;
s.serialize_field(".tag", "unlink_all")?;
s.end()
}
RolloutMethod::UnlinkMostInactive => {
let mut s = serializer.serialize_struct("RolloutMethod", 1)?;
s.serialize_field(".tag", "unlink_most_inactive")?;
s.end()
}
RolloutMethod::AddMemberToExceptions => {
let mut s = serializer.serialize_struct("RolloutMethod", 1)?;
s.serialize_field(".tag", "add_member_to_exceptions")?;
s.end()
}
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum SharedFolderJoinPolicy {
FromTeamOnly,
FromAnyone,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for SharedFolderJoinPolicy {
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 = SharedFolderJoinPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SharedFolderJoinPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"from_team_only" => SharedFolderJoinPolicy::FromTeamOnly,
"from_anyone" => SharedFolderJoinPolicy::FromAnyone,
_ => SharedFolderJoinPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["from_team_only",
"from_anyone",
"other"];
deserializer.deserialize_struct("SharedFolderJoinPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SharedFolderJoinPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SharedFolderJoinPolicy::FromTeamOnly => {
let mut s = serializer.serialize_struct("SharedFolderJoinPolicy", 1)?;
s.serialize_field(".tag", "from_team_only")?;
s.end()
}
SharedFolderJoinPolicy::FromAnyone => {
let mut s = serializer.serialize_struct("SharedFolderJoinPolicy", 1)?;
s.serialize_field(".tag", "from_anyone")?;
s.end()
}
SharedFolderJoinPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum SharedFolderMemberPolicy {
Team,
Anyone,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for SharedFolderMemberPolicy {
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 = SharedFolderMemberPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SharedFolderMemberPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"team" => SharedFolderMemberPolicy::Team,
"anyone" => SharedFolderMemberPolicy::Anyone,
_ => SharedFolderMemberPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["team",
"anyone",
"other"];
deserializer.deserialize_struct("SharedFolderMemberPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SharedFolderMemberPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SharedFolderMemberPolicy::Team => {
let mut s = serializer.serialize_struct("SharedFolderMemberPolicy", 1)?;
s.serialize_field(".tag", "team")?;
s.end()
}
SharedFolderMemberPolicy::Anyone => {
let mut s = serializer.serialize_struct("SharedFolderMemberPolicy", 1)?;
s.serialize_field(".tag", "anyone")?;
s.end()
}
SharedFolderMemberPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum SharedLinkCreatePolicy {
DefaultPublic,
DefaultTeamOnly,
TeamOnly,
DefaultNoOne,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for SharedLinkCreatePolicy {
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 = SharedLinkCreatePolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SharedLinkCreatePolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"default_public" => SharedLinkCreatePolicy::DefaultPublic,
"default_team_only" => SharedLinkCreatePolicy::DefaultTeamOnly,
"team_only" => SharedLinkCreatePolicy::TeamOnly,
"default_no_one" => SharedLinkCreatePolicy::DefaultNoOne,
_ => SharedLinkCreatePolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["default_public",
"default_team_only",
"team_only",
"default_no_one",
"other"];
deserializer.deserialize_struct("SharedLinkCreatePolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SharedLinkCreatePolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SharedLinkCreatePolicy::DefaultPublic => {
let mut s = serializer.serialize_struct("SharedLinkCreatePolicy", 1)?;
s.serialize_field(".tag", "default_public")?;
s.end()
}
SharedLinkCreatePolicy::DefaultTeamOnly => {
let mut s = serializer.serialize_struct("SharedLinkCreatePolicy", 1)?;
s.serialize_field(".tag", "default_team_only")?;
s.end()
}
SharedLinkCreatePolicy::TeamOnly => {
let mut s = serializer.serialize_struct("SharedLinkCreatePolicy", 1)?;
s.serialize_field(".tag", "team_only")?;
s.end()
}
SharedLinkCreatePolicy::DefaultNoOne => {
let mut s = serializer.serialize_struct("SharedLinkCreatePolicy", 1)?;
s.serialize_field(".tag", "default_no_one")?;
s.end()
}
SharedLinkCreatePolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum ShowcaseDownloadPolicy {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ShowcaseDownloadPolicy {
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 = ShowcaseDownloadPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ShowcaseDownloadPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => ShowcaseDownloadPolicy::Disabled,
"enabled" => ShowcaseDownloadPolicy::Enabled,
_ => ShowcaseDownloadPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("ShowcaseDownloadPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ShowcaseDownloadPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ShowcaseDownloadPolicy::Disabled => {
let mut s = serializer.serialize_struct("ShowcaseDownloadPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
ShowcaseDownloadPolicy::Enabled => {
let mut s = serializer.serialize_struct("ShowcaseDownloadPolicy", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
ShowcaseDownloadPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum ShowcaseEnabledPolicy {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ShowcaseEnabledPolicy {
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 = ShowcaseEnabledPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ShowcaseEnabledPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => ShowcaseEnabledPolicy::Disabled,
"enabled" => ShowcaseEnabledPolicy::Enabled,
_ => ShowcaseEnabledPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("ShowcaseEnabledPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ShowcaseEnabledPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ShowcaseEnabledPolicy::Disabled => {
let mut s = serializer.serialize_struct("ShowcaseEnabledPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
ShowcaseEnabledPolicy::Enabled => {
let mut s = serializer.serialize_struct("ShowcaseEnabledPolicy", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
ShowcaseEnabledPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum ShowcaseExternalSharingPolicy {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for ShowcaseExternalSharingPolicy {
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 = ShowcaseExternalSharingPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a ShowcaseExternalSharingPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => ShowcaseExternalSharingPolicy::Disabled,
"enabled" => ShowcaseExternalSharingPolicy::Enabled,
_ => ShowcaseExternalSharingPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("ShowcaseExternalSharingPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for ShowcaseExternalSharingPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
ShowcaseExternalSharingPolicy::Disabled => {
let mut s = serializer.serialize_struct("ShowcaseExternalSharingPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
ShowcaseExternalSharingPolicy::Enabled => {
let mut s = serializer.serialize_struct("ShowcaseExternalSharingPolicy", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
ShowcaseExternalSharingPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum SmartSyncPolicy {
Local,
OnDemand,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for SmartSyncPolicy {
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 = SmartSyncPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SmartSyncPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"local" => SmartSyncPolicy::Local,
"on_demand" => SmartSyncPolicy::OnDemand,
_ => SmartSyncPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["local",
"on_demand",
"other"];
deserializer.deserialize_struct("SmartSyncPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SmartSyncPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SmartSyncPolicy::Local => {
let mut s = serializer.serialize_struct("SmartSyncPolicy", 1)?;
s.serialize_field(".tag", "local")?;
s.end()
}
SmartSyncPolicy::OnDemand => {
let mut s = serializer.serialize_struct("SmartSyncPolicy", 1)?;
s.serialize_field(".tag", "on_demand")?;
s.end()
}
SmartSyncPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum SmarterSmartSyncPolicyState {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for SmarterSmartSyncPolicyState {
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 = SmarterSmartSyncPolicyState;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SmarterSmartSyncPolicyState structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => SmarterSmartSyncPolicyState::Disabled,
"enabled" => SmarterSmartSyncPolicyState::Enabled,
_ => SmarterSmartSyncPolicyState::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("SmarterSmartSyncPolicyState", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SmarterSmartSyncPolicyState {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SmarterSmartSyncPolicyState::Disabled => {
let mut s = serializer.serialize_struct("SmarterSmartSyncPolicyState", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
SmarterSmartSyncPolicyState::Enabled => {
let mut s = serializer.serialize_struct("SmarterSmartSyncPolicyState", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
SmarterSmartSyncPolicyState::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum SsoPolicy {
Disabled,
Optional,
Required,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for SsoPolicy {
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 = SsoPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SsoPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => SsoPolicy::Disabled,
"optional" => SsoPolicy::Optional,
"required" => SsoPolicy::Required,
_ => SsoPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"optional",
"required",
"other"];
deserializer.deserialize_struct("SsoPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SsoPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SsoPolicy::Disabled => {
let mut s = serializer.serialize_struct("SsoPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
SsoPolicy::Optional => {
let mut s = serializer.serialize_struct("SsoPolicy", 1)?;
s.serialize_field(".tag", "optional")?;
s.end()
}
SsoPolicy::Required => {
let mut s = serializer.serialize_struct("SsoPolicy", 1)?;
s.serialize_field(".tag", "required")?;
s.end()
}
SsoPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum SuggestMembersPolicy {
Disabled,
Enabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for SuggestMembersPolicy {
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 = SuggestMembersPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a SuggestMembersPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"disabled" => SuggestMembersPolicy::Disabled,
"enabled" => SuggestMembersPolicy::Enabled,
_ => SuggestMembersPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["disabled",
"enabled",
"other"];
deserializer.deserialize_struct("SuggestMembersPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for SuggestMembersPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
SuggestMembersPolicy::Disabled => {
let mut s = serializer.serialize_struct("SuggestMembersPolicy", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
SuggestMembersPolicy::Enabled => {
let mut s = serializer.serialize_struct("SuggestMembersPolicy", 1)?;
s.serialize_field(".tag", "enabled")?;
s.end()
}
SuggestMembersPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct TeamMemberPolicies {
pub sharing: TeamSharingPolicies,
pub emm_state: EmmState,
pub office_addin: OfficeAddInPolicy,
pub suggest_members_policy: SuggestMembersPolicy,
}
impl TeamMemberPolicies {
pub fn new(
sharing: TeamSharingPolicies,
emm_state: EmmState,
office_addin: OfficeAddInPolicy,
suggest_members_policy: SuggestMembersPolicy,
) -> Self {
TeamMemberPolicies {
sharing,
emm_state,
office_addin,
suggest_members_policy,
}
}
}
const TEAM_MEMBER_POLICIES_FIELDS: &[&str] = &["sharing",
"emm_state",
"office_addin",
"suggest_members_policy"];
impl TeamMemberPolicies {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<TeamMemberPolicies, 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<TeamMemberPolicies>, V::Error> {
let mut field_sharing = None;
let mut field_emm_state = None;
let mut field_office_addin = None;
let mut field_suggest_members_policy = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"sharing" => {
if field_sharing.is_some() {
return Err(::serde::de::Error::duplicate_field("sharing"));
}
field_sharing = Some(map.next_value()?);
}
"emm_state" => {
if field_emm_state.is_some() {
return Err(::serde::de::Error::duplicate_field("emm_state"));
}
field_emm_state = Some(map.next_value()?);
}
"office_addin" => {
if field_office_addin.is_some() {
return Err(::serde::de::Error::duplicate_field("office_addin"));
}
field_office_addin = Some(map.next_value()?);
}
"suggest_members_policy" => {
if field_suggest_members_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("suggest_members_policy"));
}
field_suggest_members_policy = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = TeamMemberPolicies {
sharing: field_sharing.ok_or_else(|| ::serde::de::Error::missing_field("sharing"))?,
emm_state: field_emm_state.ok_or_else(|| ::serde::de::Error::missing_field("emm_state"))?,
office_addin: field_office_addin.ok_or_else(|| ::serde::de::Error::missing_field("office_addin"))?,
suggest_members_policy: field_suggest_members_policy.ok_or_else(|| ::serde::de::Error::missing_field("suggest_members_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("sharing", &self.sharing)?;
s.serialize_field("emm_state", &self.emm_state)?;
s.serialize_field("office_addin", &self.office_addin)?;
s.serialize_field("suggest_members_policy", &self.suggest_members_policy)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for TeamMemberPolicies {
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 = TeamMemberPolicies;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a TeamMemberPolicies struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
TeamMemberPolicies::internal_deserialize(map)
}
}
deserializer.deserialize_struct("TeamMemberPolicies", TEAM_MEMBER_POLICIES_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for TeamMemberPolicies {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("TeamMemberPolicies", 4)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub struct TeamSharingPolicies {
pub shared_folder_member_policy: SharedFolderMemberPolicy,
pub shared_folder_join_policy: SharedFolderJoinPolicy,
pub shared_link_create_policy: SharedLinkCreatePolicy,
}
impl TeamSharingPolicies {
pub fn new(
shared_folder_member_policy: SharedFolderMemberPolicy,
shared_folder_join_policy: SharedFolderJoinPolicy,
shared_link_create_policy: SharedLinkCreatePolicy,
) -> Self {
TeamSharingPolicies {
shared_folder_member_policy,
shared_folder_join_policy,
shared_link_create_policy,
}
}
}
const TEAM_SHARING_POLICIES_FIELDS: &[&str] = &["shared_folder_member_policy",
"shared_folder_join_policy",
"shared_link_create_policy"];
impl TeamSharingPolicies {
pub(crate) fn internal_deserialize<'de, V: ::serde::de::MapAccess<'de>>(
map: V,
) -> Result<TeamSharingPolicies, 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<TeamSharingPolicies>, V::Error> {
let mut field_shared_folder_member_policy = None;
let mut field_shared_folder_join_policy = None;
let mut field_shared_link_create_policy = None;
let mut nothing = true;
while let Some(key) = map.next_key::<&str>()? {
nothing = false;
match key {
"shared_folder_member_policy" => {
if field_shared_folder_member_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("shared_folder_member_policy"));
}
field_shared_folder_member_policy = Some(map.next_value()?);
}
"shared_folder_join_policy" => {
if field_shared_folder_join_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("shared_folder_join_policy"));
}
field_shared_folder_join_policy = Some(map.next_value()?);
}
"shared_link_create_policy" => {
if field_shared_link_create_policy.is_some() {
return Err(::serde::de::Error::duplicate_field("shared_link_create_policy"));
}
field_shared_link_create_policy = Some(map.next_value()?);
}
_ => {
map.next_value::<::serde_json::Value>()?;
}
}
}
if optional && nothing {
return Ok(None);
}
let result = TeamSharingPolicies {
shared_folder_member_policy: field_shared_folder_member_policy.ok_or_else(|| ::serde::de::Error::missing_field("shared_folder_member_policy"))?,
shared_folder_join_policy: field_shared_folder_join_policy.ok_or_else(|| ::serde::de::Error::missing_field("shared_folder_join_policy"))?,
shared_link_create_policy: field_shared_link_create_policy.ok_or_else(|| ::serde::de::Error::missing_field("shared_link_create_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("shared_folder_member_policy", &self.shared_folder_member_policy)?;
s.serialize_field("shared_folder_join_policy", &self.shared_folder_join_policy)?;
s.serialize_field("shared_link_create_policy", &self.shared_link_create_policy)?;
Ok(())
}
}
impl<'de> ::serde::de::Deserialize<'de> for TeamSharingPolicies {
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 = TeamSharingPolicies;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a TeamSharingPolicies struct")
}
fn visit_map<V: MapAccess<'de>>(self, map: V) -> Result<Self::Value, V::Error> {
TeamSharingPolicies::internal_deserialize(map)
}
}
deserializer.deserialize_struct("TeamSharingPolicies", TEAM_SHARING_POLICIES_FIELDS, StructVisitor)
}
}
impl ::serde::ser::Serialize for TeamSharingPolicies {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
let mut s = serializer.serialize_struct("TeamSharingPolicies", 3)?;
self.internal_serialize::<S>(&mut s)?;
s.end()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum TwoStepVerificationPolicy {
RequireTfaEnable,
RequireTfaDisable,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for TwoStepVerificationPolicy {
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 = TwoStepVerificationPolicy;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a TwoStepVerificationPolicy structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"require_tfa_enable" => TwoStepVerificationPolicy::RequireTfaEnable,
"require_tfa_disable" => TwoStepVerificationPolicy::RequireTfaDisable,
_ => TwoStepVerificationPolicy::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["require_tfa_enable",
"require_tfa_disable",
"other"];
deserializer.deserialize_struct("TwoStepVerificationPolicy", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for TwoStepVerificationPolicy {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
TwoStepVerificationPolicy::RequireTfaEnable => {
let mut s = serializer.serialize_struct("TwoStepVerificationPolicy", 1)?;
s.serialize_field(".tag", "require_tfa_enable")?;
s.end()
}
TwoStepVerificationPolicy::RequireTfaDisable => {
let mut s = serializer.serialize_struct("TwoStepVerificationPolicy", 1)?;
s.serialize_field(".tag", "require_tfa_disable")?;
s.end()
}
TwoStepVerificationPolicy::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive] pub enum TwoStepVerificationState {
Required,
Optional,
Disabled,
Other,
}
impl<'de> ::serde::de::Deserialize<'de> for TwoStepVerificationState {
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 = TwoStepVerificationState;
fn expecting(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
f.write_str("a TwoStepVerificationState structure")
}
fn visit_map<V: MapAccess<'de>>(self, mut map: V) -> Result<Self::Value, V::Error> {
let tag: &str = match map.next_key()? {
Some(".tag") => map.next_value()?,
_ => return Err(de::Error::missing_field(".tag"))
};
let value = match tag {
"required" => TwoStepVerificationState::Required,
"optional" => TwoStepVerificationState::Optional,
"disabled" => TwoStepVerificationState::Disabled,
_ => TwoStepVerificationState::Other,
};
crate::eat_json_fields(&mut map)?;
Ok(value)
}
}
const VARIANTS: &[&str] = &["required",
"optional",
"disabled",
"other"];
deserializer.deserialize_struct("TwoStepVerificationState", VARIANTS, EnumVisitor)
}
}
impl ::serde::ser::Serialize for TwoStepVerificationState {
fn serialize<S: ::serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeStruct;
match *self {
TwoStepVerificationState::Required => {
let mut s = serializer.serialize_struct("TwoStepVerificationState", 1)?;
s.serialize_field(".tag", "required")?;
s.end()
}
TwoStepVerificationState::Optional => {
let mut s = serializer.serialize_struct("TwoStepVerificationState", 1)?;
s.serialize_field(".tag", "optional")?;
s.end()
}
TwoStepVerificationState::Disabled => {
let mut s = serializer.serialize_struct("TwoStepVerificationState", 1)?;
s.serialize_field(".tag", "disabled")?;
s.end()
}
TwoStepVerificationState::Other => Err(::serde::ser::Error::custom("cannot serialize 'Other' variant"))
}
}
}