# Code generated - EDITING IS FUTILE. DO NOT EDIT.

import typing


NoUnit: typing.Literal["none"] = "none"


Number: typing.Literal["none"] = "none"


String: typing.Literal["string"] = "string"


Short: typing.Literal["short"] = "short"


# SI short
SiShort: typing.Literal["sishort"] = "sishort"


# Percent (0-100)
Percent: typing.Literal["percent"] = "percent"


# Percent (0.0-1.0)
PercentUnit: typing.Literal["percentunit"] = "percentunit"


# Humidity (%H)
Humidity: typing.Literal["humidity"] = "humidity"


# Decibel (dB)
Decibel: typing.Literal["dB"] = "dB"


# Candela (cd)
Candela: typing.Literal["candela"] = "candela"


# Hexadecimal (0x)
HexadecimalOx: typing.Literal["hex0x"] = "hex0x"


Hexadecimal: typing.Literal["hex"] = "hex"


ScientificNotation: typing.Literal["sci"] = "sci"


LocaleFormat: typing.Literal["locale"] = "locale"


# Pixels (px)
Pixels: typing.Literal["pixel"] = "pixel"


# Acceleration: Meters/sec² (m/sec²)
MetersSecSquared: typing.Literal["accMS2"] = "accMS2"


# Acceleration: Feet/sec² (f/sec²)
FeetSecSquared: typing.Literal["accFS2"] = "accFS2"


# G unit (g)
GUnit: typing.Literal["accG"] = "accG"


# Angle: Degrees (°)
Degrees: typing.Literal["degree"] = "degree"


# Angle: Radians
Radians: typing.Literal["radian"] = "radian"


# Angle: Gradian
Gradian: typing.Literal["grad"] = "grad"


# Angle: Arc Minutes
ArcMinutes: typing.Literal["arcmin"] = "arcmin"


# Angle: Arc Seconds
ArcSeconds: typing.Literal["arcsec"] = "arcsec"


# Area: Square Meters (m²)
SquareMeters: typing.Literal["areaM2"] = "areaM2"


# Area: Square Feet (ft²)
SquareFeet: typing.Literal["areaF2"] = "areaF2"


# Area: Square Miles (mi²)
SquareMiles: typing.Literal["areaMI2"] = "areaMI2"


# Area: Acres (ac)
Acres: typing.Literal["acres"] = "acres"


# Area: Hectares (ha)
Hectares: typing.Literal["hectares"] = "hectares"


# Computation: FLOP/s
FlopsPerSecond: typing.Literal["flops"] = "flops"


# Computation: MFLOP/s
MegaFlopsPerSecond: typing.Literal["mflops"] = "mflops"


# Computation: GFLOP/s
GigaFlopsPerSecond: typing.Literal["gflops"] = "gflops"


# Computation: TFLOP/s
TeraFlopsPerSecond: typing.Literal["tflops"] = "tflops"


# Computation: PFLOP/s
PetaFlopsPerSecond: typing.Literal["pflops"] = "pflops"


# Computation: EFLOP/s
ExaFlopsPerSecond: typing.Literal["eflops"] = "eflops"


# Computation: ZFLOP/s
ZettaFlopsPerSecond: typing.Literal["zflops"] = "zflops"


# Computation: YFLOP/s
YottaFlopsPerSecond: typing.Literal["yflops"] = "yflops"


# Concentration: parts-per-million (ppm)
PartsPerMillion: typing.Literal["ppm"] = "ppm"


# Concentration: parts-per-billion (ppb)
PartsPerBillion: typing.Literal["conppb"] = "conppb"


# Concentration: nanogram per cubic meter (ng/m³)
NanogramPerCubicMeter: typing.Literal["conngm3"] = "conngm3"


# Concentration: nanogram per normal cubic meter (ng/Nm³)
NanogramPerNormalCubicMeter: typing.Literal["conngNm3"] = "conngNm3"


# Concentration: microgram per cubic meter (μg/m³)
MicrogramPerCubicMeter: typing.Literal["conμgm3"] = "conμgm3"


# Concentration: microgram per normal cubic meter (μg/Nm³)
MicrogramPerNormalCubicMeter: typing.Literal["conμgNm3"] = "conμgNm3"


# Concentration: milligram per cubic meter (mg/m³)
MilligramPerCubicMeter: typing.Literal["conmgm3"] = "conmgm3"


