//
//  Generated code. Do not modify.
//  source: base.proto
//
// @dart = 2.12

// 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 ErrorCode extends $pb.ProtobufEnum {
  static const ErrorCode OK = ErrorCode._(0, _omitEnumNames ? '' : 'OK');
  static const ErrorCode TokenExpire = ErrorCode._(1000, _omitEnumNames ? '' : 'TokenExpire');
  static const ErrorCode UserBan = ErrorCode._(1001, _omitEnumNames ? '' : 'UserBan');
  static const ErrorCode VfCodeExpire = ErrorCode._(1002, _omitEnumNames ? '' : 'VfCodeExpire');
  static const ErrorCode SmsSendFail = ErrorCode._(1003, _omitEnumNames ? '' : 'SmsSendFail');
  static const ErrorCode UserStatusErr = ErrorCode._(1008, _omitEnumNames ? '' : 'UserStatusErr');
  static const ErrorCode StatusErr = ErrorCode._(1009, _omitEnumNames ? '' : 'StatusErr');
  static const ErrorCode PhoneNotExist = ErrorCode._(2001, _omitEnumNames ? '' : 'PhoneNotExist');
  static const ErrorCode UnknownErr = ErrorCode._(2002, _omitEnumNames ? '' : 'UnknownErr');
  static const ErrorCode ParamErr = ErrorCode._(5000, _omitEnumNames ? '' : 'ParamErr');
  static const ErrorCode HeadSourceErr = ErrorCode._(5001, _omitEnumNames ? '' : 'HeadSourceErr');
  static const ErrorCode DATABASE = ErrorCode._(9000, _omitEnumNames ? '' : 'DATABASE');
  static const ErrorCode NoRecord = ErrorCode._(9001, _omitEnumNames ? '' : 'NoRecord');

  static const $core.List<ErrorCode> values = <ErrorCode> [
    OK,
    TokenExpire,
    UserBan,
    VfCodeExpire,
    SmsSendFail,
    UserStatusErr,
    StatusErr,
    PhoneNotExist,
    UnknownErr,
    ParamErr,
    HeadSourceErr,
    DATABASE,
    NoRecord,
  ];

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

  const ErrorCode._($core.int v, $core.String n) : super(v, n);
}

class ShopType extends $pb.ProtobufEnum {
  static const ShopType UnKnowShop = ShopType._(0, _omitEnumNames ? '' : 'UnKnowShop');
  static const ShopType ParkShop = ShopType._(1, _omitEnumNames ? '' : 'ParkShop');
  static const ShopType IPShop = ShopType._(2, _omitEnumNames ? '' : 'IPShop');
  static const ShopType AdminShop = ShopType._(3, _omitEnumNames ? '' : 'AdminShop');

  static const $core.List<ShopType> values = <ShopType> [
    UnKnowShop,
    ParkShop,
    IPShop,
    AdminShop,
  ];

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

  const ShopType._($core.int v, $core.String n) : super(v, n);
}

/// UserType 用户类型
class UserType extends $pb.ProtobufEnum {
  static const UserType UnDefine = UserType._(0, _omitEnumNames ? '' : 'UnDefine');
  static const UserType AppUser = UserType._(1, _omitEnumNames ? '' : 'AppUser');
  static const UserType ParkAdmin = UserType._(2, _omitEnumNames ? '' : 'ParkAdmin');
  static const UserType IPAdmin = UserType._(3, _omitEnumNames ? '' : 'IPAdmin');
  static const UserType SysAdmin = UserType._(4, _omitEnumNames ? '' : 'SysAdmin');
  static const UserType ToAdmin = UserType._(5, _omitEnumNames ? '' : 'ToAdmin');
  static const UserType CoopToAdmin = UserType._(6, _omitEnumNames ? '' : 'CoopToAdmin');

  static const $core.List<UserType> values = <UserType> [
    UnDefine,
    AppUser,
    ParkAdmin,
    IPAdmin,
    SysAdmin,
    ToAdmin,
    CoopToAdmin,
  ];

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

  const UserType._($core.int v, $core.String n) : super(v, n);
}

