Trait currencies::currency::Currency

pub trait Currency: Copy + Clone + PartialEq + Eq + PartialOrd + Ord + Hash {
    type Backing: Backing;

    const BASE: Self::Backing;
    const CODE: &'static str;
    const SYMBOL: &'static str;
    const PROPER_NAME: &'static str;
    const STYLE: FormatStyle;
    const IS_ISO: bool;
    const IS_CRYPTO: bool;

    // Provided method
    fn decimal_digits() -> usize { ... }
}

Uniquely defines a particular currency, such as USD, BTC, or ETH.

Required Associated Types

type Backing: Backing

Represents the underlying (signed or un-signed) primitive integer type used to represent Amounts of this Currency.

Required Associated Constants

const BASE: Self::Backing

Determines the numerical base of an Amount of this Currency.

For base ten currencies, this should be a 1 followed by a number of zeroes corresponding with the number of supported digits to the right of the decimal place.

Some very rare currencies use a base other than 10, such as Malagasy ariary. For these you should use an appropriate base.

const CODE: &'static str

Specifies a 3-4 digit acronym or “code” that can be used as a short name for this Currency. For ISO-supported currencies, this will be equal to the ISO-4217 alphabetic code, which can be found here: https://en.wikipedia.org/wiki/ISO_4217.

For cryptocurrencies and other currencies not named in ISO-4217, this should be a short globally unique code that is specific to the currency, for example BTC for Bitcoin, ETH for Ethereum, etc..

const SYMBOL: &'static str

Specifies the monetary symbol, such as $, that is commonly associated with this Currency.

It is worth noting that such symbols can be multiple characters long, are not globally unique (actually many currencies use the $ symbol and there are plenty examples of the same symbol being used for many currencies), and are not governed or defined by ISO-4217 or any other ISO. They also do not have to be symbols, they could be a word or several words long.

The symbol is used when formatted values of an Amount using this Currency are displayed.

const PROPER_NAME: &'static str

Specifies a long-hand / “proper” name for this Currency, for example “United States Dollar”.

For currencies governed by ISO-4217, this corresponds with the “entity” field.

const STYLE: FormatStyle

Specifies how an Amount of this Currency should be displayed when it is represented textually via core::fmt::Display and core::fmt::Debug.

const IS_ISO: bool

Set to true if this Currency is governed by ISO-4217. Otherwise false.

const IS_CRYPTO: bool

Set to true if this Currency is a cryptocurrency. Otherwise false.

This is provided separately from IS_ISO to prepare for a future where one or more cryptocurrencies are included in ISO-4217.

Provided Methods

fn decimal_digits() -> usize

Returns the number of digits to the right of the decimal point for this Currency.

Object Safety

This trait is not object safe.

Implementors

impl Currency for AAVE

type Backing = U256

const BASE: Self::Backing = ETH::BASE

const CODE: &'static str = "AAVE"

const SYMBOL: &'static str = "AAVE"

const PROPER_NAME: &'static str = "Aave Token"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = false

const IS_CRYPTO: bool = true

impl Currency for ADA

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000f4240): <currency::ADA as currency::Currency>::Backing}

const CODE: &'static str = "ADA"

const SYMBOL: &'static str = "ADA"

const PROPER_NAME: &'static str = "Cardano"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = false

const IS_CRYPTO: bool = true

impl Currency for AED

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::AED as currency::Currency>::Backing}

const CODE: &'static str = "AED"

const SYMBOL: &'static str = "Dh"

const PROPER_NAME: &'static str = "United Arab Emirates Dirham"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for AFN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::AFN as currency::Currency>::Backing}

const CODE: &'static str = "AFN"

const SYMBOL: &'static str = "Af"

const PROPER_NAME: &'static str = "Afgan Afghani"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ALL

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ALL as currency::Currency>::Backing}

const CODE: &'static str = "ALL"

const SYMBOL: &'static str = "Lek"

const PROPER_NAME: &'static str = "Albanien Lek"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for AMD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::AMD as currency::Currency>::Backing}

const CODE: &'static str = "AMD"

const SYMBOL: &'static str = "֏"

const PROPER_NAME: &'static str = "Armenian Dram"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ANG

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ANG as currency::Currency>::Backing}

const CODE: &'static str = "ANG"

const SYMBOL: &'static str = "ƒ"

const PROPER_NAME: &'static str = "Netherlands Antillean Guilder"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for AOA

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::AOA as currency::Currency>::Backing}

const CODE: &'static str = "AOA"

const SYMBOL: &'static str = "Kz"