# Concentration: milligram per normal cubic meter (mg/Nm³)
MilligramPerNormalCubicMeter: typing.Literal["conmgNm3"] = "conmgNm3"


# Concentration: gram per cubic meter (g/m³)
GramPerCubicMeter: typing.Literal["congm3"] = "congm3"


# Concentration: gram per normal cubic meter (g/Nm³)
GramPerNormalCubicMeter: typing.Literal["congNm3"] = "congNm3"


# Concentration: milligrams per decilitre (mg/dL)
MilligramsPerDecilitre: typing.Literal["conmgdL"] = "conmgdL"


# Concentration: millimoles per litre (mmol/L)
MillimolesPerLiter: typing.Literal["conmmolL"] = "conmmolL"


# Currency: Dollars ($)
Dollars: typing.Literal["currencyUSD"] = "currencyUSD"


# Currency: Pounds (£)
Pounds: typing.Literal["currencyGBP"] = "currencyGBP"


# Currency: Euro (€)
Euro: typing.Literal["currencyEUR"] = "currencyEUR"


# Currency: Yen (¥)
Yen: typing.Literal["currencyJPY"] = "currencyJPY"


# Currency: Rubles (₽)
Rubles: typing.Literal["currencyRUB"] = "currencyRUB"


# Currency: Hryvnias (₴)
Hryvnias: typing.Literal["currencyUAH"] = "currencyUAH"


# Currency: Real (R$)
Real: typing.Literal["currencyBRL"] = "currencyBRL"


# Currency: Danish Krone (kr)
DanishKrone: typing.Literal["currencyDKK"] = "currencyDKK"


# Currency: Icelandic Króna (kr)
IcelandicKrona: typing.Literal["currencyISK"] = "currencyISK"


# Currency: Norwegian Krone (kr)
NorwegianKrone: typing.Literal["currencyNOK"] = "currencyNOK"


# Currency: Swedish Krona (kr)
SwedishKrona: typing.Literal["currencySEK"] = "currencySEK"


# Currency: Czech koruna (czk)
CzechKoruna: typing.Literal["currencyCZK"] = "currencyCZK"


# Currency: Swiss franc (CHF)
SwissFranc: typing.Literal["currencyCHF"] = "currencyCHF"


# Currency: Polish Złoty (PLN)
PolishZloty: typing.Literal["currencyPLN"] = "currencyPLN"


# Currency: Bitcoin (฿)
Bictoin: typing.Literal["currencyBTC"] = "currencyBTC"


# Currency: Milli Bitcoin (฿)
MilliBitcoin: typing.Literal["currencymBTC"] = "currencymBTC"


# Currency: Micro Bitcoin (฿)
MicroBitcoin: typing.Literal["currencyμBTC"] = "currencyμBTC"


# Currency: South African Rand (R)
SouthAfricanRand: typing.Literal["currencyZAR"] = "currencyZAR"


# Currency: Indian Rupee (₹)
IndianRupee: typing.Literal["currencyINR"] = "currencyINR"


# Currency: South Korean Won (₩)
SouthKoreanWon: typing.Literal["currencyKRW"] = "currencyKRW"


# Currency: Indonesian Rupiah (Rp)
IndonesianRupiah: typing.Literal["currencyIDR"] = "currencyIDR"


# Currency: Philippine Peso (PHP)
PhilippinePeso: typing.Literal["currencyPHP"] = "currencyPHP"


# Currency: Vietnamese Dong (VND)
VietnameseDong: typing.Literal["currencyVND"] = "currencyVND"


# Currency: Turkish Lira (₺)
TurkishLira: typing.Literal["currencyTRY"] = "currencyTRY"


# Currency: Malaysian Ringgit (RM)
MalaysianRinggit: typing.Literal["currencyMYR"] = "currencyMYR"


# Currency: CFP franc (XPF)
CFPFranc: typing.Literal["currencyXPF"] = "currencyXPF"


# Currency: Bulgarian Lev (BGN)
BulgarianLev: typing.Literal["currencyBGN"] = "currencyBGN"


# Currency: Guaraní (₲)
Guarani: typing.Literal["currencyPYG"] = "currencyPYG"


# Currency: Uruguay Peso (UYU)
UruguayPeso: typing.Literal["currencyUYU"] = "currencyUYU"


