mongol-norm 0.1.1

// @generated by scripts/gen_rust_tables.py -- DO NOT EDIT.
// Source: mongol_norm/data/MNG.json (sha256 5e99d2f2b0abe022)
// Source: mongol_norm/data/TOD.json (sha256 36a25a2f6a53a0d8)
// Source: mongol_norm/data/SIB.json (sha256 97551f578d67b2b1)
// Source: mongol_norm/data/MCH.json (sha256 e1e00127e0812ecb)

use std::fmt;
use std::str::FromStr;

use crate::Error;

/// A written unit: an opaque glyph-form identifier produced by shaping (see `docs/data-format.md`). The structural tokens `Mvs`, `Nirugu` and `Zwj` are members too: they appear verbatim in [`Shaper::shape`](crate::Shaper::shape) output, exactly as the Python implementation emits them.
#[non_exhaustive]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[rustfmt::skip]
pub enum WrittenUnit {
    /// Written unit `A`.
    A,
    /// Written unit `Aa`.
    Aa,
    /// Written unit `Ah`.
    Ah,
    /// Written unit `Ai`.
    Ai,
    /// Written unit `At`.
    At,
    /// Written unit `B`.
    B,
    /// Written unit `B2`.
    B2,
    /// Written unit `C`.
    C,
    /// Written unit `Cc`.
    Cc,
    /// Written unit `Ch`.
    Ch,
    /// Written unit `Cp`.
    Cp,
    /// Written unit `Cr`.
    Cr,
    /// Written unit `Cs`.
    Cs,
    /// Written unit `D`.
    D,
    /// Written unit `Db`.
    Db,
    /// Written unit `Dd`.
    Dd,
    /// Written unit `Dh`.
    Dh,
    /// Written unit `Dp`.
    Dp,
    /// Written unit `Dt`.
    Dt,
    /// Written unit `E`.
    E,
    /// Written unit `F`.
    F,
    /// Written unit `G`.
    G,
    /// Written unit `G2`.
    G2,
    /// Written unit `G3`.
    G3,
    /// Written unit `G4`.
    G4,
    /// Written unit `Gc`.
    Gc,
    /// Written unit `Gh`.
    Gh,
    /// Written unit `Gp`.
    Gp,
    /// Written unit `Gx`.
    Gx,
    /// Written unit `H`.
    H,
    /// Written unit `Hb`.
    Hb,
    /// Written unit `Hc`.
    Hc,
    /// Written unit `Hh`.
    Hh,
    /// Written unit `Hp`.
    Hp,
    /// Written unit `Hr`.
    Hr,
    /// Written unit `Hx`.
    Hx,
    /// Written unit `Hx2`.
    Hx2,
    /// Written unit `I`.
    I,
    /// Written unit `I3`.
    I3,
    /// Written unit `Ic`.
    Ic,
    /// Written unit `Ip`.
    Ip,
    /// Written unit `Ix`.
    Ix,
    /// Written unit `Iy`.
    Iy,
    /// Written unit `J`.
    J,
    /// Written unit `J2`.
    J2,
    /// Written unit `Jb`.
    Jb,
    /// Written unit `Jc`.
    Jc,
    /// Written unit `K`.
    K,
    /// Written unit `K2`.
    K2,
    /// Written unit `Kc`.
    Kc,
    /// Written unit `Kh`.
    Kh,
    /// Written unit `Kp`.
    Kp,
    /// Written unit `L`.
    L,
    /// Written unit `Lv`.
    Lv,
    /// Written unit `M`.
    M,
    /// Written unit `M2`.
    M2,
    /// Structural token: Mongolian vowel separator U+180E (NNBSP U+202F is folded into it).
    Mvs,
    /// Written unit `N`.
    N,
    /// Written unit `N2`.
    N2,
    /// Structural token: nirugu U+180A, the visible stem extender.
    Nirugu,
    /// Written unit `Nx`.
    Nx,
    /// Written unit `Ny`.
    Ny,
    /// Written unit `O`.
    O,
    /// Written unit `Ob`.
    Ob,
    /// Written unit `Oh`.
    Oh,
    /// Written unit `Op`.
    Op,
    /// Written unit `Ot`.
    Ot,
    /// Written unit `P`.
    P,
    /// Written unit `Pb`.
    Pb,
    /// Written unit `Pp`.
    Pp,
    /// Written unit `R`.
    R,
    /// Written unit `R2`.
    R2,
    /// Written unit `R3`.
    R3,
    /// Written unit `Rh`.
    Rh,
    /// Written unit `Rr`.
    Rr,
    /// Written unit `S`.
    S,
    /// Written unit `Sh`.
    Sh,
    /// Written unit `Sp`.
    Sp,
    /// Written unit `Sz`.
    Sz,
    /// Written unit `T`.
    T,
    /// Written unit `Tb`.
    Tb,
    /// Written unit `Th`.
    Th,
    /// Written unit `Tp`.
    Tp,
    /// Written unit `Tt`.
    Tt,
    /// Written unit `U`.
    U,
    /// Written unit `Ue`.
    Ue,
    /// Written unit `Uh`.
    Uh,
    /// Written unit `Up`.
    Up,
    /// Written unit `Ux`.
    Ux,
    /// Written unit `V`.
    V,
    /// Written unit `W`.
    W,
    /// Written unit `Wb`.
    Wb,
    /// Written unit `Y`.
    Y,
    /// Written unit `Yp`.
    Yp,
    /// Written unit `Z`.
    Z,
    /// Written unit `Zc`.
    Zc,
    /// Written unit `Zr`.
    Zr,
    /// Written unit `Zs`.
    Zs,
    /// Written unit `Zs2`.
    Zs2,
    /// Structural token: zero width joiner U+200D.
    Zwj,
    /// Written unit `Zz`.
    Zz,
}