const PROPER_NAME: &'static str = "Angolan Kwanza"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ARS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ARS as currency::Currency>::Backing}

const CODE: &'static str = "ARS"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Argentine Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for AUD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::AUD as currency::Currency>::Backing}

const CODE: &'static str = "AUD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Australian Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for AWG

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::AWG as currency::Currency>::Backing}

const CODE: &'static str = "AWG"

const SYMBOL: &'static str = "ƒ"

const PROPER_NAME: &'static str = "Aruban Florin"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for AZN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::AZN as currency::Currency>::Backing}

const CODE: &'static str = "AZN"

const SYMBOL: &'static str = "₼"

const PROPER_NAME: &'static str = "Azerbaijani Manat"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BAM

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BAM as currency::Currency>::Backing}

const CODE: &'static str = "BAM"

const SYMBOL: &'static str = "KM"

const PROPER_NAME: &'static str = "Bosnia and Herzegovina Convertible Mark"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BBD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BBD as currency::Currency>::Backing}

const CODE: &'static str = "BBD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Barbados Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BDT

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BDT as currency::Currency>::Backing}

const CODE: &'static str = "BDT"

const SYMBOL: &'static str = "৳"

const PROPER_NAME: &'static str = "Bangladeshi Taka"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BGN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BGN as currency::Currency>::Backing}

const CODE: &'static str = "BGN"

const SYMBOL: &'static str = "Lev"

const PROPER_NAME: &'static str = "Bulgarian Lev"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BHD

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000003e8): <currency::BHD as currency::Currency>::Backing}

const CODE: &'static str = "BHD"

const SYMBOL: &'static str = "BD"

const PROPER_NAME: &'static str = "Bahraini Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BIF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BIF as currency::Currency>::Backing}

const CODE: &'static str = "BIF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Burundian Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BMD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BMD as currency::Currency>::Backing}

const CODE: &'static str = "BMD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Berumdian Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BND

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BND as currency::Currency>::Backing}

const CODE: &'static str = "BND"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Brunei Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BOB

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BOB as currency::Currency>::Backing}

const CODE: &'static str = "BOB"

const SYMBOL: &'static str = "Bs"

const PROPER_NAME: &'static str = "Boliviano"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BOOK

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000f4240): <currency::BOOK as currency::Currency>::Backing}

const CODE: &'static str = "BOOK"

const SYMBOL: &'static str = "BOOK"

const PROPER_NAME: &'static str = "$BOOK"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = false

const IS_CRYPTO: bool = true

impl Currency for BOV

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BOV as currency::Currency>::Backing}

const CODE: &'static str = "BOV"

const SYMBOL: &'static str = "BOV"

const PROPER_NAME: &'static str = "Bolivian Mvdol"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BRL

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BRL as currency::Currency>::Backing}

const CODE: &'static str = "BRL"

const SYMBOL: &'static str = "R$"

const PROPER_NAME: &'static str = "Brazilian Real"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BSD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BSD as currency::Currency>::Backing}

const CODE: &'static str = "BSD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Bahamian Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BTC

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000005f5e100): <currency::BTC as currency::Currency>::Backing}

const CODE: &'static str = "BTC"

const SYMBOL: &'static str = "BTC"

const PROPER_NAME: &'static str = "Bitcoin"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = false

const IS_CRYPTO: bool = true

impl Currency for BTN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BTN as currency::Currency>::Backing}

const CODE: &'static str = "BTN"

const SYMBOL: &'static str = "Nu"

const PROPER_NAME: &'static str = "Bhutanese Ngultrum"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BWP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BWP as currency::Currency>::Backing}

const CODE: &'static str = "BWP"

const SYMBOL: &'static str = "P"

const PROPER_NAME: &'static str = "Botswanna Pula"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BYN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BYN as currency::Currency>::Backing}

const CODE: &'static str = "BYN"

const SYMBOL: &'static str = "Rbl"

const PROPER_NAME: &'static str = "Belarusian Ruble"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for BZD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::BZD as currency::Currency>::Backing}

const CODE: &'static str = "BZD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Belize Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CAD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CAD as currency::Currency>::Backing}

const CODE: &'static str = "CAD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Canadian Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CDF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CDF as currency::Currency>::Backing}

const CODE: &'static str = "CDF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Congloese Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CHE

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CHE as currency::Currency>::Backing}

const CODE: &'static str = "CHE"

const SYMBOL: &'static str = "CHE"

const PROPER_NAME: &'static str = "WIR Euro"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CHF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CHF as currency::Currency>::Backing}