# Currency: Israeli New Shekels (₪)
IsraeliNewShekels: typing.Literal["currencyILS"] = "currencyILS"


# Data: bytes(IEC)
BytesIEC: typing.Literal["bytes"] = "bytes"


# Data: bytes(SI)
BytesSI: typing.Literal["decbytes"] = "decbytes"


# Data: bits(IEC)
BitsIEC: typing.Literal["bits"] = "bits"


# Data: bits(SI)
BitsSI: typing.Literal["bydecbitstes"] = "bydecbitstes"


# Data: kibibytes
Kibibytes: typing.Literal["kbytes"] = "kbytes"


# Data: kilobytes
Kilobytes: typing.Literal["deckbytes"] = "deckbytes"


# Data: mebibytes
Mebibytes: typing.Literal["mbytes"] = "mbytes"


# Data: megabytes
Megabytes: typing.Literal["decmbytes"] = "decmbytes"


# Data: gibibytes
Gibibytes: typing.Literal["gbytes"] = "gbytes"


# Data: gigabytes
Gigabytes: typing.Literal["decgbytes"] = "decgbytes"


# Data: tebibytes
Tebibytes: typing.Literal["tbytes"] = "tbytes"


# Data: terabytes
Terabytes: typing.Literal["dectbytes"] = "dectbytes"


# Data: pebibytes
Pebibytes: typing.Literal["pbytes"] = "pbytes"


# Data: petabytes
Petabytes: typing.Literal["decpbytes"] = "decpbytes"


# Data rate: packets/sec
PacketsPerSecond: typing.Literal["pps"] = "pps"


# Data rate: bytes/sec(IEC)
BytesPerSecondIEC: typing.Literal["binBps"] = "binBps"


# Data rate: bytes/sec(SI)
BytesPerSecondSI: typing.Literal["Bps"] = "Bps"


# Data rate: bits/sec(IEC)
BitsPerSecondIEC: typing.Literal["binbps"] = "binbps"


# Data rate: bits/sec(SI)
BitsPerSecondSI: typing.Literal["bps"] = "bps"


# Data rate: kibibytes/sec
KibibytesPerSecond: typing.Literal["KiBs"] = "KiBs"


# Data rate: kibibits/sec
KibibitsPerSecond: typing.Literal["Kibits"] = "Kibits"


# Data rate: kilobytes/sec
KilobytesPerSecond: typing.Literal["KBs"] = "KBs"


# Data rate: kilobits/sec
KilobitsPerSecond: typing.Literal["Kbits"] = "Kbits"


# Data rate: mebibytes/sec
MebibytesPerSecond: typing.Literal["MiBs"] = "MiBs"


# Data rate: mebibits/sec
MebibitsPerSecond: typing.Literal["Mibits"] = "Mibits"


# Data rate: megabytes/sec
MegabytesPerSecond: typing.Literal["MBs"] = "MBs"


# Data rate: megabits/sec
MegabitsPerSecond: typing.Literal["Mbits"] = "Mbits"


# Data rate: gibibytes/sec
GibibytesPerSecond: typing.Literal["GiBs"] = "GiBs"


# Data rate: gibibits/sec
GibibitsPerSecond: typing.Literal["Gibits"] = "Gibits"


# Data rate: gigabytes/sec
GigabytesPerSecond: typing.Literal["GBs"] = "GBs"


# Data rate: gigabits/sec
GigabitsPerSecond: typing.Literal["Gbits"] = "Gbits"


# Data rate: tebibytes/sec
TebibytesPerSecond: typing.Literal["TiBs"] = "TiBs"


# Data rate: tebibits/sec
TebibitsPerSecond: typing.Literal["Tibits"] = "Tibits"


# Data rate: terabytes/sec
TerabytesPerSecond: typing.Literal["TBs"] = "TBs"


# Data rate: terabits/sec
TerabitsPerSecond: typing.Literal["Tbits"] = "Tbits"


# Data rate: pebibytes/sec
PebibytesPerSecond: typing.Literal["PiBs"] = "PiBs"


# Data rate: pebibits/sec
PebibitsPerSecond: typing.Literal["Pibits"] = "Pibits"


# Data rate: petabytes/sec
PetabytesPerSecond: typing.Literal["PBs"] = "PBs"


# Data rate: petabits/sec
PetabitsPerSecond: typing.Literal["Pbits"] = "Pbits"