#[rustfmt::skip]
impl WrittenUnit {
    /// Every variant, in declaration (sorted contract-name) order.
    pub const ALL: [WrittenUnit; 101] = [
        WrittenUnit::A,
        WrittenUnit::Aa,
        WrittenUnit::Ah,
        WrittenUnit::Ai,
        WrittenUnit::At,
        WrittenUnit::B,
        WrittenUnit::B2,
        WrittenUnit::C,
        WrittenUnit::Cc,
        WrittenUnit::Ch,
        WrittenUnit::Cp,
        WrittenUnit::Cr,
        WrittenUnit::Cs,
        WrittenUnit::D,
        WrittenUnit::Db,
        WrittenUnit::Dd,
        WrittenUnit::Dh,
        WrittenUnit::Dp,
        WrittenUnit::Dt,
        WrittenUnit::E,
        WrittenUnit::F,
        WrittenUnit::G,
        WrittenUnit::G2,
        WrittenUnit::G3,
        WrittenUnit::G4,
        WrittenUnit::Gc,
        WrittenUnit::Gh,
        WrittenUnit::Gp,
        WrittenUnit::Gx,
        WrittenUnit::H,
        WrittenUnit::Hb,
        WrittenUnit::Hc,
        WrittenUnit::Hh,
        WrittenUnit::Hp,
        WrittenUnit::Hr,
        WrittenUnit::Hx,
        WrittenUnit::Hx2,
        WrittenUnit::I,
        WrittenUnit::I3,
        WrittenUnit::Ic,
        WrittenUnit::Ip,
        WrittenUnit::Ix,
        WrittenUnit::Iy,
        WrittenUnit::J,
        WrittenUnit::J2,
        WrittenUnit::Jb,
        WrittenUnit::Jc,
        WrittenUnit::K,
        WrittenUnit::K2,
        WrittenUnit::Kc,
        WrittenUnit::Kh,
        WrittenUnit::Kp,
        WrittenUnit::L,
        WrittenUnit::Lv,
        WrittenUnit::M,
        WrittenUnit::M2,
        WrittenUnit::Mvs,
        WrittenUnit::N,
        WrittenUnit::N2,
        WrittenUnit::Nirugu,
        WrittenUnit::Nx,
        WrittenUnit::Ny,
        WrittenUnit::O,
        WrittenUnit::Ob,
        WrittenUnit::Oh,
        WrittenUnit::Op,
        WrittenUnit::Ot,
        WrittenUnit::P,
        WrittenUnit::Pb,
        WrittenUnit::Pp,
        WrittenUnit::R,
        WrittenUnit::R2,
        WrittenUnit::R3,
        WrittenUnit::Rh,
        WrittenUnit::Rr,
        WrittenUnit::S,
        WrittenUnit::Sh,
        WrittenUnit::Sp,
        WrittenUnit::Sz,
        WrittenUnit::T,
        WrittenUnit::Tb,
        WrittenUnit::Th,
        WrittenUnit::Tp,
        WrittenUnit::Tt,
        WrittenUnit::U,
        WrittenUnit::Ue,
        WrittenUnit::Uh,
        WrittenUnit::Up,
        WrittenUnit::Ux,
        WrittenUnit::V,
        WrittenUnit::W,
        WrittenUnit::Wb,
        WrittenUnit::Y,
        WrittenUnit::Yp,
        WrittenUnit::Z,
        WrittenUnit::Zc,
        WrittenUnit::Zr,
        WrittenUnit::Zs,
        WrittenUnit::Zs2,
        WrittenUnit::Zwj,
        WrittenUnit::Zz,
    ];

