lingual 1.0.1

#[cfg(feature = "strings")]
pub type LanguageMap = phf::Map<&'static str, Langs>;
#[cfg(feature = "strings")]
pub const LANGUAGES: LanguageMap = phf::phf_map! {
    "auto" => Langs::Auto,
    "af" => Langs::Af,
    "sq" => Langs::Sq,
    "am" => Langs::Am,
    "ar" => Langs::Ar,
    "hy" => Langs::Hy,
    "as" => Langs::As,
    "ay" => Langs::Ay,
    "az" => Langs::Az,
    "bm" => Langs::Bm,
    "eu" => Langs::Eu,
    "be" => Langs::Be,
    "bn" => Langs::Bn,
    "bho" => Langs::Bho,
    "bs" => Langs::Bs,
    "bg" => Langs::Bg,
    "ca" => Langs::Ca,
    "ceb" => Langs::Ceb,
    "zh-cn" => Langs::ZhCn,
    "zh-tw" => Langs::ZhTw,
    "mni-mtei" => Langs::MniMtei,
    "co" => Langs::Co,
    "hr" => Langs::Hr,
    "cs" => Langs::Cs,
    "da" => Langs::Da,
    "dv" => Langs::Dv,
    "doi" => Langs::Doi,
    "nl" => Langs::Nl,
    "en" => Langs::En,
    "eo" => Langs::Eo,
    "et" => Langs::Et,
    "ee" => Langs::Ee,
    "tl" => Langs::Tl,
    "fi" => Langs::Fi,
    "fr" => Langs::Fr,
    "fy" => Langs::Fy,
    "gl" => Langs::Gl,
    "ka" => Langs::Ka,
    "de" => Langs::De,
    "el" => Langs::El,
    "gn" => Langs::Gn,
    "gu" => Langs::Gu,
    "ht" => Langs::Ht,
    "ha" => Langs::Ha,
    "haw" => Langs::Haw,
    "iw" => Langs::Iw,
    "hi" => Langs::Hi,
    "hmn" => Langs::Hmn,
    "hu" => Langs::Hu,
    "is" => Langs::Is,
    "ig" => Langs::Ig,
    "id" => Langs::Id,
    "ga" => Langs::Ga,
    "it" => Langs::It,
    "ja" => Langs::Ja,
    "kn" => Langs::Kn,
    "kk" => Langs::Kk,
    "km" => Langs::Km,
    "rw" => Langs::Rw,
    "ky" => Langs::Ky,
    "ko" => Langs::Ko,
    "ku" => Langs::Ku,
    "lo" => Langs::Lo,
    "la" => Langs::La,
    "lv" => Langs::Lv,
    "lt" => Langs::Lt,
    "lb" => Langs::Lb,
    "mk" => Langs::Mk,
    "mg" => Langs::Mg,
    "ms" => Langs::Ms,
    "ml" => Langs::Ml,
    "mt" => Langs::Mt,
    "mi" => Langs::Mi,
    "mr" => Langs::Mr,
    "mn" => Langs::Mn,
    "my" => Langs::My,
    "ne" => Langs::Ne,
    "no" => Langs::No,
    "ny" => Langs::Ny,
    "or" => Langs::Or,
    "ps" => Langs::Ps,
    "fa" => Langs::Fa,
    "pl" => Langs::Pl,
    "pt" => Langs::Pt,
    "pa" => Langs::Pa,
    "qu" => Langs::Qu,
    "ro" => Langs::Ro,
    "ru" => Langs::Ru,
    "sm" => Langs::Sm,
    "gd" => Langs::Gd,
    "sr" => Langs::Sr,
    "sn" => Langs::Sn,
    "sd" => Langs::Sd,
    "si" => Langs::Si,
    "sk" => Langs::Sk,
    "sl" => Langs::Sl,
    "so" => Langs::So,
    "st" => Langs::St,
    "es" => Langs::Es,
    "su" => Langs::Su,
    "sw" => Langs::Sw,
    "sv" => Langs::Sv,
    "tg" => Langs::Tg,
    "ta" => Langs::Ta,
    "tt" => Langs::Tt,
    "te" => Langs::Te,
    "th" => Langs::Th,
    "ti" => Langs::Ti,
    "tr" => Langs::Tr,
    "tk" => Langs::Tk,
    "ug" => Langs::Ug,
    "uk" => Langs::Uk,
    "ur" => Langs::Ur,
    "uz" => Langs::Uz,
    "vi" => Langs::Vi,
    "cy" => Langs::Cy,
    "xh" => Langs::Xh,
    "yi" => Langs::Yi,
    "yo" => Langs::Yo,
    "zu" => Langs::Zu,
};

/// The language codes supported by the API.
/// It is also possible to use strings like "en" or "fr" instead of the enum variants but it is not recommended
/// because it is not checked at compile time, therefore it is eliminated by default features.
/// To enable this feature, add `strings` to the features list of the crate.
#[derive(Debug, PartialEq, Clone, Copy)]
pub enum Langs {
    Auto,
    Af,
    Sq,
    Am,
    Ar,
    Hy,
    As,
    Ay,
    Az,
    Bm,
    Eu,
    Be,
    Bn,
    Bho,
    Bs,
    Bg,
    Ca,
    Ceb,
    ZhCn,
    ZhTw,
    Co,
    Hr,
    Cs,
    Da,
    Dv,
    Doi,
    Nl,
    En,
    Eo,
    Et,
    Ee,
    Tl,
    Fi,
    Fr,
    Fy,
    Gl,
    Ka,
    De,
    El,
    Gn,
    Gu,
    Ht,
    Ha,
    Haw,
    Iw,
    Hi,
    Hmn,
    Hu,
    Is,
    Ig,
    Ilo,
    Id,
    Ga,
    It,
    Ja,
    Jw,
    Kn,
    Kk,
    Km,
    Rw,
    Gom,
    Ko,
    Kri,
    Ku,
    Ckb,
    Ky,
    Lo,
    La,
    Lv,
    Lt,
    Lg,
    Lb,
    Mk,
    Mg,
    Mai,
    Ms,
    Ml,
    Mt,
    Mi,
    Mr,
    MniMtei,
    Lus,
    Mn,
    My,
    Ne,
    No,
    Ny,
    Or,
    Om,
    Ps,
    Fa,
    Pl,
    Pt,
    Pa,
    Qu,
    Ro,
    Ru,
    Sm,
    Sa,
    Gd,
    Nso,
    Sr,
    St,
    Sn,
    Sd,
    Si,
    Sk,
    Sl,
    So,
    Es,
    Su,
    Sw,
    Sv,
    // Tl,
    Tg,
    Ta,
    Tt,
    Te,
    Th,
    Ti,
    Ts,
    Tr,
    Tk,
    Ak,
    Uk,
    Ur,
    Ug,
    Uz,
    Vi,
    Cy,
    Xh,
    Yi,
    Yo,
    Zu,
}

impl ToString for Langs {
    fn to_string(&self) -> String {
        if self == &Langs::MniMtei {
            return "mni-mtei".to_string();
        } else if self == &Langs::ZhCn {
            return "zh-cn".to_string();
        } else if self == &Langs::ZhTw {
            return "zh-tw".to_string();
        }
        format!("{:?}", self).to_lowercase()
    }
}

impl From<Langs> for String {
    fn from(value: Langs) -> Self {
        value.to_string().to_lowercase()
    }
}

#[cfg(feature = "strings")]
impl AsRef<Langs> for &str {
    fn as_ref(&self) -> &Langs {
        LANGUAGES.get(self).unwrap_or(&Langs::Auto)
    }
}