# Date & time: Datetime ISO
DatetimeISO: typing.Literal["dateTimeAsIso"] = "dateTimeAsIso"


# Date & time: Datetime ISO (No date if today)
DatetimeISONotToday: typing.Literal["dateTimeAsIsoNoDateIfToday"] = "dateTimeAsIsoNoDateIfToday"


# Date & time: Datetime US
DatetimeUS: typing.Literal["dateTimeAsUS"] = "dateTimeAsUS"


# Date & time: Datetime US (No date if today)
DatetimeUSNotToday: typing.Literal["dateTimeAsUSNoDateIfToday"] = "dateTimeAsUSNoDateIfToday"


# Date & time: Datetime local
DatetimeLocal: typing.Literal["dateTimeAsLocal"] = "dateTimeAsLocal"


# Date & time: Datetime local (No date if today)
DatetimeLocalNotToday: typing.Literal["dateTimeAsLocalNoDateIfToday"] = "dateTimeAsLocalNoDateIfToday"


# Date & time: Datetime default
DatetimeDefault: typing.Literal["dateTimeAsSystem"] = "dateTimeAsSystem"


# Date & time: From Now
DateTimeFromNow: typing.Literal["dateTimeFromNow"] = "dateTimeFromNow"


# Energy: Watt (W)
Watt: typing.Literal["watt"] = "watt"


# Energy: Kilowatt (kW)
KiloWatt: typing.Literal["kwatt"] = "kwatt"


# Energy: Megawatt (MW)
MegaWatt: typing.Literal["megwatt"] = "megwatt"


# Energy: Gigawatt (GW)
GigaWatt: typing.Literal["gwatt"] = "gwatt"


# Energy: Milliwatt (mW)
MilliWatt: typing.Literal["mwatt"] = "mwatt"


# Energy: Watt per square meter (W/m²)
WattPerSquareMeter: typing.Literal["Wm2"] = "Wm2"


# Energy: Volt-Ampere (VA)
VoltAmpere: typing.Literal["voltamp"] = "voltamp"


# Energy: Kilovolt-Ampere (kVA)
KiloVoltAmpere: typing.Literal["kvoltamp"] = "kvoltamp"


# Energy: Volt-Ampere reactive (VAr)
VoltAmpereReactive: typing.Literal["voltampreact"] = "voltampreact"


# Energy: Kilovolt-Ampere reactive (kVAr)
KiloVoltAmpereReactive: typing.Literal["kvoltampreact"] = "kvoltampreact"


# Energy: Watt-hour (Wh)
WattHour: typing.Literal["watth"] = "watth"


# Energy: Watt-hour per Kilogram (Wh/kg)
WattHourPerKilogram: typing.Literal["watthperkg"] = "watthperkg"


# Energy: Kilowatt-hour (kWh)
KiloWattHour: typing.Literal["kwatth"] = "kwatth"


# Energy: Kilowatt-min (kWm)
KiloWattMinute: typing.Literal["kwattm"] = "kwattm"


# Energy: Megawatt-hour (MWh)
MegaWattHour: typing.Literal["mwatth"] = "mwatth"


# Energy: Ampere-hour (Ah)
AmpereHour: typing.Literal["amph"] = "amph"


# Energy: Kiloampere-hour (kAh)
KiloAmpereHour: typing.Literal["kamph"] = "kamph"


# Energy: Milliampere-hour (mAh)
MilliAmpereHour: typing.Literal["mamph"] = "mamph"


# Energy: Joule (J)
Joule: typing.Literal["joule"] = "joule"


# Energy: Electron volt (eV)
ElectronVolt: typing.Literal["ev"] = "ev"


# Energy: Ampere (A)
Ampere: typing.Literal["amp"] = "amp"


# Energy: Kiloampere (kA)
KiloAmpere: typing.Literal["kamp"] = "kamp"


# Energy: Milliampere (mA)
MilliAmpere: typing.Literal["mamp"] = "mamp"


# Energy: Volt (V)
Volt: typing.Literal["volt"] = "volt"


# Energy: Kilovolt (kV)
KiloVolt: typing.Literal["kvolt"] = "kvolt"


# Energy: Millivolt (mV)
MilliVolt: typing.Literal["mvolt"] = "mvolt"


# Energy: Decibel-milliwatt (dBm)
DecibelMilliWatt: typing.Literal["dBm"] = "dBm"