    /// The contract name used by the Python API, the CLI and the data files.
    pub const fn as_str(self) -> &'static str {
        match self {
            WrittenUnit::A => "A",
            WrittenUnit::Aa => "Aa",
            WrittenUnit::Ah => "Ah",
            WrittenUnit::Ai => "Ai",
            WrittenUnit::At => "At",
            WrittenUnit::B => "B",
            WrittenUnit::B2 => "B2",
            WrittenUnit::C => "C",
            WrittenUnit::Cc => "Cc",
            WrittenUnit::Ch => "Ch",
            WrittenUnit::Cp => "Cp",
            WrittenUnit::Cr => "Cr",
            WrittenUnit::Cs => "Cs",
            WrittenUnit::D => "D",
            WrittenUnit::Db => "Db",
            WrittenUnit::Dd => "Dd",
            WrittenUnit::Dh => "Dh",
            WrittenUnit::Dp => "Dp",
            WrittenUnit::Dt => "Dt",
            WrittenUnit::E => "E",
            WrittenUnit::F => "F",
            WrittenUnit::G => "G",
            WrittenUnit::G2 => "G2",
            WrittenUnit::G3 => "G3",
            WrittenUnit::G4 => "G4",
            WrittenUnit::Gc => "Gc",
            WrittenUnit::Gh => "Gh",
            WrittenUnit::Gp => "Gp",
            WrittenUnit::Gx => "Gx",
            WrittenUnit::H => "H",
            WrittenUnit::Hb => "Hb",
            WrittenUnit::Hc => "Hc",
            WrittenUnit::Hh => "Hh",
            WrittenUnit::Hp => "Hp",
            WrittenUnit::Hr => "Hr",
            WrittenUnit::Hx => "Hx",
            WrittenUnit::Hx2 => "Hx2",
            WrittenUnit::I => "I",
            WrittenUnit::I3 => "I3",
            WrittenUnit::Ic => "Ic",
            WrittenUnit::Ip => "Ip",
            WrittenUnit::Ix => "Ix",
            WrittenUnit::Iy => "Iy",
            WrittenUnit::J => "J",
            WrittenUnit::J2 => "J2",
            WrittenUnit::Jb => "Jb",
            WrittenUnit::Jc => "Jc",
            WrittenUnit::K => "K",
            WrittenUnit::K2 => "K2",
            WrittenUnit::Kc => "Kc",
            WrittenUnit::Kh => "Kh",
            WrittenUnit::Kp => "Kp",
            WrittenUnit::L => "L",
            WrittenUnit::Lv => "Lv",
            WrittenUnit::M => "M",
            WrittenUnit::M2 => "M2",
            WrittenUnit::Mvs => "Mvs",
            WrittenUnit::N => "N",
            WrittenUnit::N2 => "N2",
            WrittenUnit::Nirugu => "Nirugu",
            WrittenUnit::Nx => "Nx",
            WrittenUnit::Ny => "Ny",
            WrittenUnit::O => "O",
            WrittenUnit::Ob => "Ob",
            WrittenUnit::Oh => "Oh",
            WrittenUnit::Op => "Op",
            WrittenUnit::Ot => "Ot",
            WrittenUnit::P => "P",
            WrittenUnit::Pb => "Pb",
            WrittenUnit::Pp => "Pp",
            WrittenUnit::R => "R",
            WrittenUnit::R2 => "R2",
            WrittenUnit::R3 => "R3",
            WrittenUnit::Rh => "Rh",
            WrittenUnit::Rr => "Rr",
            WrittenUnit::S => "S",
            WrittenUnit::Sh => "Sh",
            WrittenUnit::Sp => "Sp",
            WrittenUnit::Sz => "Sz",
            WrittenUnit::T => "T",
            WrittenUnit::Tb => "Tb",
            WrittenUnit::Th => "Th",
            WrittenUnit::Tp => "Tp",
            WrittenUnit::Tt => "Tt",
            WrittenUnit::U => "U",
            WrittenUnit::Ue => "Ue",
            WrittenUnit::Uh => "Uh",
            WrittenUnit::Up => "Up",
            WrittenUnit::Ux => "Ux",
            WrittenUnit::V => "V",
            WrittenUnit::W => "W",
            WrittenUnit::Wb => "Wb",
            WrittenUnit::Y => "Y",
            WrittenUnit::Yp => "Yp",
            WrittenUnit::Z => "Z",
            WrittenUnit::Zc => "Zc",
            WrittenUnit::Zr => "Zr",
            WrittenUnit::Zs => "Zs",
            WrittenUnit::Zs2 => "Zs2",
            WrittenUnit::Zwj => "Zwj",
            WrittenUnit::Zz => "Zz",
        }
    }

    /// `true` for the structural tokens `Mvs`, `Nirugu` and `Zwj`.
    pub const fn is_structural(self) -> bool {
        matches!(self, WrittenUnit::Mvs | WrittenUnit::Nirugu | WrittenUnit::Zwj)
    }
}

