Enum SubmitUserVerificationFromUrlBodyMetadataAddressCountry 

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

SubmitUserVerificationFromUrlBodyMetadataAddressCountry

JSON schema

{
 "type": "string",
 "enum": [
   "0C",
   "AC",
   "AD",
   "AE",
   "AF",
   "AG",
   "AI",
   "AL",
   "AM",
   "AN",
   "AO",
   "AP",
   "AQ",
   "AR",
   "AS",
   "AT",
   "AU",
   "AW",
   "AX",
   "AZ",
   "BA",
   "BB",
   "BD",
   "BE",
   "BF",
   "BG",
   "BH",
   "BI",
   "BJ",
   "BL",
   "BM",
   "BN",
   "BO",
   "BQ",
   "BR",
   "BS",
   "BT",
   "BV",
   "BW",
   "BY",
   "BZ",
   "CA",
   "CC",
   "CD",
   "CF",
   "CG",
   "CH",
   "CI",
   "CK",
   "CL",
   "CM",
   "CN",
   "CO",
   "CP",
   "CR",
   "CU",
   "CV",
   "CW",
   "CX",
   "CY",
   "CZ",
   "DE",
   "DG",
   "DJ",
   "DK",
   "DM",
   "DO",
   "DZ",
   "EA",
   "EC",
   "EE",
   "EG",
   "EH",
   "ER",
   "ES",
   "ET",
   "EU",
   "FI",
   "FJ",
   "FK",
   "FM",
   "FO",
   "FR",
   "GA",
   "GB",
   "GD",
   "GE",
   "GF",
   "GG",
   "GH",
   "GI",
   "GL",
   "GM",
   "GN",
   "GP",
   "GQ",
   "GR",
   "GS",
   "GT",
   "GU",
   "GW",
   "GY",
   "HK",
   "HM",
   "HN",
   "HR",
   "HT",
   "HU",
   "IC",
   "ID",
   "IE",
   "IL",
   "IM",
   "IN",
   "IO",
   "IQ",
   "IR",
   "IS",
   "IT",
   "JE",
   "JM",
   "JO",
   "JP",
   "JX",
   "KE",
   "KG",
   "KH",
   "KI",
   "KM",
   "KN",
   "KP",
   "KR",
   "KW",
   "KY",
   "KZ",
   "LA",
   "LB",
   "LC",
   "LI",
   "LK",
   "LR",
   "LS",
   "LT",
   "LU",
   "LV",
   "LY",
   "MA",
   "MC",
   "MD",
   "ME",
   "MF",
   "MG",
   "MH",
   "MK",
   "ML",
   "MM",
   "MN",
   "MO",
   "MP",
   "MQ",
   "MR",
   "MS",
   "MT",
   "MU",
   "MV",
   "MW",
   "MX",
   "MY",
   "MZ",
   "NA",
   "NC",
   "NE",
   "NF",
   "NG",
   "NI",
   "NL",
   "NO",
   "NP",
   "NR",
   "NU",
   "NZ",
   "OM",
   "PA",
   "PE",
   "PF",
   "PG",
   "PH",
   "PK",
   "PL",
   "PM",
   "PN",
   "PR",
   "PS",
   "PT",
   "PW",
   "PY",
   "QA",
   "QO",
   "RE",
   "RO",
   "RS",
   "RU",
   "RW",
   "SA",
   "SB",
   "SC",
   "SD",
   "SE",
   "SG",
   "SH",
   "SI",
   "SJ",
   "SK",
   "SL",
   "SM",
   "SN",
   "SO",
   "SR",
   "SS",
   "ST",
   "SV",
   "SX",
   "SY",
   "SZ",
   "TA",
   "TC",
   "TD",
   "TF",
   "TG",
   "TH",
   "TJ",
   "TK",
   "TL",
   "TM",
   "TN",
   "TO",
   "TR",
   "TT",
   "TV",
   "TW",
   "TZ",
   "UA",
   "UG",
   "UM",
   "US",
   "UY",
   "UZ",
   "VA",
   "VC",
   "VE",
   "VG",
   "VI",
   "VN",
   "VU",
   "WF",
   "WS",
   "XK",
   "YE",
   "YT",
   "ZA",
   "ZM",
   "ZW"
 ]
}

