workos 1.0.0

// Code generated by oagen. DO NOT EDIT.

use serde::{Deserialize, Serialize};
use std::fmt;
use std::str::FromStr;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum ResendUserInviteOptionsLocale {
    Af,
    Am,
    Ar,
    Bg,
    Bn,
    Bs,
    Ca,
    Cs,
    Da,
    De,
    DeDe,
    El,
    En,
    EnAu,
    EnCa,
    EnGb,
    EnUs,
    Es,
    Es419,
    EsEs,
    EsUs,
    Et,
    Fa,
    Fi,
    Fil,
    Fr,
    FrBe,
    FrCa,
    FrFr,
    Fy,
    Gl,
    Gu,
    Ha,
    He,
    Hi,
    Hr,
    Hu,
    Hy,
    Id,
    Is,
    It,
    ItIt,
    Ja,
    Jv,
    Ka,
    Kk,
    Km,
    Kn,
    Ko,
    Lt,
    Lv,
    Mk,
    Ml,
    Mn,
    Mr,
    Ms,
    My,
    Nb,
    Ne,
    Nl,
    NlBe,
    NlNl,
    Nn,
    No,
    Pa,
    Pl,
    Pt,
    PtBr,
    PtPt,
    Ro,
    Ru,
    Sk,
    Sl,
    Sq,
    Sr,
    Sv,
    Sw,
    Ta,
    Te,
    Th,
    Tr,
    Uk,
    Ur,
    Uz,
    Vi,
    Zh,
    ZhCn,
    ZhHk,
    ZhTw,
    Zu,
    /// Wire value not recognized by this SDK version. The original
    /// string is preserved verbatim. WorkOS may add new enum values
    /// server-side; matching on this variant lets callers handle
    /// forward-compatible values without panicking.
    Unknown(String),
}

impl ResendUserInviteOptionsLocale {
    /// Canonical wire string for this value. For [`Self::Unknown`] returns the
    /// original wire value as received from the API.
    #[allow(deprecated)]
    pub fn as_str(&self) -> &str {
        match self {
            Self::Af => "af",
            Self::Am => "am",
            Self::Ar => "ar",
            Self::Bg => "bg",
            Self::Bn => "bn",
            Self::Bs => "bs",
            Self::Ca => "ca",
            Self::Cs => "cs",
            Self::Da => "da",
            Self::De => "de",
            Self::DeDe => "de-DE",
            Self::El => "el",
            Self::En => "en",
            Self::EnAu => "en-AU",
            Self::EnCa => "en-CA",
            Self::EnGb => "en-GB",
            Self::EnUs => "en-US",
            Self::Es => "es",
            Self::Es419 => "es-419",
            Self::EsEs => "es-ES",
            Self::EsUs => "es-US",
            Self::Et => "et",
            Self::Fa => "fa",
            Self::Fi => "fi",
            Self::Fil => "fil",
            Self::Fr => "fr",
            Self::FrBe => "fr-BE",
            Self::FrCa => "fr-CA",
            Self::FrFr => "fr-FR",
            Self::Fy => "fy",
            Self::Gl => "gl",
            Self::Gu => "gu",
            Self::Ha => "ha",
            Self::He => "he",
            Self::Hi => "hi",
            Self::Hr => "hr",
            Self::Hu => "hu",
            Self::Hy => "hy",
            Self::Id => "id",
            Self::Is => "is",
            Self::It => "it",
            Self::ItIt => "it-IT",
            Self::Ja => "ja",
            Self::Jv => "jv",
            Self::Ka => "ka",
            Self::Kk => "kk",
            Self::Km => "km",
            Self::Kn => "kn",
            Self::Ko => "ko",
            Self::Lt => "lt",
            Self::Lv => "lv",
            Self::Mk => "mk",
            Self::Ml => "ml",
            Self::Mn => "mn",
            Self::Mr => "mr",
            Self::Ms => "ms",
            Self::My => "my",
            Self::Nb => "nb",
            Self::Ne => "ne",
            Self::Nl => "nl",
            Self::NlBe => "nl-BE",
            Self::NlNl => "nl-NL",
            Self::Nn => "nn",
            Self::No => "no",
            Self::Pa => "pa",
            Self::Pl => "pl",
            Self::Pt => "pt",
            Self::PtBr => "pt-BR",
            Self::PtPt => "pt-PT",
            Self::Ro => "ro",
            Self::Ru => "ru",
            Self::Sk => "sk",
            Self::Sl => "sl",
            Self::Sq => "sq",
            Self::Sr => "sr",
            Self::Sv => "sv",
            Self::Sw => "sw",
            Self::Ta => "ta",
            Self::Te => "te",
            Self::Th => "th",
            Self::Tr => "tr",
            Self::Uk => "uk",
            Self::Ur => "ur",
            Self::Uz => "uz",
            Self::Vi => "vi",
            Self::Zh => "zh",
            Self::ZhCn => "zh-CN",
            Self::ZhHk => "zh-HK",
            Self::ZhTw => "zh-TW",
            Self::Zu => "zu",
            Self::Unknown(s) => s.as_str(),
        }
    }
}

