jacquard-api 0.11.0

// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: tools.ozone.report.defs
//
// This file was automatically generated from Lexicon schemas.
// Any manual changes will be overwritten on the next regeneration.

use jacquard_common::CowStr;
use jacquard_derive::IntoStatic;
use serde::{Serialize, Deserialize};
/// Appeal a previously taken moderation action

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonAppeal;
impl core::fmt::Display for ReasonAppeal {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonAppeal")
    }
}

/// Child sexual abuse material (CSAM). These reports will be sent only be sent to the application's Moderation Authority.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonChildSafetyCsam;
impl core::fmt::Display for ReasonChildSafetyCsam {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonChildSafetyCSAM")
    }
}

/// Grooming or predatory behavior. These reports will be sent only be sent to the application's Moderation Authority.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonChildSafetyGroom;
impl core::fmt::Display for ReasonChildSafetyGroom {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonChildSafetyGroom")
    }
}

/// Harassment or bullying of minors

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonChildSafetyHarassment;
impl core::fmt::Display for ReasonChildSafetyHarassment {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonChildSafetyHarassment")
    }
}

/// Other child safety. These reports will be sent only be sent to the application's Moderation Authority.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonChildSafetyOther;
impl core::fmt::Display for ReasonChildSafetyOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonChildSafetyOther")
    }
}

/// Privacy violation involving a minor

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonChildSafetyPrivacy;
impl core::fmt::Display for ReasonChildSafetyPrivacy {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonChildSafetyPrivacy")
    }
}

/// Doxxing

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonHarassmentDoxxing;
impl core::fmt::Display for ReasonHarassmentDoxxing {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonHarassmentDoxxing")
    }
}

/// Hate speech

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonHarassmentHateSpeech;
impl core::fmt::Display for ReasonHarassmentHateSpeech {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonHarassmentHateSpeech")
    }
}

/// Other harassing or hateful content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonHarassmentOther;
impl core::fmt::Display for ReasonHarassmentOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonHarassmentOther")
    }
}

/// Targeted harassment

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonHarassmentTargeted;
impl core::fmt::Display for ReasonHarassmentTargeted {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonHarassmentTargeted")
    }
}

/// Trolling

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonHarassmentTroll;
impl core::fmt::Display for ReasonHarassmentTroll {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonHarassmentTroll")
    }
}

/// Fake account or bot

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonMisleadingBot;
impl core::fmt::Display for ReasonMisleadingBot {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonMisleadingBot")
    }
}

/// False information about elections

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonMisleadingElections;
impl core::fmt::Display for ReasonMisleadingElections {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonMisleadingElections")
    }
}

/// Impersonation

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonMisleadingImpersonation;
impl core::fmt::Display for ReasonMisleadingImpersonation {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonMisleadingImpersonation")
    }
}

/// Other misleading content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonMisleadingOther;
impl core::fmt::Display for ReasonMisleadingOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonMisleadingOther")
    }
}

/// Scam

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonMisleadingScam;
impl core::fmt::Display for ReasonMisleadingScam {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonMisleadingScam")
    }
}

/// Spam

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonMisleadingSpam;
impl core::fmt::Display for ReasonMisleadingSpam {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonMisleadingSpam")
    }
}

/// An issue not included in these options

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonOther;
impl core::fmt::Display for ReasonOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonOther")
    }
}

/// Banned user returning

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonRuleBanEvasion;
impl core::fmt::Display for ReasonRuleBanEvasion {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonRuleBanEvasion")
    }
}

/// Other

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonRuleOther;
impl core::fmt::Display for ReasonRuleOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonRuleOther")
    }
}

/// Promoting or selling prohibited items or services

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonRuleProhibitedSales;
impl core::fmt::Display for ReasonRuleProhibitedSales {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonRuleProhibitedSales")
    }
}

/// Hacking or system attacks

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonRuleSiteSecurity;
impl core::fmt::Display for ReasonRuleSiteSecurity {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonRuleSiteSecurity")
    }
}

/// Content promoting or depicting self-harm

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSelfHarmContent;
impl core::fmt::Display for ReasonSelfHarmContent {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSelfHarmContent")
    }
}

/// Eating disorders

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSelfHarmEd;
impl core::fmt::Display for ReasonSelfHarmEd {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSelfHarmED")
    }
}