const CODE: &'static str = "CHF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Swiss Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CHW

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CHW as currency::Currency>::Backing}

const CODE: &'static str = "CHW"

const SYMBOL: &'static str = "CHW"

const PROPER_NAME: &'static str = "WIR Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CLF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CLF as currency::Currency>::Backing}

const CODE: &'static str = "CLF"

const SYMBOL: &'static str = "CLF"

const PROPER_NAME: &'static str = "Unidad de Fomento"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CLP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CLP as currency::Currency>::Backing}

const CODE: &'static str = "CLP"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Chilean Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CNY

type Backing = u64

const BASE: Self::Backing = {transmute(0x000000000000000a): <currency::CNY as currency::Currency>::Backing}

const CODE: &'static str = "CNY"

const SYMBOL: &'static str = "¥"

const PROPER_NAME: &'static str = "Renminbi"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for COP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::COP as currency::Currency>::Backing}

const CODE: &'static str = "COP"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Colombian Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for COU

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::COU as currency::Currency>::Backing}

const CODE: &'static str = "COU"

const SYMBOL: &'static str = "COU"

const PROPER_NAME: &'static str = "Unidad de Valor Real (UVR)"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CRC

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CRC as currency::Currency>::Backing}

const CODE: &'static str = "CRC"

const SYMBOL: &'static str = "₡"

const PROPER_NAME: &'static str = "Costa Rican Colon"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CUC

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CUC as currency::Currency>::Backing}

const CODE: &'static str = "CUC"

const SYMBOL: &'static str = "CUC"

const PROPER_NAME: &'static str = "Cuban Convertible Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CUP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CUP as currency::Currency>::Backing}

const CODE: &'static str = "CUP"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Cuban Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CVE

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CVE as currency::Currency>::Backing}

const CODE: &'static str = "CVE"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Cape Verdean Escudo"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for CZK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::CZK as currency::Currency>::Backing}

const CODE: &'static str = "CZK"

const SYMBOL: &'static str = "Kč"

const PROPER_NAME: &'static str = "Czech Koruna"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for DJF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::DJF as currency::Currency>::Backing}

const CODE: &'static str = "DJF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Dijiboutian Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for DKK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::DKK as currency::Currency>::Backing}

const CODE: &'static str = "DKK"

const SYMBOL: &'static str = "kr"

const PROPER_NAME: &'static str = "Danish Krone"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for DOP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::DOP as currency::Currency>::Backing}

const CODE: &'static str = "DOP"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Dominican Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for DOT

type Backing = u128

const BASE: Self::Backing = {transmute(0x000000000000000000000002540be400): <currency::DOT as currency::Currency>::Backing}

const CODE: &'static str = "DOT"

const SYMBOL: &'static str = "DOT"

const PROPER_NAME: &'static str = "Polkadot"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = false

const IS_CRYPTO: bool = true

impl Currency for DZD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::DZD as currency::Currency>::Backing}

const CODE: &'static str = "DZD"

const SYMBOL: &'static str = "DA"

const PROPER_NAME: &'static str = "Algerian Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for EGP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::EGP as currency::Currency>::Backing}

const CODE: &'static str = "EGP"

const SYMBOL: &'static str = "LE"

const PROPER_NAME: &'static str = "Egyptian Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ERN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ERN as currency::Currency>::Backing}

const CODE: &'static str = "ERN"

const SYMBOL: &'static str = "Nkf"

const PROPER_NAME: &'static str = "Eritrean Nakfa"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ETB

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ETB as currency::Currency>::Backing}

const CODE: &'static str = "ETB"

const SYMBOL: &'static str = "Br"

const PROPER_NAME: &'static str = "Ethiopian Birr"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ETH

type Backing = U256

const BASE: Self::Backing = _

const CODE: &'static str = "ETH"

const SYMBOL: &'static str = "ETH"

const PROPER_NAME: &'static str = "Ethereum"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = false

const IS_CRYPTO: bool = true

impl Currency for EUR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::EUR as currency::Currency>::Backing}

const CODE: &'static str = "EUR"

const SYMBOL: &'static str = "€"

const PROPER_NAME: &'static str = "Euro"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for FJD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::FJD as currency::Currency>::Backing}

const CODE: &'static str = "FJD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Fiji Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for FKP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::FKP as currency::Currency>::Backing}

const CODE: &'static str = "FKP"

const SYMBOL: &'static str = "£"

const PROPER_NAME: &'static str = "Falkland Islands Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for GBP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::GBP as currency::Currency>::Backing}

const CODE: &'static str = "GBP"

