swift-protobuf/Reference/Tests/SwiftProtobufTests/generated_swift_names_enums.pb.swift

// DO NOT EDIT.
// swift-format-ignore-file
// swiftlint:disable all
//
// Generated by the Swift generator plugin for the protocol buffer compiler.
// Source: generated_swift_names_enums.proto
//
// For information on using the generated types, please see the documentation:
//   https://github.com/apple/swift-protobuf/

/// See Makefile for the logic that generates this
/// Protoc errors imply this file is being generated incorrectly
/// Swift compile errors are probably bugs in protoc-gen-swift

import SwiftProtobuf

// If the compiler emits an error on this type, it is because this file
// was generated by a version of the `protoc` Swift plug-in that is
// incompatible with the version of SwiftProtobuf to which you are linking.
// Please ensure that you are building against the same version of the API
// that was used to generate this file.
fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
  typealias Version = _2
}

struct SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: Sendable {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum addPath: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAddPath // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAddPath
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAddPath
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAddPath: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.addPath] = [
      .noneAddPath,
    ]

  }

  enum adjusted: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAdjusted // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAdjusted
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAdjusted
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAdjusted: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.adjusted] = [
      .noneAdjusted,
    ]

  }

  enum aggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAggregateValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAggregateValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAggregateValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAggregateValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.aggregateValue] = [
      .noneAggregateValue,
    ]

  }

  enum allCases: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAllCases // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAllCases
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAllCases
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAllCases: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allCases] = [
      .noneAllCases,
    ]

  }

  enum allowAlias: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAllowAlias // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAllowAlias
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAllowAlias
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAllowAlias: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allowAlias] = [
      .noneAllowAlias,
    ]

  }

  enum alwaysPrintEnumsAsInts: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAlwaysPrintEnumsAsInts // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAlwaysPrintEnumsAsInts
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAlwaysPrintEnumsAsInts
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAlwaysPrintEnumsAsInts: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts] = [
      .noneAlwaysPrintEnumsAsInts,
    ]

  }

  enum alwaysPrintInt64sAsNumbers: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAlwaysPrintInt64SAsNumbers // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAlwaysPrintInt64SAsNumbers
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAlwaysPrintInt64SAsNumbers
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAlwaysPrintInt64SAsNumbers: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintInt64sAsNumbers] = [
      .noneAlwaysPrintInt64SAsNumbers,
    ]

  }

  enum annotation: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAnnotation // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnnotation
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnnotation
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnnotation: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.annotation] = [
      .noneAnnotation,
    ]

  }

  enum any: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAny // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAny
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAny
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAny: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.any] = [
      .noneAny,
    ]

  }

  enum AnyExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAnyExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyExtensionField] = [
      .noneAnyExtensionField,
    ]

  }

  enum AnyMessageExtension: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAnyMessageExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyMessageExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyMessageExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyMessageExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageExtension] = [
      .noneAnyMessageExtension,
    ]

  }

  enum AnyMessageStorage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAnyMessageStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyMessageStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyMessageStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyMessageStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageStorage] = [
      .noneAnyMessageStorage,
    ]

  }

  enum AnyUnpackError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAnyUnpackError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAnyUnpackError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAnyUnpackError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAnyUnpackError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyUnpackError] = [
      .noneAnyUnpackError,
    ]

  }

  enum append: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAppend // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAppend
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAppend
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAppend: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.append] = [
      .noneAppend,
    ]

  }

  enum appended: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAppended // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAppended
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAppended
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAppended: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appended] = [
      .noneAppended,
    ]

  }

  enum appendUIntHex: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAppendUintHex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAppendUintHex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAppendUintHex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAppendUintHex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUIntHex] = [
      .noneAppendUintHex,
    ]

  }

  enum appendUnknown: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAppendUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAppendUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAppendUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAppendUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUnknown] = [
      .noneAppendUnknown,
    ]

  }

  enum areAllInitialized: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAreAllInitialized // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAreAllInitialized
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAreAllInitialized
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAreAllInitialized: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.areAllInitialized] = [
      .noneAreAllInitialized,
    ]

  }

  enum Array: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneArray // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneArray
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneArray
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneArray: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Array] = [
      .noneArray,
    ]

  }

  enum arrayDepth: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneArrayDepth // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneArrayDepth
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneArrayDepth
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneArrayDepth: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayDepth] = [
      .noneArrayDepth,
    ]

  }

  enum arrayLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneArrayLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneArrayLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneArrayLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneArrayLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayLiteral] = [
      .noneArrayLiteral,
    ]

  }

  enum arraySeparator: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneArraySeparator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneArraySeparator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneArraySeparator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneArraySeparator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arraySeparator] = [
      .noneArraySeparator,
    ]

  }

  enum asEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asEnum] = [
      .noneAs,
    ]

  }

  enum asciiOpenCurlyBracket: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAsciiOpenCurlyBracket // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsciiOpenCurlyBracket
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsciiOpenCurlyBracket
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsciiOpenCurlyBracket: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket] = [
      .noneAsciiOpenCurlyBracket,
    ]

  }

  enum asciiZero: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAsciiZero // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsciiZero
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsciiZero
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsciiZero: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiZero] = [
      .noneAsciiZero,
    ]

  }

  enum async: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAsync // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsync
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsync
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsync: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.async] = [
      .noneAsync,
    ]

  }

  enum AsyncIterator: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAsyncIterator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsyncIterator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsyncIterator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsyncIterator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIterator] = [
      .noneAsyncIterator,
    ]

  }

  enum AsyncIteratorProtocol: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAsyncIteratorProtocol // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsyncIteratorProtocol
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsyncIteratorProtocol
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsyncIteratorProtocol: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIteratorProtocol] = [
      .noneAsyncIteratorProtocol,
    ]

  }

  enum AsyncMessageSequence: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAsyncMessageSequence // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAsyncMessageSequence
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAsyncMessageSequence
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAsyncMessageSequence: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncMessageSequence] = [
      .noneAsyncMessageSequence,
    ]

  }

  enum available: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneAvailable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneAvailable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneAvailable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneAvailable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.available] = [
      .noneAvailable,
    ]

  }

  enum b: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneB // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneB
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneB
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneB: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.b] = [
      .noneB,
    ]

  }

  enum Base: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBase // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBase
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBase
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBase: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Base] = [
      .noneBase,
    ]

  }

  enum base64Values: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBase64Values // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBase64Values
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBase64Values
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBase64Values: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.base64Values] = [
      .noneBase64Values,
    ]

  }

  enum baseAddress: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBaseAddress // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBaseAddress
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBaseAddress
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBaseAddress: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.baseAddress] = [
      .noneBaseAddress,
    ]

  }

  enum BaseType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBaseType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBaseType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBaseType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBaseType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BaseType] = [
      .noneBaseType,
    ]

  }

  enum begin: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBegin // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBegin
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBegin
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBegin: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.begin] = [
      .noneBegin,
    ]

  }

  enum binary: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinary // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinary
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinary
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinary: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binary] = [
      .noneBinary,
    ]

  }

  enum BinaryDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoder] = [
      .noneBinaryDecoder,
    ]

  }

  enum BinaryDecoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryDecoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDecoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDecoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDecoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoding] = [
      .noneBinaryDecoding,
    ]

  }

  enum BinaryDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryDecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingError] = [
      .noneBinaryDecodingError,
    ]

  }

  enum BinaryDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryDecodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDecodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDecodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDecodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingOptions] = [
      .noneBinaryDecodingOptions,
    ]

  }

  enum BinaryDelimited: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryDelimited // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryDelimited
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryDelimited
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryDelimited: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDelimited] = [
      .noneBinaryDelimited,
    ]

  }

  enum BinaryEncoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryEncoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncoder] = [
      .noneBinaryEncoder,
    ]

  }

  enum BinaryEncodingError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryEncodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingError] = [
      .noneBinaryEncodingError,
    ]

  }

  enum BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryEncodingMessageSetSizeVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingMessageSetSizeVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingMessageSetSizeVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingMessageSetSizeVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor] = [
      .noneBinaryEncodingMessageSetSizeVisitor,
    ]

  }

  enum BinaryEncodingMessageSetVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryEncodingMessageSetVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingMessageSetVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingMessageSetVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingMessageSetVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor] = [
      .noneBinaryEncodingMessageSetVisitor,
    ]

  }

  enum BinaryEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryEncodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingOptions] = [
      .noneBinaryEncodingOptions,
    ]

  }

  enum BinaryEncodingSizeVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryEncodingSizeVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingSizeVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingSizeVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingSizeVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor] = [
      .noneBinaryEncodingSizeVisitor,
    ]

  }

  enum BinaryEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryEncodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryEncodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryEncodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryEncodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor] = [
      .noneBinaryEncodingVisitor,
    ]

  }

  enum binaryOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryOptions] = [
      .noneBinaryOptions,
    ]

  }

  enum binaryProtobufDelimitedMessages: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryProtobufDelimitedMessages // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryProtobufDelimitedMessages
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryProtobufDelimitedMessages
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryProtobufDelimitedMessages: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryProtobufDelimitedMessages] = [
      .noneBinaryProtobufDelimitedMessages,
    ]

  }

  enum BinaryStreamDecoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryStreamDecoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryStreamDecoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryStreamDecoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryStreamDecoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryStreamDecoding] = [
      .noneBinaryStreamDecoding,
    ]

  }

  enum binaryStreamDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBinaryStreamDecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBinaryStreamDecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBinaryStreamDecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBinaryStreamDecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryStreamDecodingError] = [
      .noneBinaryStreamDecodingError,
    ]

  }

  enum bitPattern: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBitPattern // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBitPattern
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBitPattern
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBitPattern: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bitPattern] = [
      .noneBitPattern,
    ]

  }

  enum body: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBody // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBody
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBody
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBody: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.body] = [
      .noneBody,
    ]

  }

  enum BoolEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBool // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBool
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBool
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBool: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BoolEnum] = [
      .noneBool,
    ]

  }

  enum booleanLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBooleanLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBooleanLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBooleanLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBooleanLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.booleanLiteral] = [
      .noneBooleanLiteral,
    ]

  }

  enum BooleanLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBooleanLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBooleanLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBooleanLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBooleanLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BooleanLiteralType] = [
      .noneBooleanLiteralType,
    ]

  }

  enum boolValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBoolValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBoolValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBoolValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBoolValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.boolValue] = [
      .noneBoolValue,
    ]

  }

  enum buffer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBuffer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBuffer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBuffer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBuffer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.buffer] = [
      .noneBuffer,
    ]

  }

  enum byte: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneByte // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneByte
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneByte
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneByte: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.byte] = [
      .noneByte,
    ]

  }

  enum bytecode: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBytecode // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytecode
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytecode
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytecode: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytecode] = [
      .noneBytecode,
    ]

  }

  enum BytecodeReader: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBytecodeReader // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytecodeReader
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytecodeReader
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytecodeReader: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BytecodeReader] = [
      .noneBytecodeReader,
    ]

  }

  enum bytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytes] = [
      .noneBytes,
    ]

  }

  enum bytesInGroup: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBytesInGroup // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytesInGroup
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytesInGroup
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytesInGroup: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesInGroup] = [
      .noneBytesInGroup,
    ]

  }

  enum bytesNeeded: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBytesNeeded // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytesNeeded
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytesNeeded
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytesNeeded: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesNeeded] = [
      .noneBytesNeeded,
    ]

  }

  enum bytesRead: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneBytesRead // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneBytesRead
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneBytesRead
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneBytesRead: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesRead] = [
      .noneBytesRead,
    ]

  }

  enum c: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneC // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneC
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneC
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneC: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.c] = [
      .noneC,
    ]

  }

  enum canonical: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCanonical // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCanonical
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCanonical
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCanonical: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.canonical] = [
      .noneCanonical,
    ]

  }

  enum capitalizeNext: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCapitalizeNext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCapitalizeNext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCapitalizeNext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCapitalizeNext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.capitalizeNext] = [
      .noneCapitalizeNext,
    ]

  }

  enum cardinality: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCardinality // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCardinality
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCardinality
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCardinality: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.cardinality] = [
      .noneCardinality,
    ]

  }

  enum CaseIterable: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCaseIterable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCaseIterable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCaseIterable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCaseIterable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CaseIterable] = [
      .noneCaseIterable,
    ]

  }

  enum castedValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCastedValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCastedValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCastedValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCastedValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.castedValue] = [
      .noneCastedValue,
    ]

  }

  enum ccEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCcEnableArenas // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCcEnableArenas
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCcEnableArenas
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCcEnableArenas: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccEnableArenas] = [
      .noneCcEnableArenas,
    ]

  }

  enum ccGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCcGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCcGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCcGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCcGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccGenericServices] = [
      .noneCcGenericServices,
    ]

  }

  enum Character: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCharacter // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCharacter
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCharacter
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCharacter: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Character] = [
      .noneCharacter,
    ]

  }

  enum chars: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneChars // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneChars
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneChars
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneChars: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chars] = [
      .noneChars,
    ]

  }

  enum checkProgramFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCheckProgramFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCheckProgramFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCheckProgramFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCheckProgramFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.checkProgramFormat] = [
      .noneCheckProgramFormat,
    ]

  }

  enum chunk: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneChunk // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneChunk
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneChunk
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneChunk: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chunk] = [
      .noneChunk,
    ]

  }

  enum classEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClass // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClass
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClass
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClass: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.classEnum] = [
      .noneClass,
    ]

  }

  enum clearAggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearAggregateValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearAggregateValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearAggregateValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearAggregateValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAggregateValue] = [
      .noneClearAggregateValue,
    ]

  }

  enum clearAllowAlias: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearAllowAlias // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearAllowAlias
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearAllowAlias
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearAllowAlias: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAllowAlias] = [
      .noneClearAllowAlias,
    ]

  }

  enum clearBegin: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearBegin // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearBegin
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearBegin
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearBegin: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearBegin] = [
      .noneClearBegin,
    ]

  }

  enum clearCcEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearCcEnableArenas // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearCcEnableArenas
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearCcEnableArenas
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearCcEnableArenas: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcEnableArenas] = [
      .noneClearCcEnableArenas,
    ]

  }

  enum clearCcGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearCcGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearCcGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearCcGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearCcGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcGenericServices] = [
      .noneClearCcGenericServices,
    ]

  }

  enum clearClientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearClientStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearClientStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearClientStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearClientStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearClientStreaming] = [
      .noneClearClientStreaming,
    ]

  }

  enum clearCsharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearCsharpNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearCsharpNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearCsharpNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearCsharpNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCsharpNamespace] = [
      .noneClearCsharpNamespace,
    ]

  }

  enum clearCtype: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearCtype // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearCtype
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearCtype
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearCtype: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCtype] = [
      .noneClearCtype,
    ]

  }

  enum clearDebugRedact: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearDebugRedact // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearDebugRedact
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearDebugRedact
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearDebugRedact: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDebugRedact] = [
      .noneClearDebugRedact,
    ]

  }

  enum clearDefaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearDefaultSymbolVisibility // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearDefaultSymbolVisibility
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearDefaultSymbolVisibility
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearDefaultSymbolVisibility: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultSymbolVisibility] = [
      .noneClearDefaultSymbolVisibility,
    ]

  }

  enum clearDefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearDefaultValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearDefaultValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearDefaultValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearDefaultValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultValue] = [
      .noneClearDefaultValue,
    ]

  }

  enum clearDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearDeprecated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearDeprecated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearDeprecated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearDeprecated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecated] = [
      .noneClearDeprecated,
    ]

  }

  enum clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearDeprecatedLegacyJsonFieldConflicts // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearDeprecatedLegacyJsonFieldConflicts
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearDeprecatedLegacyJsonFieldConflicts
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearDeprecatedLegacyJsonFieldConflicts: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecatedLegacyJsonFieldConflicts] = [
      .noneClearDeprecatedLegacyJsonFieldConflicts,
    ]

  }

  enum clearDeprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearDeprecationWarning // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearDeprecationWarning
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearDeprecationWarning
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearDeprecationWarning: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecationWarning] = [
      .noneClearDeprecationWarning,
    ]

  }

  enum clearDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDoubleValue] = [
      .noneClearDoubleValue,
    ]

  }

  enum clearEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEdition] = [
      .noneClearEdition,
    ]

  }

  enum clearEditionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearEditionDeprecated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearEditionDeprecated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearEditionDeprecated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearEditionDeprecated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionDeprecated] = [
      .noneClearEditionDeprecated,
    ]

  }

  enum clearEditionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearEditionIntroduced // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearEditionIntroduced
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearEditionIntroduced
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearEditionIntroduced: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionIntroduced] = [
      .noneClearEditionIntroduced,
    ]

  }

  enum clearEditionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearEditionRemoved // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearEditionRemoved
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearEditionRemoved
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearEditionRemoved: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionRemoved] = [
      .noneClearEditionRemoved,
    ]

  }

  enum clearEnd: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearEnd // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearEnd
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearEnd
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearEnd: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnd] = [
      .noneClearEnd,
    ]

  }

  enum clearEnforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearEnforceNamingStyle // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearEnforceNamingStyle
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearEnforceNamingStyle
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearEnforceNamingStyle: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnforceNamingStyle] = [
      .noneClearEnforceNamingStyle,
    ]

  }

  enum clearEnumType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearEnumType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearEnumType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearEnumType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearEnumType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnumType] = [
      .noneClearEnumType,
    ]

  }

  enum clearExtendee: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearExtendee // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearExtendee
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearExtendee
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearExtendee: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtendee] = [
      .noneClearExtendee,
    ]

  }

  enum clearExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtensionValue] = [
      .noneClearExtensionValue,
    ]

  }

  enum clearFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatures] = [
      .noneClearFeatures,
    ]

  }

  enum clearFeatureSupport: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearFeatureSupport // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearFeatureSupport
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearFeatureSupport
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearFeatureSupport: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatureSupport] = [
      .noneClearFeatureSupport,
    ]

  }

  enum clearFieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearFieldPresence // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearFieldPresence
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearFieldPresence
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearFieldPresence: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFieldPresence] = [
      .noneClearFieldPresence,
    ]

  }

  enum clearFixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearFixedFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearFixedFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearFixedFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearFixedFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFixedFeatures] = [
      .noneClearFixedFeatures,
    ]

  }

  enum clearFullName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearFullName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearFullName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearFullName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearFullName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFullName] = [
      .noneClearFullName,
    ]

  }

  enum clearGoPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearGoPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearGoPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearGoPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearGoPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearGoPackage] = [
      .noneClearGoPackage,
    ]

  }

  enum clearIdempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearIdempotencyLevel // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearIdempotencyLevel
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearIdempotencyLevel
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearIdempotencyLevel: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdempotencyLevel] = [
      .noneClearIdempotencyLevel,
    ]

  }

  enum clearIdentifierValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearIdentifierValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearIdentifierValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearIdentifierValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearIdentifierValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdentifierValue] = [
      .noneClearIdentifierValue,
    ]

  }

  enum clearInputType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearInputType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearInputType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearInputType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearInputType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearInputType] = [
      .noneClearInputType,
    ]

  }

  enum clearIsExtension: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearIsExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearIsExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearIsExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearIsExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIsExtension] = [
      .noneClearIsExtension,
    ]

  }

  enum clearJavaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJavaGenerateEqualsAndHash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJavaGenerateEqualsAndHash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJavaGenerateEqualsAndHash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJavaGenerateEqualsAndHash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash] = [
      .noneClearJavaGenerateEqualsAndHash,
    ]

  }

  enum clearJavaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJavaGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJavaGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJavaGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJavaGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenericServices] = [
      .noneClearJavaGenericServices,
    ]

  }

  enum clearJavaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJavaMultipleFiles // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJavaMultipleFiles
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJavaMultipleFiles
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJavaMultipleFiles: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles] = [
      .noneClearJavaMultipleFiles,
    ]

  }

  enum clearJavaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJavaOuterClassname // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJavaOuterClassname
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJavaOuterClassname
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJavaOuterClassname: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaOuterClassname] = [
      .noneClearJavaOuterClassname,
    ]

  }

  enum clearJavaPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJavaPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJavaPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJavaPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJavaPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaPackage] = [
      .noneClearJavaPackage,
    ]

  }

  enum clearJavaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJavaStringCheckUtf8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJavaStringCheckUtf8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJavaStringCheckUtf8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJavaStringCheckUtf8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8] = [
      .noneClearJavaStringCheckUtf8,
    ]

  }

  enum clearJsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJsonFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJsonFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJsonFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJsonFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonFormat] = [
      .noneClearJsonFormat,
    ]

  }

  enum clearJsonName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJsonName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJsonName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJsonName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJsonName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonName] = [
      .noneClearJsonName,
    ]

  }

  enum clearJstype: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearJstype // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearJstype
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearJstype
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearJstype: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJstype] = [
      .noneClearJstype,
    ]

  }

  enum clearLabel: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearLabel // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearLabel
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearLabel
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearLabel: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLabel] = [
      .noneClearLabel,
    ]

  }

  enum clearLazy: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearLazy // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearLazy
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearLazy
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearLazy: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLazy] = [
      .noneClearLazy,
    ]

  }

  enum clearLeadingComments: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearLeadingComments // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearLeadingComments
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearLeadingComments
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearLeadingComments: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLeadingComments] = [
      .noneClearLeadingComments,
    ]

  }

  enum clearMapEntry: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearMapEntry // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearMapEntry
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearMapEntry
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearMapEntry: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMapEntry] = [
      .noneClearMapEntry,
    ]

  }

  enum clearMaximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearMaximumEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearMaximumEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearMaximumEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearMaximumEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMaximumEdition] = [
      .noneClearMaximumEdition,
    ]

  }

  enum clearMessageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearMessageEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearMessageEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearMessageEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearMessageEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageEncoding] = [
      .noneClearMessageEncoding,
    ]

  }

  enum clearMessageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearMessageSetWireFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearMessageSetWireFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearMessageSetWireFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearMessageSetWireFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat] = [
      .noneClearMessageSetWireFormat,
    ]

  }

  enum clearMinimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearMinimumEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearMinimumEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearMinimumEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearMinimumEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMinimumEdition] = [
      .noneClearMinimumEdition,
    ]

  }

  enum clearName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearName] = [
      .noneClearName,
    ]

  }

  enum clearNamePart: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearNamePart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearNamePart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearNamePart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearNamePart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNamePart] = [
      .noneClearNamePart,
    ]

  }

  enum clearNegativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearNegativeIntValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearNegativeIntValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearNegativeIntValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearNegativeIntValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNegativeIntValue] = [
      .noneClearNegativeIntValue,
    ]

  }

  enum clearNoStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearNoStandardDescriptorAccessor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearNoStandardDescriptorAccessor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearNoStandardDescriptorAccessor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearNoStandardDescriptorAccessor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor] = [
      .noneClearNoStandardDescriptorAccessor,
    ]

  }

  enum clearNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNumber] = [
      .noneClearNumber,
    ]

  }

  enum clearObjcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearObjcClassPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearObjcClassPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearObjcClassPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearObjcClassPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearObjcClassPrefix] = [
      .noneClearObjcClassPrefix,
    ]

  }

  enum clearOneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearOneofIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearOneofIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearOneofIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearOneofIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOneofIndex] = [
      .noneClearOneofIndex,
    ]

  }

  enum clearOptimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearOptimizeFor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearOptimizeFor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearOptimizeFor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearOptimizeFor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptimizeFor] = [
      .noneClearOptimizeFor,
    ]

  }

  enum clearOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptions] = [
      .noneClearOptions,
    ]

  }

  enum clearOutputType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearOutputType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearOutputType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearOutputType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearOutputType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOutputType] = [
      .noneClearOutputType,
    ]

  }

  enum clearOverridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearOverridableFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearOverridableFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearOverridableFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearOverridableFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOverridableFeatures] = [
      .noneClearOverridableFeatures,
    ]

  }

  enum clearPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPackage] = [
      .noneClearPackage,
    ]

  }

  enum clearPacked: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearPacked // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearPacked
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearPacked
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearPacked: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPacked] = [
      .noneClearPacked,
    ]

  }

  enum clearPhpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearPhpClassPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearPhpClassPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearPhpClassPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearPhpClassPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpClassPrefix] = [
      .noneClearPhpClassPrefix,
    ]

  }

  enum clearPhpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearPhpMetadataNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearPhpMetadataNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearPhpMetadataNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearPhpMetadataNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace] = [
      .noneClearPhpMetadataNamespace,
    ]

  }

  enum clearPhpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearPhpNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearPhpNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearPhpNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearPhpNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpNamespace] = [
      .noneClearPhpNamespace,
    ]

  }

  enum clearPositiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearPositiveIntValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearPositiveIntValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearPositiveIntValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearPositiveIntValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPositiveIntValue] = [
      .noneClearPositiveIntValue,
    ]

  }

  enum clearProto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearProto3Optional // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearProto3Optional
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearProto3Optional
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearProto3Optional: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearProto3Optional] = [
      .noneClearProto3Optional,
    ]

  }

  enum clearPyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearPyGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearPyGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearPyGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearPyGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPyGenericServices] = [
      .noneClearPyGenericServices,
    ]

  }

  enum clearRemovalError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearRemovalError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearRemovalError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearRemovalError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearRemovalError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRemovalError] = [
      .noneClearRemovalError,
    ]

  }

  enum clearRepeated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearRepeated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearRepeated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearRepeated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearRepeated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeated] = [
      .noneClearRepeated,
    ]

  }

  enum clearRepeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearRepeatedFieldEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearRepeatedFieldEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearRepeatedFieldEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearRepeatedFieldEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeatedFieldEncoding] = [
      .noneClearRepeatedFieldEncoding,
    ]

  }

  enum clearReserved: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearReserved // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearReserved
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearReserved
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearReserved: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearReserved] = [
      .noneClearReserved,
    ]

  }

  enum clearRetention: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearRetention // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearRetention
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearRetention
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearRetention: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRetention] = [
      .noneClearRetention,
    ]

  }

  enum clearRubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearRubyPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearRubyPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearRubyPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearRubyPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRubyPackage] = [
      .noneClearRubyPackage,
    ]

  }

  enum clearSemantic: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearSemantic // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearSemantic
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearSemantic
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearSemantic: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSemantic] = [
      .noneClearSemantic,
    ]

  }

  enum clearServerStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearServerStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearServerStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearServerStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearServerStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearServerStreaming] = [
      .noneClearServerStreaming,
    ]

  }

  enum clearSourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearSourceCodeInfo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearSourceCodeInfo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearSourceCodeInfo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearSourceCodeInfo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceCodeInfo] = [
      .noneClearSourceCodeInfo,
    ]

  }

  enum clearSourceContext: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceContext] = [
      .noneClearSourceContext,
    ]

  }

  enum clearSourceFile: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearSourceFile // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearSourceFile
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearSourceFile
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearSourceFile: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceFile] = [
      .noneClearSourceFile,
    ]

  }

  enum clearStart: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStart] = [
      .noneClearStart,
    ]

  }

  enum clearStringValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStringValue] = [
      .noneClearStringValue,
    ]

  }

  enum clearSwiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearSwiftPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearSwiftPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearSwiftPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearSwiftPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSwiftPrefix] = [
      .noneClearSwiftPrefix,
    ]

  }

  enum clearSyntax: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearSyntax // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearSyntax
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearSyntax
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearSyntax: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSyntax] = [
      .noneClearSyntax,
    ]

  }

  enum clearTrailingComments: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearTrailingComments // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearTrailingComments
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearTrailingComments
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearTrailingComments: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTrailingComments] = [
      .noneClearTrailingComments,
    ]

  }

  enum clearType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearType] = [
      .noneClearType,
    ]

  }

  enum clearTypeName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearTypeName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearTypeName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearTypeName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearTypeName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTypeName] = [
      .noneClearTypeName,
    ]

  }

  enum clearUnverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearUnverifiedLazy // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearUnverifiedLazy
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearUnverifiedLazy
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearUnverifiedLazy: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUnverifiedLazy] = [
      .noneClearUnverifiedLazy,
    ]

  }

  enum clearUtf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearUtf8Validation // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearUtf8Validation
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearUtf8Validation
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearUtf8Validation: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUtf8Validation] = [
      .noneClearUtf8Validation,
    ]

  }

  enum clearValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearValue] = [
      .noneClearValue,
    ]

  }

  enum clearVerification: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearVerification // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearVerification
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearVerification
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearVerification: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVerification] = [
      .noneClearVerification,
    ]

  }

  enum clearVisibility: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearVisibility // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearVisibility
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearVisibility
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearVisibility: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVisibility] = [
      .noneClearVisibility,
    ]

  }

  enum clearWeak: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClearWeak // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClearWeak
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClearWeak
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClearWeak: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearWeak] = [
      .noneClearWeak,
    ]

  }

  enum clientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneClientStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneClientStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneClientStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneClientStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clientStreaming] = [
      .noneClientStreaming,
    ]

  }

  enum code: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCode // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCode
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCode
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCode: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.code] = [
      .noneCode,
    ]

  }

  enum codePoint: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCodePoint // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCodePoint
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCodePoint
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCodePoint: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codePoint] = [
      .noneCodePoint,
    ]

  }

  enum codeUnits: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCodeUnits // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCodeUnits
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCodeUnits
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCodeUnits: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codeUnits] = [
      .noneCodeUnits,
    ]

  }

  enum Collection: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCollection // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCollection
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCollection
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCollection: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Collection] = [
      .noneCollection,
    ]

  }

  enum comma: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneComma // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneComma
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneComma
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneComma: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.comma] = [
      .noneComma,
    ]

  }

  enum consumedBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneConsumedBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneConsumedBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneConsumedBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneConsumedBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.consumedBytes] = [
      .noneConsumedBytes,
    ]

  }

  enum contains: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneContains // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneContains
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneContains
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneContains: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contains] = [
      .noneContains,
    ]

  }

  enum contentsOf: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneContentsOf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneContentsOf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneContentsOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneContentsOf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contentsOf] = [
      .noneContentsOf,
    ]

  }

  enum ContiguousBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneContiguousBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneContiguousBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneContiguousBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneContiguousBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ContiguousBytes] = [
      .noneContiguousBytes,
    ]

  }

  enum copy: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCopy // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCopy
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCopy
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCopy: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.copy] = [
      .noneCopy,
    ]

  }

  enum count: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCount // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCount
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCount
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCount: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.count] = [
      .noneCount,
    ]

  }

  enum countVarintsInBuffer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCountVarintsInBuffer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCountVarintsInBuffer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCountVarintsInBuffer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCountVarintsInBuffer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.countVarintsInBuffer] = [
      .noneCountVarintsInBuffer,
    ]

  }

  enum csharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCsharpNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCsharpNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCsharpNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCsharpNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.csharpNamespace] = [
      .noneCsharpNamespace,
    ]

  }

  enum ctype: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCtype // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCtype
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCtype
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCtype: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ctype] = [
      .noneCtype,
    ]

  }

  enum customCodable: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCustomCodable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCustomCodable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCustomCodable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCustomCodable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.customCodable] = [
      .noneCustomCodable,
    ]

  }

  enum CustomDebugStringConvertible: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCustomDebugStringConvertible // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCustomDebugStringConvertible
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCustomDebugStringConvertible
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCustomDebugStringConvertible: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible] = [
      .noneCustomDebugStringConvertible,
    ]

  }

  enum CustomStringConvertible: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneCustomStringConvertible // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneCustomStringConvertible
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneCustomStringConvertible
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneCustomStringConvertible: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomStringConvertible] = [
      .noneCustomStringConvertible,
    ]

  }

  enum D: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneD // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneD
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneD
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneD: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.D] = [
      .noneD,
    ]

  }

  enum DataEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DataEnum] = [
      .noneData,
    ]

  }

  enum dataResult: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDataResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDataResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDataResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDataResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dataResult] = [
      .noneDataResult,
    ]

  }

  enum date: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDate // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDate
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDate
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDate: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.date] = [
      .noneDate,
    ]

  }

  enum daySec: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDaySec // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDaySec
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDaySec
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDaySec: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daySec] = [
      .noneDaySec,
    ]

  }

  enum daysSinceEpoch: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDaysSinceEpoch // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDaysSinceEpoch
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDaysSinceEpoch
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDaysSinceEpoch: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daysSinceEpoch] = [
      .noneDaysSinceEpoch,
    ]

  }

  enum debugDescriptionEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDebugDescription // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDebugDescription
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDebugDescription
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDebugDescription: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugDescriptionEnum] = [
      .noneDebugDescription,
    ]

  }

  enum debugRedact: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDebugRedact // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDebugRedact
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDebugRedact
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDebugRedact: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugRedact] = [
      .noneDebugRedact,
    ]

  }

  enum declaration: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDeclaration // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDeclaration
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDeclaration
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDeclaration: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.declaration] = [
      .noneDeclaration,
    ]

  }

  enum decoded: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecoded // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecoded
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecoded
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecoded: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decoded] = [
      .noneDecoded,
    ]

  }

  enum decodedFromJSONNull: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodedFromJsonnull // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodedFromJsonnull
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodedFromJsonnull
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodedFromJsonnull: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodedFromJSONNull] = [
      .noneDecodedFromJsonnull,
    ]

  }

  enum decodeExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionField] = [
      .noneDecodeExtensionField,
    ]

  }

  enum decodeExtensionFieldsAsMessageSet: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeExtensionFieldsAsMessageSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeExtensionFieldsAsMessageSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeExtensionFieldsAsMessageSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeExtensionFieldsAsMessageSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet] = [
      .noneDecodeExtensionFieldsAsMessageSet,
    ]

  }

  enum decodeJSON: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeJson // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeJson
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeJson
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeJson: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeJSON] = [
      .noneDecodeJson,
    ]

  }

  enum decodeMapField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeMapField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeMapField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeMapField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeMapField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMapField] = [
      .noneDecodeMapField,
    ]

  }

  enum decodeMessageEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeMessage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeMessage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeMessage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeMessage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMessageEnum] = [
      .noneDecodeMessage,
    ]

  }

  enum Decoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Decoder] = [
      .noneDecoder,
    ]

  }

  enum decodeRepeated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeated] = [
      .noneDecodeRepeated,
    ]

  }

  enum decodeRepeatedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField] = [
      .noneDecodeRepeatedBoolField,
    ]

  }

  enum decodeRepeatedBytesField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField] = [
      .noneDecodeRepeatedBytesField,
    ]

  }

  enum decodeRepeatedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField] = [
      .noneDecodeRepeatedDoubleField,
    ]

  }

  enum decodeRepeatedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField] = [
      .noneDecodeRepeatedEnumField,
    ]

  }

  enum decodeRepeatedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field] = [
      .noneDecodeRepeatedFixed32Field,
    ]

  }

  enum decodeRepeatedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field] = [
      .noneDecodeRepeatedFixed64Field,
    ]

  }

  enum decodeRepeatedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField] = [
      .noneDecodeRepeatedFloatField,
    ]

  }

  enum decodeRepeatedGroupField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField] = [
      .noneDecodeRepeatedGroupField,
    ]

  }

  enum decodeRepeatedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field] = [
      .noneDecodeRepeatedInt32Field,
    ]

  }

  enum decodeRepeatedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field] = [
      .noneDecodeRepeatedInt64Field,
    ]

  }

  enum decodeRepeatedMessageField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField] = [
      .noneDecodeRepeatedMessageField,
    ]

  }

  enum decodeRepeatedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field] = [
      .noneDecodeRepeatedSfixed32Field,
    ]

  }

  enum decodeRepeatedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field] = [
      .noneDecodeRepeatedSfixed64Field,
    ]

  }

  enum decodeRepeatedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field] = [
      .noneDecodeRepeatedSint32Field,
    ]

  }

  enum decodeRepeatedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field] = [
      .noneDecodeRepeatedSint64Field,
    ]

  }

  enum decodeRepeatedStringField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedStringField] = [
      .noneDecodeRepeatedStringField,
    ]

  }

  enum decodeRepeatedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field] = [
      .noneDecodeRepeatedUint32Field,
    ]

  }

  enum decodeRepeatedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeRepeatedUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeRepeatedUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeRepeatedUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeRepeatedUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field] = [
      .noneDecodeRepeatedUint64Field,
    ]

  }

  enum decodeSingular: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingular // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingular
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingular
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingular: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingular] = [
      .noneDecodeSingular,
    ]

  }

  enum decodeSingularBoolField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBoolField] = [
      .noneDecodeSingularBoolField,
    ]

  }

  enum decodeSingularBytesField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBytesField] = [
      .noneDecodeSingularBytesField,
    ]

  }

  enum decodeSingularDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularDoubleField] = [
      .noneDecodeSingularDoubleField,
    ]

  }

  enum decodeSingularEnumField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularEnumField] = [
      .noneDecodeSingularEnumField,
    ]

  }

  enum decodeSingularFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field] = [
      .noneDecodeSingularFixed32Field,
    ]

  }

  enum decodeSingularFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field] = [
      .noneDecodeSingularFixed64Field,
    ]

  }

  enum decodeSingularFloatField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFloatField] = [
      .noneDecodeSingularFloatField,
    ]

  }

  enum decodeSingularGroupField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularGroupField] = [
      .noneDecodeSingularGroupField,
    ]

  }

  enum decodeSingularInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt32Field] = [
      .noneDecodeSingularInt32Field,
    ]

  }

  enum decodeSingularInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt64Field] = [
      .noneDecodeSingularInt64Field,
    ]

  }

  enum decodeSingularMessageField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularMessageField] = [
      .noneDecodeSingularMessageField,
    ]

  }

  enum decodeSingularSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field] = [
      .noneDecodeSingularSfixed32Field,
    ]

  }

  enum decodeSingularSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field] = [
      .noneDecodeSingularSfixed64Field,
    ]

  }

  enum decodeSingularSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field] = [
      .noneDecodeSingularSint32Field,
    ]

  }

  enum decodeSingularSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field] = [
      .noneDecodeSingularSint64Field,
    ]

  }

  enum decodeSingularStringField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularStringField] = [
      .noneDecodeSingularStringField,
    ]

  }

  enum decodeSingularUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field] = [
      .noneDecodeSingularUint32Field,
    ]

  }

  enum decodeSingularUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeSingularUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeSingularUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeSingularUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeSingularUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field] = [
      .noneDecodeSingularUint64Field,
    ]

  }

  enum decodeTextFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDecodeTextFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDecodeTextFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDecodeTextFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDecodeTextFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeTextFormat] = [
      .noneDecodeTextFormat,
    ]

  }

  enum defaultAnyTypeURLPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDefaultAnyTypeUrlprefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDefaultAnyTypeUrlprefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDefaultAnyTypeUrlprefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDefaultAnyTypeUrlprefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix] = [
      .noneDefaultAnyTypeUrlprefix,
    ]

  }

  enum defaults: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDefaults // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDefaults
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDefaults
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDefaults: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaults] = [
      .noneDefaults,
    ]

  }

  enum defaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDefaultSymbolVisibility // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDefaultSymbolVisibility
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDefaultSymbolVisibility
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDefaultSymbolVisibility: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultSymbolVisibility] = [
      .noneDefaultSymbolVisibility,
    ]

  }

  enum defaultValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDefaultValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDefaultValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDefaultValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDefaultValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultValue] = [
      .noneDefaultValue,
    ]

  }

  enum dependency: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDependency // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDependency
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDependency
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDependency: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dependency] = [
      .noneDependency,
    ]

  }

  enum deprecated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDeprecated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDeprecated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDeprecated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDeprecated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecated] = [
      .noneDeprecated,
    ]

  }

  enum deprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDeprecatedLegacyJsonFieldConflicts // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDeprecatedLegacyJsonFieldConflicts
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDeprecatedLegacyJsonFieldConflicts
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDeprecatedLegacyJsonFieldConflicts: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecatedLegacyJsonFieldConflicts] = [
      .noneDeprecatedLegacyJsonFieldConflicts,
    ]

  }

  enum deprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDeprecationWarning // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDeprecationWarning
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDeprecationWarning
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDeprecationWarning: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecationWarning] = [
      .noneDeprecationWarning,
    ]

  }

  enum descriptionEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDescription // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDescription
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDescription
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDescription: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.descriptionEnum] = [
      .noneDescription,
    ]

  }

  enum Dictionary: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDictionary // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDictionary
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDictionary
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDictionary: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Dictionary] = [
      .noneDictionary,
    ]

  }

  enum dictionaryLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDictionaryLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDictionaryLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDictionaryLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDictionaryLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dictionaryLiteral] = [
      .noneDictionaryLiteral,
    ]

  }

  enum digit: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDigit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit] = [
      .noneDigit,
    ]

  }

  enum digit0: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDigit0 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigit0
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigit0
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigit0: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit0] = [
      .noneDigit0,
    ]

  }

  enum digit1: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDigit1 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigit1
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigit1
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigit1: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit1] = [
      .noneDigit1,
    ]

  }

  enum digitCount: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDigitCount // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigitCount
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigitCount
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigitCount: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitCount] = [
      .noneDigitCount,
    ]

  }

  enum digits: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDigits // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigits
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigits
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigits: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digits] = [
      .noneDigits,
    ]

  }

  enum digitValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDigitValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDigitValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDigitValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDigitValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitValue] = [
      .noneDigitValue,
    ]

  }

  enum discardableResult: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDiscardableResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDiscardableResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDiscardableResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDiscardableResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardableResult] = [
      .noneDiscardableResult,
    ]

  }

  enum discardUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDiscardUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDiscardUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDiscardUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDiscardUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardUnknownFields] = [
      .noneDiscardUnknownFields,
    ]

  }

  enum DoubleEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDouble // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDouble
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDouble
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDouble: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DoubleEnum] = [
      .noneDouble,
    ]

  }

  enum doubleValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.doubleValue] = [
      .noneDoubleValue,
    ]

  }

  enum duration: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneDuration // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneDuration
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneDuration
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneDuration: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.duration] = [
      .noneDuration,
    ]

  }

  enum E: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneE // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneE
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneE
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneE: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.E] = [
      .noneE,
    ]

  }

  enum edition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.edition] = [
      .noneEdition,
    ]

  }

  enum EditionDefault: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEditionDefault // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEditionDefault
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEditionDefault
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEditionDefault: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EditionDefault] = [
      .noneEditionDefault,
    ]

  }

  enum editionDefaults: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEditionDefaults // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEditionDefaults
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEditionDefaults
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEditionDefaults: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDefaults] = [
      .noneEditionDefaults,
    ]

  }

  enum editionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEditionDeprecated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEditionDeprecated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEditionDeprecated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEditionDeprecated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDeprecated] = [
      .noneEditionDeprecated,
    ]

  }

  enum editionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEditionIntroduced // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEditionIntroduced
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEditionIntroduced
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEditionIntroduced: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionIntroduced] = [
      .noneEditionIntroduced,
    ]

  }

  enum editionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEditionRemoved // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEditionRemoved
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEditionRemoved
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEditionRemoved: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionRemoved] = [
      .noneEditionRemoved,
    ]

  }

  enum Element: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneElement // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneElement
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneElement
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneElement: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Element] = [
      .noneElement,
    ]

  }

  enum elements: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneElements // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneElements
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneElements
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneElements: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elements] = [
      .noneElements,
    ]

  }

  enum elseEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneElse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneElse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneElse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneElse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elseEnum] = [
      .noneElse,
    ]

  }

  enum emitExtensionFieldName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEmitExtensionFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmitExtensionFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmitExtensionFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmitExtensionFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitExtensionFieldName] = [
      .noneEmitExtensionFieldName,
    ]

  }

  enum emitFieldName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEmitFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmitFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmitFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmitFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldName] = [
      .noneEmitFieldName,
    ]

  }

  enum emitFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEmitFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmitFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmitFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmitFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldNumber] = [
      .noneEmitFieldNumber,
    ]

  }

  enum emptyAnyTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEmptyAnyTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmptyAnyTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmptyAnyTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmptyAnyTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyAnyTypeURL] = [
      .noneEmptyAnyTypeURL,
    ]

  }

  enum emptyData: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEmptyData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEmptyData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEmptyData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEmptyData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyData] = [
      .noneEmptyData,
    ]

  }

  enum encodeAsBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEncodeAsBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncodeAsBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncodeAsBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncodeAsBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeAsBytes] = [
      .noneEncodeAsBytes,
    ]

  }

  enum encoded: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEncoded // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncoded
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncoded
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncoded: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoded] = [
      .noneEncoded,
    ]

  }

  enum encodedJSONString: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEncodedJsonstring // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncodedJsonstring
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncodedJsonstring
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncodedJsonstring: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedJSONString] = [
      .noneEncodedJsonstring,
    ]

  }

  enum encodedSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEncodedSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncodedSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncodedSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncodedSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedSize] = [
      .noneEncodedSize,
    ]

  }

  enum encodeField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEncodeField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncodeField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncodeField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncodeField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeField] = [
      .noneEncodeField,
    ]

  }

  enum encoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEncoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEncoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEncoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEncoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoder] = [
      .noneEncoder,
    ]

  }

  enum end: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEnd // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnd
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnd
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnd: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.end] = [
      .noneEnd,
    ]

  }

  enum endArray: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEndArray // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndArray
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndArray
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndArray: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endArray] = [
      .noneEndArray,
    ]

  }

  enum endMessageField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEndMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endMessageField] = [
      .noneEndMessageField,
    ]

  }

  enum endObject: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEndObject // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndObject
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndObject
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndObject: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endObject] = [
      .noneEndObject,
    ]

  }

  enum endRegularField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEndRegularField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEndRegularField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEndRegularField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEndRegularField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endRegularField] = [
      .noneEndRegularField,
    ]

  }

  enum enforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEnforceNamingStyle // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnforceNamingStyle
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnforceNamingStyle
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnforceNamingStyle: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enforceNamingStyle] = [
      .noneEnforceNamingStyle,
    ]

  }

  enum enumEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEnum // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnum
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnum
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnum: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumEnum] = [
      .noneEnum,
    ]

  }

  enum EnumReservedRange: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEnumReservedRange // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnumReservedRange
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnumReservedRange
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnumReservedRange: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EnumReservedRange] = [
      .noneEnumReservedRange,
    ]

  }

  enum enumType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEnumType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnumType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnumType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnumType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumType] = [
      .noneEnumType,
    ]

  }

  enum enumvalue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEnumvalue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEnumvalue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEnumvalue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEnumvalue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumvalue] = [
      .noneEnumvalue,
    ]

  }

  enum EquatableEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneEquatable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneEquatable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneEquatable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneEquatable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EquatableEnum] = [
      .noneEquatable,
    ]

  }

  enum Error: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Error] = [
      .noneError,
    ]

  }

  enum execute: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExecute // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExecute
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExecute
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExecute: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.execute] = [
      .noneExecute,
    ]

  }

  enum ExpressibleByArrayLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExpressibleByArrayLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExpressibleByArrayLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExpressibleByArrayLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExpressibleByArrayLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral] = [
      .noneExpressibleByArrayLiteral,
    ]

  }

  enum ExpressibleByDictionaryLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExpressibleByDictionaryLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExpressibleByDictionaryLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExpressibleByDictionaryLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExpressibleByDictionaryLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral] = [
      .noneExpressibleByDictionaryLiteral,
    ]

  }

  enum ext: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ext] = [
      .noneExt,
    ]

  }

  enum extDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extDecoder] = [
      .noneExtDecoder,
    ]

  }

  enum extendedGraphemeClusterLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtendedGraphemeClusterLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtendedGraphemeClusterLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtendedGraphemeClusterLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtendedGraphemeClusterLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral] = [
      .noneExtendedGraphemeClusterLiteral,
    ]

  }

  enum ExtendedGraphemeClusterLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtendedGraphemeClusterLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtendedGraphemeClusterLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtendedGraphemeClusterLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtendedGraphemeClusterLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType] = [
      .noneExtendedGraphemeClusterLiteralType,
    ]

  }

  enum extendee: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtendee // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtendee
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtendee
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtendee: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendee] = [
      .noneExtendee,
    ]

  }

  enum ExtensibleMessage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtensibleMessage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensibleMessage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensibleMessage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensibleMessage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensibleMessage] = [
      .noneExtensibleMessage,
    ]

  }

  enum extensionEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionEnum] = [
      .noneExtension,
    ]

  }

  enum ExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionField] = [
      .noneExtensionField,
    ]

  }

  enum extensionFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtensionFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldNumber] = [
      .noneExtensionFieldNumber,
    ]

  }

  enum ExtensionFieldValueSet: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtensionFieldValueSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionFieldValueSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionFieldValueSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionFieldValueSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet] = [
      .noneExtensionFieldValueSet,
    ]

  }

  enum ExtensionMap: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtensionMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionMap] = [
      .noneExtensionMap,
    ]

  }

  enum extensionRange: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtensionRange // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensionRange
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensionRange
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensionRange: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionRange] = [
      .noneExtensionRange,
    ]

  }

  enum extensions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtensions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtensions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtensions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtensions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensions] = [
      .noneExtensions,
    ]

  }

  enum extras: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneExtras // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneExtras
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneExtras
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneExtras: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extras] = [
      .noneExtras,
    ]

  }

  enum F: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneF // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneF
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneF
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneF: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.F] = [
      .noneF,
    ]

  }

  enum falseEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFalse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFalse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFalse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFalse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.falseEnum] = [
      .noneFalse,
    ]

  }

  enum features: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.features] = [
      .noneFeatures,
    ]

  }

  enum FeatureSetEditionDefault: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFeatureSetEditionDefault // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFeatureSetEditionDefault
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFeatureSetEditionDefault
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFeatureSetEditionDefault: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FeatureSetEditionDefault] = [
      .noneFeatureSetEditionDefault,
    ]

  }

  enum featureSupport: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFeatureSupport // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFeatureSupport
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFeatureSupport
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFeatureSupport: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.featureSupport] = [
      .noneFeatureSupport,
    ]

  }

  enum field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.field] = [
      .noneField,
    ]

  }

  enum fieldData: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldData] = [
      .noneFieldData,
    ]

  }

  enum FieldMaskError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldMaskError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldMaskError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldMaskError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldMaskError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldMaskError] = [
      .noneFieldMaskError,
    ]

  }

  enum fieldName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldName] = [
      .noneFieldName,
    ]

  }

  enum fieldNameCount: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldNameCount // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNameCount
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNameCount
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNameCount: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNameCount] = [
      .noneFieldNameCount,
    ]

  }

  enum fieldNum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldNum // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNum
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNum
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNum: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNum] = [
      .noneFieldNum,
    ]

  }

  enum fieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumber] = [
      .noneFieldNumber,
    ]

  }

  enum fieldNumberForProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldNumberForProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldNumberForProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldNumberForProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldNumberForProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumberForProto] = [
      .noneFieldNumberForProto,
    ]

  }

  enum fieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldPresence // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldPresence
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldPresence
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldPresence: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldPresence] = [
      .noneFieldPresence,
    ]

  }

  enum fields: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fields] = [
      .noneFields,
    ]

  }

  enum fieldSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldSize] = [
      .noneFieldSize,
    ]

  }

  enum FieldTag: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldTag // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldTag
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldTag
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldTag: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldTag] = [
      .noneFieldTag,
    ]

  }

  enum FieldType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFieldType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFieldType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFieldType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFieldType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldType] = [
      .noneFieldType,
    ]

  }

  enum file: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFile // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFile
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFile
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFile: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.file] = [
      .noneFile,
    ]

  }

  enum fileName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFileName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFileName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFileName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFileName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fileName] = [
      .noneFileName,
    ]

  }

  enum filter: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFilter // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFilter
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFilter
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFilter: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.filter] = [
      .noneFilter,
    ]

  }

  enum final: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFinal // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFinal
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFinal
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFinal: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.final] = [
      .noneFinal,
    ]

  }

  enum finiteOnly: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFiniteOnly // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFiniteOnly
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFiniteOnly
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFiniteOnly: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.finiteOnly] = [
      .noneFiniteOnly,
    ]

  }

  enum first: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFirst // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFirst
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFirst
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFirst: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.first] = [
      .noneFirst,
    ]

  }

  enum firstItem: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFirstItem // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFirstItem
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFirstItem
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFirstItem: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.firstItem] = [
      .noneFirstItem,
    ]

  }

  enum fixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFixedFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFixedFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFixedFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFixedFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fixedFeatures] = [
      .noneFixedFeatures,
    ]

  }

  enum FloatEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFloat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatEnum] = [
      .noneFloat,
    ]

  }

  enum floatLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFloatLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloatLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloatLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloatLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.floatLiteral] = [
      .noneFloatLiteral,
    ]

  }

  enum FloatLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFloatLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFloatLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFloatLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFloatLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatLiteralType] = [
      .noneFloatLiteralType,
    ]

  }

  enum forEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forEnum] = [
      .noneFor,
    ]

  }

  enum forMessageName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneForMessageName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForMessageName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForMessageName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForMessageName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forMessageName] = [
      .noneForMessageName,
    ]

  }

  enum formUnion: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFormUnion // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFormUnion
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFormUnion
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFormUnion: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.formUnion] = [
      .noneFormUnion,
    ]

  }

  enum forReadingFrom: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneForReadingFrom // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForReadingFrom
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForReadingFrom
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForReadingFrom: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forReadingFrom] = [
      .noneForReadingFrom,
    ]

  }

  enum forTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneForTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forTypeURL] = [
      .noneForTypeURL,
    ]

  }

  enum ForwardParser: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneForwardParser // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForwardParser
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForwardParser
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForwardParser: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ForwardParser] = [
      .noneForwardParser,
    ]

  }

  enum forWritingInto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneForWritingInto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneForWritingInto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneForWritingInto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneForWritingInto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forWritingInto] = [
      .noneForWritingInto,
    ]

  }

  enum from: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFrom // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFrom
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFrom
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFrom: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.from] = [
      .noneFrom,
    ]

  }

  enum fromAscii2: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFromAscii2 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFromAscii2
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFromAscii2
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFromAscii2: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii2] = [
      .noneFromAscii2,
    ]

  }

  enum fromAscii4: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFromAscii4 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFromAscii4
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFromAscii4
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFromAscii4: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii4] = [
      .noneFromAscii4,
    ]

  }

  enum fromByteOffset: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFromByteOffset // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFromByteOffset
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFromByteOffset
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFromByteOffset: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromByteOffset] = [
      .noneFromByteOffset,
    ]

  }

  enum fromHexDigit: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFromHexDigit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFromHexDigit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFromHexDigit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFromHexDigit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromHexDigit] = [
      .noneFromHexDigit,
    ]

  }

  enum fullName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFullName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFullName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFullName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFullName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fullName] = [
      .noneFullName,
    ]

  }

  enum funcEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFunc // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFunc
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFunc
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFunc: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.funcEnum] = [
      .noneFunc,
    ]

  }

  enum function: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneFunction // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneFunction
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneFunction
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneFunction: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.function] = [
      .noneFunction,
    ]

  }

  enum G: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneG // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneG
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneG
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneG: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.G] = [
      .noneG,
    ]

  }

  enum get: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.get] = [
      .noneGet,
    ]

  }

  enum getExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGetExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGetExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGetExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGetExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getExtensionValue] = [
      .noneGetExtensionValue,
    ]

  }

  enum Google_Protobuf_Any: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufAny // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufAny
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufAny
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufAny: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Any] = [
      .noneGoogleProtobufAny,
    ]

  }

  enum Google_Protobuf_Api: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufApi // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufApi
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufApi
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufApi: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Api] = [
      .noneGoogleProtobufApi,
    ]

  }

  enum Google_Protobuf_BoolValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufBoolValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufBoolValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufBoolValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufBoolValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue] = [
      .noneGoogleProtobufBoolValue,
    ]

  }

  enum Google_Protobuf_BytesValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufBytesValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufBytesValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufBytesValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufBytesValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue] = [
      .noneGoogleProtobufBytesValue,
    ]

  }

  enum Google_Protobuf_DescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto] = [
      .noneGoogleProtobufDescriptorProto,
    ]

  }

  enum Google_Protobuf_DoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue] = [
      .noneGoogleProtobufDoubleValue,
    ]

  }

  enum Google_Protobuf_Duration: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufDuration // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufDuration
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufDuration
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufDuration: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration] = [
      .noneGoogleProtobufDuration,
    ]

  }

  enum Google_Protobuf_Edition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Edition] = [
      .noneGoogleProtobufEdition,
    ]

  }

  enum Google_Protobuf_Empty: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEmpty // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEmpty
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEmpty
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEmpty: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty] = [
      .noneGoogleProtobufEmpty,
    ]

  }

  enum Google_Protobuf_Enum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEnum // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnum
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnum
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnum: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum] = [
      .noneGoogleProtobufEnum,
    ]

  }

  enum Google_Protobuf_EnumDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEnumDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnumDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnumDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnumDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto] = [
      .noneGoogleProtobufEnumDescriptorProto,
    ]

  }

  enum Google_Protobuf_EnumOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEnumOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnumOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnumOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnumOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions] = [
      .noneGoogleProtobufEnumOptions,
    ]

  }

  enum Google_Protobuf_EnumValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEnumValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnumValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnumValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnumValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue] = [
      .noneGoogleProtobufEnumValue,
    ]

  }

  enum Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEnumValueDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnumValueDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnumValueDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnumValueDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto] = [
      .noneGoogleProtobufEnumValueDescriptorProto,
    ]

  }

  enum Google_Protobuf_EnumValueOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufEnumValueOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufEnumValueOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufEnumValueOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufEnumValueOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions] = [
      .noneGoogleProtobufEnumValueOptions,
    ]

  }

  enum Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufExtensionRangeOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufExtensionRangeOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufExtensionRangeOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufExtensionRangeOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions] = [
      .noneGoogleProtobufExtensionRangeOptions,
    ]

  }

  enum Google_Protobuf_FeatureSet: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFeatureSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFeatureSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFeatureSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFeatureSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSet] = [
      .noneGoogleProtobufFeatureSet,
    ]

  }

  enum Google_Protobuf_FeatureSetDefaults: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFeatureSetDefaults // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFeatureSetDefaults
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFeatureSetDefaults
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFeatureSetDefaults: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSetDefaults] = [
      .noneGoogleProtobufFeatureSetDefaults,
    ]

  }

  enum Google_Protobuf_Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Field] = [
      .noneGoogleProtobufField,
    ]

  }

  enum Google_Protobuf_FieldDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFieldDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFieldDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFieldDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFieldDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto] = [
      .noneGoogleProtobufFieldDescriptorProto,
    ]

  }

  enum Google_Protobuf_FieldMask: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFieldMask // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFieldMask
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFieldMask
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFieldMask: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask] = [
      .noneGoogleProtobufFieldMask,
    ]

  }

  enum Google_Protobuf_FieldOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFieldOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFieldOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFieldOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFieldOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions] = [
      .noneGoogleProtobufFieldOptions,
    ]

  }

  enum Google_Protobuf_FileDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFileDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFileDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFileDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFileDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto] = [
      .noneGoogleProtobufFileDescriptorProto,
    ]

  }

  enum Google_Protobuf_FileDescriptorSet: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFileDescriptorSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFileDescriptorSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFileDescriptorSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFileDescriptorSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet] = [
      .noneGoogleProtobufFileDescriptorSet,
    ]

  }

  enum Google_Protobuf_FileOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFileOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFileOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFileOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFileOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions] = [
      .noneGoogleProtobufFileOptions,
    ]

  }

  enum Google_Protobuf_FloatValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufFloatValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufFloatValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufFloatValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufFloatValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue] = [
      .noneGoogleProtobufFloatValue,
    ]

  }

  enum Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufGeneratedCodeInfo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufGeneratedCodeInfo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufGeneratedCodeInfo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufGeneratedCodeInfo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo] = [
      .noneGoogleProtobufGeneratedCodeInfo,
    ]

  }

  enum Google_Protobuf_Int32Value: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufInt32Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufInt32Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufInt32Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufInt32Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value] = [
      .noneGoogleProtobufInt32Value,
    ]

  }

  enum Google_Protobuf_Int64Value: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufInt64Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufInt64Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufInt64Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufInt64Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value] = [
      .noneGoogleProtobufInt64Value,
    ]

  }

  enum Google_Protobuf_ListValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufListValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufListValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufListValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufListValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue] = [
      .noneGoogleProtobufListValue,
    ]

  }

  enum Google_Protobuf_MessageOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufMessageOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufMessageOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufMessageOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufMessageOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions] = [
      .noneGoogleProtobufMessageOptions,
    ]

  }

  enum Google_Protobuf_Method: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufMethod // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufMethod
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufMethod
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufMethod: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Method] = [
      .noneGoogleProtobufMethod,
    ]

  }

  enum Google_Protobuf_MethodDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufMethodDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufMethodDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufMethodDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufMethodDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto] = [
      .noneGoogleProtobufMethodDescriptorProto,
    ]

  }

  enum Google_Protobuf_MethodOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufMethodOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufMethodOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufMethodOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufMethodOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions] = [
      .noneGoogleProtobufMethodOptions,
    ]

  }

  enum Google_Protobuf_Mixin: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufMixin // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufMixin
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufMixin
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufMixin: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin] = [
      .noneGoogleProtobufMixin,
    ]

  }

  enum Google_Protobuf_NullValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufNullValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufNullValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufNullValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufNullValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue] = [
      .noneGoogleProtobufNullValue,
    ]

  }

  enum Google_Protobuf_OneofDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufOneofDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufOneofDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufOneofDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufOneofDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto] = [
      .noneGoogleProtobufOneofDescriptorProto,
    ]

  }

  enum Google_Protobuf_OneofOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufOneofOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufOneofOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufOneofOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufOneofOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions] = [
      .noneGoogleProtobufOneofOptions,
    ]

  }

  enum Google_Protobuf_Option: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufOption // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufOption
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufOption
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufOption: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Option] = [
      .noneGoogleProtobufOption,
    ]

  }

  enum Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufServiceDescriptorProto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufServiceDescriptorProto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufServiceDescriptorProto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufServiceDescriptorProto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto] = [
      .noneGoogleProtobufServiceDescriptorProto,
    ]

  }

  enum Google_Protobuf_ServiceOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufServiceOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufServiceOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufServiceOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufServiceOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions] = [
      .noneGoogleProtobufServiceOptions,
    ]

  }

  enum Google_Protobuf_SourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufSourceCodeInfo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufSourceCodeInfo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufSourceCodeInfo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufSourceCodeInfo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo] = [
      .noneGoogleProtobufSourceCodeInfo,
    ]

  }

  enum Google_Protobuf_SourceContext: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext] = [
      .noneGoogleProtobufSourceContext,
    ]

  }

  enum Google_Protobuf_StringValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue] = [
      .noneGoogleProtobufStringValue,
    ]

  }

  enum Google_Protobuf_Struct: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufStruct // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufStruct
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufStruct
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufStruct: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct] = [
      .noneGoogleProtobufStruct,
    ]

  }

  enum Google_Protobuf_SymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufSymbolVisibility // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufSymbolVisibility
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufSymbolVisibility
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufSymbolVisibility: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SymbolVisibility] = [
      .noneGoogleProtobufSymbolVisibility,
    ]

  }

  enum Google_Protobuf_Syntax: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufSyntax // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufSyntax
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufSyntax
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufSyntax: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax] = [
      .noneGoogleProtobufSyntax,
    ]

  }

  enum Google_Protobuf_Timestamp: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufTimestamp // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufTimestamp
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufTimestamp
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufTimestamp: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp] = [
      .noneGoogleProtobufTimestamp,
    ]

  }

  enum Google_Protobuf_Type: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Type] = [
      .noneGoogleProtobufType,
    ]

  }

  enum Google_Protobuf_UInt32Value: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufUint32Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufUint32Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufUint32Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufUint32Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value] = [
      .noneGoogleProtobufUint32Value,
    ]

  }

  enum Google_Protobuf_UInt64Value: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufUint64Value // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufUint64Value
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufUint64Value
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufUint64Value: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value] = [
      .noneGoogleProtobufUint64Value,
    ]

  }

  enum Google_Protobuf_UninterpretedOption: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufUninterpretedOption // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufUninterpretedOption
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufUninterpretedOption
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufUninterpretedOption: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption] = [
      .noneGoogleProtobufUninterpretedOption,
    ]

  }

  enum Google_Protobuf_Value: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoogleProtobufValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoogleProtobufValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoogleProtobufValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoogleProtobufValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Value] = [
      .noneGoogleProtobufValue,
    ]

  }

  enum goPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGoPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGoPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGoPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGoPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.goPackage] = [
      .noneGoPackage,
    ]

  }

  enum gotData: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGotData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGotData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGotData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGotData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.gotData] = [
      .noneGotData,
    ]

  }

  enum group: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGroup // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGroup
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGroup
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGroup: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.group] = [
      .noneGroup,
    ]

  }

  enum groupFieldNumberStack: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGroupFieldNumberStack // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGroupFieldNumberStack
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGroupFieldNumberStack
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGroupFieldNumberStack: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupFieldNumberStack] = [
      .noneGroupFieldNumberStack,
    ]

  }

  enum groupSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGroupSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGroupSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGroupSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGroupSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupSize] = [
      .noneGroupSize,
    ]

  }

  enum guardEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneGuard // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneGuard
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneGuard
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneGuard: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.guardEnum] = [
      .noneGuard,
    ]

  }

  enum hadOneofValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHadOneofValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHadOneofValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHadOneofValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHadOneofValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hadOneofValue] = [
      .noneHadOneofValue,
    ]

  }

  enum handleConflictingOneOf: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHandleConflictingOneOf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHandleConflictingOneOf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHandleConflictingOneOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHandleConflictingOneOf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleConflictingOneOf] = [
      .noneHandleConflictingOneOf,
    ]

  }

  enum handleInstruction: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHandleInstruction // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHandleInstruction
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHandleInstruction
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHandleInstruction: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleInstruction] = [
      .noneHandleInstruction,
    ]

  }

  enum hasAggregateValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasAggregateValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasAggregateValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasAggregateValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasAggregateValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAggregateValue] = [
      .noneHasAggregateValue,
    ]

  }

  enum hasAllowAlias: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasAllowAlias // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasAllowAlias
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasAllowAlias
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasAllowAlias: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAllowAlias] = [
      .noneHasAllowAlias,
    ]

  }

  enum hasBegin: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasBegin // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasBegin
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasBegin
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasBegin: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasBegin] = [
      .noneHasBegin,
    ]

  }

  enum hasCcEnableArenas: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasCcEnableArenas // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasCcEnableArenas
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasCcEnableArenas
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasCcEnableArenas: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcEnableArenas] = [
      .noneHasCcEnableArenas,
    ]

  }

  enum hasCcGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasCcGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasCcGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasCcGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasCcGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcGenericServices] = [
      .noneHasCcGenericServices,
    ]

  }

  enum hasClientStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasClientStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasClientStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasClientStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasClientStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasClientStreaming] = [
      .noneHasClientStreaming,
    ]

  }

  enum hasCsharpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasCsharpNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasCsharpNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasCsharpNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasCsharpNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCsharpNamespace] = [
      .noneHasCsharpNamespace,
    ]

  }

  enum hasCtype: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasCtype // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasCtype
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasCtype
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasCtype: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCtype] = [
      .noneHasCtype,
    ]

  }

  enum hasData: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasData] = [
      .noneHasData,
    ]

  }

  enum hasDebugRedact: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasDebugRedact // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasDebugRedact
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasDebugRedact
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasDebugRedact: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDebugRedact] = [
      .noneHasDebugRedact,
    ]

  }

  enum hasDefaultSymbolVisibility: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasDefaultSymbolVisibility // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasDefaultSymbolVisibility
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasDefaultSymbolVisibility
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasDefaultSymbolVisibility: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultSymbolVisibility] = [
      .noneHasDefaultSymbolVisibility,
    ]

  }

  enum hasDefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasDefaultValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasDefaultValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasDefaultValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasDefaultValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultValue] = [
      .noneHasDefaultValue,
    ]

  }

  enum hasDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasDeprecated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasDeprecated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasDeprecated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasDeprecated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecated] = [
      .noneHasDeprecated,
    ]

  }

  enum hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasDeprecatedLegacyJsonFieldConflicts // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasDeprecatedLegacyJsonFieldConflicts
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasDeprecatedLegacyJsonFieldConflicts
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasDeprecatedLegacyJsonFieldConflicts: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecatedLegacyJsonFieldConflicts] = [
      .noneHasDeprecatedLegacyJsonFieldConflicts,
    ]

  }

  enum hasDeprecationWarning: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasDeprecationWarning // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasDeprecationWarning
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasDeprecationWarning
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasDeprecationWarning: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecationWarning] = [
      .noneHasDeprecationWarning,
    ]

  }

  enum hasDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDoubleValue] = [
      .noneHasDoubleValue,
    ]

  }

  enum hasEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEdition] = [
      .noneHasEdition,
    ]

  }

  enum hasEditionDeprecated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasEditionDeprecated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasEditionDeprecated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasEditionDeprecated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasEditionDeprecated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionDeprecated] = [
      .noneHasEditionDeprecated,
    ]

  }

  enum hasEditionIntroduced: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasEditionIntroduced // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasEditionIntroduced
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasEditionIntroduced
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasEditionIntroduced: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionIntroduced] = [
      .noneHasEditionIntroduced,
    ]

  }

  enum hasEditionRemoved: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasEditionRemoved // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasEditionRemoved
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasEditionRemoved
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasEditionRemoved: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionRemoved] = [
      .noneHasEditionRemoved,
    ]

  }

  enum hasEnd: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasEnd // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasEnd
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasEnd
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasEnd: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnd] = [
      .noneHasEnd,
    ]

  }

  enum hasEnforceNamingStyle: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasEnforceNamingStyle // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasEnforceNamingStyle
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasEnforceNamingStyle
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasEnforceNamingStyle: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnforceNamingStyle] = [
      .noneHasEnforceNamingStyle,
    ]

  }

  enum hasEnumType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasEnumType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasEnumType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasEnumType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasEnumType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnumType] = [
      .noneHasEnumType,
    ]

  }

  enum hasExplicitDelta: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasExplicitDelta // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasExplicitDelta
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasExplicitDelta
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasExplicitDelta: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExplicitDelta] = [
      .noneHasExplicitDelta,
    ]

  }

  enum hasExtendee: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasExtendee // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasExtendee
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasExtendee
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasExtendee: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtendee] = [
      .noneHasExtendee,
    ]

  }

  enum hasExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtensionValue] = [
      .noneHasExtensionValue,
    ]

  }

  enum hasFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatures] = [
      .noneHasFeatures,
    ]

  }

  enum hasFeatureSupport: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasFeatureSupport // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasFeatureSupport
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasFeatureSupport
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasFeatureSupport: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatureSupport] = [
      .noneHasFeatureSupport,
    ]

  }

  enum hasFieldPresence: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasFieldPresence // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasFieldPresence
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasFieldPresence
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasFieldPresence: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFieldPresence] = [
      .noneHasFieldPresence,
    ]

  }

  enum hasFixedFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasFixedFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasFixedFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasFixedFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasFixedFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFixedFeatures] = [
      .noneHasFixedFeatures,
    ]

  }

  enum hasFullName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasFullName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasFullName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasFullName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasFullName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFullName] = [
      .noneHasFullName,
    ]

  }

  enum hasGoPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasGoPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasGoPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasGoPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasGoPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasGoPackage] = [
      .noneHasGoPackage,
    ]

  }

  enum hash: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hash] = [
      .noneHash,
    ]

  }

  enum HashableEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHashable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHashable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHashable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHashable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashableEnum] = [
      .noneHashable,
    ]

  }

  enum hasher: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasher // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasher
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasher
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasher: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasher] = [
      .noneHasher,
    ]

  }

  enum HashVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHashVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHashVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHashVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHashVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashVisitor] = [
      .noneHashVisitor,
    ]

  }

  enum hasIdempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasIdempotencyLevel // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasIdempotencyLevel
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasIdempotencyLevel
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasIdempotencyLevel: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdempotencyLevel] = [
      .noneHasIdempotencyLevel,
    ]

  }

  enum hasIdentifierValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasIdentifierValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasIdentifierValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasIdentifierValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasIdentifierValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdentifierValue] = [
      .noneHasIdentifierValue,
    ]

  }

  enum hasInputType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasInputType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasInputType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasInputType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasInputType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasInputType] = [
      .noneHasInputType,
    ]

  }

  enum hasIsExtension: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasIsExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasIsExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasIsExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasIsExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIsExtension] = [
      .noneHasIsExtension,
    ]

  }

  enum hasJavaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJavaGenerateEqualsAndHash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJavaGenerateEqualsAndHash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJavaGenerateEqualsAndHash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJavaGenerateEqualsAndHash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash] = [
      .noneHasJavaGenerateEqualsAndHash,
    ]

  }

  enum hasJavaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJavaGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJavaGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJavaGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJavaGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenericServices] = [
      .noneHasJavaGenericServices,
    ]

  }

  enum hasJavaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJavaMultipleFiles // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJavaMultipleFiles
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJavaMultipleFiles
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJavaMultipleFiles: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles] = [
      .noneHasJavaMultipleFiles,
    ]

  }

  enum hasJavaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJavaOuterClassname // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJavaOuterClassname
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJavaOuterClassname
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJavaOuterClassname: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaOuterClassname] = [
      .noneHasJavaOuterClassname,
    ]

  }

  enum hasJavaPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJavaPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJavaPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJavaPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJavaPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaPackage] = [
      .noneHasJavaPackage,
    ]

  }

  enum hasJavaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJavaStringCheckUtf8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJavaStringCheckUtf8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJavaStringCheckUtf8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJavaStringCheckUtf8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8] = [
      .noneHasJavaStringCheckUtf8,
    ]

  }

  enum hasJsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJsonFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJsonFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJsonFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJsonFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonFormat] = [
      .noneHasJsonFormat,
    ]

  }

  enum hasJsonName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJsonName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJsonName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJsonName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJsonName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonName] = [
      .noneHasJsonName,
    ]

  }

  enum hasJstype: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasJstype // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasJstype
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasJstype
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasJstype: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJstype] = [
      .noneHasJstype,
    ]

  }

  enum hasLabel: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasLabel // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasLabel
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasLabel
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasLabel: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLabel] = [
      .noneHasLabel,
    ]

  }

  enum hasLazy: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasLazy // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasLazy
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasLazy
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasLazy: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLazy] = [
      .noneHasLazy,
    ]

  }

  enum hasLeadingComments: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasLeadingComments // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasLeadingComments
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasLeadingComments
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasLeadingComments: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLeadingComments] = [
      .noneHasLeadingComments,
    ]

  }

  enum hasMapEntry: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasMapEntry // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasMapEntry
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasMapEntry
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasMapEntry: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMapEntry] = [
      .noneHasMapEntry,
    ]

  }

  enum hasMaximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasMaximumEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasMaximumEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasMaximumEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasMaximumEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMaximumEdition] = [
      .noneHasMaximumEdition,
    ]

  }

  enum hasMessageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasMessageEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasMessageEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasMessageEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasMessageEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageEncoding] = [
      .noneHasMessageEncoding,
    ]

  }

  enum hasMessageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasMessageSetWireFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasMessageSetWireFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasMessageSetWireFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasMessageSetWireFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat] = [
      .noneHasMessageSetWireFormat,
    ]

  }

  enum hasMinimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasMinimumEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasMinimumEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasMinimumEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasMinimumEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMinimumEdition] = [
      .noneHasMinimumEdition,
    ]

  }

  enum hasName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasName] = [
      .noneHasName,
    ]

  }

  enum hasNamePart: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasNamePart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasNamePart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasNamePart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasNamePart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNamePart] = [
      .noneHasNamePart,
    ]

  }

  enum hasNegativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasNegativeIntValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasNegativeIntValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasNegativeIntValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasNegativeIntValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNegativeIntValue] = [
      .noneHasNegativeIntValue,
    ]

  }

  enum hasNoStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasNoStandardDescriptorAccessor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasNoStandardDescriptorAccessor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasNoStandardDescriptorAccessor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasNoStandardDescriptorAccessor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor] = [
      .noneHasNoStandardDescriptorAccessor,
    ]

  }

  enum hasNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNumber] = [
      .noneHasNumber,
    ]

  }

  enum hasObjcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasObjcClassPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasObjcClassPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasObjcClassPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasObjcClassPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasObjcClassPrefix] = [
      .noneHasObjcClassPrefix,
    ]

  }

  enum hasOneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasOneofIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasOneofIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasOneofIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasOneofIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOneofIndex] = [
      .noneHasOneofIndex,
    ]

  }

  enum hasOptimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasOptimizeFor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasOptimizeFor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasOptimizeFor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasOptimizeFor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptimizeFor] = [
      .noneHasOptimizeFor,
    ]

  }

  enum hasOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptions] = [
      .noneHasOptions,
    ]

  }

  enum hasOutputType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasOutputType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasOutputType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasOutputType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasOutputType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOutputType] = [
      .noneHasOutputType,
    ]

  }

  enum hasOverridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasOverridableFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasOverridableFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasOverridableFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasOverridableFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOverridableFeatures] = [
      .noneHasOverridableFeatures,
    ]

  }

  enum hasPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPackage] = [
      .noneHasPackage,
    ]

  }

  enum hasPacked: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasPacked // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasPacked
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasPacked
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasPacked: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPacked] = [
      .noneHasPacked,
    ]

  }

  enum hasPhpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasPhpClassPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasPhpClassPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasPhpClassPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasPhpClassPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpClassPrefix] = [
      .noneHasPhpClassPrefix,
    ]

  }

  enum hasPhpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasPhpMetadataNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasPhpMetadataNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasPhpMetadataNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasPhpMetadataNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace] = [
      .noneHasPhpMetadataNamespace,
    ]

  }

  enum hasPhpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasPhpNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasPhpNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasPhpNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasPhpNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpNamespace] = [
      .noneHasPhpNamespace,
    ]

  }

  enum hasPositiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasPositiveIntValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasPositiveIntValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasPositiveIntValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasPositiveIntValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPositiveIntValue] = [
      .noneHasPositiveIntValue,
    ]

  }

  enum hasProto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasProto3Optional // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasProto3Optional
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasProto3Optional
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasProto3Optional: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasProto3Optional] = [
      .noneHasProto3Optional,
    ]

  }

  enum hasPyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasPyGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasPyGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasPyGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasPyGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPyGenericServices] = [
      .noneHasPyGenericServices,
    ]

  }

  enum hasRemovalError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasRemovalError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasRemovalError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasRemovalError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasRemovalError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRemovalError] = [
      .noneHasRemovalError,
    ]

  }

  enum hasRepeated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasRepeated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasRepeated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasRepeated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasRepeated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeated] = [
      .noneHasRepeated,
    ]

  }

  enum hasRepeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasRepeatedFieldEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasRepeatedFieldEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasRepeatedFieldEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasRepeatedFieldEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeatedFieldEncoding] = [
      .noneHasRepeatedFieldEncoding,
    ]

  }

  enum hasReserved: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasReserved // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasReserved
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasReserved
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasReserved: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasReserved] = [
      .noneHasReserved,
    ]

  }

  enum hasRetention: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasRetention // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasRetention
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasRetention
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasRetention: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRetention] = [
      .noneHasRetention,
    ]

  }

  enum hasRubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasRubyPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasRubyPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasRubyPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasRubyPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRubyPackage] = [
      .noneHasRubyPackage,
    ]

  }

  enum hasSemantic: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasSemantic // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasSemantic
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasSemantic
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasSemantic: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSemantic] = [
      .noneHasSemantic,
    ]

  }

  enum hasServerStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasServerStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasServerStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasServerStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasServerStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasServerStreaming] = [
      .noneHasServerStreaming,
    ]

  }

  enum hasSourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasSourceCodeInfo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasSourceCodeInfo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasSourceCodeInfo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasSourceCodeInfo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceCodeInfo] = [
      .noneHasSourceCodeInfo,
    ]

  }

  enum hasSourceContext: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceContext] = [
      .noneHasSourceContext,
    ]

  }

  enum hasSourceFile: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasSourceFile // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasSourceFile
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasSourceFile
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasSourceFile: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceFile] = [
      .noneHasSourceFile,
    ]

  }

  enum hasStart: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStart] = [
      .noneHasStart,
    ]

  }

  enum hasStringValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStringValue] = [
      .noneHasStringValue,
    ]

  }

  enum hasSwiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasSwiftPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasSwiftPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasSwiftPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasSwiftPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSwiftPrefix] = [
      .noneHasSwiftPrefix,
    ]

  }

  enum hasSyntax: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasSyntax // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasSyntax
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasSyntax
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasSyntax: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSyntax] = [
      .noneHasSyntax,
    ]

  }

  enum hasTrailingComments: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasTrailingComments // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasTrailingComments
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasTrailingComments
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasTrailingComments: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTrailingComments] = [
      .noneHasTrailingComments,
    ]

  }

  enum hasType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasType] = [
      .noneHasType,
    ]

  }

  enum hasTypeName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasTypeName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasTypeName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasTypeName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasTypeName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTypeName] = [
      .noneHasTypeName,
    ]

  }

  enum hasUnverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasUnverifiedLazy // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasUnverifiedLazy
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasUnverifiedLazy
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasUnverifiedLazy: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUnverifiedLazy] = [
      .noneHasUnverifiedLazy,
    ]

  }

  enum hasUtf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasUtf8Validation // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasUtf8Validation
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasUtf8Validation
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasUtf8Validation: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUtf8Validation] = [
      .noneHasUtf8Validation,
    ]

  }

  enum hasValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasValue] = [
      .noneHasValue,
    ]

  }

  enum hasVerification: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasVerification // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasVerification
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasVerification
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasVerification: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVerification] = [
      .noneHasVerification,
    ]

  }

  enum hasVisibility: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasVisibility // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasVisibility
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasVisibility
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasVisibility: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVisibility] = [
      .noneHasVisibility,
    ]

  }

  enum hasWeak: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHasWeak // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHasWeak
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHasWeak
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHasWeak: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasWeak] = [
      .noneHasWeak,
    ]

  }

  enum hour: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneHour // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneHour
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneHour
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneHour: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hour] = [
      .noneHour,
    ]

  }

  enum i: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneI // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneI
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneI
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneI: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.i] = [
      .noneI,
    ]

  }

  enum idempotencyLevel: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIdempotencyLevel // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIdempotencyLevel
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIdempotencyLevel
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIdempotencyLevel: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.idempotencyLevel] = [
      .noneIdempotencyLevel,
    ]

  }

  enum identifierValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIdentifierValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIdentifierValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIdentifierValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIdentifierValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.identifierValue] = [
      .noneIdentifierValue,
    ]

  }

  enum ifEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ifEnum] = [
      .noneIf,
    ]

  }

  enum ignoreUnknownExtensionFields: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIgnoreUnknownExtensionFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIgnoreUnknownExtensionFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIgnoreUnknownExtensionFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIgnoreUnknownExtensionFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownExtensionFields] = [
      .noneIgnoreUnknownExtensionFields,
    ]

  }

  enum ignoreUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIgnoreUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIgnoreUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIgnoreUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIgnoreUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownFields] = [
      .noneIgnoreUnknownFields,
    ]

  }

  enum index: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.index] = [
      .noneIndex,
    ]

  }

  enum initEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.initEnum] = [
      .noneInit,
    ]

  }

  enum inoutEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInout // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInout
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInout
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInout: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inoutEnum] = [
      .noneInout,
    ]

  }

  enum inputType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInputType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInputType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInputType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInputType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inputType] = [
      .noneInputType,
    ]

  }

  enum insert: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInsert // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInsert
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInsert
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInsert: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.insert] = [
      .noneInsert,
    ]

  }

  enum Instruction: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInstruction // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInstruction
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInstruction
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInstruction: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Instruction] = [
      .noneInstruction,
    ]

  }

  enum IntEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntEnum] = [
      .noneInt,
    ]

  }

  enum Int32Enum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInt32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int32Enum] = [
      .noneInt32,
    ]

  }

  enum Int64Enum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInt64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int64Enum] = [
      .noneInt64,
    ]

  }

  enum Int8: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInt8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInt8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInt8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInt8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int8] = [
      .noneInt8,
    ]

  }

  enum integerLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIntegerLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIntegerLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIntegerLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIntegerLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.integerLiteral] = [
      .noneIntegerLiteral,
    ]

  }

  enum IntegerLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIntegerLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIntegerLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIntegerLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIntegerLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntegerLiteralType] = [
      .noneIntegerLiteralType,
    ]

  }

  enum intern: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIntern // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIntern
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIntern
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIntern: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intern] = [
      .noneIntern,
    ]

  }

  enum Internal: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInternal // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInternal
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInternal
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInternal: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Internal] = [
      .noneInternal,
    ]

  }

  enum InternalState: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInternalState // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInternalState
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInternalState
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInternalState: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.InternalState] = [
      .noneInternalState,
    ]

  }

  enum intersect: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIntersect // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIntersect
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIntersect
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIntersect: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intersect] = [
      .noneIntersect,
    ]

  }

  enum into: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInto // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInto
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInto
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInto: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.into] = [
      .noneInto,
    ]

  }

  enum ints: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInts // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInts
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInts
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInts: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ints] = [
      .noneInts,
    ]

  }

  enum invalidAnyTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneInvalidAnyTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneInvalidAnyTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneInvalidAnyTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneInvalidAnyTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.invalidAnyTypeURL] = [
      .noneInvalidAnyTypeURL,
    ]

  }

  enum isA: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsA // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsA
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsA
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsA: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isA] = [
      .noneIsA,
    ]

  }

  enum isEqual: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsEqual // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsEqual
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsEqual
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsEqual: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqual] = [
      .noneIsEqual,
    ]

  }

  enum isEqualTo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsEqualTo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsEqualTo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsEqualTo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsEqualTo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqualTo] = [
      .noneIsEqualTo,
    ]

  }

  enum isExtension: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isExtension] = [
      .noneIsExtension,
    ]

  }

  enum isInitializedEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsInitialized // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsInitialized
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsInitialized
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsInitialized: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isInitializedEnum] = [
      .noneIsInitialized,
    ]

  }

  enum isNegative: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsNegative // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsNegative
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsNegative
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsNegative: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isNegative] = [
      .noneIsNegative,
    ]

  }

  enum isPathValid: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsPathValid // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsPathValid
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsPathValid
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsPathValid: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isPathValid] = [
      .noneIsPathValid,
    ]

  }

  enum isReserved: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsReserved // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsReserved
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsReserved
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsReserved: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isReserved] = [
      .noneIsReserved,
    ]

  }

  enum isValid: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIsValid // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIsValid
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIsValid
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIsValid: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isValid] = [
      .noneIsValid,
    ]

  }

  enum itemTagsEncodedSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneItemTagsEncodedSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneItemTagsEncodedSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneItemTagsEncodedSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneItemTagsEncodedSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.itemTagsEncodedSize] = [
      .noneItemTagsEncodedSize,
    ]

  }

  enum iterator: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneIterator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneIterator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneIterator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneIterator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.iterator] = [
      .noneIterator,
    ]

  }

  enum javaGenerateEqualsAndHash: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJavaGenerateEqualsAndHash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJavaGenerateEqualsAndHash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJavaGenerateEqualsAndHash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJavaGenerateEqualsAndHash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash] = [
      .noneJavaGenerateEqualsAndHash,
    ]

  }

  enum javaGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJavaGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJavaGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJavaGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJavaGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenericServices] = [
      .noneJavaGenericServices,
    ]

  }

  enum javaMultipleFiles: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJavaMultipleFiles // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJavaMultipleFiles
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJavaMultipleFiles
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJavaMultipleFiles: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaMultipleFiles] = [
      .noneJavaMultipleFiles,
    ]

  }

  enum javaOuterClassname: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJavaOuterClassname // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJavaOuterClassname
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJavaOuterClassname
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJavaOuterClassname: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaOuterClassname] = [
      .noneJavaOuterClassname,
    ]

  }

  enum javaPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJavaPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJavaPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJavaPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJavaPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaPackage] = [
      .noneJavaPackage,
    ]

  }

  enum javaStringCheckUtf8: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJavaStringCheckUtf8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJavaStringCheckUtf8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJavaStringCheckUtf8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJavaStringCheckUtf8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaStringCheckUtf8] = [
      .noneJavaStringCheckUtf8,
    ]

  }

  enum JSONDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsondecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsondecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsondecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsondecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoder] = [
      .noneJsondecoder,
    ]

  }

  enum JSONDecoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsondecoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsondecoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsondecoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsondecoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoding] = [
      .noneJsondecoding,
    ]

  }

  enum JSONDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsondecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsondecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsondecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsondecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingError] = [
      .noneJsondecodingError,
    ]

  }

  enum JSONDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsondecodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsondecodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsondecodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsondecodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingOptions] = [
      .noneJsondecodingOptions,
    ]

  }

  enum jsonEncoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonEncoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonEncoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonEncoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonEncoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonEncoder] = [
      .noneJsonEncoder,
    ]

  }

  enum JSONEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonencoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonencoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonencoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonencoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncoding] = [
      .noneJsonencoding,
    ]

  }

  enum JSONEncodingError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonencodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonencodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonencodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonencodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingError] = [
      .noneJsonencodingError,
    ]

  }

  enum JSONEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonencodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonencodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonencodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonencodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingOptions] = [
      .noneJsonencodingOptions,
    ]

  }

  enum JSONEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonencodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonencodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonencodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonencodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingVisitor] = [
      .noneJsonencodingVisitor,
    ]

  }

  enum jsonFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonFormat] = [
      .noneJsonFormat,
    ]

  }

  enum JSONMapEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonmapEncodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonmapEncodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonmapEncodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonmapEncodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor] = [
      .noneJsonmapEncodingVisitor,
    ]

  }

  enum jsonName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonName] = [
      .noneJsonName,
    ]

  }

  enum jsonPath: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonPath // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonPath
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonPath
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonPath: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPath] = [
      .noneJsonPath,
    ]

  }

  enum jsonPaths: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonPaths // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonPaths
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonPaths
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonPaths: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPaths] = [
      .noneJsonPaths,
    ]

  }

  enum JSONScanner: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonscanner // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonscanner
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonscanner
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonscanner: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONScanner] = [
      .noneJsonscanner,
    ]

  }

  enum jsonString: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonString] = [
      .noneJsonString,
    ]

  }

  enum jsonText: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonText // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonText
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonText
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonText: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonText] = [
      .noneJsonText,
    ]

  }

  enum jsonUTF8Bytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonUtf8Bytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonUtf8Bytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonUtf8Bytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonUtf8Bytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Bytes] = [
      .noneJsonUtf8Bytes,
    ]

  }

  enum jsonUTF8Data: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJsonUtf8Data // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJsonUtf8Data
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJsonUtf8Data
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJsonUtf8Data: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Data] = [
      .noneJsonUtf8Data,
    ]

  }

  enum jstype: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneJstype // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneJstype
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneJstype
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneJstype: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jstype] = [
      .noneJstype,
    ]

  }

  enum k: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneK // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneK
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneK
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneK: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.k] = [
      .noneK,
    ]

  }

  enum kChunkSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneKChunkSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKChunkSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKChunkSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKChunkSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kChunkSize] = [
      .noneKChunkSize,
    ]

  }

  enum Key: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneKey // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKey
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKey
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKey: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Key] = [
      .noneKey,
    ]

  }

  enum keyField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneKeyField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKeyField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKeyField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKeyField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyField] = [
      .noneKeyField,
    ]

  }

  enum keyFieldOpt: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneKeyFieldOpt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKeyFieldOpt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKeyFieldOpt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKeyFieldOpt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyFieldOpt] = [
      .noneKeyFieldOpt,
    ]

  }

  enum KeyType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneKeyType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKeyType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKeyType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKeyType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.KeyType] = [
      .noneKeyType,
    ]

  }

  enum kind: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneKind // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneKind
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneKind
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneKind: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kind] = [
      .noneKind,
    ]

  }

  enum l: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.l] = [
      .noneL,
    ]

  }

  enum label: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLabel // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLabel
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLabel
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLabel: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.label] = [
      .noneLabel,
    ]

  }

  enum lazy: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLazy // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLazy
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLazy
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLazy: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lazy] = [
      .noneLazy,
    ]

  }

  enum leadingComments: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLeadingComments // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLeadingComments
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLeadingComments
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLeadingComments: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingComments] = [
      .noneLeadingComments,
    ]

  }

  enum leadingDetachedComments: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLeadingDetachedComments // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLeadingDetachedComments
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLeadingDetachedComments
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLeadingDetachedComments: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingDetachedComments] = [
      .noneLeadingDetachedComments,
    ]

  }

  enum length: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLength // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLength
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLength
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLength: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.length] = [
      .noneLength,
    ]

  }

  enum lessThan: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLessThan // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLessThan
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLessThan
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLessThan: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lessThan] = [
      .noneLessThan,
    ]

  }

  enum letEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.letEnum] = [
      .noneLet,
    ]

  }

  enum lhs: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLhs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLhs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLhs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLhs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lhs] = [
      .noneLhs,
    ]

  }

  enum line: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLine // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLine
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLine
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLine: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.line] = [
      .noneLine,
    ]

  }

  enum list: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneList // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneList
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneList
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneList: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.list] = [
      .noneList,
    ]

  }

  enum listOfMessages: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneListOfMessages // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneListOfMessages
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneListOfMessages
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneListOfMessages: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listOfMessages] = [
      .noneListOfMessages,
    ]

  }

  enum listValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneListValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneListValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneListValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneListValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listValue] = [
      .noneListValue,
    ]

  }

  enum littleEndian: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLittleEndian // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLittleEndian
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLittleEndian
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLittleEndian: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.littleEndian] = [
      .noneLittleEndian,
    ]

  }

  enum load: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLoad // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLoad
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLoad
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLoad: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.load] = [
      .noneLoad,
    ]

  }

  enum localHasher: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLocalHasher // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLocalHasher
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLocalHasher
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLocalHasher: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.localHasher] = [
      .noneLocalHasher,
    ]

  }

  enum location: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneLocation // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneLocation
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneLocation
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneLocation: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.location] = [
      .noneLocation,
    ]

  }

  enum M: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneM // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneM
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneM
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneM: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.M] = [
      .noneM,
    ]

  }

  enum major: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMajor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMajor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMajor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMajor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.major] = [
      .noneMajor,
    ]

  }

  enum makeAsyncIterator: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMakeAsyncIterator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMakeAsyncIterator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMakeAsyncIterator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMakeAsyncIterator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeAsyncIterator] = [
      .noneMakeAsyncIterator,
    ]

  }

  enum makeIterator: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMakeIterator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMakeIterator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMakeIterator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMakeIterator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeIterator] = [
      .noneMakeIterator,
    ]

  }

  enum malformedLength: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMalformedLength // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMalformedLength
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMalformedLength
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMalformedLength: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.malformedLength] = [
      .noneMalformedLength,
    ]

  }

  enum mapEntry: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMapEntry // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapEntry
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapEntry
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapEntry: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapEntry] = [
      .noneMapEntry,
    ]

  }

  enum MapKeyType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMapKeyType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapKeyType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapKeyType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapKeyType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapKeyType] = [
      .noneMapKeyType,
    ]

  }

  enum mapToMessages: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMapToMessages // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapToMessages
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapToMessages
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapToMessages: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapToMessages] = [
      .noneMapToMessages,
    ]

  }

  enum MapValueType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMapValueType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapValueType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapValueType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapValueType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapValueType] = [
      .noneMapValueType,
    ]

  }

  enum mapVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMapVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMapVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMapVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMapVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapVisitor] = [
      .noneMapVisitor,
    ]

  }

  enum mask: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMask // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMask
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMask
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMask: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mask] = [
      .noneMask,
    ]

  }

  enum maximumEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMaximumEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMaximumEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMaximumEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMaximumEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.maximumEdition] = [
      .noneMaximumEdition,
    ]

  }

  enum mdayStart: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMdayStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMdayStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMdayStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMdayStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mdayStart] = [
      .noneMdayStart,
    ]

  }

  enum merge: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMerge // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMerge
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMerge
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMerge: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.merge] = [
      .noneMerge,
    ]

  }

  enum MergeOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMergeOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMergeOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMergeOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMergeOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MergeOptions] = [
      .noneMergeOptions,
    ]

  }

  enum message: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.message] = [
      .noneMessage,
    ]

  }

  enum messageDepthLimit: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageDepthLimit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageDepthLimit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageDepthLimit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageDepthLimit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageDepthLimit] = [
      .noneMessageDepthLimit,
    ]

  }

  enum messageEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageEncoding] = [
      .noneMessageEncoding,
    ]

  }

  enum MessageExtension: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageExtension] = [
      .noneMessageExtension,
    ]

  }

  enum MessageImplementationBase: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageImplementationBase // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageImplementationBase
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageImplementationBase
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageImplementationBase: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageImplementationBase] = [
      .noneMessageImplementationBase,
    ]

  }

  enum MessageSet: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageSet] = [
      .noneMessageSet,
    ]

  }

  enum messageSetWireFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageSetWireFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageSetWireFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageSetWireFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageSetWireFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSetWireFormat] = [
      .noneMessageSetWireFormat,
    ]

  }

  enum messageSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSize] = [
      .noneMessageSize,
    ]

  }

  enum messageType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMessageType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMessageType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMessageType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMessageType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageType] = [
      .noneMessageType,
    ]

  }

  enum method: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMethod // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMethod
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMethod
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMethod: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.method] = [
      .noneMethod,
    ]

  }

  enum methods: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMethods // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMethods
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMethods
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMethods: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.methods] = [
      .noneMethods,
    ]

  }

  enum min: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMin // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMin
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMin
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMin: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.min] = [
      .noneMin,
    ]

  }

  enum minimumEdition: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMinimumEdition // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMinimumEdition
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMinimumEdition
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMinimumEdition: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minimumEdition] = [
      .noneMinimumEdition,
    ]

  }

  enum minor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMinor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMinor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMinor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMinor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minor] = [
      .noneMinor,
    ]

  }

  enum mixins: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMixins // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMixins
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMixins
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMixins: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mixins] = [
      .noneMixins,
    ]

  }

  enum modify: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneModify // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneModify
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneModify
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneModify: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.modify] = [
      .noneModify,
    ]

  }

  enum month: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMonth // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMonth
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMonth
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMonth: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.month] = [
      .noneMonth,
    ]

  }

  enum msgExtension: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMsgExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMsgExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMsgExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMsgExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.msgExtension] = [
      .noneMsgExtension,
    ]

  }

  enum mutating: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneMutating // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneMutating
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneMutating
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneMutating: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mutating] = [
      .noneMutating,
    ]

  }

  enum n: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case oneN // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .oneN
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .oneN
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .oneN: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.n] = [
      .oneN,
    ]

  }

  enum name: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.name] = [
      .noneName,
    ]

  }

  enum NameDescription: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNameDescription // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNameDescription
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNameDescription
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNameDescription: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameDescription] = [
      .noneNameDescription,
    ]

  }

  enum NameMap: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNameMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNameMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNameMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNameMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameMap] = [
      .noneNameMap,
    ]

  }

  enum NamePart: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNamePart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNamePart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNamePart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNamePart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NamePart] = [
      .noneNamePart,
    ]

  }

  enum names: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNames // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNames
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNames
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNames: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.names] = [
      .noneNames,
    ]

  }

  enum nanos: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNanos // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNanos
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNanos
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNanos: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nanos] = [
      .noneNanos,
    ]

  }

  enum negativeIntValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNegativeIntValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNegativeIntValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNegativeIntValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNegativeIntValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.negativeIntValue] = [
      .noneNegativeIntValue,
    ]

  }

  enum nestedType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNestedType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNestedType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNestedType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNestedType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nestedType] = [
      .noneNestedType,
    ]

  }

  enum newExtensible: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNewExtensible // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewExtensible
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewExtensible
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewExtensible: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newExtensible] = [
      .noneNewExtensible,
    ]

  }

  enum newL: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNewL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newL] = [
      .noneNewL,
    ]

  }

  enum newList: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNewList // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewList
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewList
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewList: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newList] = [
      .noneNewList,
    ]

  }

  enum newMessage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNewMessage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewMessage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewMessage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewMessage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newMessage] = [
      .noneNewMessage,
    ]

  }

  enum newValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNewValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNewValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNewValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNewValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newValue] = [
      .noneNewValue,
    ]

  }

  enum next: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.next] = [
      .noneNext,
    ]

  }

  enum nextByte: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextByte // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextByte
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextByte
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextByte: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextByte] = [
      .noneNextByte,
    ]

  }

  enum nextFieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextFieldNumber] = [
      .noneNextFieldNumber,
    ]

  }

  enum nextInstruction: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextInstruction // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextInstruction
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextInstruction
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextInstruction: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInstruction] = [
      .noneNextInstruction,
    ]

  }

  enum nextInt32: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextInt32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextInt32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextInt32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextInt32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInt32] = [
      .noneNextInt32,
    ]

  }

  enum nextNullTerminatedString: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextNullTerminatedString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextNullTerminatedString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextNullTerminatedString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextNullTerminatedString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedString] = [
      .noneNextNullTerminatedString,
    ]

  }

  enum nextNullTerminatedStringArray: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextNullTerminatedStringArray // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextNullTerminatedStringArray
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextNullTerminatedStringArray
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextNullTerminatedStringArray: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedStringArray] = [
      .noneNextNullTerminatedStringArray,
    ]

  }

  enum nextNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNumber] = [
      .noneNextNumber,
    ]

  }

  enum nextUInt64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextUInt64] = [
      .noneNextUint64,
    ]

  }

  enum nextVarInt: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNextVarInt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNextVarInt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNextVarInt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNextVarInt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextVarInt] = [
      .noneNextVarInt,
    ]

  }

  enum nilEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNil // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNil
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNil
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNil: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilEnum] = [
      .noneNil,
    ]

  }

  enum nilLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNilLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNilLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNilLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNilLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilLiteral] = [
      .noneNilLiteral,
    ]

  }

  enum noBytesAvailable: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNoBytesAvailable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNoBytesAvailable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNoBytesAvailable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNoBytesAvailable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noBytesAvailable] = [
      .noneNoBytesAvailable,
    ]

  }

  enum noStandardDescriptorAccessor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNoStandardDescriptorAccessor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNoStandardDescriptorAccessor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNoStandardDescriptorAccessor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNoStandardDescriptorAccessor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor] = [
      .noneNoStandardDescriptorAccessor,
    ]

  }

  enum nullValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNullValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNullValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNullValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNullValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nullValue] = [
      .noneNullValue,
    ]

  }

  enum number: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.number] = [
      .noneNumber,
    ]

  }

  enum numberValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneNumberValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneNumberValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneNumberValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneNumberValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.numberValue] = [
      .noneNumberValue,
    ]

  }

  enum objcClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneObjcClassPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneObjcClassPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneObjcClassPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneObjcClassPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.objcClassPrefix] = [
      .noneObjcClassPrefix,
    ]

  }

  enum of: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.of] = [
      .noneOf,
    ]

  }

  enum OneOf_Kind: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOneOfKind // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOneOfKind
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOneOfKind
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOneOfKind: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OneOf_Kind] = [
      .noneOneOfKind,
    ]

  }

  enum oneofDecl: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOneofDecl // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOneofDecl
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOneofDecl
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOneofDecl: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofDecl] = [
      .noneOneofDecl,
    ]

  }

  enum oneofIndex: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOneofIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOneofIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOneofIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOneofIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofIndex] = [
      .noneOneofIndex,
    ]

  }

  enum oneofs: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOneofs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOneofs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOneofs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOneofs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofs] = [
      .noneOneofs,
    ]

  }

  enum optimizeFor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptimizeFor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptimizeFor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptimizeFor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptimizeFor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optimizeFor] = [
      .noneOptimizeFor,
    ]

  }

  enum OptimizeMode: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptimizeMode // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptimizeMode
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptimizeMode
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptimizeMode: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptimizeMode] = [
      .noneOptimizeMode,
    ]

  }

  enum OptionalEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptionalEnumExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalEnumExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalEnumExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalEnumExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField] = [
      .noneOptionalEnumExtensionField,
    ]

  }

  enum OptionalExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptionalExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalExtensionField] = [
      .noneOptionalExtensionField,
    ]

  }

  enum OptionalGroupExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptionalGroupExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalGroupExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalGroupExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalGroupExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField] = [
      .noneOptionalGroupExtensionField,
    ]

  }

  enum OptionalMessageExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptionalMessageExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionalMessageExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionalMessageExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionalMessageExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField] = [
      .noneOptionalMessageExtensionField,
    ]

  }

  enum optionDependency: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptionDependency // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionDependency
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionDependency
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionDependency: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optionDependency] = [
      .noneOptionDependency,
    ]

  }

  enum OptionRetention: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptionRetention // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionRetention
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionRetention
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionRetention: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionRetention] = [
      .noneOptionRetention,
    ]

  }

  enum options: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.options] = [
      .noneOptions,
    ]

  }

  enum OptionTargetType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOptionTargetType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOptionTargetType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOptionTargetType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOptionTargetType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionTargetType] = [
      .noneOptionTargetType,
    ]

  }

  enum other: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOther // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOther
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOther
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOther: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.other] = [
      .noneOther,
    ]

  }

  enum others: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOthers // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOthers
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOthers
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOthers: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.others] = [
      .noneOthers,
    ]

  }

  enum out: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOut // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOut
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOut
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOut: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.out] = [
      .noneOut,
    ]

  }

  enum outputType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOutputType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOutputType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOutputType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOutputType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.outputType] = [
      .noneOutputType,
    ]

  }

  enum overridableFeatures: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneOverridableFeatures // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneOverridableFeatures
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneOverridableFeatures
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneOverridableFeatures: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.overridableFeatures] = [
      .noneOverridableFeatures,
    ]

  }

  enum p: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneP // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneP
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneP
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneP: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.p] = [
      .noneP,
    ]

  }

  enum package: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.package] = [
      .nonePackage,
    ]

  }

  enum packed: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePacked // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePacked
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePacked
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePacked: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packed] = [
      .nonePacked,
    ]

  }

  enum PackedEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePackedEnumExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePackedEnumExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePackedEnumExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePackedEnumExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField] = [
      .nonePackedEnumExtensionField,
    ]

  }

  enum PackedExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePackedExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePackedExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePackedExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePackedExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField] = [
      .nonePackedExtensionField,
    ]

  }

  enum padding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePadding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePadding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePadding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePadding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding] = [
      .nonePadding,
    ]

  }

  enum parent: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneParent // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneParent
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneParent
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneParent: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent] = [
      .noneParent,
    ]

  }

  enum parse: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneParse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneParse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneParse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneParse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse] = [
      .noneParse,
    ]

  }

  enum partial: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePartial // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePartial
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePartial
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePartial: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.partial] = [
      .nonePartial,
    ]

  }

  enum path: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePath // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePath
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePath
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePath: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path] = [
      .nonePath,
    ]

  }

  enum PathDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePathDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePathDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePathDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePathDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecoder] = [
      .nonePathDecoder,
    ]

  }

  enum PathDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePathDecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePathDecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePathDecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePathDecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecodingError] = [
      .nonePathDecodingError,
    ]

  }

  enum paths: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePaths // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePaths
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePaths
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePaths: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths] = [
      .nonePaths,
    ]

  }

  enum PathVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePathVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePathVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePathVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePathVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathVisitor] = [
      .nonePathVisitor,
    ]

  }

  enum payload: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePayload // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePayload
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePayload
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePayload: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload] = [
      .nonePayload,
    ]

  }

  enum payloadSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePayloadSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePayloadSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePayloadSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePayloadSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize] = [
      .nonePayloadSize,
    ]

  }

  enum phpClassPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePhpClassPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePhpClassPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePhpClassPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePhpClassPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix] = [
      .nonePhpClassPrefix,
    ]

  }

  enum phpMetadataNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePhpMetadataNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePhpMetadataNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePhpMetadataNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePhpMetadataNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace] = [
      .nonePhpMetadataNamespace,
    ]

  }

  enum phpNamespace: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePhpNamespace // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePhpNamespace
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePhpNamespace
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePhpNamespace: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace] = [
      .nonePhpNamespace,
    ]

  }

  enum pos: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePos // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePos
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePos
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePos: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos] = [
      .nonePos,
    ]

  }

  enum positiveIntValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePositiveIntValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePositiveIntValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePositiveIntValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePositiveIntValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue] = [
      .nonePositiveIntValue,
    ]

  }

  enum prefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix] = [
      .nonePrefix,
    ]

  }

  enum preserveProtoFieldNames: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePreserveProtoFieldNames // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePreserveProtoFieldNames
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePreserveProtoFieldNames
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePreserveProtoFieldNames: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames] = [
      .nonePreserveProtoFieldNames,
    ]

  }

  enum preTraverse: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePreTraverse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePreTraverse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePreTraverse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePreTraverse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse] = [
      .nonePreTraverse,
    ]

  }

  enum previousNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePreviousNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePreviousNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePreviousNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePreviousNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.previousNumber] = [
      .nonePreviousNumber,
    ]

  }

  enum prevPath: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePrevPath // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePrevPath
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePrevPath
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePrevPath: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prevPath] = [
      .nonePrevPath,
    ]

  }

  enum printUnknownFields: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePrintUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePrintUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePrintUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePrintUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields] = [
      .nonePrintUnknownFields,
    ]

  }

  enum programBuffer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProgramBuffer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProgramBuffer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProgramBuffer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProgramBuffer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programBuffer] = [
      .noneProgramBuffer,
    ]

  }

  enum programFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProgramFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProgramFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProgramFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProgramFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programFormat] = [
      .noneProgramFormat,
    ]

  }

  enum proto2: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProto2 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProto2
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProto2
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProto2: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2] = [
      .noneProto2,
    ]

  }

  enum proto3DefaultValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProto3DefaultValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProto3DefaultValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProto3DefaultValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProto3DefaultValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue] = [
      .noneProto3DefaultValue,
    ]

  }

  enum proto3Optional: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProto3Optional // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProto3Optional
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProto3Optional
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProto3Optional: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional] = [
      .noneProto3Optional,
    ]

  }

  enum protobuf_extensionFieldValues: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufExtensionFieldValues // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufExtensionFieldValues
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufExtensionFieldValues
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufExtensionFieldValues: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues] = [
      .noneProtobufExtensionFieldValues,
    ]

  }

  enum protobuf_fieldNumber: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufFieldNumber // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFieldNumber
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFieldNumber
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFieldNumber: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber] = [
      .noneProtobufFieldNumber,
    ]

  }

  enum protobuf_generated_isEqualTo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufGeneratedIsEqualTo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufGeneratedIsEqualTo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufGeneratedIsEqualTo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufGeneratedIsEqualTo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo] = [
      .noneProtobufGeneratedIsEqualTo,
    ]

  }

  enum protobuf_nameMap: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufNameMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufNameMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufNameMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufNameMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap] = [
      .noneProtobufNameMap,
    ]

  }

  enum protobuf_newField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufNewField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufNewField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufNewField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufNewField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField] = [
      .noneProtobufNewField,
    ]

  }

  enum protobuf_package: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package] = [
      .noneProtobufPackage,
    ]

  }

  enum ProtobufAPIVersion_2: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufApiversion2 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufApiversion2
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufApiversion2
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufApiversion2: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2] = [
      .noneProtobufApiversion2,
    ]

  }

  enum ProtobufAPIVersionCheck: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufApiversionCheck // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufApiversionCheck
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufApiversionCheck
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufApiversionCheck: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck] = [
      .noneProtobufApiversionCheck,
    ]

  }

  enum ProtobufBool: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufBool // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufBool
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufBool
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufBool: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool] = [
      .noneProtobufBool,
    ]

  }

  enum ProtobufBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes] = [
      .noneProtobufBytes,
    ]

  }

  enum protobufData: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufData] = [
      .noneProtobufData,
    ]

  }

  enum ProtobufDouble: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufDouble // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufDouble
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufDouble
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufDouble: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble] = [
      .noneProtobufDouble,
    ]

  }

  enum ProtobufEnumMap: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufEnumMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufEnumMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufEnumMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufEnumMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap] = [
      .noneProtobufEnumMap,
    ]

  }

  enum protobufExtension: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufExtension // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufExtension
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufExtension
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufExtension: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension] = [
      .noneProtobufExtension,
    ]

  }

  enum ProtobufFixed32: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufFixed32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFixed32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFixed32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFixed32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32] = [
      .noneProtobufFixed32,
    ]

  }

  enum ProtobufFixed64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufFixed64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFixed64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFixed64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFixed64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64] = [
      .noneProtobufFixed64,
    ]

  }

  enum ProtobufFloat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufFloat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufFloat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufFloat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufFloat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat] = [
      .noneProtobufFloat,
    ]

  }

  enum ProtobufInt32: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufInt32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufInt32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufInt32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufInt32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32] = [
      .noneProtobufInt32,
    ]

  }

  enum ProtobufInt64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufInt64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufInt64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufInt64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufInt64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64] = [
      .noneProtobufInt64,
    ]

  }

  enum ProtobufMap: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap] = [
      .noneProtobufMap,
    ]

  }

  enum ProtobufMessageMap: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufMessageMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufMessageMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufMessageMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufMessageMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap] = [
      .noneProtobufMessageMap,
    ]

  }

  enum ProtobufSFixed32: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufSfixed32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSfixed32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSfixed32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSfixed32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32] = [
      .noneProtobufSfixed32,
    ]

  }

  enum ProtobufSFixed64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufSfixed64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSfixed64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSfixed64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSfixed64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64] = [
      .noneProtobufSfixed64,
    ]

  }

  enum ProtobufSInt32: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufSint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32] = [
      .noneProtobufSint32,
    ]

  }

  enum ProtobufSInt64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufSint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufSint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufSint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufSint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64] = [
      .noneProtobufSint64,
    ]

  }

  enum ProtobufString: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString] = [
      .noneProtobufString,
    ]

  }

  enum ProtobufUInt32: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufUint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufUint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufUint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufUint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32] = [
      .noneProtobufUint32,
    ]

  }

  enum ProtobufUInt64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtobufUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtobufUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtobufUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtobufUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64] = [
      .noneProtobufUint64,
    ]

  }

  enum protocolEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtocol // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtocol
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtocol
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtocol: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum] = [
      .noneProtocol,
    ]

  }

  enum protoFieldName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtoFieldName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoFieldName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoFieldName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoFieldName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName] = [
      .noneProtoFieldName,
    ]

  }

  enum protoMessageNameEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtoMessageName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoMessageName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoMessageName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoMessageName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum] = [
      .noneProtoMessageName,
    ]

  }

  enum ProtoNameProviding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtoNameProviding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoNameProviding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoNameProviding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoNameProviding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding] = [
      .noneProtoNameProviding,
    ]

  }

  enum protoPaths: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneProtoPaths // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneProtoPaths
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneProtoPaths
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneProtoPaths: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths] = [
      .noneProtoPaths,
    ]

  }

  enum publicEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePublic // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePublic
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePublic
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePublic: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum] = [
      .nonePublic,
    ]

  }

  enum publicDependency: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePublicDependency // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePublicDependency
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePublicDependency
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePublicDependency: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency] = [
      .nonePublicDependency,
    ]

  }

  enum putBoolValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutBoolValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutBoolValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutBoolValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutBoolValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue] = [
      .nonePutBoolValue,
    ]

  }

  enum putBytesValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutBytesValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutBytesValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutBytesValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutBytesValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue] = [
      .nonePutBytesValue,
    ]

  }

  enum putDoubleValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutDoubleValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutDoubleValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutDoubleValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutDoubleValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue] = [
      .nonePutDoubleValue,
    ]

  }

  enum putEnumValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutEnumValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutEnumValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutEnumValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutEnumValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue] = [
      .nonePutEnumValue,
    ]

  }

  enum putFixedUInt32: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutFixedUint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutFixedUint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutFixedUint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutFixedUint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32] = [
      .nonePutFixedUint32,
    ]

  }

  enum putFixedUInt64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutFixedUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutFixedUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutFixedUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutFixedUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64] = [
      .nonePutFixedUint64,
    ]

  }

  enum putFloatValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutFloatValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutFloatValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutFloatValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutFloatValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue] = [
      .nonePutFloatValue,
    ]

  }

  enum putInt64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutInt64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutInt64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutInt64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutInt64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64] = [
      .nonePutInt64,
    ]

  }

  enum putStringValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue] = [
      .nonePutStringValue,
    ]

  }

  enum putUInt64: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64] = [
      .nonePutUint64,
    ]

  }

  enum putUInt64Hex: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutUint64Hex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutUint64Hex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutUint64Hex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutUint64Hex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex] = [
      .nonePutUint64Hex,
    ]

  }

  enum putVarInt: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutVarInt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutVarInt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutVarInt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutVarInt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt] = [
      .nonePutVarInt,
    ]

  }

  enum putZigZagVarInt: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePutZigZagVarInt // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePutZigZagVarInt
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePutZigZagVarInt
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePutZigZagVarInt: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt] = [
      .nonePutZigZagVarInt,
    ]

  }

  enum pyGenericServices: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case nonePyGenericServices // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .nonePyGenericServices
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .nonePyGenericServices
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .nonePyGenericServices: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices] = [
      .nonePyGenericServices,
    ]

  }

  enum R: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneR // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneR
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneR
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneR: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R] = [
      .noneR,
    ]

  }

  enum rawChars: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRawChars // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRawChars
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRawChars
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRawChars: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars] = [
      .noneRawChars,
    ]

  }

  enum RawRepresentable: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRawRepresentable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRawRepresentable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRawRepresentable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRawRepresentable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable] = [
      .noneRawRepresentable,
    ]

  }

  enum RawValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRawValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRawValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRawValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRawValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue] = [
      .noneRawValue,
    ]

  }

  enum read4HexDigits: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRead4HexDigits // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRead4HexDigits
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRead4HexDigits
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRead4HexDigits: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits] = [
      .noneRead4HexDigits,
    ]

  }

  enum readBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneReadBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneReadBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneReadBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneReadBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes] = [
      .noneReadBytes,
    ]

  }

  enum reader: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneReader // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneReader
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneReader
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneReader: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.reader] = [
      .noneReader,
    ]

  }

  enum register: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRegister // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRegister
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRegister
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRegister: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register] = [
      .noneRegister,
    ]

  }

  enum remainingProgram: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRemainingProgram // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRemainingProgram
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRemainingProgram
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRemainingProgram: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.remainingProgram] = [
      .noneRemainingProgram,
    ]

  }

  enum removalError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRemovalError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRemovalError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRemovalError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRemovalError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removalError] = [
      .noneRemovalError,
    ]

  }

  enum removingAllFieldsOf: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRemovingAllFieldsOf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRemovingAllFieldsOf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRemovingAllFieldsOf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRemovingAllFieldsOf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removingAllFieldsOf] = [
      .noneRemovingAllFieldsOf,
    ]

  }

  enum repeated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRepeated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated] = [
      .noneRepeated,
    ]

  }

  enum RepeatedEnumExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRepeatedEnumExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedEnumExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedEnumExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedEnumExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField] = [
      .noneRepeatedEnumExtensionField,
    ]

  }

  enum RepeatedExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRepeatedExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField] = [
      .noneRepeatedExtensionField,
    ]

  }

  enum repeatedFieldEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRepeatedFieldEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedFieldEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedFieldEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedFieldEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding] = [
      .noneRepeatedFieldEncoding,
    ]

  }

  enum RepeatedGroupExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRepeatedGroupExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedGroupExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedGroupExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedGroupExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField] = [
      .noneRepeatedGroupExtensionField,
    ]

  }

  enum RepeatedMessageExtensionField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRepeatedMessageExtensionField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeatedMessageExtensionField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeatedMessageExtensionField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeatedMessageExtensionField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField] = [
      .noneRepeatedMessageExtensionField,
    ]

  }

  enum repeating: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRepeating // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRepeating
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRepeating
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRepeating: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating] = [
      .noneRepeating,
    ]

  }

  enum replaceRepeatedFields: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneReplaceRepeatedFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneReplaceRepeatedFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneReplaceRepeatedFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneReplaceRepeatedFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.replaceRepeatedFields] = [
      .noneReplaceRepeatedFields,
    ]

  }

  enum requestStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRequestStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRequestStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRequestStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRequestStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming] = [
      .noneRequestStreaming,
    ]

  }

  enum requestTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRequestTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRequestTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRequestTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRequestTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL] = [
      .noneRequestTypeURL,
    ]

  }

  enum requiredSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRequiredSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRequiredSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRequiredSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRequiredSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize] = [
      .noneRequiredSize,
    ]

  }

  enum responseStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneResponseStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneResponseStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneResponseStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneResponseStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming] = [
      .noneResponseStreaming,
    ]

  }

  enum responseTypeURL: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneResponseTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneResponseTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneResponseTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneResponseTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL] = [
      .noneResponseTypeURL,
    ]

  }

  enum result: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result] = [
      .noneResult,
    ]

  }

  enum retention: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRetention // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRetention
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRetention
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRetention: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention] = [
      .noneRetention,
    ]

  }

  enum rethrowsEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRethrows // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRethrows
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRethrows
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRethrows: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum] = [
      .noneRethrows,
    ]

  }

  enum ReturnType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneReturnType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneReturnType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneReturnType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneReturnType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType] = [
      .noneReturnType,
    ]

  }

  enum revision: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRevision // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRevision
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRevision
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRevision: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision] = [
      .noneRevision,
    ]

  }

  enum rhs: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRhs // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRhs
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRhs
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRhs: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs] = [
      .noneRhs,
    ]

  }

  enum root: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRoot // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRoot
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRoot
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRoot: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root] = [
      .noneRoot,
    ]

  }

  enum rubyPackage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneRubyPackage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneRubyPackage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneRubyPackage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneRubyPackage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage] = [
      .noneRubyPackage,
    ]

  }

  enum s: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneS // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneS
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneS
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneS: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s] = [
      .noneS,
    ]

  }

  enum sawBackslash: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSawBackslash // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSawBackslash
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSawBackslash
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSawBackslash: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash] = [
      .noneSawBackslash,
    ]

  }

  enum sawSection4Characters: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSawSection4Characters // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSawSection4Characters
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSawSection4Characters
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSawSection4Characters: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters] = [
      .noneSawSection4Characters,
    ]

  }

  enum sawSection5Characters: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSawSection5Characters // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSawSection5Characters
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSawSection5Characters
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSawSection5Characters: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters] = [
      .noneSawSection5Characters,
    ]

  }

  enum Scalar: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneScalar // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneScalar
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneScalar
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneScalar: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Scalar] = [
      .noneScalar,
    ]

  }

  enum scan: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneScan // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneScan
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneScan
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneScan: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scan] = [
      .noneScan,
    ]

  }

  enum scanner: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneScanner // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneScanner
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneScanner
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneScanner: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner] = [
      .noneScanner,
    ]

  }

  enum seconds: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSeconds // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSeconds
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSeconds
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSeconds: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds] = [
      .noneSeconds,
    ]

  }

  enum selfEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSelf // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSelf
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSelf
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSelf: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum] = [
      .noneSelf,
    ]

  }

  enum semantic: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSemantic // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSemantic
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSemantic
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSemantic: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic] = [
      .noneSemantic,
    ]

  }

  enum SendableEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSendable // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSendable
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSendable
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSendable: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum] = [
      .noneSendable,
    ]

  }

  enum separator: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSeparator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSeparator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSeparator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSeparator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator] = [
      .noneSeparator,
    ]

  }

  enum serialize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSerialize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSerialize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSerialize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSerialize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize] = [
      .noneSerialize,
    ]

  }

  enum serializedBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSerializedBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSerializedBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSerializedBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSerializedBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes] = [
      .noneSerializedBytes,
    ]

  }

  enum serializedData: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSerializedData // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSerializedData
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSerializedData
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSerializedData: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData] = [
      .noneSerializedData,
    ]

  }

  enum serializedSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSerializedSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSerializedSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSerializedSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSerializedSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize] = [
      .noneSerializedSize,
    ]

  }

  enum serverStreaming: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneServerStreaming // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneServerStreaming
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneServerStreaming
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneServerStreaming: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming] = [
      .noneServerStreaming,
    ]

  }

  enum service: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneService // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneService
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneService
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneService: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service] = [
      .noneService,
    ]

  }

  enum set: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set] = [
      .noneSet,
    ]

  }

  enum setExtensionValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSetExtensionValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSetExtensionValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSetExtensionValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSetExtensionValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue] = [
      .noneSetExtensionValue,
    ]

  }

  enum shift: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneShift // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneShift
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneShift
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneShift: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift] = [
      .noneShift,
    ]

  }

  enum SimpleExtensionMap: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSimpleExtensionMap // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSimpleExtensionMap
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSimpleExtensionMap
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSimpleExtensionMap: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap] = [
      .noneSimpleExtensionMap,
    ]

  }

  enum size: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.size] = [
      .noneSize,
    ]

  }

  enum sizer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSizer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSizer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSizer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSizer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sizer] = [
      .noneSizer,
    ]

  }

  enum source: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSource // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSource
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSource
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSource: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.source] = [
      .noneSource,
    ]

  }

  enum sourceCodeInfo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSourceCodeInfo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSourceCodeInfo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSourceCodeInfo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSourceCodeInfo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceCodeInfo] = [
      .noneSourceCodeInfo,
    ]

  }

  enum sourceContext: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSourceContext // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSourceContext
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSourceContext
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSourceContext: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceContext] = [
      .noneSourceContext,
    ]

  }

  enum sourceEncoding: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSourceEncoding // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSourceEncoding
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSourceEncoding
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSourceEncoding: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceEncoding] = [
      .noneSourceEncoding,
    ]

  }

  enum sourceFile: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSourceFile // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSourceFile
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSourceFile
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSourceFile: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceFile] = [
      .noneSourceFile,
    ]

  }

  enum SourceLocation: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSourceLocation // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSourceLocation
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSourceLocation
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSourceLocation: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SourceLocation] = [
      .noneSourceLocation,
    ]

  }

  enum span: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSpan // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSpan
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSpan
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSpan: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.span] = [
      .noneSpan,
    ]

  }

  enum split: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSplit // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSplit
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSplit
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSplit: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.split] = [
      .noneSplit,
    ]

  }

  enum start: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.start] = [
      .noneStart,
    ]

  }

  enum startArray: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStartArray // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartArray
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartArray
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartArray: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArray] = [
      .noneStartArray,
    ]

  }

  enum startArrayObject: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStartArrayObject // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartArrayObject
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartArrayObject
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartArrayObject: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArrayObject] = [
      .noneStartArrayObject,
    ]

  }

  enum startField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStartField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startField] = [
      .noneStartField,
    ]

  }

  enum startIndex: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStartIndex // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartIndex
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartIndex
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartIndex: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startIndex] = [
      .noneStartIndex,
    ]

  }

  enum startMessageField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStartMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startMessageField] = [
      .noneStartMessageField,
    ]

  }

  enum startObject: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStartObject // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartObject
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartObject
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartObject: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startObject] = [
      .noneStartObject,
    ]

  }

  enum startRegularField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStartRegularField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStartRegularField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStartRegularField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStartRegularField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startRegularField] = [
      .noneStartRegularField,
    ]

  }

  enum state: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneState // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneState
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneState
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneState: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.state] = [
      .noneState,
    ]

  }

  enum staticEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStatic // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStatic
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStatic
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStatic: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.staticEnum] = [
      .noneStatic,
    ]

  }

  enum StaticString: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStaticString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStaticString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStaticString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStaticString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StaticString] = [
      .noneStaticString,
    ]

  }

  enum storage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.storage] = [
      .noneStorage,
    ]

  }

  enum StringEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringEnum] = [
      .noneString,
    ]

  }

  enum stringLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStringLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringLiteral] = [
      .noneStringLiteral,
    ]

  }

  enum StringLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStringLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringLiteralType] = [
      .noneStringLiteralType,
    ]

  }

  enum stringResult: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStringResult // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringResult
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringResult
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringResult: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringResult] = [
      .noneStringResult,
    ]

  }

  enum stringValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStringValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStringValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStringValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStringValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringValue] = [
      .noneStringValue,
    ]

  }

  enum structEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStruct // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStruct
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStruct
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStruct: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structEnum] = [
      .noneStruct,
    ]

  }

  enum structValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneStructValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneStructValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneStructValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneStructValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structValue] = [
      .noneStructValue,
    ]

  }

  enum subDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSubDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSubDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSubDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSubDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subDecoder] = [
      .noneSubDecoder,
    ]

  }

  enum subscriptEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSubscript // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSubscript
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSubscript
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSubscript: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subscriptEnum] = [
      .noneSubscript,
    ]

  }

  enum subtract: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSubtract // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSubtract
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSubtract
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSubtract: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subtract] = [
      .noneSubtract,
    ]

  }

  enum subVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSubVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSubVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSubVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSubVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subVisitor] = [
      .noneSubVisitor,
    ]

  }

  enum SwiftEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSwift // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSwift
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSwift
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSwift: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftEnum] = [
      .noneSwift,
    ]

  }

  enum swiftPrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSwiftPrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSwiftPrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSwiftPrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSwiftPrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.swiftPrefix] = [
      .noneSwiftPrefix,
    ]

  }

  enum SwiftProtobufContiguousBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSwiftProtobufContiguousBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSwiftProtobufContiguousBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSwiftProtobufContiguousBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSwiftProtobufContiguousBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufContiguousBytes] = [
      .noneSwiftProtobufContiguousBytes,
    ]

  }

  enum SwiftProtobufError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSwiftProtobufError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSwiftProtobufError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSwiftProtobufError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSwiftProtobufError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufError] = [
      .noneSwiftProtobufError,
    ]

  }

  enum syntax: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneSyntax // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneSyntax
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneSyntax
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneSyntax: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.syntax] = [
      .noneSyntax,
    ]

  }

  enum T: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneT // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneT
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneT
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneT: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.T] = [
      .noneT,
    ]

  }

  enum tag: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTag // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTag
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTag
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTag: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tag] = [
      .noneTag,
    ]

  }

  enum targets: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTargets // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTargets
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTargets
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTargets: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.targets] = [
      .noneTargets,
    ]

  }

  enum terminator: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTerminator // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTerminator
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTerminator
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTerminator: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.terminator] = [
      .noneTerminator,
    ]

  }

  enum testDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTestDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTestDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTestDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTestDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.testDecoder] = [
      .noneTestDecoder,
    ]

  }

  enum text: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneText // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneText
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneText
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneText: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.text] = [
      .noneText,
    ]

  }

  enum textDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTextDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textDecoder] = [
      .noneTextDecoder,
    ]

  }

  enum TextFormatDecoder: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTextFormatDecoder // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatDecoder
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatDecoder
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatDecoder: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecoder] = [
      .noneTextFormatDecoder,
    ]

  }

  enum TextFormatDecodingError: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTextFormatDecodingError // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatDecodingError
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatDecodingError
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatDecodingError: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingError] = [
      .noneTextFormatDecodingError,
    ]

  }

  enum TextFormatDecodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTextFormatDecodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatDecodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatDecodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatDecodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions] = [
      .noneTextFormatDecodingOptions,
    ]

  }

  enum TextFormatEncodingOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTextFormatEncodingOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatEncodingOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatEncodingOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatEncodingOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions] = [
      .noneTextFormatEncodingOptions,
    ]

  }

  enum TextFormatEncodingVisitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTextFormatEncodingVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatEncodingVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatEncodingVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatEncodingVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor] = [
      .noneTextFormatEncodingVisitor,
    ]

  }

  enum textFormatString: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTextFormatString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTextFormatString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTextFormatString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTextFormatString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textFormatString] = [
      .noneTextFormatString,
    ]

  }

  enum throwOrIgnore: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneThrowOrIgnore // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneThrowOrIgnore
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneThrowOrIgnore
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneThrowOrIgnore: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwOrIgnore] = [
      .noneThrowOrIgnore,
    ]

  }

  enum throwsEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneThrows // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneThrows
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneThrows
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneThrows: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwsEnum] = [
      .noneThrows,
    ]

  }

  enum timeInterval: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTimeInterval // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTimeInterval
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTimeInterval
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTimeInterval: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeInterval] = [
      .noneTimeInterval,
    ]

  }

  enum timeIntervalSince1970: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTimeIntervalSince1970 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTimeIntervalSince1970
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTimeIntervalSince1970
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTimeIntervalSince1970: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSince1970] = [
      .noneTimeIntervalSince1970,
    ]

  }

  enum timeIntervalSinceReferenceDate: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTimeIntervalSinceReferenceDate // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTimeIntervalSinceReferenceDate
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTimeIntervalSinceReferenceDate
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTimeIntervalSinceReferenceDate: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate] = [
      .noneTimeIntervalSinceReferenceDate,
    ]

  }

  enum tmp: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTmp // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTmp
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTmp
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTmp: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tmp] = [
      .noneTmp,
    ]

  }

  enum tooLarge: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTooLarge // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTooLarge
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTooLarge
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTooLarge: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tooLarge] = [
      .noneTooLarge,
    ]

  }

  enum total: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTotal // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTotal
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTotal
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTotal: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.total] = [
      .noneTotal,
    ]

  }

  enum totalArrayDepth: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTotalArrayDepth // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTotalArrayDepth
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTotalArrayDepth
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTotalArrayDepth: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalArrayDepth] = [
      .noneTotalArrayDepth,
    ]

  }

  enum totalSize: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTotalSize // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTotalSize
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTotalSize
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTotalSize: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalSize] = [
      .noneTotalSize,
    ]

  }

  enum trailingComments: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTrailingComments // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTrailingComments
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTrailingComments
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTrailingComments: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trailingComments] = [
      .noneTrailingComments,
    ]

  }

  enum traverseEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTraverse // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTraverse
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTraverse
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTraverse: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.traverseEnum] = [
      .noneTraverse,
    ]

  }

  enum trim: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTrim // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTrim
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTrim
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTrim: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trim] = [
      .noneTrim,
    ]

  }

  enum trueEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTrue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTrue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTrue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTrue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trueEnum] = [
      .noneTrue,
    ]

  }

  enum tryEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTry // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTry
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTry
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTry: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tryEnum] = [
      .noneTry,
    ]

  }

  enum type: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.type] = [
      .noneType,
    ]

  }

  enum typealiasEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTypealias // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypealias
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypealias
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypealias: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typealiasEnum] = [
      .noneTypealias,
    ]

  }

  enum TypeEnumEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTypeEnum // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeEnum
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeEnum
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeEnum: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TypeEnumEnum] = [
      .noneTypeEnum,
    ]

  }

  enum typeName: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTypeName // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeName
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeName
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeName: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeName] = [
      .noneTypeName,
    ]

  }

  enum typePrefix: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTypePrefix // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypePrefix
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypePrefix
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypePrefix: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typePrefix] = [
      .noneTypePrefix,
    ]

  }

  enum typeStart: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTypeStart // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeStart
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeStart
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeStart: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeStart] = [
      .noneTypeStart,
    ]

  }

  enum typeUnknown: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTypeUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeUnknown] = [
      .noneTypeUnknown,
    ]

  }

  enum typeURL: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneTypeURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneTypeURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneTypeURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneTypeURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeURL] = [
      .noneTypeURL,
    ]

  }

  enum UInt32Enum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUint32 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint32
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint32
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint32: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt32Enum] = [
      .noneUint32,
    ]

  }

  enum UInt64Enum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUint64 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint64
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint64
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint64: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt64Enum] = [
      .noneUint64,
    ]

  }

  enum UInt8: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUint8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUint8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUint8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUint8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt8] = [
      .noneUint8,
    ]

  }

  enum unchecked: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnchecked // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnchecked
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnchecked
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnchecked: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unchecked] = [
      .noneUnchecked,
    ]

  }

  enum Unicode: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnicode // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicode
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicode
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicode: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Unicode] = [
      .noneUnicode,
    ]

  }

  enum unicodeScalarLiteral: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnicodeScalarLiteral // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalarLiteral
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalarLiteral
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalarLiteral: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalarLiteral] = [
      .noneUnicodeScalarLiteral,
    ]

  }

  enum UnicodeScalarLiteralType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnicodeScalarLiteralType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalarLiteralType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalarLiteralType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalarLiteralType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType] = [
      .noneUnicodeScalarLiteralType,
    ]

  }

  enum unicodeScalars: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnicodeScalars // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalars
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalars
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalars: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalars] = [
      .noneUnicodeScalars,
    ]

  }

  enum UnicodeScalarView: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnicodeScalarView // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnicodeScalarView
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnicodeScalarView
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnicodeScalarView: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarView] = [
      .noneUnicodeScalarView,
    ]

  }

  enum uninterpretedOption: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUninterpretedOption // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUninterpretedOption
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUninterpretedOption
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUninterpretedOption: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uninterpretedOption] = [
      .noneUninterpretedOption,
    ]

  }

  enum union: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnion // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnion
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnion
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnion: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.union] = [
      .noneUnion,
    ]

  }

  enum uniqueStorage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUniqueStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUniqueStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUniqueStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUniqueStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uniqueStorage] = [
      .noneUniqueStorage,
    ]

  }

  enum unknown: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknown] = [
      .noneUnknown,
    ]

  }

  enum unknownFieldsEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnknownFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnknownFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnknownFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnknownFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknownFieldsEnum] = [
      .noneUnknownFields,
    ]

  }

  enum UnknownStorage: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnknownStorage // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnknownStorage
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnknownStorage
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnknownStorage: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnknownStorage] = [
      .noneUnknownStorage,
    ]

  }

  enum unpackTo: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnpackTo // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnpackTo
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnpackTo
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnpackTo: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unpackTo] = [
      .noneUnpackTo,
    ]

  }

  enum UnsafeBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnsafeBufferPointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeBufferPointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeBufferPointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeBufferPointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeBufferPointer] = [
      .noneUnsafeBufferPointer,
    ]

  }

  enum UnsafeMutablePointer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnsafeMutablePointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeMutablePointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeMutablePointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeMutablePointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutablePointer] = [
      .noneUnsafeMutablePointer,
    ]

  }

  enum UnsafeMutableRawBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnsafeMutableRawBufferPointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeMutableRawBufferPointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeMutableRawBufferPointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeMutableRawBufferPointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer] = [
      .noneUnsafeMutableRawBufferPointer,
    ]

  }

  enum UnsafeRawBufferPointer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnsafeRawBufferPointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeRawBufferPointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeRawBufferPointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeRawBufferPointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer] = [
      .noneUnsafeRawBufferPointer,
    ]

  }

  enum UnsafeRawPointer: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnsafeRawPointer // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnsafeRawPointer
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnsafeRawPointer
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnsafeRawPointer: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawPointer] = [
      .noneUnsafeRawPointer,
    ]

  }

  enum unverifiedLazy: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUnverifiedLazy // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUnverifiedLazy
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUnverifiedLazy
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUnverifiedLazy: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unverifiedLazy] = [
      .noneUnverifiedLazy,
    ]

  }

  enum updatedOptions: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUpdatedOptions // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUpdatedOptions
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUpdatedOptions
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUpdatedOptions: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.updatedOptions] = [
      .noneUpdatedOptions,
    ]

  }

  enum uppercasedAssumingASCII: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUppercasedAssumingAscii // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUppercasedAssumingAscii
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUppercasedAssumingAscii
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUppercasedAssumingAscii: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uppercasedAssumingASCII] = [
      .noneUppercasedAssumingAscii,
    ]

  }

  enum url: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneURL // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneURL
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneURL
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneURL: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.url] = [
      .noneURL,
    ]

  }

  enum useDeterministicOrdering: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUseDeterministicOrdering // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUseDeterministicOrdering
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUseDeterministicOrdering
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUseDeterministicOrdering: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.useDeterministicOrdering] = [
      .noneUseDeterministicOrdering,
    ]

  }

  enum utf8: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUtf8 // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8] = [
      .noneUtf8,
    ]

  }

  enum utf8Ptr: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUtf8Ptr // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8Ptr
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8Ptr
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8Ptr: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Ptr] = [
      .noneUtf8Ptr,
    ]

  }

  enum utf8ToDouble: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUtf8ToDouble // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8ToDouble
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8ToDouble
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8ToDouble: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8ToDouble] = [
      .noneUtf8ToDouble,
    ]

  }

  enum utf8Validation: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUtf8Validation // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8Validation
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8Validation
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8Validation: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Validation] = [
      .noneUtf8Validation,
    ]

  }

  enum UTF8View: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneUtf8View // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneUtf8View
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneUtf8View
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneUtf8View: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UTF8View] = [
      .noneUtf8View,
    ]

  }

  enum V: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneV // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneV
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneV
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneV: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.V] = [
      .noneV,
    ]

  }

  enum value: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.value] = [
      .noneValue,
    ]

  }

  enum valueField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneValueField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValueField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValueField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValueField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.valueField] = [
      .noneValueField,
    ]

  }

  enum values: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneValues // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValues
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValues
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValues: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.values] = [
      .noneValues,
    ]

  }

  enum ValueType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneValueType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneValueType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneValueType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneValueType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ValueType] = [
      .noneValueType,
    ]

  }

  enum varEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVar // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVar
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVar
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVar: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.varEnum] = [
      .noneVar,
    ]

  }

  enum verification: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVerification // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVerification
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVerification
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVerification: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.verification] = [
      .noneVerification,
    ]

  }

  enum VerificationState: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVerificationState // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVerificationState
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVerificationState
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVerificationState: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VerificationState] = [
      .noneVerificationState,
    ]

  }

  enum version: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVersion // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVersion
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVersion
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVersion: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.version] = [
      .noneVersion,
    ]

  }

  enum versionString: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVersionString // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVersionString
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVersionString
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVersionString: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.versionString] = [
      .noneVersionString,
    ]

  }

  enum visibility: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisibility // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisibility
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisibility
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisibility: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visibility] = [
      .noneVisibility,
    ]

  }

  enum VisibilityFeature: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisibilityFeature // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisibilityFeature
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisibilityFeature
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisibilityFeature: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VisibilityFeature] = [
      .noneVisibilityFeature,
    ]

  }

  enum visitExtensionFields: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitExtensionFields // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitExtensionFields
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitExtensionFields
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitExtensionFields: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFields] = [
      .noneVisitExtensionFields,
    ]

  }

  enum visitExtensionFieldsAsMessageSet: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitExtensionFieldsAsMessageSet // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitExtensionFieldsAsMessageSet
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitExtensionFieldsAsMessageSet
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitExtensionFieldsAsMessageSet: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet] = [
      .noneVisitExtensionFieldsAsMessageSet,
    ]

  }

  enum visitMapField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitMapField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitMapField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitMapField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitMapField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitMapField] = [
      .noneVisitMapField,
    ]

  }

  enum Visitor: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitor // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitor
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitor
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitor: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Visitor] = [
      .noneVisitor,
    ]

  }

  enum visitPacked: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPacked // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPacked
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPacked
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPacked: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPacked] = [
      .noneVisitPacked,
    ]

  }

  enum visitPackedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedBoolField] = [
      .noneVisitPackedBoolField,
    ]

  }

  enum visitPackedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedDoubleField] = [
      .noneVisitPackedDoubleField,
    ]

  }

  enum visitPackedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedEnumField] = [
      .noneVisitPackedEnumField,
    ]

  }

  enum visitPackedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed32Field] = [
      .noneVisitPackedFixed32Field,
    ]

  }

  enum visitPackedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed64Field] = [
      .noneVisitPackedFixed64Field,
    ]

  }

  enum visitPackedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFloatField] = [
      .noneVisitPackedFloatField,
    ]

  }

  enum visitPackedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt32Field] = [
      .noneVisitPackedInt32Field,
    ]

  }

  enum visitPackedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt64Field] = [
      .noneVisitPackedInt64Field,
    ]

  }

  enum visitPackedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field] = [
      .noneVisitPackedSfixed32Field,
    ]

  }

  enum visitPackedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field] = [
      .noneVisitPackedSfixed64Field,
    ]

  }

  enum visitPackedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt32Field] = [
      .noneVisitPackedSint32Field,
    ]

  }

  enum visitPackedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt64Field] = [
      .noneVisitPackedSint64Field,
    ]

  }

  enum visitPackedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt32Field] = [
      .noneVisitPackedUint32Field,
    ]

  }

  enum visitPackedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitPackedUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitPackedUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitPackedUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitPackedUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt64Field] = [
      .noneVisitPackedUint64Field,
    ]

  }

  enum visitRepeated: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeated // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeated
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeated
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeated: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeated] = [
      .noneVisitRepeated,
    ]

  }

  enum visitRepeatedBoolField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBoolField] = [
      .noneVisitRepeatedBoolField,
    ]

  }

  enum visitRepeatedBytesField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBytesField] = [
      .noneVisitRepeatedBytesField,
    ]

  }

  enum visitRepeatedDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField] = [
      .noneVisitRepeatedDoubleField,
    ]

  }

  enum visitRepeatedEnumField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedEnumField] = [
      .noneVisitRepeatedEnumField,
    ]

  }

  enum visitRepeatedFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field] = [
      .noneVisitRepeatedFixed32Field,
    ]

  }

  enum visitRepeatedFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field] = [
      .noneVisitRepeatedFixed64Field,
    ]

  }

  enum visitRepeatedFloatField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFloatField] = [
      .noneVisitRepeatedFloatField,
    ]

  }

  enum visitRepeatedGroupField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedGroupField] = [
      .noneVisitRepeatedGroupField,
    ]

  }

  enum visitRepeatedInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field] = [
      .noneVisitRepeatedInt32Field,
    ]

  }

  enum visitRepeatedInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field] = [
      .noneVisitRepeatedInt64Field,
    ]

  }

  enum visitRepeatedMessageField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedMessageField] = [
      .noneVisitRepeatedMessageField,
    ]

  }

  enum visitRepeatedSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field] = [
      .noneVisitRepeatedSfixed32Field,
    ]

  }

  enum visitRepeatedSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field] = [
      .noneVisitRepeatedSfixed64Field,
    ]

  }

  enum visitRepeatedSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field] = [
      .noneVisitRepeatedSint32Field,
    ]

  }

  enum visitRepeatedSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field] = [
      .noneVisitRepeatedSint64Field,
    ]

  }

  enum visitRepeatedStringField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedStringField] = [
      .noneVisitRepeatedStringField,
    ]

  }

  enum visitRepeatedUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field] = [
      .noneVisitRepeatedUint32Field,
    ]

  }

  enum visitRepeatedUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitRepeatedUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitRepeatedUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitRepeatedUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitRepeatedUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field] = [
      .noneVisitRepeatedUint64Field,
    ]

  }

  enum visitSingular: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingular // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingular
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingular
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingular: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingular] = [
      .noneVisitSingular,
    ]

  }

  enum visitSingularBoolField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularBoolField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularBoolField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularBoolField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularBoolField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBoolField] = [
      .noneVisitSingularBoolField,
    ]

  }

  enum visitSingularBytesField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularBytesField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularBytesField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularBytesField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularBytesField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBytesField] = [
      .noneVisitSingularBytesField,
    ]

  }

  enum visitSingularDoubleField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularDoubleField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularDoubleField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularDoubleField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularDoubleField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularDoubleField] = [
      .noneVisitSingularDoubleField,
    ]

  }

  enum visitSingularEnumField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularEnumField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularEnumField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularEnumField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularEnumField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularEnumField] = [
      .noneVisitSingularEnumField,
    ]

  }

  enum visitSingularFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularFixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularFixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularFixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularFixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed32Field] = [
      .noneVisitSingularFixed32Field,
    ]

  }

  enum visitSingularFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularFixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularFixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularFixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularFixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed64Field] = [
      .noneVisitSingularFixed64Field,
    ]

  }

  enum visitSingularFloatField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularFloatField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularFloatField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularFloatField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularFloatField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFloatField] = [
      .noneVisitSingularFloatField,
    ]

  }

  enum visitSingularGroupField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularGroupField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularGroupField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularGroupField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularGroupField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularGroupField] = [
      .noneVisitSingularGroupField,
    ]

  }

  enum visitSingularInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularInt32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularInt32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularInt32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularInt32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt32Field] = [
      .noneVisitSingularInt32Field,
    ]

  }

  enum visitSingularInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularInt64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularInt64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularInt64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularInt64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt64Field] = [
      .noneVisitSingularInt64Field,
    ]

  }

  enum visitSingularMessageField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularMessageField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularMessageField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularMessageField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularMessageField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularMessageField] = [
      .noneVisitSingularMessageField,
    ]

  }

  enum visitSingularSFixed32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularSfixed32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSfixed32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSfixed32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSfixed32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field] = [
      .noneVisitSingularSfixed32Field,
    ]

  }

  enum visitSingularSFixed64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularSfixed64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSfixed64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSfixed64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSfixed64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field] = [
      .noneVisitSingularSfixed64Field,
    ]

  }

  enum visitSingularSInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularSint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt32Field] = [
      .noneVisitSingularSint32Field,
    ]

  }

  enum visitSingularSInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularSint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularSint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularSint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularSint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt64Field] = [
      .noneVisitSingularSint64Field,
    ]

  }

  enum visitSingularStringField: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularStringField // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularStringField
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularStringField
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularStringField: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularStringField] = [
      .noneVisitSingularStringField,
    ]

  }

  enum visitSingularUInt32Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularUint32Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularUint32Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularUint32Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularUint32Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt32Field] = [
      .noneVisitSingularUint32Field,
    ]

  }

  enum visitSingularUInt64Field: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitSingularUint64Field // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitSingularUint64Field
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitSingularUint64Field
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitSingularUint64Field: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt64Field] = [
      .noneVisitSingularUint64Field,
    ]

  }

  enum visitUnknown: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVisitUnknown // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVisitUnknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVisitUnknown
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVisitUnknown: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitUnknown] = [
      .noneVisitUnknown,
    ]

  }

  enum Void: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneVoid // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneVoid
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneVoid
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneVoid: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Void] = [
      .noneVoid,
    ]

  }

  enum wasDecoded: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWasDecoded // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWasDecoded
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWasDecoded
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWasDecoded: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wasDecoded] = [
      .noneWasDecoded,
    ]

  }

  enum weak: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWeak // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWeak
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWeak
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWeak: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weak] = [
      .noneWeak,
    ]

  }

  enum weakDependency: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWeakDependency // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWeakDependency
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWeakDependency
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWeakDependency: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weakDependency] = [
      .noneWeakDependency,
    ]

  }

  enum whereEnum: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWhere // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWhere
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWhere
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWhere: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.whereEnum] = [
      .noneWhere,
    ]

  }

  enum wireFormat: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWireFormat // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWireFormat
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWireFormat
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWireFormat: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wireFormat] = [
      .noneWireFormat,
    ]

  }

  enum with: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWith // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWith
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWith
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWith: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.with] = [
      .noneWith,
    ]

  }

  enum withUnsafeBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWithUnsafeBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWithUnsafeBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWithUnsafeBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWithUnsafeBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeBytes] = [
      .noneWithUnsafeBytes,
    ]

  }

  enum withUnsafeMutableBytes: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWithUnsafeMutableBytes // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWithUnsafeMutableBytes
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWithUnsafeMutableBytes
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWithUnsafeMutableBytes: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes] = [
      .noneWithUnsafeMutableBytes,
    ]

  }

  enum work: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWork // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWork
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWork
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWork: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.work] = [
      .noneWork,
    ]

  }

  enum Wrapped: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWrapped // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWrapped
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWrapped
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWrapped: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Wrapped] = [
      .noneWrapped,
    ]

  }

  enum WrappedType: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWrappedType // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWrappedType
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWrappedType
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWrappedType: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.WrappedType] = [
      .noneWrappedType,
    ]

  }

  enum wrappedValue: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWrappedValue // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWrappedValue
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWrappedValue
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWrappedValue: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wrappedValue] = [
      .noneWrappedValue,
    ]

  }

  enum written: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneWritten // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneWritten
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneWritten
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneWritten: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.written] = [
      .noneWritten,
    ]

  }

  enum yday: SwiftProtobuf.Enum, Swift.CaseIterable {
    typealias RawValue = Int
    case noneYday // = 0
    case UNRECOGNIZED(Int)

    init() {
      self = .noneYday
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .noneYday
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .noneYday: return 0
      case .UNRECOGNIZED(let i): return i
      }
    }

    // The compiler won't synthesize support with the UNRECOGNIZED case.
    static let allCases: [SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.yday] = [
      .noneYday,
    ]

  }

  init() {}
}