# Energy: Milliohm (mΩ)
MilliOhm: typing.Literal["mohm"] = "mohm"


# Energy: Ohm (Ω)
Ohm: typing.Literal["ohm"] = "ohm"


# Energy: Kiloohm (kΩ)
KiloOhm: typing.Literal["kohm"] = "kohm"


# Energy: Megaohm (MΩ)
MegaOhm: typing.Literal["Mohm"] = "Mohm"


# Energy: Farad (F)
Farad: typing.Literal["farad"] = "farad"


# Energy: Microfarad (µF)
MicroFarad: typing.Literal["watt"] = "watt"


# Energy: Nanofarad (nF)
NanoFarad: typing.Literal["nfarad"] = "nfarad"


# Energy: Picofarad (pF)
PicoFarad: typing.Literal["pfarad"] = "pfarad"


# Energy: Femtofarad (fF)
FemtoFarad: typing.Literal["ffarad"] = "ffarad"


# Energy: Henry (H)
Henry: typing.Literal["henry"] = "henry"


# Energy: Millihenry (mH)
MilliHenry: typing.Literal["mhenry"] = "mhenry"


# Energy: Microhenry (µH)
MicroHenry: typing.Literal["µhenry"] = "µhenry"


# Energy: Lumens (Lm)
Lumens: typing.Literal["lumens"] = "lumens"


# Flow: Gallons/min (gpm)
GallonsPerMinute: typing.Literal["flowgpm"] = "flowgpm"


# Flow: Cubic meters/sec (cms)
CubicMetersPerSecond: typing.Literal["flowcms"] = "flowcms"


# Flow: Cubic feet/sec (cfs)
CubicFeetPerSecond: typing.Literal["flowcms"] = "flowcms"


# Flow: Cubic feet/min (cfm)
CubicFeetPerMinute: typing.Literal["flowcms"] = "flowcms"


# Flow: Litre/hour
LitrePerHour: typing.Literal["litreh"] = "litreh"


# Flow: Litre/min (L/min)
LitrePerMinute: typing.Literal["flowlpm"] = "flowlpm"


# Flow: milliLitre/min (mL/min)
MilliLitrePerMinute: typing.Literal["flowmlpm"] = "flowmlpm"


# Flow: Lux (lx)
Lux: typing.Literal["lux"] = "lux"


# Force: Newton-meters (Nm)
NewtonMeters: typing.Literal["forceNm"] = "forceNm"


# Force: Kilonewton-meters (kNm)
KiloNewtonMeters: typing.Literal["forcekNm"] = "forcekNm"


# Force: Newtons (N)
Newtons: typing.Literal["forceN"] = "forceN"


# Force: Kilonewtons (kN)
KiloNewtons: typing.Literal["forcekN"] = "forcekN"


# Hash rate: hashes/sec
HashesPerSecond: typing.Literal["Hs"] = "Hs"


# Hash rate: kilohashes/sec
KiloHashesPerSecond: typing.Literal["KHs"] = "KHs"


# Hash rate: megahashes/sec
MegaHashesPerSecond: typing.Literal["MHs"] = "MHs"


# Hash rate: gigahashes/sec
GigaHashesPerSecond: typing.Literal["GHs"] = "GHs"


# Hash rate: terahashes/sec
TeraHashesPerSecond: typing.Literal["THs"] = "THs"


# Hash rate: petahashes/sec
PetaHashesPerSecond: typing.Literal["PHs"] = "PHs"


# Hash rate: exahashes/sec
ExaHashesPerSecond: typing.Literal["EHs"] = "EHs"


# Mass: milligram (mg)
Milligram: typing.Literal["massmg"] = "massmg"


# Mass: gram (g)
Gram: typing.Literal["massg"] = "massg"


# Mass: pound (lb)
Pound: typing.Literal["masslb"] = "masslb"


# Mass: kilogram (kg)
Kilogram: typing.Literal["masskg"] = "masskg"


# Mass: metric ton (t)
MetricTon: typing.Literal["masst"] = "masst"


# Length: millimeter (mm)
Millimeter: typing.Literal["lengthmm"] = "lengthmm"


# Length: inch (in)
Inch: typing.Literal["lengthin"] = "lengthin"


# Length: feet (ft)
Feet: typing.Literal["lengthft"] = "lengthft"