impl fmt::Display for ResendUserInviteOptionsLocale {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

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

impl FromStr for ResendUserInviteOptionsLocale {
    type Err = std::convert::Infallible;
    #[allow(deprecated)]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(match s {
            "af" => Self::Af,
            "am" => Self::Am,
            "ar" => Self::Ar,
            "bg" => Self::Bg,
            "bn" => Self::Bn,
            "bs" => Self::Bs,
            "ca" => Self::Ca,
            "cs" => Self::Cs,
            "da" => Self::Da,
            "de" => Self::De,
            "de-DE" => Self::DeDe,
            "el" => Self::El,
            "en" => Self::En,
            "en-AU" => Self::EnAu,
            "en-CA" => Self::EnCa,
            "en-GB" => Self::EnGb,
            "en-US" => Self::EnUs,
            "es" => Self::Es,
            "es-419" => Self::Es419,
            "es-ES" => Self::EsEs,
            "es-US" => Self::EsUs,
            "et" => Self::Et,
            "fa" => Self::Fa,
            "fi" => Self::Fi,
            "fil" => Self::Fil,
            "fr" => Self::Fr,
            "fr-BE" => Self::FrBe,
            "fr-CA" => Self::FrCa,
            "fr-FR" => Self::FrFr,
            "fy" => Self::Fy,
            "gl" => Self::Gl,
            "gu" => Self::Gu,
            "ha" => Self::Ha,
            "he" => Self::He,
            "hi" => Self::Hi,
            "hr" => Self::Hr,
            "hu" => Self::Hu,
            "hy" => Self::Hy,
            "id" => Self::Id,
            "is" => Self::Is,
            "it" => Self::It,
            "it-IT" => Self::ItIt,
            "ja" => Self::Ja,
            "jv" => Self::Jv,
            "ka" => Self::Ka,
            "kk" => Self::Kk,
            "km" => Self::Km,
            "kn" => Self::Kn,
            "ko" => Self::Ko,
            "lt" => Self::Lt,
            "lv" => Self::Lv,
            "mk" => Self::Mk,
            "ml" => Self::Ml,
            "mn" => Self::Mn,
            "mr" => Self::Mr,
            "ms" => Self::Ms,
            "my" => Self::My,
            "nb" => Self::Nb,
            "ne" => Self::Ne,
            "nl" => Self::Nl,
            "nl-BE" => Self::NlBe,
            "nl-NL" => Self::NlNl,
            "nn" => Self::Nn,
            "no" => Self::No,
            "pa" => Self::Pa,
            "pl" => Self::Pl,
            "pt" => Self::Pt,
            "pt-BR" => Self::PtBr,
            "pt-PT" => Self::PtPt,
            "ro" => Self::Ro,
            "ru" => Self::Ru,
            "sk" => Self::Sk,
            "sl" => Self::Sl,
            "sq" => Self::Sq,
            "sr" => Self::Sr,
            "sv" => Self::Sv,
            "sw" => Self::Sw,
            "ta" => Self::Ta,
            "te" => Self::Te,
            "th" => Self::Th,
            "tr" => Self::Tr,
            "uk" => Self::Uk,
            "ur" => Self::Ur,
            "uz" => Self::Uz,
            "vi" => Self::Vi,
            "zh" => Self::Zh,
            "zh-CN" => Self::ZhCn,
            "zh-HK" => Self::ZhHk,
            "zh-TW" => Self::ZhTw,
            "zu" => Self::Zu,
            other => Self::Unknown(other.to_string()),
        })
    }
}

impl From<String> for ResendUserInviteOptionsLocale {
    fn from(s: String) -> Self {
        // Reuse the original `String` allocation in the fallback branch.
        match Self::from_str(&s) {
            Ok(Self::Unknown(_)) => Self::Unknown(s),
            Ok(other) => other,
        }
    }
}

impl From<&str> for ResendUserInviteOptionsLocale {
    fn from(s: &str) -> Self {
        Self::from_str(s).unwrap_or_else(|_| Self::Unknown(s.to_string()))
    }
}

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

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