/// Other dangerous content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSelfHarmOther;
impl core::fmt::Display for ReasonSelfHarmOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSelfHarmOther")
    }
}

/// Dangerous challenges or activities

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSelfHarmStunts;
impl core::fmt::Display for ReasonSelfHarmStunts {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSelfHarmStunts")
    }
}

/// Dangerous substances or drug abuse

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSelfHarmSubstances;
impl core::fmt::Display for ReasonSelfHarmSubstances {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSelfHarmSubstances")
    }
}

/// Adult sexual abuse content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSexualAbuseContent;
impl core::fmt::Display for ReasonSexualAbuseContent {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSexualAbuseContent")
    }
}

/// Animal sexual abuse

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSexualAnimal;
impl core::fmt::Display for ReasonSexualAnimal {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSexualAnimal")
    }
}

/// Deepfake adult content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSexualDeepfake;
impl core::fmt::Display for ReasonSexualDeepfake {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSexualDeepfake")
    }
}

/// Non-consensual intimate imagery

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSexualNcii;
impl core::fmt::Display for ReasonSexualNcii {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSexualNCII")
    }
}

/// Other sexual violence content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSexualOther;
impl core::fmt::Display for ReasonSexualOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSexualOther")
    }
}

/// Unlabelled adult content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonSexualUnlabeled;
impl core::fmt::Display for ReasonSexualUnlabeled {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonSexualUnlabeled")
    }
}


#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ReasonType<'a> {
    ToolsOzoneReportDefsReasonAppeal,
    ToolsOzoneReportDefsReasonOther,
    ToolsOzoneReportDefsReasonViolenceAnimal,
    ToolsOzoneReportDefsReasonViolenceThreats,
    ToolsOzoneReportDefsReasonViolenceGraphicContent,
    ToolsOzoneReportDefsReasonViolenceGlorification,
    ToolsOzoneReportDefsReasonViolenceExtremistContent,
    ToolsOzoneReportDefsReasonViolenceTrafficking,
    ToolsOzoneReportDefsReasonViolenceOther,
    ToolsOzoneReportDefsReasonSexualAbuseContent,
    ToolsOzoneReportDefsReasonSexualNcii,
    ToolsOzoneReportDefsReasonSexualDeepfake,
    ToolsOzoneReportDefsReasonSexualAnimal,
    ToolsOzoneReportDefsReasonSexualUnlabeled,
    ToolsOzoneReportDefsReasonSexualOther,
    ToolsOzoneReportDefsReasonChildSafetyCsam,
    ToolsOzoneReportDefsReasonChildSafetyGroom,
    ToolsOzoneReportDefsReasonChildSafetyPrivacy,
    ToolsOzoneReportDefsReasonChildSafetyHarassment,
    ToolsOzoneReportDefsReasonChildSafetyOther,
    ToolsOzoneReportDefsReasonHarassmentTroll,
    ToolsOzoneReportDefsReasonHarassmentTargeted,
    ToolsOzoneReportDefsReasonHarassmentHateSpeech,
    ToolsOzoneReportDefsReasonHarassmentDoxxing,
    ToolsOzoneReportDefsReasonHarassmentOther,
    ToolsOzoneReportDefsReasonMisleadingBot,
    ToolsOzoneReportDefsReasonMisleadingImpersonation,
    ToolsOzoneReportDefsReasonMisleadingSpam,
    ToolsOzoneReportDefsReasonMisleadingScam,
    ToolsOzoneReportDefsReasonMisleadingElections,
    ToolsOzoneReportDefsReasonMisleadingOther,
    ToolsOzoneReportDefsReasonRuleSiteSecurity,
    ToolsOzoneReportDefsReasonRuleProhibitedSales,
    ToolsOzoneReportDefsReasonRuleBanEvasion,
    ToolsOzoneReportDefsReasonRuleOther,
    ToolsOzoneReportDefsReasonSelfHarmContent,
    ToolsOzoneReportDefsReasonSelfHarmEd,
    ToolsOzoneReportDefsReasonSelfHarmStunts,
    ToolsOzoneReportDefsReasonSelfHarmSubstances,
    ToolsOzoneReportDefsReasonSelfHarmOther,
    Other(CowStr<'a>),
}