# Length: meter (m)
Meter: typing.Literal["lengthm"] = "lengthm"


# Length: kilometer (km)
Kilometer: typing.Literal["lengthkm"] = "lengthkm"


# Length: mile (mi)
Mile: typing.Literal["lengthmi"] = "lengthmi"


# Pressure: Millibars
Millibars: typing.Literal["pressurembar"] = "pressurembar"


# Pressure: Bars
Bars: typing.Literal["pressurebar"] = "pressurebar"


# Pressure: Kilobars
Kilobars: typing.Literal["pressurekbar"] = "pressurekbar"


# Pressure: Pascals
Pascals: typing.Literal["pressurepa"] = "pressurepa"


# Pressure: Hectopascals
Hectopascals: typing.Literal["pressurehpa"] = "pressurehpa"


# Pressure: Kilopascals
Kilopascals: typing.Literal["pressurekpa"] = "pressurekpa"


# Pressure: Inches of mercury
InchesOfMercury: typing.Literal["pressurehg"] = "pressurehg"


# Pressure: PSI
PSI: typing.Literal["pressurepsi"] = "pressurepsi"


# Radiation: Becquerel (Bq)
Becquerel: typing.Literal["radbq"] = "radbq"


# Radiation: curie (Ci)
Curie: typing.Literal["radci"] = "radci"


# Radiation: Gray (Gy)
Gray: typing.Literal["radgy"] = "radgy"


# Radiation: rad
Rad: typing.Literal["radrad"] = "radrad"


# Radiation: Sievert (Sv)
Sievert: typing.Literal["radsv"] = "radsv"


# Radiation: milliSievert (mSv)
Millisievert: typing.Literal["radmsv"] = "radmsv"


# Radiation: microSievert (µSv)
Microsievert: typing.Literal["radusv"] = "radusv"


# Radiation: rem
Rem: typing.Literal["radrem"] = "radrem"


# Radiation: Exposure (C/kg)
Exposure: typing.Literal["radexpckg"] = "radexpckg"


# Radiation: roentgen (R)
Roentgen: typing.Literal["radr"] = "radr"


# Radiation: Sievert/hour (Sv/h)
SievertPerHour: typing.Literal["radsvh"] = "radsvh"


# Radiation: milliSievert/hour (mSv/h)
MillisievertPerHour: typing.Literal["radmsvh"] = "radmsvh"


# Radiation: microSievert/hour (µSv/h)
MicrosievertPerHour: typing.Literal["radusvh"] = "radusvh"


# Rotational Speed: Revolutions per minute (rpm)
RevolutionsPerMinute: typing.Literal["rotrpm"] = "rotrpm"


# Rotational Speed: Hertz (Hz)
HertzRotation: typing.Literal["rothz"] = "rothz"


# Rotational Speed: Kilohertz (kHz)
KilohertzRotation: typing.Literal["rotkhz"] = "rotkhz"


# Rotational Speed: Megahertz (MHz)
MegahertzRotation: typing.Literal["rotmhz"] = "rotmhz"


# Rotational Speed: Gigahertz (GHz)
GigahertzRotation: typing.Literal["rotghz"] = "rotghz"


# Rotational Speed: Radians per second (rad/s)
RadiansPerSecond: typing.Literal["rotrads"] = "rotrads"


# Rotational Speed: Degrees per second (°/s)
DegreesPerSecond: typing.Literal["rotdegs"] = "rotdegs"


# Temperature: Celsius (°C)
Celsius: typing.Literal["celsius"] = "celsius"


# Temperature: Fahrenheit (°F)
Fahrenheit: typing.Literal["fahrenheit"] = "fahrenheit"


# Temperature: Kelvin (K)
Kelvin: typing.Literal["kelvin"] = "kelvin"


# Time: Hertz (1/s)
Hertz: typing.Literal["hertz"] = "hertz"


# Time: nanoseconds (ns)
Nanoseconds: typing.Literal["ns"] = "ns"


# Time: microseconds (µs)
Microseconds: typing.Literal["µs"] = "µs"


# Time: milliseconds (ms)
Milliseconds: typing.Literal["ms"] = "ms"


# Time: seconds (s)
Seconds: typing.Literal["s"] = "s"


# Time: minutes (m)
Minutes: typing.Literal["m"] = "m"


# Time: hours (h)
Hours: typing.Literal["h"] = "h"


