//
//  Generated code. Do not modify.
//  source: unitOfMeasures.proto
//
// @dart = 3.3

// ignore_for_file: annotate_overrides, camel_case_types, comment_references
// ignore_for_file: constant_identifier_names, library_prefixes
// ignore_for_file: non_constant_identifier_names, prefer_final_fields
// ignore_for_file: unnecessary_import, unnecessary_this, unused_import

import 'dart:core' as $core;

import 'package:protobuf/protobuf.dart' as $pb;

class Length extends $pb.ProtobufEnum {
  static const Length LENGTH_UNKNOWN = Length._(0, _omitEnumNames ? '' : 'LENGTH_UNKNOWN');
  static const Length METER = Length._(10, _omitEnumNames ? '' : 'METER');
  static const Length MILLIMETER = Length._(20, _omitEnumNames ? '' : 'MILLIMETER');
  static const Length CENTIMETER = Length._(30, _omitEnumNames ? '' : 'CENTIMETER');
  static const Length DECIMETER = Length._(40, _omitEnumNames ? '' : 'DECIMETER');
  static const Length DECAMETER = Length._(50, _omitEnumNames ? '' : 'DECAMETER');
  static const Length HECTOMETER = Length._(60, _omitEnumNames ? '' : 'HECTOMETER');
  static const Length KILOMETER = Length._(70, _omitEnumNames ? '' : 'KILOMETER');
  static const Length INCH = Length._(80, _omitEnumNames ? '' : 'INCH');
  static const Length FOOT = Length._(90, _omitEnumNames ? '' : 'FOOT');
  static const Length YARD = Length._(100, _omitEnumNames ? '' : 'YARD');
  static const Length MILE = Length._(110, _omitEnumNames ? '' : 'MILE');

  static const $core.List<Length> values = <Length> [
    LENGTH_UNKNOWN,
    METER,
    MILLIMETER,
    CENTIMETER,
    DECIMETER,
    DECAMETER,
    HECTOMETER,
    KILOMETER,
    INCH,
    FOOT,
    YARD,
    MILE,
  ];

  static final $core.Map<$core.int, Length> _byValue = $pb.ProtobufEnum.initByValue(values);
  static Length? valueOf($core.int value) => _byValue[value];

  const Length._(super.v, super.n);
}

class Weight extends $pb.ProtobufEnum {
  static const Weight WEIGHT_UNKNOWN = Weight._(0, _omitEnumNames ? '' : 'WEIGHT_UNKNOWN');
  static const Weight GRAMME = Weight._(10, _omitEnumNames ? '' : 'GRAMME');
  static const Weight MILLIGRAM = Weight._(20, _omitEnumNames ? '' : 'MILLIGRAM');
  static const Weight CENTIGRAM = Weight._(30, _omitEnumNames ? '' : 'CENTIGRAM');
  static const Weight DECIGRAM = Weight._(40, _omitEnumNames ? '' : 'DECIGRAM');
  static const Weight DECAGRAM = Weight._(50, _omitEnumNames ? '' : 'DECAGRAM');
  static const Weight HECTOGRAM = Weight._(60, _omitEnumNames ? '' : 'HECTOGRAM');
  static const Weight KILOGRAM = Weight._(70, _omitEnumNames ? '' : 'KILOGRAM');
  static const Weight TONNE = Weight._(80, _omitEnumNames ? '' : 'TONNE');
  static const Weight GRAIN = Weight._(90, _omitEnumNames ? '' : 'GRAIN');
  static const Weight ONCE = Weight._(100, _omitEnumNames ? '' : 'ONCE');
  static const Weight POUND = Weight._(110, _omitEnumNames ? '' : 'POUND');
  static const Weight SHORT_TON = Weight._(120, _omitEnumNames ? '' : 'SHORT_TON');
  static const Weight LONG_TON = Weight._(130, _omitEnumNames ? '' : 'LONG_TON');
  static const Weight STONE = Weight._(140, _omitEnumNames ? '' : 'STONE');

  static const $core.List<Weight> values = <Weight> [
    WEIGHT_UNKNOWN,
    GRAMME,
    MILLIGRAM,
    CENTIGRAM,
    DECIGRAM,
    DECAGRAM,
    HECTOGRAM,
    KILOGRAM,
    TONNE,
    GRAIN,
    ONCE,
    POUND,
    SHORT_TON,
    LONG_TON,
    STONE,
  ];