impl<'a> ReasonType<'a> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::ToolsOzoneReportDefsReasonAppeal => {
                "tools.ozone.report.defs#reasonAppeal"
            }
            Self::ToolsOzoneReportDefsReasonOther => {
                "tools.ozone.report.defs#reasonOther"
            }
            Self::ToolsOzoneReportDefsReasonViolenceAnimal => {
                "tools.ozone.report.defs#reasonViolenceAnimal"
            }
            Self::ToolsOzoneReportDefsReasonViolenceThreats => {
                "tools.ozone.report.defs#reasonViolenceThreats"
            }
            Self::ToolsOzoneReportDefsReasonViolenceGraphicContent => {
                "tools.ozone.report.defs#reasonViolenceGraphicContent"
            }
            Self::ToolsOzoneReportDefsReasonViolenceGlorification => {
                "tools.ozone.report.defs#reasonViolenceGlorification"
            }
            Self::ToolsOzoneReportDefsReasonViolenceExtremistContent => {
                "tools.ozone.report.defs#reasonViolenceExtremistContent"
            }
            Self::ToolsOzoneReportDefsReasonViolenceTrafficking => {
                "tools.ozone.report.defs#reasonViolenceTrafficking"
            }
            Self::ToolsOzoneReportDefsReasonViolenceOther => {
                "tools.ozone.report.defs#reasonViolenceOther"
            }
            Self::ToolsOzoneReportDefsReasonSexualAbuseContent => {
                "tools.ozone.report.defs#reasonSexualAbuseContent"
            }
            Self::ToolsOzoneReportDefsReasonSexualNcii => {
                "tools.ozone.report.defs#reasonSexualNCII"
            }
            Self::ToolsOzoneReportDefsReasonSexualDeepfake => {
                "tools.ozone.report.defs#reasonSexualDeepfake"
            }
            Self::ToolsOzoneReportDefsReasonSexualAnimal => {
                "tools.ozone.report.defs#reasonSexualAnimal"
            }
            Self::ToolsOzoneReportDefsReasonSexualUnlabeled => {
                "tools.ozone.report.defs#reasonSexualUnlabeled"
            }
            Self::ToolsOzoneReportDefsReasonSexualOther => {
                "tools.ozone.report.defs#reasonSexualOther"
            }
            Self::ToolsOzoneReportDefsReasonChildSafetyCsam => {
                "tools.ozone.report.defs#reasonChildSafetyCSAM"
            }
            Self::ToolsOzoneReportDefsReasonChildSafetyGroom => {
                "tools.ozone.report.defs#reasonChildSafetyGroom"
            }
            Self::ToolsOzoneReportDefsReasonChildSafetyPrivacy => {
                "tools.ozone.report.defs#reasonChildSafetyPrivacy"
            }
            Self::ToolsOzoneReportDefsReasonChildSafetyHarassment => {
                "tools.ozone.report.defs#reasonChildSafetyHarassment"
            }
            Self::ToolsOzoneReportDefsReasonChildSafetyOther => {
                "tools.ozone.report.defs#reasonChildSafetyOther"
            }
            Self::ToolsOzoneReportDefsReasonHarassmentTroll => {
                "tools.ozone.report.defs#reasonHarassmentTroll"
            }
            Self::ToolsOzoneReportDefsReasonHarassmentTargeted => {
                "tools.ozone.report.defs#reasonHarassmentTargeted"
            }
            Self::ToolsOzoneReportDefsReasonHarassmentHateSpeech => {
                "tools.ozone.report.defs#reasonHarassmentHateSpeech"
            }
            Self::ToolsOzoneReportDefsReasonHarassmentDoxxing => {
                "tools.ozone.report.defs#reasonHarassmentDoxxing"
            }
            Self::ToolsOzoneReportDefsReasonHarassmentOther => {
                "tools.ozone.report.defs#reasonHarassmentOther"
            }
            Self::ToolsOzoneReportDefsReasonMisleadingBot => {
                "tools.ozone.report.defs#reasonMisleadingBot"
            }
            Self::ToolsOzoneReportDefsReasonMisleadingImpersonation => {
                "tools.ozone.report.defs#reasonMisleadingImpersonation"
            }
            Self::ToolsOzoneReportDefsReasonMisleadingSpam => {
                "tools.ozone.report.defs#reasonMisleadingSpam"
            }
            Self::ToolsOzoneReportDefsReasonMisleadingScam => {
                "tools.ozone.report.defs#reasonMisleadingScam"
            }
            Self::ToolsOzoneReportDefsReasonMisleadingElections => {
                "tools.ozone.report.defs#reasonMisleadingElections"
            }
            Self::ToolsOzoneReportDefsReasonMisleadingOther => {
                "tools.ozone.report.defs#reasonMisleadingOther"
            }
            Self::ToolsOzoneReportDefsReasonRuleSiteSecurity => {
                "tools.ozone.report.defs#reasonRuleSiteSecurity"
            }
            Self::ToolsOzoneReportDefsReasonRuleProhibitedSales => {
                "tools.ozone.report.defs#reasonRuleProhibitedSales"
            }
            Self::ToolsOzoneReportDefsReasonRuleBanEvasion => {
                "tools.ozone.report.defs#reasonRuleBanEvasion"
            }
            Self::ToolsOzoneReportDefsReasonRuleOther => {
                "tools.ozone.report.defs#reasonRuleOther"
            }
            Self::ToolsOzoneReportDefsReasonSelfHarmContent => {
                "tools.ozone.report.defs#reasonSelfHarmContent"
            }
            Self::ToolsOzoneReportDefsReasonSelfHarmEd => {
                "tools.ozone.report.defs#reasonSelfHarmED"
            }
            Self::ToolsOzoneReportDefsReasonSelfHarmStunts => {
                "tools.ozone.report.defs#reasonSelfHarmStunts"
            }
            Self::ToolsOzoneReportDefsReasonSelfHarmSubstances => {
                "tools.ozone.report.defs#reasonSelfHarmSubstances"
            }
            Self::ToolsOzoneReportDefsReasonSelfHarmOther => {
                "tools.ozone.report.defs#reasonSelfHarmOther"
            }
            Self::Other(s) => s.as_ref(),
        }
    }
}