#[rustfmt::skip]
impl FromStr for WrittenUnit {
    type Err = Error;

    fn from_str(name: &str) -> Result<WrittenUnit, Error> {
        match name {
            "A" => Ok(WrittenUnit::A),
            "Aa" => Ok(WrittenUnit::Aa),
            "Ah" => Ok(WrittenUnit::Ah),
            "Ai" => Ok(WrittenUnit::Ai),
            "At" => Ok(WrittenUnit::At),
            "B" => Ok(WrittenUnit::B),
            "B2" => Ok(WrittenUnit::B2),
            "C" => Ok(WrittenUnit::C),
            "Cc" => Ok(WrittenUnit::Cc),
            "Ch" => Ok(WrittenUnit::Ch),
            "Cp" => Ok(WrittenUnit::Cp),
            "Cr" => Ok(WrittenUnit::Cr),
            "Cs" => Ok(WrittenUnit::Cs),
            "D" => Ok(WrittenUnit::D),
            "Db" => Ok(WrittenUnit::Db),
            "Dd" => Ok(WrittenUnit::Dd),
            "Dh" => Ok(WrittenUnit::Dh),
            "Dp" => Ok(WrittenUnit::Dp),
            "Dt" => Ok(WrittenUnit::Dt),
            "E" => Ok(WrittenUnit::E),
            "F" => Ok(WrittenUnit::F),
            "G" => Ok(WrittenUnit::G),
            "G2" => Ok(WrittenUnit::G2),
            "G3" => Ok(WrittenUnit::G3),
            "G4" => Ok(WrittenUnit::G4),
            "Gc" => Ok(WrittenUnit::Gc),
            "Gh" => Ok(WrittenUnit::Gh),
            "Gp" => Ok(WrittenUnit::Gp),
            "Gx" => Ok(WrittenUnit::Gx),
            "H" => Ok(WrittenUnit::H),
            "Hb" => Ok(WrittenUnit::Hb),
            "Hc" => Ok(WrittenUnit::Hc),
            "Hh" => Ok(WrittenUnit::Hh),
            "Hp" => Ok(WrittenUnit::Hp),
            "Hr" => Ok(WrittenUnit::Hr),
            "Hx" => Ok(WrittenUnit::Hx),
            "Hx2" => Ok(WrittenUnit::Hx2),
            "I" => Ok(WrittenUnit::I),
            "I3" => Ok(WrittenUnit::I3),
            "Ic" => Ok(WrittenUnit::Ic),
            "Ip" => Ok(WrittenUnit::Ip),
            "Ix" => Ok(WrittenUnit::Ix),
            "Iy" => Ok(WrittenUnit::Iy),
            "J" => Ok(WrittenUnit::J),
            "J2" => Ok(WrittenUnit::J2),
            "Jb" => Ok(WrittenUnit::Jb),
            "Jc" => Ok(WrittenUnit::Jc),
            "K" => Ok(WrittenUnit::K),
            "K2" => Ok(WrittenUnit::K2),
            "Kc" => Ok(WrittenUnit::Kc),
            "Kh" => Ok(WrittenUnit::Kh),
            "Kp" => Ok(WrittenUnit::Kp),
            "L" => Ok(WrittenUnit::L),
            "Lv" => Ok(WrittenUnit::Lv),
            "M" => Ok(WrittenUnit::M),
            "M2" => Ok(WrittenUnit::M2),
            "Mvs" => Ok(WrittenUnit::Mvs),
            "N" => Ok(WrittenUnit::N),
            "N2" => Ok(WrittenUnit::N2),
            "Nirugu" => Ok(WrittenUnit::Nirugu),
            "Nx" => Ok(WrittenUnit::Nx),
            "Ny" => Ok(WrittenUnit::Ny),
            "O" => Ok(WrittenUnit::O),
            "Ob" => Ok(WrittenUnit::Ob),
            "Oh" => Ok(WrittenUnit::Oh),
            "Op" => Ok(WrittenUnit::Op),
            "Ot" => Ok(WrittenUnit::Ot),
            "P" => Ok(WrittenUnit::P),
            "Pb" => Ok(WrittenUnit::Pb),
            "Pp" => Ok(WrittenUnit::Pp),
            "R" => Ok(WrittenUnit::R),
            "R2" => Ok(WrittenUnit::R2),
            "R3" => Ok(WrittenUnit::R3),
            "Rh" => Ok(WrittenUnit::Rh),
            "Rr" => Ok(WrittenUnit::Rr),
            "S" => Ok(WrittenUnit::S),
            "Sh" => Ok(WrittenUnit::Sh),
            "Sp" => Ok(WrittenUnit::Sp),
            "Sz" => Ok(WrittenUnit::Sz),
            "T" => Ok(WrittenUnit::T),
            "Tb" => Ok(WrittenUnit::Tb),
            "Th" => Ok(WrittenUnit::Th),
            "Tp" => Ok(WrittenUnit::Tp),
            "Tt" => Ok(WrittenUnit::Tt),
            "U" => Ok(WrittenUnit::U),
            "Ue" => Ok(WrittenUnit::Ue),
            "Uh" => Ok(WrittenUnit::Uh),
            "Up" => Ok(WrittenUnit::Up),
            "Ux" => Ok(WrittenUnit::Ux),
            "V" => Ok(WrittenUnit::V),
            "W" => Ok(WrittenUnit::W),
            "Wb" => Ok(WrittenUnit::Wb),
            "Y" => Ok(WrittenUnit::Y),
            "Yp" => Ok(WrittenUnit::Yp),
            "Z" => Ok(WrittenUnit::Z),
            "Zc" => Ok(WrittenUnit::Zc),
            "Zr" => Ok(WrittenUnit::Zr),
            "Zs" => Ok(WrittenUnit::Zs),
            "Zs2" => Ok(WrittenUnit::Zs2),
            "Zwj" => Ok(WrittenUnit::Zwj),
            "Zz" => Ok(WrittenUnit::Zz),
            _ => Err(Error::UnknownName { kind: "written unit", name: name.to_owned() }),
        }
    }
}