  static final $core.Map<$core.int, Weight> _byValue = $pb.ProtobufEnum.initByValue(values);
  static Weight? valueOf($core.int value) => _byValue[value];

  const Weight._(super.v, super.n);
}

class Temperature extends $pb.ProtobufEnum {
  static const Temperature TEMPERATURE_UNKNOWN = Temperature._(0, _omitEnumNames ? '' : 'TEMPERATURE_UNKNOWN');
  static const Temperature CELSIUS = Temperature._(1, _omitEnumNames ? '' : 'CELSIUS');
  static const Temperature FAHRENHEIT = Temperature._(2, _omitEnumNames ? '' : 'FAHRENHEIT');

  static const $core.List<Temperature> values = <Temperature> [
    TEMPERATURE_UNKNOWN,
    CELSIUS,
    FAHRENHEIT,
  ];

  static final $core.Map<$core.int, Temperature> _byValue = $pb.ProtobufEnum.initByValue(values);
  static Temperature? valueOf($core.int value) => _byValue[value];

  const Temperature._(super.v, super.n);
}

class Speed extends $pb.ProtobufEnum {
  static const Speed SPEED_UNKNOWN = Speed._(0, _omitEnumNames ? '' : 'SPEED_UNKNOWN');
  static const Speed KM_PER_HOUR = Speed._(10, _omitEnumNames ? '' : 'KM_PER_HOUR');
  static const Speed METER_PER_SECOND = Speed._(20, _omitEnumNames ? '' : 'METER_PER_SECOND');
  static const Speed YARD_PER_SECOND = Speed._(30, _omitEnumNames ? '' : 'YARD_PER_SECOND');
  static const Speed MILE_PER_HOUR = Speed._(40, _omitEnumNames ? '' : 'MILE_PER_HOUR');

  static const $core.List<Speed> values = <Speed> [
    SPEED_UNKNOWN,
    KM_PER_HOUR,
    METER_PER_SECOND,
    YARD_PER_SECOND,
    MILE_PER_HOUR,
  ];

  static final $core.Map<$core.int, Speed> _byValue = $pb.ProtobufEnum.initByValue(values);
  static Speed? valueOf($core.int value) => _byValue[value];

  const Speed._(super.v, super.n);
}

class Area extends $pb.ProtobufEnum {
  static const Area AREA_UNKNOWN = Area._(0, _omitEnumNames ? '' : 'AREA_UNKNOWN');
  static const Area SQUARE_METER = Area._(10, _omitEnumNames ? '' : 'SQUARE_METER');
  static const Area SQUARE_MILLIMETER = Area._(20, _omitEnumNames ? '' : 'SQUARE_MILLIMETER');
  static const Area SQUARE_CENTIMETER = Area._(30, _omitEnumNames ? '' : 'SQUARE_CENTIMETER');
  static const Area SQUARE_DECIMETER = Area._(40, _omitEnumNames ? '' : 'SQUARE_DECIMETER');
  static const Area SQUARE_DECAMETER = Area._(50, _omitEnumNames ? '' : 'SQUARE_DECAMETER');
  static const Area SQUARE_HECTOMETER = Area._(60, _omitEnumNames ? '' : 'SQUARE_HECTOMETER');
  static const Area SQUARE_INCH = Area._(70, _omitEnumNames ? '' : 'SQUARE_INCH');
  static const Area SQUARE_FEET = Area._(80, _omitEnumNames ? '' : 'SQUARE_FEET');
  static const Area SQUARE_YARD = Area._(90, _omitEnumNames ? '' : 'SQUARE_YARD');
  static const Area ACRE = Area._(100, _omitEnumNames ? '' : 'ACRE');

  static const $core.List<Area> values = <Area> [
    AREA_UNKNOWN,
    SQUARE_METER,
    SQUARE_MILLIMETER,
    SQUARE_CENTIMETER,
    SQUARE_DECIMETER,
    SQUARE_DECAMETER,
    SQUARE_HECTOMETER,
    SQUARE_INCH,
    SQUARE_FEET,
    SQUARE_YARD,
    ACRE,
  ];

  static final $core.Map<$core.int, Area> _byValue = $pb.ProtobufEnum.initByValue(values);
  static Area? valueOf($core.int value) => _byValue[value];

  const Area._(super.v, super.n);
}