/// LoginSource 登陆来源
class LoginSource extends $pb.ProtobufEnum {
  static const LoginSource UnDef = LoginSource._(0, _omitEnumNames ? '' : 'UnDef');
  static const LoginSource UserApp = LoginSource._(1, _omitEnumNames ? '' : 'UserApp');
  static const LoginSource WebAdmin = LoginSource._(2, _omitEnumNames ? '' : 'WebAdmin');
  static const LoginSource ShopApp = LoginSource._(3, _omitEnumNames ? '' : 'ShopApp');
  static const LoginSource ToApp = LoginSource._(4, _omitEnumNames ? '' : 'ToApp');
  static const LoginSource CoopToWebAdmin = LoginSource._(5, _omitEnumNames ? '' : 'CoopToWebAdmin');
  static const LoginSource CoopToApp = LoginSource._(6, _omitEnumNames ? '' : 'CoopToApp');

  static const $core.List<LoginSource> values = <LoginSource> [
    UnDef,
    UserApp,
    WebAdmin,
    ShopApp,
    ToApp,
    CoopToWebAdmin,
    CoopToApp,
  ];

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

  const LoginSource._($core.int v, $core.String n) : super(v, n);
}

class SmsType extends $pb.ProtobufEnum {
  static const SmsType UnKnow = SmsType._(0, _omitEnumNames ? '' : 'UnKnow');
  static const SmsType Login = SmsType._(1, _omitEnumNames ? '' : 'Login');
  static const SmsType SignUp = SmsType._(2, _omitEnumNames ? '' : 'SignUp');

  static const $core.List<SmsType> values = <SmsType> [
    UnKnow,
    Login,
    SignUp,
  ];

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

  const SmsType._($core.int v, $core.String n) : super(v, n);
}

class ProjectContentType extends $pb.ProtobufEnum {
  static const ProjectContentType Text = ProjectContentType._(0, _omitEnumNames ? '' : 'Text');
  static const ProjectContentType Html = ProjectContentType._(1, _omitEnumNames ? '' : 'Html');

  static const $core.List<ProjectContentType> values = <ProjectContentType> [
    Text,
    Html,
  ];

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

  const ProjectContentType._($core.int v, $core.String n) : super(v, n);
}

class CriterionType extends $pb.ProtobufEnum {
  static const CriterionType CrUnKnow = CriterionType._(0, _omitEnumNames ? '' : 'CrUnKnow');
  static const CriterionType CrOrder = CriterionType._(1, _omitEnumNames ? '' : 'CrOrder');
  static const CriterionType CrNum = CriterionType._(2, _omitEnumNames ? '' : 'CrNum');

  static const $core.List<CriterionType> values = <CriterionType> [
    CrUnKnow,
    CrOrder,
    CrNum,
  ];

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

  const CriterionType._($core.int v, $core.String n) : super(v, n);
}

class CType extends $pb.ProtobufEnum {
  static const CType UnKnowType = CType._(0, _omitEnumNames ? '' : 'UnKnowType');
  static const CType BeginType = CType._(1, _omitEnumNames ? '' : 'BeginType');
  static const CType MiddleType = CType._(2, _omitEnumNames ? '' : 'MiddleType');
  static const CType EndType = CType._(3, _omitEnumNames ? '' : 'EndType');

  static const $core.List<CType> values = <CType> [
    UnKnowType,
    BeginType,
    MiddleType,
    EndType,
  ];

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

  const CType._($core.int v, $core.String n) : super(v, n);
}

class StatusType extends $pb.ProtobufEnum {
  static const StatusType UnKnowStatus = StatusType._(0, _omitEnumNames ? '' : 'UnKnowStatus');
  static const StatusType NormalStatus = StatusType._(1, _omitEnumNames ? '' : 'NormalStatus');
  static const StatusType DisabledStatus = StatusType._(8, _omitEnumNames ? '' : 'DisabledStatus');
  static const StatusType DeleteStatus = StatusType._(9, _omitEnumNames ? '' : 'DeleteStatus');

  static const $core.List<StatusType> values = <StatusType> [
    UnKnowStatus,
    NormalStatus,
    DisabledStatus,
    DeleteStatus,
  ];

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

  const StatusType._($core.int v, $core.String n) : super(v, n);
}