#[rustfmt::skip]
impl fmt::Display for WrittenUnit {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// A shaping condition assigned by the rule pipeline; `as_str()` is the data-file name (`chachlag_onset`, ...).
#[non_exhaustive]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[rustfmt::skip]
pub enum Condition {
    /// Shaping condition `chachlag`.
    Chachlag,
    /// Shaping condition `chachlag_onset`.
    ChachlagOnset,
    /// Shaping condition `chachlag_onset_gb`.
    ChachlagOnsetGb,
    /// Shaping condition `devsger`.
    Devsger,
    /// Shaping condition `dotless`.
    Dotless,
    /// Shaping condition `feminine`.
    Feminine,
    /// Shaping condition `feminine_marked`.
    FeminineMarked,
    /// Shaping condition `marked`.
    Marked,
    /// Shaping condition `masculine_devsger`.
    MasculineDevsger,
    /// Shaping condition `masculine_onset`.
    MasculineOnset,
    /// Shaping condition `onset`.
    Onset,
    /// Shaping condition `particle`.
    Particle,
    /// Shaping condition `post_bowed`.
    PostBowed,
    /// Shaping condition `post_bowed_feminine`.
    PostBowedFeminine,
    /// Shaping condition `vowel_devsger`.
    VowelDevsger,
}

#[rustfmt::skip]
impl Condition {
    /// Every variant, in declaration (sorted contract-name) order.
    pub const ALL: [Condition; 15] = [
        Condition::Chachlag,
        Condition::ChachlagOnset,
        Condition::ChachlagOnsetGb,
        Condition::Devsger,
        Condition::Dotless,
        Condition::Feminine,
        Condition::FeminineMarked,
        Condition::Marked,
        Condition::MasculineDevsger,
        Condition::MasculineOnset,
        Condition::Onset,
        Condition::Particle,
        Condition::PostBowed,
        Condition::PostBowedFeminine,
        Condition::VowelDevsger,
    ];