impl<'a> From<&'a str> for ReasonType<'a> {
    fn from(s: &'a str) -> Self {
        match s {
            "tools.ozone.report.defs#reasonAppeal" => {
                Self::ToolsOzoneReportDefsReasonAppeal
            }
            "tools.ozone.report.defs#reasonOther" => {
                Self::ToolsOzoneReportDefsReasonOther
            }
            "tools.ozone.report.defs#reasonViolenceAnimal" => {
                Self::ToolsOzoneReportDefsReasonViolenceAnimal
            }
            "tools.ozone.report.defs#reasonViolenceThreats" => {
                Self::ToolsOzoneReportDefsReasonViolenceThreats
            }
            "tools.ozone.report.defs#reasonViolenceGraphicContent" => {
                Self::ToolsOzoneReportDefsReasonViolenceGraphicContent
            }
            "tools.ozone.report.defs#reasonViolenceGlorification" => {
                Self::ToolsOzoneReportDefsReasonViolenceGlorification
            }
            "tools.ozone.report.defs#reasonViolenceExtremistContent" => {
                Self::ToolsOzoneReportDefsReasonViolenceExtremistContent
            }
            "tools.ozone.report.defs#reasonViolenceTrafficking" => {
                Self::ToolsOzoneReportDefsReasonViolenceTrafficking
            }
            "tools.ozone.report.defs#reasonViolenceOther" => {
                Self::ToolsOzoneReportDefsReasonViolenceOther
            }
            "tools.ozone.report.defs#reasonSexualAbuseContent" => {
                Self::ToolsOzoneReportDefsReasonSexualAbuseContent
            }
            "tools.ozone.report.defs#reasonSexualNCII" => {
                Self::ToolsOzoneReportDefsReasonSexualNcii
            }
            "tools.ozone.report.defs#reasonSexualDeepfake" => {
                Self::ToolsOzoneReportDefsReasonSexualDeepfake
            }
            "tools.ozone.report.defs#reasonSexualAnimal" => {
                Self::ToolsOzoneReportDefsReasonSexualAnimal
            }
            "tools.ozone.report.defs#reasonSexualUnlabeled" => {
                Self::ToolsOzoneReportDefsReasonSexualUnlabeled
            }
            "tools.ozone.report.defs#reasonSexualOther" => {
                Self::ToolsOzoneReportDefsReasonSexualOther
            }
            "tools.ozone.report.defs#reasonChildSafetyCSAM" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyCsam
            }
            "tools.ozone.report.defs#reasonChildSafetyGroom" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyGroom
            }
            "tools.ozone.report.defs#reasonChildSafetyPrivacy" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyPrivacy
            }
            "tools.ozone.report.defs#reasonChildSafetyHarassment" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyHarassment
            }
            "tools.ozone.report.defs#reasonChildSafetyOther" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyOther
            }
            "tools.ozone.report.defs#reasonHarassmentTroll" => {
                Self::ToolsOzoneReportDefsReasonHarassmentTroll
            }
            "tools.ozone.report.defs#reasonHarassmentTargeted" => {
                Self::ToolsOzoneReportDefsReasonHarassmentTargeted
            }
            "tools.ozone.report.defs#reasonHarassmentHateSpeech" => {
                Self::ToolsOzoneReportDefsReasonHarassmentHateSpeech
            }
            "tools.ozone.report.defs#reasonHarassmentDoxxing" => {
                Self::ToolsOzoneReportDefsReasonHarassmentDoxxing
            }
            "tools.ozone.report.defs#reasonHarassmentOther" => {
                Self::ToolsOzoneReportDefsReasonHarassmentOther
            }
            "tools.ozone.report.defs#reasonMisleadingBot" => {
                Self::ToolsOzoneReportDefsReasonMisleadingBot
            }
            "tools.ozone.report.defs#reasonMisleadingImpersonation" => {
                Self::ToolsOzoneReportDefsReasonMisleadingImpersonation
            }
            "tools.ozone.report.defs#reasonMisleadingSpam" => {
                Self::ToolsOzoneReportDefsReasonMisleadingSpam
            }
            "tools.ozone.report.defs#reasonMisleadingScam" => {
                Self::ToolsOzoneReportDefsReasonMisleadingScam
            }
            "tools.ozone.report.defs#reasonMisleadingElections" => {
                Self::ToolsOzoneReportDefsReasonMisleadingElections
            }
            "tools.ozone.report.defs#reasonMisleadingOther" => {
                Self::ToolsOzoneReportDefsReasonMisleadingOther
            }
            "tools.ozone.report.defs#reasonRuleSiteSecurity" => {
                Self::ToolsOzoneReportDefsReasonRuleSiteSecurity
            }
            "tools.ozone.report.defs#reasonRuleProhibitedSales" => {
                Self::ToolsOzoneReportDefsReasonRuleProhibitedSales
            }
            "tools.ozone.report.defs#reasonRuleBanEvasion" => {
                Self::ToolsOzoneReportDefsReasonRuleBanEvasion
            }
            "tools.ozone.report.defs#reasonRuleOther" => {
                Self::ToolsOzoneReportDefsReasonRuleOther
            }
            "tools.ozone.report.defs#reasonSelfHarmContent" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmContent
            }
            "tools.ozone.report.defs#reasonSelfHarmED" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmEd
            }
            "tools.ozone.report.defs#reasonSelfHarmStunts" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmStunts
            }
            "tools.ozone.report.defs#reasonSelfHarmSubstances" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmSubstances
            }
            "tools.ozone.report.defs#reasonSelfHarmOther" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmOther
            }
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> From<String> for ReasonType<'a> {
    fn from(s: String) -> Self {
        match s.as_str() {
            "tools.ozone.report.defs#reasonAppeal" => {
                Self::ToolsOzoneReportDefsReasonAppeal
            }
            "tools.ozone.report.defs#reasonOther" => {
                Self::ToolsOzoneReportDefsReasonOther
            }
            "tools.ozone.report.defs#reasonViolenceAnimal" => {
                Self::ToolsOzoneReportDefsReasonViolenceAnimal
            }
            "tools.ozone.report.defs#reasonViolenceThreats" => {
                Self::ToolsOzoneReportDefsReasonViolenceThreats
            }
            "tools.ozone.report.defs#reasonViolenceGraphicContent" => {
                Self::ToolsOzoneReportDefsReasonViolenceGraphicContent
            }
            "tools.ozone.report.defs#reasonViolenceGlorification" => {
                Self::ToolsOzoneReportDefsReasonViolenceGlorification
            }
            "tools.ozone.report.defs#reasonViolenceExtremistContent" => {
                Self::ToolsOzoneReportDefsReasonViolenceExtremistContent
            }
            "tools.ozone.report.defs#reasonViolenceTrafficking" => {
                Self::ToolsOzoneReportDefsReasonViolenceTrafficking
            }
            "tools.ozone.report.defs#reasonViolenceOther" => {
                Self::ToolsOzoneReportDefsReasonViolenceOther
            }
            "tools.ozone.report.defs#reasonSexualAbuseContent" => {
                Self::ToolsOzoneReportDefsReasonSexualAbuseContent
            }
            "tools.ozone.report.defs#reasonSexualNCII" => {
                Self::ToolsOzoneReportDefsReasonSexualNcii
            }
            "tools.ozone.report.defs#reasonSexualDeepfake" => {
                Self::ToolsOzoneReportDefsReasonSexualDeepfake
            }
            "tools.ozone.report.defs#reasonSexualAnimal" => {
                Self::ToolsOzoneReportDefsReasonSexualAnimal
            }
            "tools.ozone.report.defs#reasonSexualUnlabeled" => {
                Self::ToolsOzoneReportDefsReasonSexualUnlabeled
            }
            "tools.ozone.report.defs#reasonSexualOther" => {
                Self::ToolsOzoneReportDefsReasonSexualOther
            }
            "tools.ozone.report.defs#reasonChildSafetyCSAM" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyCsam
            }
            "tools.ozone.report.defs#reasonChildSafetyGroom" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyGroom
            }
            "tools.ozone.report.defs#reasonChildSafetyPrivacy" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyPrivacy
            }
            "tools.ozone.report.defs#reasonChildSafetyHarassment" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyHarassment
            }
            "tools.ozone.report.defs#reasonChildSafetyOther" => {
                Self::ToolsOzoneReportDefsReasonChildSafetyOther
            }
            "tools.ozone.report.defs#reasonHarassmentTroll" => {
                Self::ToolsOzoneReportDefsReasonHarassmentTroll
            }
            "tools.ozone.report.defs#reasonHarassmentTargeted" => {
                Self::ToolsOzoneReportDefsReasonHarassmentTargeted
            }
            "tools.ozone.report.defs#reasonHarassmentHateSpeech" => {
                Self::ToolsOzoneReportDefsReasonHarassmentHateSpeech
            }
            "tools.ozone.report.defs#reasonHarassmentDoxxing" => {
                Self::ToolsOzoneReportDefsReasonHarassmentDoxxing
            }
            "tools.ozone.report.defs#reasonHarassmentOther" => {
                Self::ToolsOzoneReportDefsReasonHarassmentOther
            }
            "tools.ozone.report.defs#reasonMisleadingBot" => {
                Self::ToolsOzoneReportDefsReasonMisleadingBot
            }
            "tools.ozone.report.defs#reasonMisleadingImpersonation" => {
                Self::ToolsOzoneReportDefsReasonMisleadingImpersonation
            }
            "tools.ozone.report.defs#reasonMisleadingSpam" => {
                Self::ToolsOzoneReportDefsReasonMisleadingSpam
            }
            "tools.ozone.report.defs#reasonMisleadingScam" => {
                Self::ToolsOzoneReportDefsReasonMisleadingScam
            }
            "tools.ozone.report.defs#reasonMisleadingElections" => {
                Self::ToolsOzoneReportDefsReasonMisleadingElections
            }
            "tools.ozone.report.defs#reasonMisleadingOther" => {
                Self::ToolsOzoneReportDefsReasonMisleadingOther
            }
            "tools.ozone.report.defs#reasonRuleSiteSecurity" => {
                Self::ToolsOzoneReportDefsReasonRuleSiteSecurity
            }
            "tools.ozone.report.defs#reasonRuleProhibitedSales" => {
                Self::ToolsOzoneReportDefsReasonRuleProhibitedSales
            }
            "tools.ozone.report.defs#reasonRuleBanEvasion" => {
                Self::ToolsOzoneReportDefsReasonRuleBanEvasion
            }
            "tools.ozone.report.defs#reasonRuleOther" => {
                Self::ToolsOzoneReportDefsReasonRuleOther
            }
            "tools.ozone.report.defs#reasonSelfHarmContent" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmContent
            }
            "tools.ozone.report.defs#reasonSelfHarmED" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmEd
            }
            "tools.ozone.report.defs#reasonSelfHarmStunts" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmStunts
            }
            "tools.ozone.report.defs#reasonSelfHarmSubstances" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmSubstances
            }
            "tools.ozone.report.defs#reasonSelfHarmOther" => {
                Self::ToolsOzoneReportDefsReasonSelfHarmOther
            }
            _ => Self::Other(CowStr::from(s)),
        }
    }
}