const SYMBOL: &'static str = "£"

const PROPER_NAME: &'static str = "Pound Sterling"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for GEL

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::GEL as currency::Currency>::Backing}

const CODE: &'static str = "GEL"

const SYMBOL: &'static str = "₾"

const PROPER_NAME: &'static str = "Georgian Iari"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for GHS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::GHS as currency::Currency>::Backing}

const CODE: &'static str = "GHS"

const SYMBOL: &'static str = "₵"

const PROPER_NAME: &'static str = "Ghanaian Cedi"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for GIP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::GIP as currency::Currency>::Backing}

const CODE: &'static str = "GIP"

const SYMBOL: &'static str = "£"

const PROPER_NAME: &'static str = "Gibralter Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for GMD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::GMD as currency::Currency>::Backing}

const CODE: &'static str = "GMD"

const SYMBOL: &'static str = "D"

const PROPER_NAME: &'static str = "Gambian Dalasi"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for GNF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::GNF as currency::Currency>::Backing}

const CODE: &'static str = "GNF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Guinean Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for GTQ

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::GTQ as currency::Currency>::Backing}

const CODE: &'static str = "GTQ"

const SYMBOL: &'static str = "Q"

const PROPER_NAME: &'static str = "Guatemalan Quetzal"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for HKD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::HKD as currency::Currency>::Backing}

const CODE: &'static str = "HKD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Hong Kong Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for HNL

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::HNL as currency::Currency>::Backing}

const CODE: &'static str = "HNL"

const SYMBOL: &'static str = "L"

const PROPER_NAME: &'static str = "Honduran Lempira"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for HTG

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::HTG as currency::Currency>::Backing}

const CODE: &'static str = "HTG"

const SYMBOL: &'static str = "G"

const PROPER_NAME: &'static str = "Haitian Gourde"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for HUF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::HUF as currency::Currency>::Backing}

const CODE: &'static str = "HUF"

const SYMBOL: &'static str = "Ft"

const PROPER_NAME: &'static str = "Hungarian Forint"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for IDR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::IDR as currency::Currency>::Backing}

const CODE: &'static str = "IDR"

const SYMBOL: &'static str = "Rp"

const PROPER_NAME: &'static str = "Indonesian Rupiah"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ILS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ILS as currency::Currency>::Backing}

const CODE: &'static str = "ILS"

const SYMBOL: &'static str = "₪"

const PROPER_NAME: &'static str = "Israeli New Shekel"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for INR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::INR as currency::Currency>::Backing}

const CODE: &'static str = "INR"

const SYMBOL: &'static str = "₹"

const PROPER_NAME: &'static str = "Indian Rupee"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for IQD

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000003e8): <currency::IQD as currency::Currency>::Backing}

const CODE: &'static str = "IQD"

const SYMBOL: &'static str = "ID"

const PROPER_NAME: &'static str = "Iraqi Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for IRR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000001): <currency::IRR as currency::Currency>::Backing}

const CODE: &'static str = "IRR"

const SYMBOL: &'static str = "Rl"

const PROPER_NAME: &'static str = "Iranian Rial"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ISK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ISK as currency::Currency>::Backing}

const CODE: &'static str = "ISK"

const SYMBOL: &'static str = "kr"

const PROPER_NAME: &'static str = "Icelandic Króna"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for JMD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::JMD as currency::Currency>::Backing}

const CODE: &'static str = "JMD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Jamaican Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for JOD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::JOD as currency::Currency>::Backing}

const CODE: &'static str = "JOD"

const SYMBOL: &'static str = "JD"

const PROPER_NAME: &'static str = "Jordanian Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for JPY

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::JPY as currency::Currency>::Backing}

const CODE: &'static str = "JPY"

const SYMBOL: &'static str = "¥"

const PROPER_NAME: &'static str = "Japanese Yen"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KES

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KES as currency::Currency>::Backing}

const CODE: &'static str = "KES"

const SYMBOL: &'static str = "Sh"

const PROPER_NAME: &'static str = "Kenyan Shilling"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KGS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KGS as currency::Currency>::Backing}

const CODE: &'static str = "KGS"

const SYMBOL: &'static str = "som"

const PROPER_NAME: &'static str = "Kyrgyzstani Som"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KHR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KHR as currency::Currency>::Backing}

const CODE: &'static str = "KHR"

const SYMBOL: &'static str = "CR"

const PROPER_NAME: &'static str = "Cambodian Riel"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KMF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KMF as currency::Currency>::Backing}

const CODE: &'static str = "KMF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Comoro Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KPW

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KPW as currency::Currency>::Backing}