    /// The contract name used by the Python API, the CLI and the data files.
    pub const fn as_str(self) -> &'static str {
        match self {
            Condition::Chachlag => "chachlag",
            Condition::ChachlagOnset => "chachlag_onset",
            Condition::ChachlagOnsetGb => "chachlag_onset_gb",
            Condition::Devsger => "devsger",
            Condition::Dotless => "dotless",
            Condition::Feminine => "feminine",
            Condition::FeminineMarked => "feminine_marked",
            Condition::Marked => "marked",
            Condition::MasculineDevsger => "masculine_devsger",
            Condition::MasculineOnset => "masculine_onset",
            Condition::Onset => "onset",
            Condition::Particle => "particle",
            Condition::PostBowed => "post_bowed",
            Condition::PostBowedFeminine => "post_bowed_feminine",
            Condition::VowelDevsger => "vowel_devsger",
        }
    }
}

#[rustfmt::skip]
impl FromStr for Condition {
    type Err = Error;

    fn from_str(name: &str) -> Result<Condition, Error> {
        match name {
            "chachlag" => Ok(Condition::Chachlag),
            "chachlag_onset" => Ok(Condition::ChachlagOnset),
            "chachlag_onset_gb" => Ok(Condition::ChachlagOnsetGb),
            "devsger" => Ok(Condition::Devsger),
            "dotless" => Ok(Condition::Dotless),
            "feminine" => Ok(Condition::Feminine),
            "feminine_marked" => Ok(Condition::FeminineMarked),
            "marked" => Ok(Condition::Marked),
            "masculine_devsger" => Ok(Condition::MasculineDevsger),
            "masculine_onset" => Ok(Condition::MasculineOnset),
            "onset" => Ok(Condition::Onset),
            "particle" => Ok(Condition::Particle),
            "post_bowed" => Ok(Condition::PostBowed),
            "post_bowed_feminine" => Ok(Condition::PostBowedFeminine),
            "vowel_devsger" => Ok(Condition::VowelDevsger),
            _ => Err(Error::UnknownName { kind: "condition", name: name.to_owned() }),
        }
    }
}