class Volume extends $pb.ProtobufEnum {
  static const Volume VOLUME_UNKNOWN = Volume._(0, _omitEnumNames ? '' : 'VOLUME_UNKNOWN');
  static const Volume CUBIC_METER = Volume._(10, _omitEnumNames ? '' : 'CUBIC_METER');
  static const Volume CUBIC_MILLIMETER = Volume._(20, _omitEnumNames ? '' : 'CUBIC_MILLIMETER');
  static const Volume CUBIC_CENTIMETER = Volume._(30, _omitEnumNames ? '' : 'CUBIC_CENTIMETER');
  static const Volume CUBIC_DECIMETER = Volume._(40, _omitEnumNames ? '' : 'CUBIC_DECIMETER');
  static const Volume LITER = Volume._(50, _omitEnumNames ? '' : 'LITER');
  static const Volume MILLI_LITER = Volume._(60, _omitEnumNames ? '' : 'MILLI_LITER');
  static const Volume CENTI_LITER = Volume._(70, _omitEnumNames ? '' : 'CENTI_LITER');
  static const Volume DECI_LITER = Volume._(80, _omitEnumNames ? '' : 'DECI_LITER');
  static const Volume DECA_LITER = Volume._(90, _omitEnumNames ? '' : 'DECA_LITER');
  static const Volume HECTO_LITER = Volume._(100, _omitEnumNames ? '' : 'HECTO_LITER');
  static const Volume CUBIC_INCH = Volume._(110, _omitEnumNames ? '' : 'CUBIC_INCH');
  static const Volume CUBIC_FEET = Volume._(120, _omitEnumNames ? '' : 'CUBIC_FEET');
  static const Volume CUBIC_YARD = Volume._(130, _omitEnumNames ? '' : 'CUBIC_YARD');
  static const Volume US_FLUID_OUNCE = Volume._(140, _omitEnumNames ? '' : 'US_FLUID_OUNCE');
  static const Volume US_PINT = Volume._(150, _omitEnumNames ? '' : 'US_PINT');
  static const Volume US_DRY_PINT = Volume._(160, _omitEnumNames ? '' : 'US_DRY_PINT');
  static const Volume US_DRY_QUART = Volume._(170, _omitEnumNames ? '' : 'US_DRY_QUART');
  static const Volume US_GAL = Volume._(180, _omitEnumNames ? '' : 'US_GAL');
  static const Volume IMPERIAL_OUNCE = Volume._(190, _omitEnumNames ? '' : 'IMPERIAL_OUNCE');
  static const Volume IMPERIAL_PINT = Volume._(200, _omitEnumNames ? '' : 'IMPERIAL_PINT');
  static const Volume IMPERIAL_QUART = Volume._(210, _omitEnumNames ? '' : 'IMPERIAL_QUART');
  static const Volume IMPERIAL_GAL = Volume._(220, _omitEnumNames ? '' : 'IMPERIAL_GAL');

  static const $core.List<Volume> values = <Volume> [
    VOLUME_UNKNOWN,
    CUBIC_METER,
    CUBIC_MILLIMETER,
    CUBIC_CENTIMETER,
    CUBIC_DECIMETER,
    LITER,
    MILLI_LITER,
    CENTI_LITER,
    DECI_LITER,
    DECA_LITER,
    HECTO_LITER,
    CUBIC_INCH,
    CUBIC_FEET,
    CUBIC_YARD,
    US_FLUID_OUNCE,
    US_PINT,
    US_DRY_PINT,
    US_DRY_QUART,
    US_GAL,
    IMPERIAL_OUNCE,
    IMPERIAL_PINT,
    IMPERIAL_QUART,
    IMPERIAL_GAL,
  ];

  static final $core.Map<$core.int, Volume> _byValue = $pb.ProtobufEnum.initByValue(values);
  static Volume? valueOf($core.int value) => _byValue[value];

  const Volume._(super.v, super.n);
}

class DimensionLess extends $pb.ProtobufEnum {
  static const DimensionLess DIMENSIONLESS_UNKNOWN = DimensionLess._(0, _omitEnumNames ? '' : 'DIMENSIONLESS_UNKNOWN');
  static const DimensionLess UNIT = DimensionLess._(1, _omitEnumNames ? '' : 'UNIT');

  static const $core.List<DimensionLess> values = <DimensionLess> [
    DIMENSIONLESS_UNKNOWN,
    UNIT,
  ];

  static final $core.Map<$core.int, DimensionLess> _byValue = $pb.ProtobufEnum.initByValue(values);
  static DimensionLess? valueOf($core.int value) => _byValue[value];

  const DimensionLess._(super.v, super.n);
}


const _omitEnumNames = $core.bool.fromEnvironment('protobuf.omit_enum_names');