// MARK: - Code below here is support for the SwiftProtobuf runtime.

fileprivate let _protobuf_package = "swift_proto_testing.generated"

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".GeneratedSwiftReservedEnums"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    // Load everything into unknown fields
    while try decoder.nextFieldNumber() != nil {}
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums, rhs: SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.addPath: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_addPath\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.adjusted: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_adjusted\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.aggregateValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_aggregateValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allCases: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_allCases\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.allowAlias: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_allowAlias\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintEnumsAsInts: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_alwaysPrintEnumsAsInts\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.alwaysPrintInt64sAsNumbers: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_alwaysPrintInt64sAsNumbers\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.annotation: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_annotation\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.any: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_any\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyMessageExtension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyMessageStorage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyMessageStorage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AnyUnpackError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AnyUnpackError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.append: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_append\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appended: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appended\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUIntHex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appendUIntHex\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.appendUnknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_appendUnknown\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.areAllInitialized: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_areAllInitialized\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Array: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Array\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayDepth: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arrayDepth\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arrayLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arrayLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.arraySeparator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_arraySeparator\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_as\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiOpenCurlyBracket: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_asciiOpenCurlyBracket\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.asciiZero: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_asciiZero\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.async: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_async\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIterator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncIterator\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncIteratorProtocol: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncIteratorProtocol\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.AsyncMessageSequence: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_AsyncMessageSequence\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.available: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_available\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.b: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_b\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Base: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Base\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.base64Values: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_base64Values\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.baseAddress: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_baseAddress\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BaseType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BaseType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.begin: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_begin\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binary: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binary\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecodingError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDecodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDecodingOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryDelimited: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryDelimited\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetSizeVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingMessageSetSizeVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingMessageSetVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingMessageSetVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingSizeVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingSizeVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryEncodingVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryProtobufDelimitedMessages: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryProtobufDelimitedMessages\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BinaryStreamDecoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BinaryStreamDecoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.binaryStreamDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_binaryStreamDecodingError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bitPattern: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bitPattern\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.body: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_body\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BoolEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Bool\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.booleanLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_booleanLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BooleanLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BooleanLiteralType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.boolValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_boolValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.buffer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_buffer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.byte: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_byte\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytecode: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytecode\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.BytecodeReader: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_BytecodeReader\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesInGroup: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesInGroup\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesNeeded: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesNeeded\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.bytesRead: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_bytesRead\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.c: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_c\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.canonical: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_canonical\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.capitalizeNext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_capitalizeNext\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.cardinality: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_cardinality\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CaseIterable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CaseIterable\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.castedValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_castedValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccEnableArenas: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ccEnableArenas\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ccGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ccGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Character: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Character\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chars: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_chars\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.checkProgramFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_checkProgramFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.chunk: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_chunk\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.classEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_class\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAggregateValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearAggregateValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearAllowAlias: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearAllowAlias\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearBegin: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearBegin\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcEnableArenas: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCcEnableArenas\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCcGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCcGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearClientStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearClientStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCsharpNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCsharpNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearCtype: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearCtype\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDebugRedact: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDebugRedact\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDefaultSymbolVisibility\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDefaultValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDefaultValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecatedLegacyJsonFieldConflicts\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDeprecationWarning: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDeprecationWarning\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearDoubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearDoubleValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionDeprecated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionDeprecated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionIntroduced: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionIntroduced\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEditionRemoved: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEditionRemoved\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnd: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnd\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnforceNamingStyle: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnforceNamingStyle\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearEnumType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearEnumType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtendee: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearExtendee\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearExtensionValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFeatureSupport: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFeatureSupport\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFieldPresence: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFieldPresence\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFixedFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFixedFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearFullName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearFullName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearGoPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearGoPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdempotencyLevel: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIdempotencyLevel\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIdentifierValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIdentifierValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearInputType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearInputType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearIsExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearIsExtension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaGenerateEqualsAndHash\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaMultipleFiles\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaOuterClassname: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaOuterClassname\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJavaStringCheckUtf8\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJsonFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJsonName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJsonName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearJstype: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearJstype\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLabel: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLabel\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLazy: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLazy\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearLeadingComments: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearLeadingComments\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMapEntry: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMapEntry\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMaximumEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMaximumEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMessageEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMessageSetWireFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearMinimumEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearMinimumEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNamePart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNamePart\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNegativeIntValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNegativeIntValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNoStandardDescriptorAccessor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearObjcClassPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearObjcClassPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOneofIndex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOneofIndex\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptimizeFor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOptimizeFor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOutputType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOutputType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearOverridableFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearOverridableFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPacked: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPacked\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpClassPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpClassPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpMetadataNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPhpNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPhpNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPositiveIntValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPositiveIntValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearProto3Optional: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearProto3Optional\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearPyGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearPyGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRemovalError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRemovalError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRepeated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRepeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRepeatedFieldEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearReserved: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearReserved\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRetention: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRetention\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearRubyPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearRubyPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSemantic: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSemantic\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearServerStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearServerStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceCodeInfo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceCodeInfo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceContext\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSourceFile: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSourceFile\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearStart\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearStringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearStringValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSwiftPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSwiftPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearSyntax: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearSyntax\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTrailingComments: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearTrailingComments\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearTypeName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearTypeName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUnverifiedLazy: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearUnverifiedLazy\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearUtf8Validation: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearUtf8Validation\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVerification: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearVerification\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearVisibility: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearVisibility\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clearWeak: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clearWeak\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.clientStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_clientStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.code: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_code\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codePoint: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_codePoint\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.codeUnits: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_codeUnits\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Collection: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Collection\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.comma: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_comma\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.consumedBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_consumedBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contains: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_contains\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.contentsOf: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_contentsOf\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ContiguousBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ContiguousBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.copy: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_copy\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.count: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_count\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.countVarintsInBuffer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_countVarintsInBuffer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.csharpNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_csharpNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ctype: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ctype\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.customCodable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_customCodable\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomDebugStringConvertible: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CustomDebugStringConvertible\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.CustomStringConvertible: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_CustomStringConvertible\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.D: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_D\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DataEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Data\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dataResult: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dataResult\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.date: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_date\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daySec: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_daySec\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.daysSinceEpoch: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_daysSinceEpoch\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugDescriptionEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_debugDescription\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.debugRedact: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_debugRedact\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.declaration: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_declaration\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decoded: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decoded\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodedFromJSONNull: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodedFromJSONNull\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeExtensionFieldsAsMessageSet\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeJSON: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeJSON\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMapField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeMapField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeMessageEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeMessage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Decoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Decoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedBoolField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedBytesField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedDoubleField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedEnumField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedFloatField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedGroupField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedMessageField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedSInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedStringField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedUInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeRepeatedUInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingular: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingular\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularBoolField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularBytesField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularDoubleField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularEnumField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularFloatField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularGroupField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularMessageField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularSInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularStringField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularUInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeSingularUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeSingularUInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.decodeTextFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_decodeTextFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultAnyTypeURLPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultAnyTypeURLPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaults: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaults\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultSymbolVisibility\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.defaultValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_defaultValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dependency: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dependency\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecatedLegacyJsonFieldConflicts\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.deprecationWarning: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_deprecationWarning\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.descriptionEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_description\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Dictionary: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Dictionary\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.dictionaryLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_dictionaryLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit0: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit0\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digit1: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digit1\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitCount: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digitCount\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digits: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digits\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.digitValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_digitValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardableResult: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_discardableResult\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.discardUnknownFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_discardUnknownFields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.DoubleEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Double\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.doubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_doubleValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.duration: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_duration\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.E: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_E\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.edition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_edition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EditionDefault: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_EditionDefault\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDefaults: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionDefaults\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionDeprecated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionDeprecated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionIntroduced: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionIntroduced\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.editionRemoved: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_editionRemoved\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Element: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Element\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elements: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_elements\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.elseEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_else\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitExtensionFieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitExtensionFieldName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitFieldName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emitFieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emitFieldNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyAnyTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emptyAnyTypeURL\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.emptyData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_emptyData\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeAsBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodeAsBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoded: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encoded\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedJSONString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodedJSONString\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodedSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodedSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encodeField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encodeField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.encoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_encoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.end: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_end\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endArray: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endArray\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endMessageField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endObject: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endObject\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.endRegularField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_endRegularField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enforceNamingStyle: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enforceNamingStyle\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enum\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EnumReservedRange: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_EnumReservedRange\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enumType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.enumvalue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_enumvalue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.EquatableEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Equatable\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Error: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Error\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.execute: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_execute\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByArrayLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExpressibleByArrayLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExpressibleByDictionaryLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExpressibleByDictionaryLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ext\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendedGraphemeClusterLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extendedGraphemeClusterLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtendedGraphemeClusterLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtendedGraphemeClusterLiteralType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extendee: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extendee\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensibleMessage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensibleMessage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionFieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensionFieldNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionFieldValueSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionFieldValueSet\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ExtensionMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ExtensionMap\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensionRange: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensionRange\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extensions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extensions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.extras: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_extras\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.F: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_F\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.falseEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_false\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.features: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_features\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FeatureSetEditionDefault: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FeatureSetEditionDefault\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.featureSupport: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_featureSupport\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldData\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldMaskError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldMaskError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNameCount: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNameCount\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNum\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldNumberForProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldNumberForProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldPresence: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldPresence\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fieldSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fieldSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldTag: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldTag\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FieldType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FieldType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.file: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_file\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fileName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fileName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.filter: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_filter\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.final: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_final\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.finiteOnly: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_finiteOnly\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.first: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_first\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.firstItem: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_firstItem\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fixedFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fixedFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Float\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.floatLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_floatLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.FloatLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_FloatLiteralType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_for\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forMessageName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forMessageName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.formUnion: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_formUnion\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forReadingFrom: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forReadingFrom\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forTypeURL\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ForwardParser: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ForwardParser\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.forWritingInto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_forWritingInto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.from: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_from\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii2: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromAscii2\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromAscii4: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromAscii4\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromByteOffset: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromByteOffset\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fromHexDigit: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fromHexDigit\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.fullName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_fullName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.funcEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_func\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.function: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_function\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.G: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_G\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.get: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_get\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.getExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_getExtensionValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Any: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Any\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Api: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Api\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BoolValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_BoolValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_BytesValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_BytesValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_DescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_DoubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_DoubleValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Duration: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Duration\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Edition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Edition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Empty: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Empty\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Enum\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumDescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumDescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueDescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValueDescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_EnumValueOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_EnumValueOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ExtensionRangeOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ExtensionRangeOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FeatureSet\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FeatureSetDefaults: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FeatureSetDefaults\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldDescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldDescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldMask: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldMask\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FieldOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FieldOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileDescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileDescriptorSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileDescriptorSet\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FileOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FileOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_FloatValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_FloatValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_GeneratedCodeInfo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_GeneratedCodeInfo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int32Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Int32Value\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Int64Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Int64Value\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ListValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ListValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MessageOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MessageOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Method: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Method\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodDescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MethodDescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_MethodOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_MethodOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Mixin: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Mixin\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_NullValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_NullValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofDescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_OneofDescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_OneofOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_OneofOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Option: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Option\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceDescriptorProto: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ServiceDescriptorProto\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_ServiceOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_ServiceOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceCodeInfo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SourceCodeInfo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SourceContext\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_StringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_StringValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Struct: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Struct\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_SymbolVisibility: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_SymbolVisibility\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Syntax: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Syntax\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Timestamp: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Timestamp\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Type: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Type\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt32Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UInt32Value\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UInt64Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UInt64Value\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_UninterpretedOption: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_UninterpretedOption\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Google_Protobuf_Value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Google_Protobuf_Value\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.goPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_goPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.gotData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_gotData\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.group: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_group\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupFieldNumberStack: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_groupFieldNumberStack\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.groupSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_groupSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.guardEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_guard\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hadOneofValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hadOneofValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleConflictingOneOf: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_handleConflictingOneOf\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.handleInstruction: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_handleInstruction\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAggregateValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasAggregateValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasAllowAlias: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasAllowAlias\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasBegin: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasBegin\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcEnableArenas: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCcEnableArenas\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCcGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCcGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasClientStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasClientStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCsharpNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCsharpNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasCtype: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasCtype\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasData\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDebugRedact: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDebugRedact\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultSymbolVisibility: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDefaultSymbolVisibility\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDefaultValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDefaultValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecatedLegacyJsonFieldConflicts: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecatedLegacyJsonFieldConflicts\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDeprecationWarning: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDeprecationWarning\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasDoubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasDoubleValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionDeprecated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionDeprecated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionIntroduced: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionIntroduced\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEditionRemoved: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEditionRemoved\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnd: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnd\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnforceNamingStyle: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnforceNamingStyle\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasEnumType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasEnumType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExplicitDelta: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExplicitDelta\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtendee: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExtendee\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasExtensionValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFeatureSupport: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFeatureSupport\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFieldPresence: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFieldPresence\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFixedFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFixedFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasFullName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasFullName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasGoPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasGoPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hash\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashableEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Hashable\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasher: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasher\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.HashVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_HashVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdempotencyLevel: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIdempotencyLevel\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIdentifierValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIdentifierValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasInputType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasInputType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasIsExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasIsExtension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaGenerateEqualsAndHash\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaMultipleFiles: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaMultipleFiles\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaOuterClassname: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaOuterClassname\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJavaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJavaStringCheckUtf8\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJsonFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJsonName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJsonName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasJstype: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasJstype\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLabel: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLabel\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLazy: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLazy\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasLeadingComments: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasLeadingComments\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMapEntry: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMapEntry\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMaximumEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMaximumEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMessageEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMessageSetWireFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMessageSetWireFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasMinimumEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasMinimumEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNamePart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNamePart\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNegativeIntValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNegativeIntValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNoStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNoStandardDescriptorAccessor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasObjcClassPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasObjcClassPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOneofIndex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOneofIndex\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptimizeFor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOptimizeFor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOutputType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOutputType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasOverridableFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasOverridableFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPacked: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPacked\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpClassPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpClassPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpMetadataNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpMetadataNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPhpNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPhpNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPositiveIntValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPositiveIntValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasProto3Optional: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasProto3Optional\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasPyGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasPyGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRemovalError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRemovalError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRepeated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRepeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRepeatedFieldEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasReserved: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasReserved\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRetention: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRetention\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasRubyPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasRubyPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSemantic: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSemantic\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasServerStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasServerStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceCodeInfo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceCodeInfo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceContext\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSourceFile: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSourceFile\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasStart\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasStringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasStringValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSwiftPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSwiftPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasSyntax: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasSyntax\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTrailingComments: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasTrailingComments\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasTypeName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasTypeName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUnverifiedLazy: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasUnverifiedLazy\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasUtf8Validation: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasUtf8Validation\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVerification: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasVerification\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasVisibility: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasVisibility\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hasWeak: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hasWeak\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.hour: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_hour\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.i: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_i\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.idempotencyLevel: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_idempotencyLevel\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.identifierValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_identifierValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ifEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_if\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownExtensionFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ignoreUnknownExtensionFields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ignoreUnknownFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ignoreUnknownFields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.index: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_index\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.initEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_init\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inoutEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_inout\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.inputType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_inputType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.insert: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_insert\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Instruction: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Instruction\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int32Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int64Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Int8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Int8\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.integerLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_integerLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.IntegerLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_IntegerLiteralType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intern: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_intern\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Internal: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Internal\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.InternalState: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_InternalState\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.intersect: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_intersect\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.into: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_into\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ints: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ints\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.invalidAnyTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_invalidAnyTypeURL\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isA: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isA\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqual: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isEqual\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isEqualTo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isEqualTo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isExtension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isInitializedEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isInitialized\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isNegative: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isNegative\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isPathValid: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isPathValid\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isReserved: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isReserved\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.isValid: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_isValid\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.itemTagsEncodedSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_itemTagsEncodedSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.iterator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_iterator\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenerateEqualsAndHash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaGenerateEqualsAndHash\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaMultipleFiles: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaMultipleFiles\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaOuterClassname: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaOuterClassname\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.javaStringCheckUtf8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_javaStringCheckUtf8\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecodingError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONDecodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONDecodingOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonEncoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonEncoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONEncodingVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONMapEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONMapEncodingVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPath: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonPath\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonPaths: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonPaths\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.JSONScanner: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_JSONScanner\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonString\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonText: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonText\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Bytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonUTF8Bytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jsonUTF8Data: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jsonUTF8Data\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.jstype: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_jstype\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.k: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_k\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kChunkSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_kChunkSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Key: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Key\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_keyField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.keyFieldOpt: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_keyFieldOpt\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.KeyType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_KeyType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.kind: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_kind\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.l: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_l\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.label: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_label\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lazy: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lazy\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingComments: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_leadingComments\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.leadingDetachedComments: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_leadingDetachedComments\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.length: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_length\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lessThan: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lessThan\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.letEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_let\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.lhs: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_lhs\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.line: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_line\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.list: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_list\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listOfMessages: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_listOfMessages\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.listValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_listValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.littleEndian: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_littleEndian\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.load: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_load\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.localHasher: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_localHasher\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.location: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_location\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.M: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_M\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.major: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_major\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeAsyncIterator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_makeAsyncIterator\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.makeIterator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_makeIterator\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.malformedLength: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_malformedLength\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapEntry: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapEntry\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapKeyType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MapKeyType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapToMessages: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapToMessages\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MapValueType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MapValueType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mapVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mapVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mask: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mask\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.maximumEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_maximumEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mdayStart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mdayStart\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.merge: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_merge\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MergeOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MergeOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.message: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_message\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageDepthLimit: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageDepthLimit\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageExtension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageImplementationBase: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageImplementationBase\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.MessageSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_MessageSet\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSetWireFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageSetWireFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.messageType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_messageType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.method: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_method\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.methods: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_methods\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.min: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_min\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minimumEdition: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_minimumEdition\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.minor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_minor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mixins: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mixins\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.modify: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_modify\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.month: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_month\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.msgExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_msgExtension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.mutating: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_mutating\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.n: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_n\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.name: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_name\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameDescription: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NameDescription\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NameMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NameMap\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.NamePart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_NamePart\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.names: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_names\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nanos: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nanos\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.negativeIntValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_negativeIntValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nestedType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nestedType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newExtensible: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newExtensible\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newL\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newList: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newList\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newMessage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newMessage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.newValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_newValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.next: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_next\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextByte: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextByte\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextFieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextFieldNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInstruction: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextInstruction\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextInt32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNullTerminatedString\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNullTerminatedStringArray: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNullTerminatedStringArray\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextUInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextUInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nextVarInt: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nextVarInt\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nil\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nilLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nilLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noBytesAvailable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_noBytesAvailable\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.noStandardDescriptorAccessor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_noStandardDescriptorAccessor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.nullValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_nullValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.number: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_number\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.numberValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_numberValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.objcClassPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_objcClassPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.of: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_of\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OneOf_Kind: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OneOf_Kind\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofDecl: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofDecl\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofIndex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofIndex\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.oneofs: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_oneofs\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optimizeFor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_optimizeFor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptimizeMode: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptimizeMode\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalEnumExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalGroupExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalGroupExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionalMessageExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionalMessageExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.optionDependency: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_optionDependency\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionRetention: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionRetention\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.options: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_options\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.OptionTargetType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_OptionTargetType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.other: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_other\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.others: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_others\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.out: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_out\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.outputType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_outputType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.overridableFeatures: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_overridableFeatures\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.p: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_p\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.package: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_package\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.packed: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_packed\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PackedEnumExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PackedExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PackedExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.padding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_padding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parent: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_parent\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.parse: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_parse\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.partial: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_partial\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.path: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_path\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathDecodingError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.paths: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_paths\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.PathVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_PathVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payload: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_payload\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.payloadSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_payloadSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpClassPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpClassPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpMetadataNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpMetadataNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.phpNamespace: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_phpNamespace\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pos: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_pos\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.positiveIntValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_positiveIntValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_prefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preserveProtoFieldNames: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_preserveProtoFieldNames\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.preTraverse: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_preTraverse\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.previousNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_previousNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.prevPath: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_prevPath\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.printUnknownFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_printUnknownFields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programBuffer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_programBuffer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.programFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_programFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto2: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto2\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3DefaultValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto3DefaultValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.proto3Optional: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_proto3Optional\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_extensionFieldValues: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_extensionFieldValues\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_fieldNumber: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_fieldNumber\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_generated_isEqualTo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_generated_isEqualTo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_nameMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_nameMap\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_newField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_newField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobuf_package: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobuf_package\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersion_2: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufAPIVersion_2\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufAPIVersionCheck: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufAPIVersionCheck\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBool: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufBool\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobufData\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufDouble: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufDouble\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufEnumMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufEnumMap\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protobufExtension: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protobufExtension\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFixed32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFixed64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFixed64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufFloat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufFloat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufInt32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufMap\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufMessageMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufMessageMap\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSFixed32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSFixed64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSFixed64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSInt32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufSInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufSInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufString\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufUInt32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtobufUInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtobufUInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protocolEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protocol\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoFieldName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoFieldName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoMessageNameEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoMessageName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ProtoNameProviding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ProtoNameProviding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.protoPaths: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_protoPaths\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_public\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.publicDependency: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_publicDependency\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBoolValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putBoolValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putBytesValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putBytesValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putDoubleValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putDoubleValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putEnumValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putEnumValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt32: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFixedUInt32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFixedUInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFixedUInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putFloatValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putFloatValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putStringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putStringValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putUInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putUInt64Hex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putUInt64Hex\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putVarInt: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putVarInt\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.putZigZagVarInt: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_putZigZagVarInt\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.pyGenericServices: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_pyGenericServices\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.R: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_R\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rawChars: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rawChars\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawRepresentable: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RawRepresentable\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RawValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RawValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.read4HexDigits: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_read4HexDigits\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.readBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_readBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.reader: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_reader\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.register: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_register\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.remainingProgram: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_remainingProgram\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removalError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_removalError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.removingAllFieldsOf: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_removingAllFieldsOf\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedEnumExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedEnumExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeatedFieldEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeatedFieldEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedGroupExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedGroupExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.RepeatedMessageExtensionField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_RepeatedMessageExtensionField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.repeating: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_repeating\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.replaceRepeatedFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_replaceRepeatedFields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requestStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requestTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requestTypeURL\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.requiredSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_requiredSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_responseStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.responseTypeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_responseTypeURL\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.result: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_result\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.retention: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_retention\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rethrowsEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rethrows\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ReturnType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ReturnType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.revision: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_revision\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rhs: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rhs\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.root: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_root\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.rubyPackage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_rubyPackage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.s: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_s\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawBackslash: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawBackslash\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection4Characters: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawSection4Characters\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sawSection5Characters: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sawSection5Characters\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Scalar: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Scalar\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scan: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_scan\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.scanner: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_scanner\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.seconds: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_seconds\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.selfEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_self\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.semantic: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_semantic\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SendableEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Sendable\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.separator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_separator\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serialize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serialize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedData: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedData\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serializedSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serializedSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.serverStreaming: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_serverStreaming\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.service: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_service\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.set: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_set\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.setExtensionValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_setExtensionValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.shift: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_shift\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SimpleExtensionMap: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SimpleExtensionMap\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.size: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_size\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sizer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sizer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.source: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_source\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceCodeInfo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceCodeInfo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceContext: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceContext\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceEncoding: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceEncoding\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.sourceFile: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_sourceFile\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SourceLocation: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SourceLocation\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.span: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_span\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.split: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_split\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.start: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_start\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArray: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startArray\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startArrayObject: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startArrayObject\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startIndex: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startIndex\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startMessageField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startObject: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startObject\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.startRegularField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_startRegularField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.state: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_state\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.staticEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_static\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StaticString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_StaticString\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.storage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_storage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_String\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.StringLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_StringLiteralType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringResult: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringResult\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.stringValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_stringValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_struct\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.structValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_structValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subscriptEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subscript\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subtract: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subtract\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.subVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_subVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Swift\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.swiftPrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_swiftPrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufContiguousBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SwiftProtobufContiguousBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.SwiftProtobufError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_SwiftProtobufError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.syntax: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_syntax\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.T: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_T\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tag: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tag\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.targets: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_targets\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.terminator: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_terminator\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.testDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_testDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.text: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_text\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_textDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecoder: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecoder\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingError: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecodingError\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatDecodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatDecodingOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatEncodingOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TextFormatEncodingVisitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TextFormatEncodingVisitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.textFormatString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_textFormatString\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwOrIgnore: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_throwOrIgnore\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.throwsEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_throws\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeInterval: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeInterval\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSince1970: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeIntervalSince1970\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.timeIntervalSinceReferenceDate: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_timeIntervalSinceReferenceDate\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tmp: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tmp\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tooLarge: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_tooLarge\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.total: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_total\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalArrayDepth: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_totalArrayDepth\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.totalSize: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_totalSize\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trailingComments: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_trailingComments\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.traverseEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_traverse\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trim: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_trim\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.trueEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_true\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.tryEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_try\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.type: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_type\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typealiasEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typealias\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.TypeEnumEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_TypeEnum\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeName: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeName\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typePrefix: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typePrefix\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeStart: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeStart\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeUnknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeUnknown\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.typeURL: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_typeURL\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt32Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt32\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt64Enum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt64\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UInt8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UInt8\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unchecked: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unchecked\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Unicode: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Unicode\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalarLiteral: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unicodeScalarLiteral\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarLiteralType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnicodeScalarLiteralType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unicodeScalars: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unicodeScalars\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnicodeScalarView: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnicodeScalarView\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uninterpretedOption: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uninterpretedOption\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.union: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_union\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uniqueStorage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uniqueStorage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unknown\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unknownFieldsEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unknownFields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnknownStorage: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnknownStorage\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unpackTo: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unpackTo\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeBufferPointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeBufferPointer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutablePointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeMutablePointer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeMutableRawBufferPointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeMutableRawBufferPointer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawBufferPointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeRawBufferPointer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UnsafeRawPointer: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UnsafeRawPointer\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.unverifiedLazy: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_unverifiedLazy\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.updatedOptions: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_updatedOptions\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.uppercasedAssumingASCII: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_uppercasedAssumingASCII\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.url: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_url\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.useDeterministicOrdering: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_useDeterministicOrdering\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Ptr: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8Ptr\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8ToDouble: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8ToDouble\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.utf8Validation: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_utf8Validation\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.UTF8View: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_UTF8View\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.V: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_V\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.value: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_value\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.valueField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_valueField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.values: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_values\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.ValueType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_ValueType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.varEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_var\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.verification: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_verification\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VerificationState: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_VerificationState\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.version: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_version\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.versionString: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_versionString\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visibility: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visibility\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.VisibilityFeature: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_VisibilityFeature\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFields: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitExtensionFields\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitExtensionFieldsAsMessageSet: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitExtensionFieldsAsMessageSet\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitMapField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitMapField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Visitor: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Visitor\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPacked: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPacked\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedBoolField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedDoubleField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedEnumField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedFloatField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedSInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedUInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitPackedUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitPackedUInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeated: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeated\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedBoolField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedBytesField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedDoubleField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedEnumField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedFloatField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedGroupField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedMessageField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedSInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedStringField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedUInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitRepeatedUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitRepeatedUInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingular: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingular\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBoolField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularBoolField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularBytesField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularBytesField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularDoubleField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularDoubleField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularEnumField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularEnumField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularFloatField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularFloatField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularGroupField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularGroupField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularMessageField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularMessageField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSFixed32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSFixed64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSFixed64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularSInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularSInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularStringField: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularStringField\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt32Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularUInt32Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitSingularUInt64Field: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitSingularUInt64Field\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.visitUnknown: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_visitUnknown\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Void: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Void\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wasDecoded: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wasDecoded\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weak: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_weak\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.weakDependency: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_weakDependency\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.whereEnum: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_where\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wireFormat: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wireFormat\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.with: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_with\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_withUnsafeBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.withUnsafeMutableBytes: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_withUnsafeMutableBytes\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.work: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_work\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.Wrapped: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_Wrapped\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.WrappedType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_WrappedType\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.wrappedValue: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_wrappedValue\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.written: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_written\0")
}

extension SwiftProtoTesting_Generated_GeneratedSwiftReservedEnums.yday: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{2}\0NONE_yday\0")
}