impl<'a> AsRef<str> for ReasonType<'a> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<'a> core::fmt::Display for ReasonType<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> serde::Serialize for ReasonType<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, 'a> serde::Deserialize<'de> for ReasonType<'a>
where
    'de: 'a,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = <&'de str>::deserialize(deserializer)?;
        Ok(Self::from(s))
    }
}

impl jacquard_common::IntoStatic for ReasonType<'_> {
    type Output = ReasonType<'static>;
    fn into_static(self) -> Self::Output {
        match self {
            ReasonType::ToolsOzoneReportDefsReasonAppeal => {
                ReasonType::ToolsOzoneReportDefsReasonAppeal
            }
            ReasonType::ToolsOzoneReportDefsReasonOther => {
                ReasonType::ToolsOzoneReportDefsReasonOther
            }
            ReasonType::ToolsOzoneReportDefsReasonViolenceAnimal => {
                ReasonType::ToolsOzoneReportDefsReasonViolenceAnimal
            }
            ReasonType::ToolsOzoneReportDefsReasonViolenceThreats => {
                ReasonType::ToolsOzoneReportDefsReasonViolenceThreats
            }
            ReasonType::ToolsOzoneReportDefsReasonViolenceGraphicContent => {
                ReasonType::ToolsOzoneReportDefsReasonViolenceGraphicContent
            }
            ReasonType::ToolsOzoneReportDefsReasonViolenceGlorification => {
                ReasonType::ToolsOzoneReportDefsReasonViolenceGlorification
            }
            ReasonType::ToolsOzoneReportDefsReasonViolenceExtremistContent => {
                ReasonType::ToolsOzoneReportDefsReasonViolenceExtremistContent
            }
            ReasonType::ToolsOzoneReportDefsReasonViolenceTrafficking => {
                ReasonType::ToolsOzoneReportDefsReasonViolenceTrafficking
            }
            ReasonType::ToolsOzoneReportDefsReasonViolenceOther => {
                ReasonType::ToolsOzoneReportDefsReasonViolenceOther
            }
            ReasonType::ToolsOzoneReportDefsReasonSexualAbuseContent => {
                ReasonType::ToolsOzoneReportDefsReasonSexualAbuseContent
            }
            ReasonType::ToolsOzoneReportDefsReasonSexualNcii => {
                ReasonType::ToolsOzoneReportDefsReasonSexualNcii
            }
            ReasonType::ToolsOzoneReportDefsReasonSexualDeepfake => {
                ReasonType::ToolsOzoneReportDefsReasonSexualDeepfake
            }
            ReasonType::ToolsOzoneReportDefsReasonSexualAnimal => {
                ReasonType::ToolsOzoneReportDefsReasonSexualAnimal
            }
            ReasonType::ToolsOzoneReportDefsReasonSexualUnlabeled => {
                ReasonType::ToolsOzoneReportDefsReasonSexualUnlabeled
            }
            ReasonType::ToolsOzoneReportDefsReasonSexualOther => {
                ReasonType::ToolsOzoneReportDefsReasonSexualOther
            }
            ReasonType::ToolsOzoneReportDefsReasonChildSafetyCsam => {
                ReasonType::ToolsOzoneReportDefsReasonChildSafetyCsam
            }
            ReasonType::ToolsOzoneReportDefsReasonChildSafetyGroom => {
                ReasonType::ToolsOzoneReportDefsReasonChildSafetyGroom
            }
            ReasonType::ToolsOzoneReportDefsReasonChildSafetyPrivacy => {
                ReasonType::ToolsOzoneReportDefsReasonChildSafetyPrivacy
            }
            ReasonType::ToolsOzoneReportDefsReasonChildSafetyHarassment => {
                ReasonType::ToolsOzoneReportDefsReasonChildSafetyHarassment
            }
            ReasonType::ToolsOzoneReportDefsReasonChildSafetyOther => {
                ReasonType::ToolsOzoneReportDefsReasonChildSafetyOther
            }
            ReasonType::ToolsOzoneReportDefsReasonHarassmentTroll => {
                ReasonType::ToolsOzoneReportDefsReasonHarassmentTroll
            }
            ReasonType::ToolsOzoneReportDefsReasonHarassmentTargeted => {
                ReasonType::ToolsOzoneReportDefsReasonHarassmentTargeted
            }
            ReasonType::ToolsOzoneReportDefsReasonHarassmentHateSpeech => {
                ReasonType::ToolsOzoneReportDefsReasonHarassmentHateSpeech
            }
            ReasonType::ToolsOzoneReportDefsReasonHarassmentDoxxing => {
                ReasonType::ToolsOzoneReportDefsReasonHarassmentDoxxing
            }
            ReasonType::ToolsOzoneReportDefsReasonHarassmentOther => {
                ReasonType::ToolsOzoneReportDefsReasonHarassmentOther
            }
            ReasonType::ToolsOzoneReportDefsReasonMisleadingBot => {
                ReasonType::ToolsOzoneReportDefsReasonMisleadingBot
            }
            ReasonType::ToolsOzoneReportDefsReasonMisleadingImpersonation => {
                ReasonType::ToolsOzoneReportDefsReasonMisleadingImpersonation
            }
            ReasonType::ToolsOzoneReportDefsReasonMisleadingSpam => {
                ReasonType::ToolsOzoneReportDefsReasonMisleadingSpam
            }
            ReasonType::ToolsOzoneReportDefsReasonMisleadingScam => {
                ReasonType::ToolsOzoneReportDefsReasonMisleadingScam
            }
            ReasonType::ToolsOzoneReportDefsReasonMisleadingElections => {
                ReasonType::ToolsOzoneReportDefsReasonMisleadingElections
            }
            ReasonType::ToolsOzoneReportDefsReasonMisleadingOther => {
                ReasonType::ToolsOzoneReportDefsReasonMisleadingOther
            }
            ReasonType::ToolsOzoneReportDefsReasonRuleSiteSecurity => {
                ReasonType::ToolsOzoneReportDefsReasonRuleSiteSecurity
            }
            ReasonType::ToolsOzoneReportDefsReasonRuleProhibitedSales => {
                ReasonType::ToolsOzoneReportDefsReasonRuleProhibitedSales
            }
            ReasonType::ToolsOzoneReportDefsReasonRuleBanEvasion => {
                ReasonType::ToolsOzoneReportDefsReasonRuleBanEvasion
            }
            ReasonType::ToolsOzoneReportDefsReasonRuleOther => {
                ReasonType::ToolsOzoneReportDefsReasonRuleOther
            }
            ReasonType::ToolsOzoneReportDefsReasonSelfHarmContent => {
                ReasonType::ToolsOzoneReportDefsReasonSelfHarmContent
            }
            ReasonType::ToolsOzoneReportDefsReasonSelfHarmEd => {
                ReasonType::ToolsOzoneReportDefsReasonSelfHarmEd
            }
            ReasonType::ToolsOzoneReportDefsReasonSelfHarmStunts => {
                ReasonType::ToolsOzoneReportDefsReasonSelfHarmStunts
            }
            ReasonType::ToolsOzoneReportDefsReasonSelfHarmSubstances => {
                ReasonType::ToolsOzoneReportDefsReasonSelfHarmSubstances
            }
            ReasonType::ToolsOzoneReportDefsReasonSelfHarmOther => {
                ReasonType::ToolsOzoneReportDefsReasonSelfHarmOther
            }
            ReasonType::Other(v) => ReasonType::Other(v.into_static()),
        }
    }
}

/// Animal welfare violations

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonViolenceAnimal;
impl core::fmt::Display for ReasonViolenceAnimal {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonViolenceAnimal")
    }
}

/// Extremist content. These reports will be sent only be sent to the application's Moderation Authority.

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonViolenceExtremistContent;
impl core::fmt::Display for ReasonViolenceExtremistContent {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonViolenceExtremistContent")
    }
}

/// Glorification of violence

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonViolenceGlorification;
impl core::fmt::Display for ReasonViolenceGlorification {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonViolenceGlorification")
    }
}

/// Graphic violent content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonViolenceGraphicContent;
impl core::fmt::Display for ReasonViolenceGraphicContent {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonViolenceGraphicContent")
    }
}

/// Other violent content

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonViolenceOther;
impl core::fmt::Display for ReasonViolenceOther {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonViolenceOther")
    }
}

/// Threats or incitement

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonViolenceThreats;
impl core::fmt::Display for ReasonViolenceThreats {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonViolenceThreats")
    }
}

/// Human trafficking

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ReasonViolenceTrafficking;
impl core::fmt::Display for ReasonViolenceTrafficking {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "reasonViolenceTrafficking")
    }
}