class HrBandType extends $pb.ProtobufEnum {
  static const HrBandType UnKnowHrBand = HrBandType._(0, _omitEnumNames ? '' : 'UnKnowHrBand');
  static const HrBandType UseHrBand = HrBandType._(1, _omitEnumNames ? '' : 'UseHrBand');
  static const HrBandType NotUseHrBand = HrBandType._(2, _omitEnumNames ? '' : 'NotUseHrBand');

  static const $core.List<HrBandType> values = <HrBandType> [
    UnKnowHrBand,
    UseHrBand,
    NotUseHrBand,
  ];

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

  const HrBandType._($core.int v, $core.String n) : super(v, n);
}

class GameState extends $pb.ProtobufEnum {
  static const GameState AllGameState = GameState._(0, _omitEnumNames ? '' : 'AllGameState');
  static const GameState NormalGameState = GameState._(1, _omitEnumNames ? '' : 'NormalGameState');
  static const GameState abnormalGameState = GameState._(2, _omitEnumNames ? '' : 'abnormalGameState');

  static const $core.List<GameState> values = <GameState> [
    AllGameState,
    NormalGameState,
    abnormalGameState,
  ];

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

  const GameState._($core.int v, $core.String n) : super(v, n);
}

class CState extends $pb.ProtobufEnum {
  static const CState ToUnSend = CState._(0, _omitEnumNames ? '' : 'ToUnSend');
  static const CState ToUnStart = CState._(1, _omitEnumNames ? '' : 'ToUnStart');
  static const CState ToStart = CState._(2, _omitEnumNames ? '' : 'ToStart');
  static const CState ToFinish = CState._(3, _omitEnumNames ? '' : 'ToFinish');
  static const CState ToOther = CState._(9, _omitEnumNames ? '' : 'ToOther');

  static const $core.List<CState> values = <CState> [
    ToUnSend,
    ToUnStart,
    ToStart,
    ToFinish,
    ToOther,
  ];

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

  const CState._($core.int v, $core.String n) : super(v, n);
}

class GameHistorySource extends $pb.ProtobufEnum {
  static const GameHistorySource GameHistorySourcAll = GameHistorySource._(0, _omitEnumNames ? '' : 'GameHistorySourcAll');
  static const GameHistorySource GameHistorySourceOrienteer = GameHistorySource._(1, _omitEnumNames ? '' : 'GameHistorySourceOrienteer');
  static const GameHistorySource GameHistorySourceAss = GameHistorySource._(2, _omitEnumNames ? '' : 'GameHistorySourceAss');

  static const $core.List<GameHistorySource> values = <GameHistorySource> [
    GameHistorySourcAll,
    GameHistorySourceOrienteer,
    GameHistorySourceAss,
  ];

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

  const GameHistorySource._($core.int v, $core.String n) : super(v, n);
}

class BackGroundColor extends $pb.ProtobufEnum {
  static const BackGroundColor UnKnowColor = BackGroundColor._(0, _omitEnumNames ? '' : 'UnKnowColor');
  static const BackGroundColor BlueColor = BackGroundColor._(1, _omitEnumNames ? '' : 'BlueColor');
  static const BackGroundColor GreenColor = BackGroundColor._(2, _omitEnumNames ? '' : 'GreenColor');
  static const BackGroundColor BrownColor = BackGroundColor._(3, _omitEnumNames ? '' : 'BrownColor');

  static const $core.List<BackGroundColor> values = <BackGroundColor> [
    UnKnowColor,
    BlueColor,
    GreenColor,
    BrownColor,
  ];

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

  const BackGroundColor._($core.int v, $core.String n) : super(v, n);
}

class User_Sex extends $pb.ProtobufEnum {
  static const User_Sex UnDefine = User_Sex._(0, _omitEnumNames ? '' : 'UnDefine');
  static const User_Sex Male = User_Sex._(1, _omitEnumNames ? '' : 'Male');
  static const User_Sex Female = User_Sex._(2, _omitEnumNames ? '' : 'Female');

  static const $core.List<User_Sex> values = <User_Sex> [
    UnDefine,
    Male,
    Female,
  ];

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

  const User_Sex._($core.int v, $core.String n) : super(v, n);
}


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