#[rustfmt::skip]
impl fmt::Display for Condition {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}

/// A letter alias (phonemic short name, locale-relative); `as_str()` is the data-file name (`a`, `oe`, `k2`, ...).
#[non_exhaustive]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
#[rustfmt::skip]
pub enum Alias {
    /// Letter alias `a`.
    A,
    /// Letter alias `b`.
    B,
    /// Letter alias `c`.
    C,
    /// Letter alias `ch`.
    Ch,
    /// Letter alias `cr`.
    Cr,
    /// Letter alias `d`.
    D,
    /// Letter alias `e`.
    E,
    /// Letter alias `ee`.
    Ee,
    /// Letter alias `f`.
    F,
    /// Letter alias `g`.
    G,
    /// Letter alias `gh`.
    Gh,
    /// Letter alias `h`.
    H,
    /// Letter alias `hh`.
    Hh,
    /// Letter alias `i`.
    I,
    /// Letter alias `ii`.
    Ii,
    /// Letter alias `j`.
    J,
    /// Letter alias `jy`.
    Jy,
    /// Letter alias `k`.
    K,
    /// Letter alias `k2`.
    K2,
    /// Letter alias `kh`.
    Kh,
    /// Letter alias `l`.
    L,
    /// Letter alias `lh`.
    Lh,
    /// Letter alias `lvs`.
    Lvs,
    /// Letter alias `m`.
    M,
    /// Letter alias `n`.
    N,
    /// Letter alias `ng`.
    Ng,
    /// Letter alias `ny`.
    Ny,
    /// Letter alias `o`.
    O,
    /// Letter alias `oe`.
    Oe,
    /// Letter alias `p`.
    P,
    /// Letter alias `r`.
    R,
    /// Letter alias `rh`.
    Rh,
    /// Letter alias `s`.
    S,
    /// Letter alias `sbm`.
    Sbm,
    /// Letter alias `sh`.
    Sh,
    /// Letter alias `t`.
    T,
    /// Letter alias `u`.
    U,
    /// Letter alias `ue`.
    Ue,
    /// Letter alias `w`.
    W,
    /// Letter alias `y`.
    Y,
    /// Letter alias `z`.
    Z,
    /// Letter alias `zr`.
    Zr,
}

#[rustfmt::skip]
impl Alias {
    /// Every variant, in declaration (sorted contract-name) order.
    pub const ALL: [Alias; 42] = [
        Alias::A,
        Alias::B,
        Alias::C,
        Alias::Ch,
        Alias::Cr,
        Alias::D,
        Alias::E,
        Alias::Ee,
        Alias::F,
        Alias::G,
        Alias::Gh,
        Alias::H,
        Alias::Hh,
        Alias::I,
        Alias::Ii,
        Alias::J,
        Alias::Jy,
        Alias::K,
        Alias::K2,
        Alias::Kh,
        Alias::L,
        Alias::Lh,
        Alias::Lvs,
        Alias::M,
        Alias::N,
        Alias::Ng,
        Alias::Ny,
        Alias::O,
        Alias::Oe,
        Alias::P,
        Alias::R,
        Alias::Rh,
        Alias::S,
        Alias::Sbm,
        Alias::Sh,
        Alias::T,
        Alias::U,
        Alias::Ue,
        Alias::W,
        Alias::Y,
        Alias::Z,
        Alias::Zr,
    ];