# Time: days (d)
Days: typing.Literal["d"] = "d"


# Time: duration (ms)
DurationMilliseconds: typing.Literal["dtdurationms"] = "dtdurationms"


# Time: duration (s)
DurationSeconds: typing.Literal["dtdurations"] = "dtdurations"


# Time: duration (hh:mm:ss)
DurationInHoursMinutesSeconds: typing.Literal["dthms"] = "dthms"


# Time: duration (d hh:mm:ss)
DurationInDaysHoursMinutesSeconds: typing.Literal["dtdhms"] = "dtdhms"


# Time: Timeticks (s/100)
Timeticks: typing.Literal["timeticks"] = "timeticks"


# Time: clock (ms)
ClockMilliseconds: typing.Literal["clockms"] = "clockms"


# Time: clock (s)
ClockSeconds: typing.Literal["clocks"] = "clocks"


# Throughput: counts/sec (cps)
CountsPerSecond: typing.Literal["cps"] = "cps"


# Throughput: ops/sec (ops)
OpsPerSecond: typing.Literal["ops"] = "ops"


# Throughput: requests/sec (rps)
RequestsPerSecond: typing.Literal["reqps"] = "reqps"


# Throughput: reads/sec (rps)
ReadsPerSecond: typing.Literal["rps"] = "rps"


# Throughput: writes/sec (wps)
WritesPerSecond: typing.Literal["wps"] = "wps"


# Throughput: I/O ops/sec (iops)
IOOpsPerSecond: typing.Literal["iops"] = "iops"


# Throughput: events/sec (eps)
EventsPerSecond: typing.Literal["eps"] = "eps"


# Throughput: messages/sec (mps)
MessagesPerSecond: typing.Literal["mps"] = "mps"


# Throughput: records/sec (rps)
RecordsPerSecond: typing.Literal["recps"] = "recps"


# Throughput: rows/sec (rps)
RowsPerSecond: typing.Literal["rowsps"] = "rowsps"


# Throughput: counts/min (cpm)
CountsPerMinute: typing.Literal["cpm"] = "cpm"


# Throughput: ops/min (opm)
OpsPerMinute: typing.Literal["opm"] = "opm"


# Throughput: requests/min (rpm)
RequestsPerMinute: typing.Literal["reqpm"] = "reqpm"


# Throughput: reads/min (rpm)
ReadsPerMinute: typing.Literal["rpm"] = "rpm"


# Throughput: writes/min (wpm)
WritesPerMinute: typing.Literal["wpm"] = "wpm"


# Throughput: events/min (epm)
EventsPerMinute: typing.Literal["epm"] = "epm"


# Throughput: messages/min (mpm)
MessagesPerMinute: typing.Literal["mpm"] = "mpm"


# Throughput: records/min (rpm)
RecordsPerMinute: typing.Literal["recpm"] = "recpm"


# Throughput: rows/min (rpm)
RowsPerMinute: typing.Literal["rowspm"] = "rowspm"


# Velocity: meters/second (m/s)
MetersPerSecond: typing.Literal["velocityms"] = "velocityms"


# Velocity: kilometers/hour (km/h)
KilometersPerHour: typing.Literal["velocitykmh"] = "velocitykmh"


# Velocity: miles/hour (mph)
MilesPerHour: typing.Literal["velocitymph"] = "velocitymph"


# Velocity: knot (kn)
Knot: typing.Literal["velocityknot"] = "velocityknot"


# Volume: millilitre (mL)
Millilitre: typing.Literal["mlitre"] = "mlitre"


# Volume: litre (L)
Litre: typing.Literal["litre"] = "litre"


# Volume: cubic meter
CubicMeter: typing.Literal["m3"] = "m3"


# Volume: Normal cubic meter
NormalCubicMeter: typing.Literal["Nm3"] = "Nm3"


# Volume: cubic decimeter
CubicDecimeter: typing.Literal["dm3"] = "dm3"


# Volume: gallons
Gallons: typing.Literal["gallons"] = "gallons"


# Boolean: True / False
Bool: typing.Literal["bool"] = "bool"


# Boolean: Yes / No
BoolYesNo: typing.Literal["bool_yes_no"] = "bool_yes_no"


# Boolean: On / Off
BoolOnOff: typing.Literal["bool_on_off"] = "bool_on_off"