const CODE: &'static str = "KPW"

const SYMBOL: &'static str = "₩"

const PROPER_NAME: &'static str = "North Korean Won"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KRW

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KRW as currency::Currency>::Backing}

const CODE: &'static str = "KRW"

const SYMBOL: &'static str = "₩"

const PROPER_NAME: &'static str = "South Korean Won"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KSM

type Backing = u128

const BASE: Self::Backing = {transmute(0x0000000000000000000000e8d4a51000): <currency::KSM as currency::Currency>::Backing}

const CODE: &'static str = "KSM"

const SYMBOL: &'static str = "KSM"

const PROPER_NAME: &'static str = "Kusama"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = false

const IS_CRYPTO: bool = true

impl Currency for KWD

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000003e8): <currency::KWD as currency::Currency>::Backing}

const CODE: &'static str = "KWD"

const SYMBOL: &'static str = "KD"

const PROPER_NAME: &'static str = "Kuwaiti Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KYD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KYD as currency::Currency>::Backing}

const CODE: &'static str = "KYD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Caymen Islands Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for KZT

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::KZT as currency::Currency>::Backing}

const CODE: &'static str = "KZT"

const SYMBOL: &'static str = "₸"

const PROPER_NAME: &'static str = "Kazakhstani Tenge"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for LAK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::LAK as currency::Currency>::Backing}

const CODE: &'static str = "LAK"

const SYMBOL: &'static str = "₭"

const PROPER_NAME: &'static str = "Lao Kip"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for LBP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::LBP as currency::Currency>::Backing}

const CODE: &'static str = "LBP"

const SYMBOL: &'static str = "LL"

const PROPER_NAME: &'static str = "Lebanese Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for LKR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::LKR as currency::Currency>::Backing}

const CODE: &'static str = "LKR"

const SYMBOL: &'static str = "Re"

const PROPER_NAME: &'static str = "Sri Lankan Rupee"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for LRD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::LRD as currency::Currency>::Backing}

const CODE: &'static str = "LRD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Liberian Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for LSL

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::LSL as currency::Currency>::Backing}

const CODE: &'static str = "LSL"

const SYMBOL: &'static str = "L"

const PROPER_NAME: &'static str = "Lesotho Loti"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for LYD

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000003e8): <currency::LYD as currency::Currency>::Backing}

const CODE: &'static str = "LYD"

const SYMBOL: &'static str = "LD"

const PROPER_NAME: &'static str = "Libyan Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MAD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MAD as currency::Currency>::Backing}

const CODE: &'static str = "MAD"

const SYMBOL: &'static str = "DH"

const PROPER_NAME: &'static str = "Moroccan Dirham"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MDL

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MDL as currency::Currency>::Backing}

const CODE: &'static str = "MDL"

const SYMBOL: &'static str = "Leu"

const PROPER_NAME: &'static str = "Moldovan Leu"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MGA

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000005): <currency::MGA as currency::Currency>::Backing}

const CODE: &'static str = "MGA"

const SYMBOL: &'static str = "Ar"

const PROPER_NAME: &'static str = "Malagasy Ariary"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MKD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MKD as currency::Currency>::Backing}

const CODE: &'static str = "MKD"

const SYMBOL: &'static str = "DEN"

const PROPER_NAME: &'static str = "Macedonian Denar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MMK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MMK as currency::Currency>::Backing}

const CODE: &'static str = "MMK"

const SYMBOL: &'static str = "K"

const PROPER_NAME: &'static str = "Myanmar Kyat"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MNT

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MNT as currency::Currency>::Backing}

const CODE: &'static str = "MNT"

const SYMBOL: &'static str = "₮"

const PROPER_NAME: &'static str = "Mongolian Tögrög"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MOP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MOP as currency::Currency>::Backing}

const CODE: &'static str = "MOP"

const SYMBOL: &'static str = "MOP$"

const PROPER_NAME: &'static str = "Macanese Pataca"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MRU

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000005): <currency::MRU as currency::Currency>::Backing}

const CODE: &'static str = "MRU"

const SYMBOL: &'static str = "UM"

const PROPER_NAME: &'static str = "Mauritanian Ouguiya"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MUR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MUR as currency::Currency>::Backing}

const CODE: &'static str = "MUR"

const SYMBOL: &'static str = "Re"

const PROPER_NAME: &'static str = "Mauritian Rupee"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MVR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MVR as currency::Currency>::Backing}

const CODE: &'static str = "MVR"

const SYMBOL: &'static str = "Rf"

