Enum Citizenship

pub enum Citizenship {
    Af,
    Ax,
    Al,
    Dz,
    As,
    Ad,
    Ao,
    Ai,
    Aq,
    Ag,
    Ar,
    Am,
    Aw,
    Au,
    At,
    Az,
    Bs,
    Bh,
    Bd,
    Bb,
    By,
    Be,
    Bz,
    Bj,
    Bm,
    Bt,
    Bo,
    Bq,
    Ba,
    Bw,
    Bv,
    Br,
    Io,
    Bn,
    Bg,
    Bf,
    Bi,
    Cv,
    Kh,
    Cm,
    Ca,
    Ky,
    Cf,
    Td,
    Cl,
    Cn,
    Cx,
    Cc,
    Co,
    Km,
    Cg,
    Cd,
    Ck,
    Cr,
    Ci,
    Hr,
    Cw,
    Cy,
    Cz,
    Dk,
    Dj,
    Dm,
    Do,
    Ec,
    Eg,
    Sv,
    Gq,
    Er,
    Ee,
    Sz,
    Et,
    Fk,
    Fo,
    Fj,
    Fi,
    Fr,
    Gf,
    Pf,
    Tf,
    Ga,
    Gm,
    Ge,
    De,
    Gh,
    Gi,
    Gr,
    Gl,
    Gd,
    Gp,
    Gu,
    Gt,
    Gg,
    Gn,
    Gw,
    Gy,
    Ht,
    Hm,
    Va,
    Hn,
    Hk,
    Hu,
    Is,
    In,
    Id,
    Iq,
    Ie,
    Im,
    Il,
    It,
    Jm,
    Jp,
    Je,
    Jo,
    Kz,
    Ke,
    Ki,
    Kr,
    Xk,
    Kw,
    Kg,
    La,
    Lv,
    Lb,
    Ls,
    Lr,
    Ly,
    Li,
    Lt,
    Lu,
    Mo,
    Mg,
    Mw,
    My,
    Mv,
    Ml,
    Mt,
    Mh,
    Mq,
    Mr,
    Mu,
    Yt,
    Mx,
    Fm,
    Md,
    Mc,
    Mn,
    Me,
    Ms,
    Ma,
    Mz,
    Mm,
    Na,
    Nr,
    Np,
    Nl,
    An,
    Nc,
    Nz,
    Ni,
    Ne,
    Ng,
    Nu,
    Nf,
    Mk,
    Mp,
    No,
    Om,
    Pk,
    Pw,
    Ps,
    Pa,
    Pg,
    Py,
    Pe,
    Ph,
    Pn,
    Pl,
    Pt,
    Pr,
    Qa,
    Ro,
    Ru,
    Rw,
    Re,
    Bl,
    Sh,
    Kn,
    Lc,
    Mf,
    Pm,
    Vc,
    Ws,
    Sm,
    St,
    Sa,
    Sn,
    Rs,
    Sc,
    Sl,
    Sg,
    Sx,
    Sk,
    Si,
    Sb,
    So,
    Za,
    Gs,
    Ss,
    Es,
    Lk,
    Sd,
    Sr,
    Sj,
    Se,
    Ch,
    Tw,
    Tj,
    Tz,
    Th,
    Tl,
    Tg,
    Tk,
    To,
    Tt,
    Tn,
    Tr,
    Tm,
    Tc,
    Tv,
    Ug,
    Ua,
    Ae,
    Gb,
    Us,
    Um,
    Uy,
    Uz,
    Vu,
    Ve,
    Vn,
    Vg,
    Vi,
    Wf,
    Eh,
    Ye,
    Zm,
    Zw,
}

The countries that the worker has citizenship in.

Variants

Af

Ax

Al

Dz

As

Ad

Ao

Ai

Aq

Ag

Ar

Am

Aw

Au

At

Az

Bs

Bh

Bd

Bb

By

Be

Bz

Bj

Bm

Bt

Bo

Bq

Ba

Bw

Bv

Br

Io

Bn

Bg

Bf

Bi

Cv

Kh

Cm

Ca

Ky

Cf

Td

Cl

Cn

Cx

Cc

Co

Km

Cg

Cd

Ck

Cr

Ci

Hr

Cw

Cy

Cz

Dk

Dj

Dm

Do

Ec

Eg

Sv

Gq

Er

Ee

Sz

Et

Fk

Fo

Fj

Fi

Fr

Gf

Pf

Tf

Ga

Gm

Ge

De

Gh

Gi

Gr

Gl

Gd

Gp

Gu

Gt

Gg

Gn

Gw

Gy

Ht

Hm

Va

Hn

Hk

Hu

Is

In

Id

Iq

Ie

Im

Il

It

Jm

Jp

Je

Jo

Kz

Ke

Ki

Kr

Xk

Kw

Kg

La

Lv

Lb

Ls

Lr

Ly

Li

Lt

Lu

Mo

Mg

Mw

My

Mv

Ml

Mt

Mh

Mq

Mr

Mu

Yt

Mx

Fm

Md

Mc

Mn

Me

Ms

Ma

Mz

Mm

Na

Nr

Np

Nl

An

Nc

Nz

Ni

Ne

Ng

Nu

Nf

Mk

Mp

No

Om

Pk

Pw

Ps

Pa

Pg

Py

Pe

Ph

Pn

Pl

Pt

Pr

Qa

Ro

Ru

Rw

Re

Bl

Sh

Kn

Lc

Mf

Pm

Vc

Ws

Sm

St

Sa

Sn

Rs

Sc

Sl

Sg

Sx

Sk

Si

Sb

So

Za

Gs

Ss

Es

Lk

Sd

Sr

Sj

Se

Ch

Tw

Tj

Tz

Th

Tl

Tg

Tk

To

Tt

Tn

Tr

Tm

Tc

Tv

Ug

Ua

Ae

Gb

Us

Um

Uy

Uz

Vu

Ve

Vn

Vg

Vi

Wf

Eh

Ye

Zm

Zw

Trait Implementations

impl Clone for Citizenship

fn clone(&self) -> Citizenship

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Citizenship

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Citizenship

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Citizenship

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for Citizenship

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Citizenship

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl JsonSchema for Citizenship

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for Citizenship

fn eq(&self, other: &Citizenship) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Citizenship

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Tabled for Citizenship

const LENGTH: usize = 247usize

A length of fields and headers, which must be the same.

fn fields(&self) -> Vec<Cow<'_, str>>

Fields method must return a list of cells.

fn headers() -> Vec<Cow<'static, str>>

Headers must return a list of column names.

impl ValueEnum for Citizenship

fn value_variants<'a>() -> &'a [Self]

All possible argument values, in display order.

fn to_possible_value<'a>(&self) -> Option<PossibleValue>

The canonical argument value.

fn from_str(input: &str, ignore_case: bool) -> Result<Self, String>

Parse an argument into Self.

impl StructuralPartialEq for Citizenship