    /// The contract name used by the Python API, the CLI and the data files.
    pub const fn as_str(self) -> &'static str {
        match self {
            Alias::A => "a",
            Alias::B => "b",
            Alias::C => "c",
            Alias::Ch => "ch",
            Alias::Cr => "cr",
            Alias::D => "d",
            Alias::E => "e",
            Alias::Ee => "ee",
            Alias::F => "f",
            Alias::G => "g",
            Alias::Gh => "gh",
            Alias::H => "h",
            Alias::Hh => "hh",
            Alias::I => "i",
            Alias::Ii => "ii",
            Alias::J => "j",
            Alias::Jy => "jy",
            Alias::K => "k",
            Alias::K2 => "k2",
            Alias::Kh => "kh",
            Alias::L => "l",
            Alias::Lh => "lh",
            Alias::Lvs => "lvs",
            Alias::M => "m",
            Alias::N => "n",
            Alias::Ng => "ng",
            Alias::Ny => "ny",
            Alias::O => "o",
            Alias::Oe => "oe",
            Alias::P => "p",
            Alias::R => "r",
            Alias::Rh => "rh",
            Alias::S => "s",
            Alias::Sbm => "sbm",
            Alias::Sh => "sh",
            Alias::T => "t",
            Alias::U => "u",
            Alias::Ue => "ue",
            Alias::W => "w",
            Alias::Y => "y",
            Alias::Z => "z",
            Alias::Zr => "zr",
        }
    }
}

#[rustfmt::skip]
impl FromStr for Alias {
    type Err = Error;

    fn from_str(name: &str) -> Result<Alias, Error> {
        match name {
            "a" => Ok(Alias::A),
            "b" => Ok(Alias::B),
            "c" => Ok(Alias::C),
            "ch" => Ok(Alias::Ch),
            "cr" => Ok(Alias::Cr),
            "d" => Ok(Alias::D),
            "e" => Ok(Alias::E),
            "ee" => Ok(Alias::Ee),
            "f" => Ok(Alias::F),
            "g" => Ok(Alias::G),
            "gh" => Ok(Alias::Gh),
            "h" => Ok(Alias::H),
            "hh" => Ok(Alias::Hh),
            "i" => Ok(Alias::I),
            "ii" => Ok(Alias::Ii),
            "j" => Ok(Alias::J),
            "jy" => Ok(Alias::Jy),
            "k" => Ok(Alias::K),
            "k2" => Ok(Alias::K2),
            "kh" => Ok(Alias::Kh),
            "l" => Ok(Alias::L),
            "lh" => Ok(Alias::Lh),
            "lvs" => Ok(Alias::Lvs),
            "m" => Ok(Alias::M),
            "n" => Ok(Alias::N),
            "ng" => Ok(Alias::Ng),
            "ny" => Ok(Alias::Ny),
            "o" => Ok(Alias::O),
            "oe" => Ok(Alias::Oe),
            "p" => Ok(Alias::P),
            "r" => Ok(Alias::R),
            "rh" => Ok(Alias::Rh),
            "s" => Ok(Alias::S),
            "sbm" => Ok(Alias::Sbm),
            "sh" => Ok(Alias::Sh),
            "t" => Ok(Alias::T),
            "u" => Ok(Alias::U),
            "ue" => Ok(Alias::Ue),
            "w" => Ok(Alias::W),
            "y" => Ok(Alias::Y),
            "z" => Ok(Alias::Z),
            "zr" => Ok(Alias::Zr),
            _ => Err(Error::UnknownName { kind: "alias", name: name.to_owned() }),
        }
    }
}

#[rustfmt::skip]
impl fmt::Display for Alias {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(self.as_str())
    }
}