const PROPER_NAME: &'static str = "Maldivian Rufiyaa"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MWK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MWK as currency::Currency>::Backing}

const CODE: &'static str = "MWK"

const SYMBOL: &'static str = "K"

const PROPER_NAME: &'static str = "Malawian Kwacha"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MXN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MXN as currency::Currency>::Backing}

const CODE: &'static str = "MXN"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Mexican Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MXV

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MXV as currency::Currency>::Backing}

const CODE: &'static str = "MXV"

const SYMBOL: &'static str = "MXV"

const PROPER_NAME: &'static str = "Mexican Unidad de Inversion (UDI)"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MYR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MYR as currency::Currency>::Backing}

const CODE: &'static str = "MYR"

const SYMBOL: &'static str = "RM"

const PROPER_NAME: &'static str = "Malaysian Ringgit"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for MZN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::MZN as currency::Currency>::Backing}

const CODE: &'static str = "MZN"

const SYMBOL: &'static str = "Mt"

const PROPER_NAME: &'static str = "Mozambican Metical"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for NAD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::NAD as currency::Currency>::Backing}

const CODE: &'static str = "NAD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Namibian Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for NGN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::NGN as currency::Currency>::Backing}

const CODE: &'static str = "NGN"

const SYMBOL: &'static str = "₦"

const PROPER_NAME: &'static str = "Nigerian Naira"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for NIO

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::NIO as currency::Currency>::Backing}

const CODE: &'static str = "NIO"

const SYMBOL: &'static str = "C$"

const PROPER_NAME: &'static str = "Nicaraguan Córdoba"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for NOK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::NOK as currency::Currency>::Backing}

const CODE: &'static str = "NOK"

const SYMBOL: &'static str = "kr"

const PROPER_NAME: &'static str = "Norwegian Krone"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for NPR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::NPR as currency::Currency>::Backing}

const CODE: &'static str = "NPR"

const SYMBOL: &'static str = "Re"

const PROPER_NAME: &'static str = "Nepalese Rupee"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for NZD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::NZD as currency::Currency>::Backing}

const CODE: &'static str = "NZD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "New Zealand Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for OMR

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000003e8): <currency::OMR as currency::Currency>::Backing}

const CODE: &'static str = "OMR"

const SYMBOL: &'static str = "RO"

const PROPER_NAME: &'static str = "Omani Rial"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for PAB

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::PAB as currency::Currency>::Backing}

const CODE: &'static str = "PAB"

const SYMBOL: &'static str = "B/"

const PROPER_NAME: &'static str = "Panamanian Balboa"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for PEN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::PEN as currency::Currency>::Backing}

const CODE: &'static str = "PEN"

const SYMBOL: &'static str = "S/"

const PROPER_NAME: &'static str = "Peruvian Sol"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for PGK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::PGK as currency::Currency>::Backing}

const CODE: &'static str = "PGK"

const SYMBOL: &'static str = "K"

const PROPER_NAME: &'static str = "Papua New Guinean Kina"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for PHP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::PHP as currency::Currency>::Backing}

const CODE: &'static str = "PHP"

const SYMBOL: &'static str = "₱"

const PROPER_NAME: &'static str = "Philippine Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for PKR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::PKR as currency::Currency>::Backing}

const CODE: &'static str = "PKR"

const SYMBOL: &'static str = "Re"

const PROPER_NAME: &'static str = "Pakistani Rupee"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for PLN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::PLN as currency::Currency>::Backing}

const CODE: &'static str = "PLN"

const SYMBOL: &'static str = "zł"

const PROPER_NAME: &'static str = "Polish Złoty"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for PYG

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::PYG as currency::Currency>::Backing}

const CODE: &'static str = "PYG"

const SYMBOL: &'static str = "₲"

const PROPER_NAME: &'static str = "Paraguayan Guarani"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for QAR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::QAR as currency::Currency>::Backing}

const CODE: &'static str = "QAR"

const SYMBOL: &'static str = "QR"

const PROPER_NAME: &'static str = "Qatari Riyal"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for RON

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::RON as currency::Currency>::Backing}

const CODE: &'static str = "RON"

const SYMBOL: &'static str = "Leu"

const PROPER_NAME: &'static str = "Romanian Leu"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for RSD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::RSD as currency::Currency>::Backing}

const CODE: &'static str = "RSD"

const SYMBOL: &'static str = "DIN"

const PROPER_NAME: &'static str = "Serbian Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for RUB

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::RUB as currency::Currency>::Backing}

const CODE: &'static str = "RUB"