Variants

X0c

Ac

Ad

Ae

Af

Ag

Ai

Al

Am

An

Ao

Ap

Aq

Ar

As

At

Au

Aw

Ax

Az

Ba

Bb

Bd

Be

Bf

Bg

Bh

Bi

Bj

Bl

Bm

Bn

Bo

Bq

Br

Bs

Bt

Bv

Bw

By

Bz

Ca

Cc

Cd

Cf

Cg

Ch

Ci

Ck

Cl

Cm

Cn

Co

Cp

Cr

Cu

Cv

Cw

Cx

Cy

Cz

De

Dg

Dj

Dk

Dm

Do

Dz

Ea

Ec

Ee

Eg

Eh

Er

Es

Et

Eu

Fi

Fj

Fk

Fm

Fo

Fr

Ga

Gb

Gd

Ge

Gf

Gg

Gh

Gi

Gl

Gm

Gn

Gp

Gq

Gr

Gs

Gt

Gu

Gw

Gy

Hk

Hm

Hn

Hr

Ht

Hu

Ic

Id

Ie

Il

Im

In

Io

Iq

Ir

Is

It

Je

Jm

Jo

Jp

Jx

Ke

Kg

Kh

Ki

Km

Kn

Kp

Kr

Kw

Ky

Kz

La

Lb

Lc

Li

Lk

Lr

Ls

Lt

Lu

Lv

Ly

Ma

Mc

Md

Me

Mf

Mg

Mh

Mk

Ml

Mm

Mn

Mo

Mp

Mq

Mr

Ms

Mt

Mu

Mv

Mw

Mx

My

Mz

Na

Nc

Ne

Nf

Ng

Ni

Nl

No

Np

Nr

Nu

Nz

Om

Pa

Pe

Pf

Pg

Ph

Pk

Pl

Pm

Pn

Pr

Ps

Pt

Pw

Py

Qa

Qo

Re

Ro

Rs

Ru

Rw

Sa

Sb

Sc

Sd

Se

Sg

Sh

Si

Sj

Sk

Sl

Sm

Sn

So

Sr

Ss

St

Sv

Sx

Sy

Sz

Ta

Tc

Td

Tf

Tg

Th

Tj

Tk

Tl

Tm

Tn

To

Tr

Tt

Tv

Tw

Tz

Ua

Ug

Um

Us

Uy

Uz

Va

Vc

Ve

Vg

Vi

Vn

Vu

Wf

Ws

Xk

Ye

Yt

Za

Zm

Zw

Trait Implementations

impl Clone for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

fn clone(&self) -> SubmitUserVerificationFromUrlBodyMetadataAddressCountry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

fn deserialize<__D>( __deserializer: __D, ) -> Result<SubmitUserVerificationFromUrlBodyMetadataAddressCountry, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

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

Formats the value using the given formatter.

impl From<&SubmitUserVerificationFromUrlBodyMetadataAddressCountry> for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

fn from( value: &SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ) -> SubmitUserVerificationFromUrlBodyMetadataAddressCountry

Converts to this type from the input type.

impl FromStr for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

type Err = ConversionError

The associated error which can be returned from parsing.

fn from_str( value: &str, ) -> Result<SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ConversionError>

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

impl Hash for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

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

where __H: Hasher,

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 Ord for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

fn cmp( &self, other: &SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

fn eq( &self, other: &SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ) -> 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 PartialOrd for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

fn partial_cmp( &self, other: &SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&String> for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( value: &String, ) -> Result<SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ConversionError>

Performs the conversion.

impl TryFrom<&str> for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( value: &str, ) -> Result<SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ConversionError>

Performs the conversion.

impl TryFrom<String> for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( value: String, ) -> Result<SubmitUserVerificationFromUrlBodyMetadataAddressCountry, ConversionError>

Performs the conversion.

impl Copy for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

impl Eq for SubmitUserVerificationFromUrlBodyMetadataAddressCountry

impl StructuralPartialEq for SubmitUserVerificationFromUrlBodyMetadataAddressCountry