const SYMBOL: &'static str = "₽"

const PROPER_NAME: &'static str = "Russian Ruble"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for RWF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::RWF as currency::Currency>::Backing}

const CODE: &'static str = "RWF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Rwandan Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SAR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SAR as currency::Currency>::Backing}

const CODE: &'static str = "SAR"

const SYMBOL: &'static str = "Rl"

const PROPER_NAME: &'static str = "Saudi Riyal"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SBD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SBD as currency::Currency>::Backing}

const CODE: &'static str = "SBD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Solomon Islands Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SCR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SCR as currency::Currency>::Backing}

const CODE: &'static str = "SCR"

const SYMBOL: &'static str = "Re"

const PROPER_NAME: &'static str = "Seychelles Rupee"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SDG

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SDG as currency::Currency>::Backing}

const CODE: &'static str = "SDG"

const SYMBOL: &'static str = "LS"

const PROPER_NAME: &'static str = "Sudanese Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SEK

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SEK as currency::Currency>::Backing}

const CODE: &'static str = "SEK"

const SYMBOL: &'static str = "kr"

const PROPER_NAME: &'static str = "Swedish Krona"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SGD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SGD as currency::Currency>::Backing}

const CODE: &'static str = "SGD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Singapore Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SHP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SHP as currency::Currency>::Backing}

const CODE: &'static str = "SHP"

const SYMBOL: &'static str = "£"

const PROPER_NAME: &'static str = "Saint Helena Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SLE

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SLE as currency::Currency>::Backing}

const CODE: &'static str = "SLE"

const SYMBOL: &'static str = "Le"

const PROPER_NAME: &'static str = "Sierra Leonean Leone"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SOS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SOS as currency::Currency>::Backing}

const CODE: &'static str = "SOS"

const SYMBOL: &'static str = "Sh"

const PROPER_NAME: &'static str = "Somali Shilling"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SRD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SRD as currency::Currency>::Backing}

const CODE: &'static str = "SRD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Surinamese Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SSP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SSP as currency::Currency>::Backing}

const CODE: &'static str = "SSP"

const SYMBOL: &'static str = "SSP"

const PROPER_NAME: &'static str = "South Sudanese Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for STN

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::STN as currency::Currency>::Backing}

const CODE: &'static str = "STN"

const SYMBOL: &'static str = "Db"

const PROPER_NAME: &'static str = "São Tomé and Príncipe Dobra"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SYP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SYP as currency::Currency>::Backing}

const CODE: &'static str = "SYP"

const SYMBOL: &'static str = "LS"

const PROPER_NAME: &'static str = "Syrian Pound"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for SZL

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::SZL as currency::Currency>::Backing}

const CODE: &'static str = "SZL"

const SYMBOL: &'static str = "L"

const PROPER_NAME: &'static str = "Swazi Lilangeni"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for THB

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::THB as currency::Currency>::Backing}

const CODE: &'static str = "THB"

const SYMBOL: &'static str = "฿"

const PROPER_NAME: &'static str = "Thai Baht"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TJS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::TJS as currency::Currency>::Backing}

const CODE: &'static str = "TJS"

const SYMBOL: &'static str = "SM"

const PROPER_NAME: &'static str = "Tajikistani Somoni"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TMT

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::TMT as currency::Currency>::Backing}

const CODE: &'static str = "TMT"

const SYMBOL: &'static str = "m"

const PROPER_NAME: &'static str = "Turkmenistan Manat"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TND

type Backing = u64

const BASE: Self::Backing = {transmute(0x00000000000003e8): <currency::TND as currency::Currency>::Backing}

const CODE: &'static str = "TND"

const SYMBOL: &'static str = "DT"

const PROPER_NAME: &'static str = "Tunisian Dinar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TOP

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::TOP as currency::Currency>::Backing}

const CODE: &'static str = "TOP"

const SYMBOL: &'static str = "T$"

const PROPER_NAME: &'static str = "Tongan Paʻanga"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TRY

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::TRY as currency::Currency>::Backing}

const CODE: &'static str = "TRY"

const SYMBOL: &'static str = "₺"

const PROPER_NAME: &'static str = "Turkish Lira"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TTD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::TTD as currency::Currency>::Backing}

const CODE: &'static str = "TTD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Trinidad and Tobago Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TWD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::TWD as currency::Currency>::Backing}

const CODE: &'static str = "TWD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "New Taiwan Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for TZS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::TZS as currency::Currency>::Backing}

const CODE: &'static str = "TZS"

const SYMBOL: &'static str = "Sh"

const PROPER_NAME: &'static str = "Tanzanian Shilling"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for UAH

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::UAH as currency::Currency>::Backing}

const CODE: &'static str = "UAH"

const SYMBOL: &'static str = "₴"

const PROPER_NAME: &'static str = "Ukrainian Hryvnia"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for UGX

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000001): <currency::UGX as currency::Currency>::Backing}

const CODE: &'static str = "UGX"

const SYMBOL: &'static str = "Sh"

const PROPER_NAME: &'static str = "Ugandan Shilling"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for USD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::USD as currency::Currency>::Backing}

const CODE: &'static str = "USD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "United States Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for UYU

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::UYU as currency::Currency>::Backing}

const CODE: &'static str = "UYU"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Uruguayan Peso"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for UZS

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::UZS as currency::Currency>::Backing}

const CODE: &'static str = "UZS"

const SYMBOL: &'static str = "soum"

const PROPER_NAME: &'static str = "Uzbekistan Sum"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for VED

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::VED as currency::Currency>::Backing}

const CODE: &'static str = "VED"

const SYMBOL: &'static str = "Bs.D"

const PROPER_NAME: &'static str = "Venezuelan Digital Bolívar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for VES

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::VES as currency::Currency>::Backing}

const CODE: &'static str = "VES"

const SYMBOL: &'static str = "Bs.S"

const PROPER_NAME: &'static str = "Venezuelan Sovereign Bolívar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for VND

type Backing = u64

const BASE: Self::Backing = {transmute(0x000000000000000a): <currency::VND as currency::Currency>::Backing}

const CODE: &'static str = "VND"

const SYMBOL: &'static str = "₫"

const PROPER_NAME: &'static str = "Vietnamese đồng"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for VUV

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::VUV as currency::Currency>::Backing}

const CODE: &'static str = "VUV"

const SYMBOL: &'static str = "VT"

const PROPER_NAME: &'static str = "Vanuatu Vatu"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for WST

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::WST as currency::Currency>::Backing}

const CODE: &'static str = "WST"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "Samoan Tālā"

const STYLE: FormatStyle = crate::currency::FormatStyle::PrefixAttached

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XAF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XAF as currency::Currency>::Backing}

const CODE: &'static str = "XAF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "Central African CFA Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XAG

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XAG as currency::Currency>::Backing}

const CODE: &'static str = "XAG"

const SYMBOL: &'static str = "t oz"

const PROPER_NAME: &'static str = "Silver (Troy Ounce)"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XAU

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XAU as currency::Currency>::Backing}

const CODE: &'static str = "XAU"

const SYMBOL: &'static str = "t oz"

const PROPER_NAME: &'static str = "Gold (Troy Ounce"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XCD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XCD as currency::Currency>::Backing}

const CODE: &'static str = "XCD"

const SYMBOL: &'static str = "$"

const PROPER_NAME: &'static str = "East Caribbean Dollar"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XOF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XOF as currency::Currency>::Backing}

const CODE: &'static str = "XOF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "West African CFA Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XPD

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XPD as currency::Currency>::Backing}

const CODE: &'static str = "XPD"

const SYMBOL: &'static str = "t oz"

const PROPER_NAME: &'static str = "Palladium (Troy Ounce)"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XPF

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XPF as currency::Currency>::Backing}

const CODE: &'static str = "XPF"

const SYMBOL: &'static str = "Fr"

const PROPER_NAME: &'static str = "CFP Franc"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for XPT

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::XPT as currency::Currency>::Backing}

const CODE: &'static str = "XPT"

const SYMBOL: &'static str = "t oz"

const PROPER_NAME: &'static str = "Platinum (Troy Ounce)"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for YER

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::YER as currency::Currency>::Backing}

const CODE: &'static str = "YER"

const SYMBOL: &'static str = "Rl"

const PROPER_NAME: &'static str = "Yemeni Rial"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ZAR

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ZAR as currency::Currency>::Backing}

const CODE: &'static str = "ZAR"

const SYMBOL: &'static str = "R"

const PROPER_NAME: &'static str = "South African Rand"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false

impl Currency for ZMW

type Backing = u64

const BASE: Self::Backing = {transmute(0x0000000000000064): <currency::ZMW as currency::Currency>::Backing}

const CODE: &'static str = "ZMW"

const SYMBOL: &'static str = "K"

const PROPER_NAME: &'static str = "Zambian Kwacha"

const STYLE: FormatStyle = crate::currency::FormatStyle::SuffixSpaced

const IS_ISO: bool = true

const IS_CRYPTO: bool = false