{- This file was auto-generated from google/protobuf/descriptor.proto by the proto-lens-protoc program. -}
{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,
  UndecidableInstances, GeneralizedNewtypeDeriving,
  MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,
  PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds,
  BangPatterns, TypeApplications #-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports#-}
module Proto.Google.Protobuf.Descriptor
       (DescriptorProto(), DescriptorProto'ExtensionRange(),
        DescriptorProto'ReservedRange(), EnumDescriptorProto(),
        EnumDescriptorProto'EnumReservedRange(), EnumOptions(),
        EnumValueDescriptorProto(), EnumValueOptions(),
        ExtensionRangeOptions(), FieldDescriptorProto(),
        FieldDescriptorProto'Label(..), FieldDescriptorProto'Label(),
        FieldDescriptorProto'Type(..), FieldDescriptorProto'Type(),
        FieldOptions(), FieldOptions'CType(..), FieldOptions'CType(),
        FieldOptions'JSType(..), FieldOptions'JSType(),
        FileDescriptorProto(), FileDescriptorSet(), FileOptions(),
        FileOptions'OptimizeMode(..), FileOptions'OptimizeMode(),
        GeneratedCodeInfo(), GeneratedCodeInfo'Annotation(),
        MessageOptions(), MethodDescriptorProto(), MethodOptions(),
        MethodOptions'IdempotencyLevel(..),
        MethodOptions'IdempotencyLevel(), OneofDescriptorProto(),
        OneofOptions(), ServiceDescriptorProto(), ServiceOptions(),
        SourceCodeInfo(), SourceCodeInfo'Location(), UninterpretedOption(),
        UninterpretedOption'NamePart())
       where
import qualified Control.DeepSeq
import qualified Data.ProtoLens.Prism
import qualified Prelude
import qualified Data.Int
import qualified Data.Monoid
import qualified Data.Word
import qualified Data.ProtoLens
import qualified Data.ProtoLens.Encoding.Bytes
import qualified Data.ProtoLens.Encoding.Growing
import qualified Data.ProtoLens.Encoding.Parser.Unsafe
import qualified Data.ProtoLens.Encoding.Wire
import qualified Data.ProtoLens.Field
import qualified Data.ProtoLens.Message.Enum
import qualified Data.ProtoLens.Service.Types
import qualified Lens.Family2
import qualified Lens.Family2.Unchecked
import qualified Data.Text
import qualified Data.Map
import qualified Data.ByteString
import qualified Data.ByteString.Char8
import qualified Data.Text.Encoding
import qualified Data.Vector
import qualified Data.Vector.Generic
import qualified Data.Vector.Unboxed
import qualified Text.Read

{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' DescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' DescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.field' @:: Lens' DescriptorProto [FieldDescriptorProto]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'field' @:: Lens' DescriptorProto (Data.Vector.Vector FieldDescriptorProto)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.extension' @:: Lens' DescriptorProto [FieldDescriptorProto]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extension' @:: Lens' DescriptorProto (Data.Vector.Vector FieldDescriptorProto)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.nestedType' @:: Lens' DescriptorProto [DescriptorProto]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'nestedType' @:: Lens' DescriptorProto (Data.Vector.Vector DescriptorProto)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.enumType' @:: Lens' DescriptorProto [EnumDescriptorProto]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'enumType' @:: Lens' DescriptorProto (Data.Vector.Vector EnumDescriptorProto)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.extensionRange' @:: Lens' DescriptorProto [DescriptorProto'ExtensionRange]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'extensionRange' @:: Lens' DescriptorProto
  (Data.Vector.Vector DescriptorProto'ExtensionRange)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.oneofDecl' @:: Lens' DescriptorProto [OneofDescriptorProto]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'oneofDecl' @:: Lens' DescriptorProto (Data.Vector.Vector OneofDescriptorProto)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' DescriptorProto MessageOptions@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' DescriptorProto (Prelude.Maybe MessageOptions)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.reservedRange' @:: Lens' DescriptorProto [DescriptorProto'ReservedRange]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedRange' @:: Lens' DescriptorProto
  (Data.Vector.Vector DescriptorProto'ReservedRange)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' DescriptorProto [Data.Text.Text]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedName' @:: Lens' DescriptorProto (Data.Vector.Vector Data.Text.Text)@
 -}
data DescriptorProto = DescriptorProto{_DescriptorProto'name ::
                                       !(Prelude.Maybe Data.Text.Text),
                                       _DescriptorProto'field ::
                                       !(Data.Vector.Vector FieldDescriptorProto),
                                       _DescriptorProto'extension ::
                                       !(Data.Vector.Vector FieldDescriptorProto),
                                       _DescriptorProto'nestedType ::
                                       !(Data.Vector.Vector DescriptorProto),
                                       _DescriptorProto'enumType ::
                                       !(Data.Vector.Vector EnumDescriptorProto),
                                       _DescriptorProto'extensionRange ::
                                       !(Data.Vector.Vector DescriptorProto'ExtensionRange),
                                       _DescriptorProto'oneofDecl ::
                                       !(Data.Vector.Vector OneofDescriptorProto),
                                       _DescriptorProto'options :: !(Prelude.Maybe MessageOptions),
                                       _DescriptorProto'reservedRange ::
                                       !(Data.Vector.Vector DescriptorProto'ReservedRange),
                                       _DescriptorProto'reservedName ::
                                       !(Data.Vector.Vector Data.Text.Text),
                                       _DescriptorProto'_unknownFields :: !Data.ProtoLens.FieldSet}
                         deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show DescriptorProto where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField DescriptorProto "name"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'name
               (\ x__ y__ -> x__{_DescriptorProto'name = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField DescriptorProto "maybe'name"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'name
               (\ x__ y__ -> x__{_DescriptorProto'name = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto "field"
           ([FieldDescriptorProto])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'field
               (\ x__ y__ -> x__{_DescriptorProto'field = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto "vec'field"
           (Data.Vector.Vector FieldDescriptorProto)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'field
               (\ x__ y__ -> x__{_DescriptorProto'field = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto "extension"
           ([FieldDescriptorProto])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'extension
               (\ x__ y__ -> x__{_DescriptorProto'extension = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto
           "vec'extension"
           (Data.Vector.Vector FieldDescriptorProto)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'extension
               (\ x__ y__ -> x__{_DescriptorProto'extension = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto "nestedType"
           ([DescriptorProto])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'nestedType
               (\ x__ y__ -> x__{_DescriptorProto'nestedType = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto
           "vec'nestedType"
           (Data.Vector.Vector DescriptorProto)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'nestedType
               (\ x__ y__ -> x__{_DescriptorProto'nestedType = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto "enumType"
           ([EnumDescriptorProto])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'enumType
               (\ x__ y__ -> x__{_DescriptorProto'enumType = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto
           "vec'enumType"
           (Data.Vector.Vector EnumDescriptorProto)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'enumType
               (\ x__ y__ -> x__{_DescriptorProto'enumType = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto
           "extensionRange"
           ([DescriptorProto'ExtensionRange])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'extensionRange
               (\ x__ y__ -> x__{_DescriptorProto'extensionRange = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto
           "vec'extensionRange"
           (Data.Vector.Vector DescriptorProto'ExtensionRange)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'extensionRange
               (\ x__ y__ -> x__{_DescriptorProto'extensionRange = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto "oneofDecl"
           ([OneofDescriptorProto])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'oneofDecl
               (\ x__ y__ -> x__{_DescriptorProto'oneofDecl = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto
           "vec'oneofDecl"
           (Data.Vector.Vector OneofDescriptorProto)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'oneofDecl
               (\ x__ y__ -> x__{_DescriptorProto'oneofDecl = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto "options"
           (MessageOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'options
               (\ x__ y__ -> x__{_DescriptorProto'options = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField DescriptorProto
           "maybe'options"
           (Prelude.Maybe MessageOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'options
               (\ x__ y__ -> x__{_DescriptorProto'options = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto
           "reservedRange"
           ([DescriptorProto'ReservedRange])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'reservedRange
               (\ x__ y__ -> x__{_DescriptorProto'reservedRange = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto
           "vec'reservedRange"
           (Data.Vector.Vector DescriptorProto'ReservedRange)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'reservedRange
               (\ x__ y__ -> x__{_DescriptorProto'reservedRange = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DescriptorProto
           "reservedName"
           ([Data.Text.Text])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'reservedName
               (\ x__ y__ -> x__{_DescriptorProto'reservedName = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField DescriptorProto
           "vec'reservedName"
           (Data.Vector.Vector Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'reservedName
               (\ x__ y__ -> x__{_DescriptorProto'reservedName = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message DescriptorProto where
        messageName _ = Data.Text.pack "google.protobuf.DescriptorProto"
        fieldsByTag
          = let name__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'name"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                field__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "field"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"field"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                extension__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "extension"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"extension"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                nestedType__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "nested_type"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor DescriptorProto)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"nestedType"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                enumType__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "enum_type"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor EnumDescriptorProto)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"enumType"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                extensionRange__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "extension_range"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ExtensionRange)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"extensionRange"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                oneofDecl__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "oneof_decl"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor OneofDescriptorProto)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"oneofDecl"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                options__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "options"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor MessageOptions)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'options"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                reservedRange__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "reserved_range"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor DescriptorProto'ReservedRange)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"reservedRange"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
                reservedName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "reserved_name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"reservedName"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, name__field_descriptor),
                 (Data.ProtoLens.Tag 2, field__field_descriptor),
                 (Data.ProtoLens.Tag 6, extension__field_descriptor),
                 (Data.ProtoLens.Tag 3, nestedType__field_descriptor),
                 (Data.ProtoLens.Tag 4, enumType__field_descriptor),
                 (Data.ProtoLens.Tag 5, extensionRange__field_descriptor),
                 (Data.ProtoLens.Tag 8, oneofDecl__field_descriptor),
                 (Data.ProtoLens.Tag 7, options__field_descriptor),
                 (Data.ProtoLens.Tag 9, reservedRange__field_descriptor),
                 (Data.ProtoLens.Tag 10, reservedName__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _DescriptorProto'_unknownFields
              (\ x__ y__ -> x__{_DescriptorProto'_unknownFields = y__})
        defMessage
          = DescriptorProto{_DescriptorProto'name = Prelude.Nothing,
                            _DescriptorProto'field = Data.Vector.Generic.empty,
                            _DescriptorProto'extension = Data.Vector.Generic.empty,
                            _DescriptorProto'nestedType = Data.Vector.Generic.empty,
                            _DescriptorProto'enumType = Data.Vector.Generic.empty,
                            _DescriptorProto'extensionRange = Data.Vector.Generic.empty,
                            _DescriptorProto'oneofDecl = Data.Vector.Generic.empty,
                            _DescriptorProto'options = Prelude.Nothing,
                            _DescriptorProto'reservedRange = Data.Vector.Generic.empty,
                            _DescriptorProto'reservedName = Data.Vector.Generic.empty,
                            _DescriptorProto'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     DescriptorProto ->
                       Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                         Data.ProtoLens.Encoding.Growing.RealWorld
                         EnumDescriptorProto
                         ->
                         Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                           Data.ProtoLens.Encoding.Growing.RealWorld
                           FieldDescriptorProto
                           ->
                           Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                             Data.ProtoLens.Encoding.Growing.RealWorld
                             DescriptorProto'ExtensionRange
                             ->
                             Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                               Data.ProtoLens.Encoding.Growing.RealWorld
                               FieldDescriptorProto
                               ->
                               Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                                 Data.ProtoLens.Encoding.Growing.RealWorld
                                 DescriptorProto
                                 ->
                                 Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                                   Data.ProtoLens.Encoding.Growing.RealWorld
                                   OneofDescriptorProto
                                   ->
                                   Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                                     Data.ProtoLens.Encoding.Growing.RealWorld
                                     Data.Text.Text
                                     ->
                                     Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                                       Data.ProtoLens.Encoding.Growing.RealWorld
                                       DescriptorProto'ReservedRange
                                       -> Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto
                loop x mutable'enumType mutable'extension mutable'extensionRange
                  mutable'field mutable'nestedType mutable'oneofDecl
                  mutable'reservedName mutable'reservedRange
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do frozen'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                 (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                    mutable'enumType)
                            frozen'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                  (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                     mutable'extension)
                            frozen'extensionRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                       (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                          mutable'extensionRange)
                            frozen'field <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                              (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                 mutable'field)
                            frozen'nestedType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                   (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                      mutable'nestedType)
                            frozen'oneofDecl <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                  (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                     mutable'oneofDecl)
                            frozen'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                     (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                        mutable'reservedName)
                            frozen'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                         mutable'reservedRange)
                            let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 (Lens.Family2.set (Data.ProtoLens.Field.field @"vec'enumType")
                                    frozen'enumType
                                    (Lens.Family2.set (Data.ProtoLens.Field.field @"vec'extension")
                                       frozen'extension
                                       (Lens.Family2.set
                                          (Data.ProtoLens.Field.field @"vec'extensionRange")
                                          frozen'extensionRange
                                          (Lens.Family2.set
                                             (Data.ProtoLens.Field.field @"vec'field")
                                             frozen'field
                                             (Lens.Family2.set
                                                (Data.ProtoLens.Field.field @"vec'nestedType")
                                                frozen'nestedType
                                                (Lens.Family2.set
                                                   (Data.ProtoLens.Field.field @"vec'oneofDecl")
                                                   frozen'oneofDecl
                                                   (Lens.Family2.set
                                                      (Data.ProtoLens.Field.field
                                                         @"vec'reservedName")
                                                      frozen'reservedName
                                                      (Lens.Family2.set
                                                         (Data.ProtoLens.Field.field
                                                            @"vec'reservedRange")
                                                         frozen'reservedRange
                                                         x)))))))))
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "name"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y
                                              x)
                                           mutable'enumType
                                           mutable'extension
                                           mutable'extensionRange
                                           mutable'field
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           mutable'reservedRange
                                18 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "field"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'field
                                                   y)
                                         loop x mutable'enumType mutable'extension
                                           mutable'extensionRange
                                           v
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           mutable'reservedRange
                                50 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "extension"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'extension
                                                   y)
                                         loop x mutable'enumType v mutable'extensionRange
                                           mutable'field
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           mutable'reservedRange
                                26 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "nested_type"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'nestedType
                                                   y)
                                         loop x mutable'enumType mutable'extension
                                           mutable'extensionRange
                                           mutable'field
                                           v
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           mutable'reservedRange
                                34 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "enum_type"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'enumType
                                                   y)
                                         loop x v mutable'extension mutable'extensionRange
                                           mutable'field
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           mutable'reservedRange
                                42 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "extension_range"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'extensionRange
                                                   y)
                                         loop x mutable'enumType mutable'extension v mutable'field
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           mutable'reservedRange
                                66 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "oneof_decl"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'oneofDecl
                                                   y)
                                         loop x mutable'enumType mutable'extension
                                           mutable'extensionRange
                                           mutable'field
                                           mutable'nestedType
                                           v
                                           mutable'reservedName
                                           mutable'reservedRange
                                58 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "options"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"options")
                                              y
                                              x)
                                           mutable'enumType
                                           mutable'extension
                                           mutable'extensionRange
                                           mutable'field
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           mutable'reservedRange
                                74 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "reserved_range"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'reservedRange
                                                   y)
                                         loop x mutable'enumType mutable'extension
                                           mutable'extensionRange
                                           mutable'field
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           mutable'reservedName
                                           v
                                82 -> do !y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                               Data.ProtoLens.Encoding.Bytes.getBytes
                                                                 (Prelude.fromIntegral len)
                                                   Data.ProtoLens.Encoding.Bytes.runEither
                                                     (case Data.Text.Encoding.decodeUtf8' value of
                                                          Prelude.Left err -> Prelude.Left
                                                                                (Prelude.show err)
                                                          Prelude.Right r -> Prelude.Right r))
                                                 Data.ProtoLens.Encoding.Bytes.<?> "reserved_name"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'reservedName
                                                   y)
                                         loop x mutable'enumType mutable'extension
                                           mutable'extensionRange
                                           mutable'field
                                           mutable'nestedType
                                           mutable'oneofDecl
                                           v
                                           mutable'reservedRange
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
                                             mutable'enumType
                                             mutable'extension
                                             mutable'extensionRange
                                             mutable'field
                                             mutable'nestedType
                                             mutable'oneofDecl
                                             mutable'reservedName
                                             mutable'reservedRange
              in
              (do mutable'enumType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                        Data.ProtoLens.Encoding.Growing.new
                  mutable'extension <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                         Data.ProtoLens.Encoding.Growing.new
                  mutable'extensionRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                              Data.ProtoLens.Encoding.Growing.new
                  mutable'field <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                     Data.ProtoLens.Encoding.Growing.new
                  mutable'nestedType <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                          Data.ProtoLens.Encoding.Growing.new
                  mutable'oneofDecl <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                         Data.ProtoLens.Encoding.Growing.new
                  mutable'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                            Data.ProtoLens.Encoding.Growing.new
                  mutable'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                             Data.ProtoLens.Encoding.Growing.new
                  loop Data.ProtoLens.defMessage mutable'enumType mutable'extension
                    mutable'extensionRange
                    mutable'field
                    mutable'nestedType
                    mutable'oneofDecl
                    mutable'reservedName
                    mutable'reservedRange)
                Data.ProtoLens.Encoding.Bytes.<?> "DescriptorProto"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
                                         Data.Monoid.<>
                                         (((\ bs ->
                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                                Data.Monoid.<>
                                                Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                            Prelude.. Data.Text.Encoding.encodeUtf8)
                                           _v)
                 Data.Monoid.<>
                 (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                    (\ _v ->
                       (Data.ProtoLens.Encoding.Bytes.putVarInt 18) Data.Monoid.<>
                         (((\ bs ->
                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                            Prelude.. Data.ProtoLens.encodeMessage)
                           _v)
                    (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'field") _x))
                   Data.Monoid.<>
                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                      (\ _v ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt 50) Data.Monoid.<>
                           (((\ bs ->
                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                   (Prelude.fromIntegral (Data.ByteString.length bs)))
                                  Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                              Prelude.. Data.ProtoLens.encodeMessage)
                             _v)
                      (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'extension")
                         _x))
                     Data.Monoid.<>
                     (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                        (\ _v ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt 26) Data.Monoid.<>
                             (((\ bs ->
                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
                                    Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                Prelude.. Data.ProtoLens.encodeMessage)
                               _v)
                        (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'nestedType")
                           _x))
                       Data.Monoid.<>
                       (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                          (\ _v ->
                             (Data.ProtoLens.Encoding.Bytes.putVarInt 34) Data.Monoid.<>
                               (((\ bs ->
                                    (Data.ProtoLens.Encoding.Bytes.putVarInt
                                       (Prelude.fromIntegral (Data.ByteString.length bs)))
                                      Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                  Prelude.. Data.ProtoLens.encodeMessage)
                                 _v)
                          (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'enumType")
                             _x))
                         Data.Monoid.<>
                         (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                            (\ _v ->
                               (Data.ProtoLens.Encoding.Bytes.putVarInt 42) Data.Monoid.<>
                                 (((\ bs ->
                                      (Data.ProtoLens.Encoding.Bytes.putVarInt
                                         (Prelude.fromIntegral (Data.ByteString.length bs)))
                                        Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                    Prelude.. Data.ProtoLens.encodeMessage)
                                   _v)
                            (Lens.Family2.view
                               (Data.ProtoLens.Field.field @"vec'extensionRange")
                               _x))
                           Data.Monoid.<>
                           (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                              (\ _v ->
                                 (Data.ProtoLens.Encoding.Bytes.putVarInt 66) Data.Monoid.<>
                                   (((\ bs ->
                                        (Data.ProtoLens.Encoding.Bytes.putVarInt
                                           (Prelude.fromIntegral (Data.ByteString.length bs)))
                                          Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                      Prelude.. Data.ProtoLens.encodeMessage)
                                     _v)
                              (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'oneofDecl")
                                 _x))
                             Data.Monoid.<>
                             (case
                                Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x
                                of
                                  (Prelude.Nothing) -> Data.Monoid.mempty
                                  Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 58)
                                                       Data.Monoid.<>
                                                       (((\ bs ->
                                                            (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                               (Prelude.fromIntegral
                                                                  (Data.ByteString.length bs)))
                                                              Data.Monoid.<>
                                                              Data.ProtoLens.Encoding.Bytes.putBytes
                                                                bs))
                                                          Prelude.. Data.ProtoLens.encodeMessage)
                                                         _v)
                               Data.Monoid.<>
                               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                                  (\ _v ->
                                     (Data.ProtoLens.Encoding.Bytes.putVarInt 74) Data.Monoid.<>
                                       (((\ bs ->
                                            (Data.ProtoLens.Encoding.Bytes.putVarInt
                                               (Prelude.fromIntegral (Data.ByteString.length bs)))
                                              Data.Monoid.<>
                                              Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                          Prelude.. Data.ProtoLens.encodeMessage)
                                         _v)
                                  (Lens.Family2.view
                                     (Data.ProtoLens.Field.field @"vec'reservedRange")
                                     _x))
                                 Data.Monoid.<>
                                 (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                                    (\ _v ->
                                       (Data.ProtoLens.Encoding.Bytes.putVarInt 82) Data.Monoid.<>
                                         (((\ bs ->
                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                                Data.Monoid.<>
                                                Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                            Prelude.. Data.Text.Encoding.encodeUtf8)
                                           _v)
                                    (Lens.Family2.view
                                       (Data.ProtoLens.Field.field @"vec'reservedName")
                                       _x))
                                   Data.Monoid.<>
                                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData DescriptorProto where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_DescriptorProto'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_DescriptorProto'name x__)
                    (Control.DeepSeq.deepseq (_DescriptorProto'field x__)
                       (Control.DeepSeq.deepseq (_DescriptorProto'extension x__)
                          (Control.DeepSeq.deepseq (_DescriptorProto'nestedType x__)
                             (Control.DeepSeq.deepseq (_DescriptorProto'enumType x__)
                                (Control.DeepSeq.deepseq (_DescriptorProto'extensionRange x__)
                                   (Control.DeepSeq.deepseq (_DescriptorProto'oneofDecl x__)
                                      (Control.DeepSeq.deepseq (_DescriptorProto'options x__)
                                         (Control.DeepSeq.deepseq
                                            (_DescriptorProto'reservedRange x__)
                                            (Control.DeepSeq.deepseq
                                               (_DescriptorProto'reservedName x__)
                                               (()))))))))))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ExtensionRange Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ExtensionRange (Prelude.Maybe Data.Int.Int32)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' DescriptorProto'ExtensionRange ExtensionRangeOptions@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' DescriptorProto'ExtensionRange
  (Prelude.Maybe ExtensionRangeOptions)@
 -}
data DescriptorProto'ExtensionRange = DescriptorProto'ExtensionRange{_DescriptorProto'ExtensionRange'start
                                                                     ::
                                                                     !(Prelude.Maybe
                                                                         Data.Int.Int32),
                                                                     _DescriptorProto'ExtensionRange'end
                                                                     ::
                                                                     !(Prelude.Maybe
                                                                         Data.Int.Int32),
                                                                     _DescriptorProto'ExtensionRange'options
                                                                     ::
                                                                     !(Prelude.Maybe
                                                                         ExtensionRangeOptions),
                                                                     _DescriptorProto'ExtensionRange'_unknownFields
                                                                     :: !Data.ProtoLens.FieldSet}
                                        deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show DescriptorProto'ExtensionRange where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ExtensionRange
           "start"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _DescriptorProto'ExtensionRange'start
               (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'start = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ExtensionRange
           "maybe'start"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _DescriptorProto'ExtensionRange'start
               (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'start = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ExtensionRange
           "end"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'end
               (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'end = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ExtensionRange
           "maybe'end"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'ExtensionRange'end
               (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'end = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ExtensionRange
           "options"
           (ExtensionRangeOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _DescriptorProto'ExtensionRange'options
               (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'options = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ExtensionRange
           "maybe'options"
           (Prelude.Maybe ExtensionRangeOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _DescriptorProto'ExtensionRange'options
               (\ x__ y__ -> x__{_DescriptorProto'ExtensionRange'options = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message DescriptorProto'ExtensionRange
         where
        messageName _
          = Data.Text.pack "google.protobuf.DescriptorProto.ExtensionRange"
        fieldsByTag
          = let start__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "start"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'start"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange
                end__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "end"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'end"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange
                options__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "options"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor ExtensionRangeOptions)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'options"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ExtensionRange
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, start__field_descriptor),
                 (Data.ProtoLens.Tag 2, end__field_descriptor),
                 (Data.ProtoLens.Tag 3, options__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens
              _DescriptorProto'ExtensionRange'_unknownFields
              (\ x__ y__ ->
                 x__{_DescriptorProto'ExtensionRange'_unknownFields = y__})
        defMessage
          = DescriptorProto'ExtensionRange{_DescriptorProto'ExtensionRange'start
                                             = Prelude.Nothing,
                                           _DescriptorProto'ExtensionRange'end = Prelude.Nothing,
                                           _DescriptorProto'ExtensionRange'options =
                                             Prelude.Nothing,
                                           _DescriptorProto'ExtensionRange'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     DescriptorProto'ExtensionRange ->
                       Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto'ExtensionRange
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "start"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y
                                             x)
                                16 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "end"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y
                                              x)
                                26 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "options"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"options")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "ExtensionRange"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
                                         Data.Monoid.<>
                                         ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                            Prelude.fromIntegral)
                                           _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
                                           Data.Monoid.<>
                                           ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                              Prelude.fromIntegral)
                                             _v)
                   Data.Monoid.<>
                   (case
                      Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x
                      of
                        (Prelude.Nothing) -> Data.Monoid.mempty
                        Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 26)
                                             Data.Monoid.<>
                                             (((\ bs ->
                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                     (Prelude.fromIntegral
                                                        (Data.ByteString.length bs)))
                                                    Data.Monoid.<>
                                                    Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                                Prelude.. Data.ProtoLens.encodeMessage)
                                               _v)
                     Data.Monoid.<>
                     Data.ProtoLens.Encoding.Wire.buildFieldSet
                       (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData DescriptorProto'ExtensionRange
         where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq
                 (_DescriptorProto'ExtensionRange'_unknownFields x__)
                 (Control.DeepSeq.deepseq
                    (_DescriptorProto'ExtensionRange'start x__)
                    (Control.DeepSeq.deepseq (_DescriptorProto'ExtensionRange'end x__)
                       (Control.DeepSeq.deepseq
                          (_DescriptorProto'ExtensionRange'options x__)
                          (())))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' DescriptorProto'ReservedRange Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' DescriptorProto'ReservedRange (Prelude.Maybe Data.Int.Int32)@
 -}
data DescriptorProto'ReservedRange = DescriptorProto'ReservedRange{_DescriptorProto'ReservedRange'start
                                                                   ::
                                                                   !(Prelude.Maybe Data.Int.Int32),
                                                                   _DescriptorProto'ReservedRange'end
                                                                   ::
                                                                   !(Prelude.Maybe Data.Int.Int32),
                                                                   _DescriptorProto'ReservedRange'_unknownFields
                                                                   :: !Data.ProtoLens.FieldSet}
                                       deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show DescriptorProto'ReservedRange where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ReservedRange
           "start"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'start
               (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'start = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ReservedRange
           "maybe'start"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'start
               (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'start = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ReservedRange
           "end"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'end
               (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'end = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField
           DescriptorProto'ReservedRange
           "maybe'end"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DescriptorProto'ReservedRange'end
               (\ x__ y__ -> x__{_DescriptorProto'ReservedRange'end = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message DescriptorProto'ReservedRange where
        messageName _
          = Data.Text.pack "google.protobuf.DescriptorProto.ReservedRange"
        fieldsByTag
          = let start__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "start"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'start"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange
                end__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "end"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'end"))
                      :: Data.ProtoLens.FieldDescriptor DescriptorProto'ReservedRange
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, start__field_descriptor),
                 (Data.ProtoLens.Tag 2, end__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens
              _DescriptorProto'ReservedRange'_unknownFields
              (\ x__ y__ ->
                 x__{_DescriptorProto'ReservedRange'_unknownFields = y__})
        defMessage
          = DescriptorProto'ReservedRange{_DescriptorProto'ReservedRange'start
                                            = Prelude.Nothing,
                                          _DescriptorProto'ReservedRange'end = Prelude.Nothing,
                                          _DescriptorProto'ReservedRange'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     DescriptorProto'ReservedRange ->
                       Data.ProtoLens.Encoding.Bytes.Parser DescriptorProto'ReservedRange
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "start"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y
                                             x)
                                16 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "end"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "ReservedRange"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
                                         Data.Monoid.<>
                                         ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                            Prelude.fromIntegral)
                                           _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
                                           Data.Monoid.<>
                                           ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                              Prelude.fromIntegral)
                                             _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData DescriptorProto'ReservedRange where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq
                 (_DescriptorProto'ReservedRange'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_DescriptorProto'ReservedRange'start x__)
                    (Control.DeepSeq.deepseq (_DescriptorProto'ReservedRange'end x__)
                       (()))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumDescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumDescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.value' @:: Lens' EnumDescriptorProto [EnumValueDescriptorProto]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'value' @:: Lens' EnumDescriptorProto
  (Data.Vector.Vector EnumValueDescriptorProto)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumDescriptorProto EnumOptions@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumDescriptorProto (Prelude.Maybe EnumOptions)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.reservedRange' @:: Lens' EnumDescriptorProto [EnumDescriptorProto'EnumReservedRange]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedRange' @:: Lens' EnumDescriptorProto
  (Data.Vector.Vector EnumDescriptorProto'EnumReservedRange)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.reservedName' @:: Lens' EnumDescriptorProto [Data.Text.Text]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'reservedName' @:: Lens' EnumDescriptorProto (Data.Vector.Vector Data.Text.Text)@
 -}
data EnumDescriptorProto = EnumDescriptorProto{_EnumDescriptorProto'name
                                               :: !(Prelude.Maybe Data.Text.Text),
                                               _EnumDescriptorProto'value ::
                                               !(Data.Vector.Vector EnumValueDescriptorProto),
                                               _EnumDescriptorProto'options ::
                                               !(Prelude.Maybe EnumOptions),
                                               _EnumDescriptorProto'reservedRange ::
                                               !(Data.Vector.Vector
                                                   EnumDescriptorProto'EnumReservedRange),
                                               _EnumDescriptorProto'reservedName ::
                                               !(Data.Vector.Vector Data.Text.Text),
                                               _EnumDescriptorProto'_unknownFields ::
                                               !Data.ProtoLens.FieldSet}
                             deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show EnumDescriptorProto where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField EnumDescriptorProto "name"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'name
               (\ x__ y__ -> x__{_EnumDescriptorProto'name = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "maybe'name"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'name
               (\ x__ y__ -> x__{_EnumDescriptorProto'name = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumDescriptorProto "value"
           ([EnumValueDescriptorProto])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'value
               (\ x__ y__ -> x__{_EnumDescriptorProto'value = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "vec'value"
           (Data.Vector.Vector EnumValueDescriptorProto)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'value
               (\ x__ y__ -> x__{_EnumDescriptorProto'value = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "options"
           (EnumOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'options
               (\ x__ y__ -> x__{_EnumDescriptorProto'options = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "maybe'options"
           (Prelude.Maybe EnumOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'options
               (\ x__ y__ -> x__{_EnumDescriptorProto'options = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "reservedRange"
           ([EnumDescriptorProto'EnumReservedRange])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'reservedRange
               (\ x__ y__ -> x__{_EnumDescriptorProto'reservedRange = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "vec'reservedRange"
           (Data.Vector.Vector EnumDescriptorProto'EnumReservedRange)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'reservedRange
               (\ x__ y__ -> x__{_EnumDescriptorProto'reservedRange = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "reservedName"
           ([Data.Text.Text])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'reservedName
               (\ x__ y__ -> x__{_EnumDescriptorProto'reservedName = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField EnumDescriptorProto
           "vec'reservedName"
           (Data.Vector.Vector Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumDescriptorProto'reservedName
               (\ x__ y__ -> x__{_EnumDescriptorProto'reservedName = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message EnumDescriptorProto where
        messageName _
          = Data.Text.pack "google.protobuf.EnumDescriptorProto"
        fieldsByTag
          = let name__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'name"))
                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor EnumValueDescriptorProto)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"value"))
                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto
                options__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "options"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor EnumOptions)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'options"))
                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto
                reservedRange__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "reserved_range"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor
                           EnumDescriptorProto'EnumReservedRange)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"reservedRange"))
                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto
                reservedName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "reserved_name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"reservedName"))
                      :: Data.ProtoLens.FieldDescriptor EnumDescriptorProto
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, name__field_descriptor),
                 (Data.ProtoLens.Tag 2, value__field_descriptor),
                 (Data.ProtoLens.Tag 3, options__field_descriptor),
                 (Data.ProtoLens.Tag 4, reservedRange__field_descriptor),
                 (Data.ProtoLens.Tag 5, reservedName__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _EnumDescriptorProto'_unknownFields
              (\ x__ y__ -> x__{_EnumDescriptorProto'_unknownFields = y__})
        defMessage
          = EnumDescriptorProto{_EnumDescriptorProto'name = Prelude.Nothing,
                                _EnumDescriptorProto'value = Data.Vector.Generic.empty,
                                _EnumDescriptorProto'options = Prelude.Nothing,
                                _EnumDescriptorProto'reservedRange = Data.Vector.Generic.empty,
                                _EnumDescriptorProto'reservedName = Data.Vector.Generic.empty,
                                _EnumDescriptorProto'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     EnumDescriptorProto ->
                       Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                         Data.ProtoLens.Encoding.Growing.RealWorld
                         Data.Text.Text
                         ->
                         Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                           Data.ProtoLens.Encoding.Growing.RealWorld
                           EnumDescriptorProto'EnumReservedRange
                           ->
                           Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                             Data.ProtoLens.Encoding.Growing.RealWorld
                             EnumValueDescriptorProto
                             -> Data.ProtoLens.Encoding.Bytes.Parser EnumDescriptorProto
                loop x mutable'reservedName mutable'reservedRange mutable'value
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do frozen'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                     (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                        mutable'reservedName)
                            frozen'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                      (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                         mutable'reservedRange)
                            frozen'value <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                              (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                 mutable'value)
                            let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 (Lens.Family2.set (Data.ProtoLens.Field.field @"vec'reservedName")
                                    frozen'reservedName
                                    (Lens.Family2.set
                                       (Data.ProtoLens.Field.field @"vec'reservedRange")
                                       frozen'reservedRange
                                       (Lens.Family2.set (Data.ProtoLens.Field.field @"vec'value")
                                          frozen'value
                                          x))))
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "name"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y
                                              x)
                                           mutable'reservedName
                                           mutable'reservedRange
                                           mutable'value
                                18 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "value"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'value
                                                   y)
                                         loop x mutable'reservedName mutable'reservedRange v
                                26 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "options"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"options")
                                              y
                                              x)
                                           mutable'reservedName
                                           mutable'reservedRange
                                           mutable'value
                                34 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "reserved_range"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'reservedRange
                                                   y)
                                         loop x mutable'reservedName v mutable'value
                                42 -> do !y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                               Data.ProtoLens.Encoding.Bytes.getBytes
                                                                 (Prelude.fromIntegral len)
                                                   Data.ProtoLens.Encoding.Bytes.runEither
                                                     (case Data.Text.Encoding.decodeUtf8' value of
                                                          Prelude.Left err -> Prelude.Left
                                                                                (Prelude.show err)
                                                          Prelude.Right r -> Prelude.Right r))
                                                 Data.ProtoLens.Encoding.Bytes.<?> "reserved_name"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'reservedName
                                                   y)
                                         loop x v mutable'reservedRange mutable'value
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
                                             mutable'reservedName
                                             mutable'reservedRange
                                             mutable'value
              in
              (do mutable'reservedName <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                            Data.ProtoLens.Encoding.Growing.new
                  mutable'reservedRange <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                             Data.ProtoLens.Encoding.Growing.new
                  mutable'value <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                     Data.ProtoLens.Encoding.Growing.new
                  loop Data.ProtoLens.defMessage mutable'reservedName
                    mutable'reservedRange
                    mutable'value)
                Data.ProtoLens.Encoding.Bytes.<?> "EnumDescriptorProto"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
                                         Data.Monoid.<>
                                         (((\ bs ->
                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                                Data.Monoid.<>
                                                Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                            Prelude.. Data.Text.Encoding.encodeUtf8)
                                           _v)
                 Data.Monoid.<>
                 (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                    (\ _v ->
                       (Data.ProtoLens.Encoding.Bytes.putVarInt 18) Data.Monoid.<>
                         (((\ bs ->
                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                            Prelude.. Data.ProtoLens.encodeMessage)
                           _v)
                    (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'value") _x))
                   Data.Monoid.<>
                   (case
                      Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x
                      of
                        (Prelude.Nothing) -> Data.Monoid.mempty
                        Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 26)
                                             Data.Monoid.<>
                                             (((\ bs ->
                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                     (Prelude.fromIntegral
                                                        (Data.ByteString.length bs)))
                                                    Data.Monoid.<>
                                                    Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                                Prelude.. Data.ProtoLens.encodeMessage)
                                               _v)
                     Data.Monoid.<>
                     (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                        (\ _v ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt 34) Data.Monoid.<>
                             (((\ bs ->
                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
                                    Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                Prelude.. Data.ProtoLens.encodeMessage)
                               _v)
                        (Lens.Family2.view
                           (Data.ProtoLens.Field.field @"vec'reservedRange")
                           _x))
                       Data.Monoid.<>
                       (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                          (\ _v ->
                             (Data.ProtoLens.Encoding.Bytes.putVarInt 42) Data.Monoid.<>
                               (((\ bs ->
                                    (Data.ProtoLens.Encoding.Bytes.putVarInt
                                       (Prelude.fromIntegral (Data.ByteString.length bs)))
                                      Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                  Prelude.. Data.Text.Encoding.encodeUtf8)
                                 _v)
                          (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'reservedName")
                             _x))
                         Data.Monoid.<>
                         Data.ProtoLens.Encoding.Wire.buildFieldSet
                           (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData EnumDescriptorProto where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_EnumDescriptorProto'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_EnumDescriptorProto'name x__)
                    (Control.DeepSeq.deepseq (_EnumDescriptorProto'value x__)
                       (Control.DeepSeq.deepseq (_EnumDescriptorProto'options x__)
                          (Control.DeepSeq.deepseq (_EnumDescriptorProto'reservedRange x__)
                             (Control.DeepSeq.deepseq (_EnumDescriptorProto'reservedName x__)
                                (())))))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.start' @:: Lens' EnumDescriptorProto'EnumReservedRange Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'start' @:: Lens' EnumDescriptorProto'EnumReservedRange
  (Prelude.Maybe Data.Int.Int32)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.end' @:: Lens' EnumDescriptorProto'EnumReservedRange Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'end' @:: Lens' EnumDescriptorProto'EnumReservedRange
  (Prelude.Maybe Data.Int.Int32)@
 -}
data EnumDescriptorProto'EnumReservedRange = EnumDescriptorProto'EnumReservedRange{_EnumDescriptorProto'EnumReservedRange'start
                                                                                   ::
                                                                                   !(Prelude.Maybe
                                                                                       Data.Int.Int32),
                                                                                   _EnumDescriptorProto'EnumReservedRange'end
                                                                                   ::
                                                                                   !(Prelude.Maybe
                                                                                       Data.Int.Int32),
                                                                                   _EnumDescriptorProto'EnumReservedRange'_unknownFields
                                                                                   ::
                                                                                   !Data.ProtoLens.FieldSet}
                                               deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show EnumDescriptorProto'EnumReservedRange where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField
           EnumDescriptorProto'EnumReservedRange
           "start"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _EnumDescriptorProto'EnumReservedRange'start
               (\ x__ y__ ->
                  x__{_EnumDescriptorProto'EnumReservedRange'start = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField
           EnumDescriptorProto'EnumReservedRange
           "maybe'start"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _EnumDescriptorProto'EnumReservedRange'start
               (\ x__ y__ ->
                  x__{_EnumDescriptorProto'EnumReservedRange'start = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField
           EnumDescriptorProto'EnumReservedRange
           "end"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _EnumDescriptorProto'EnumReservedRange'end
               (\ x__ y__ ->
                  x__{_EnumDescriptorProto'EnumReservedRange'end = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField
           EnumDescriptorProto'EnumReservedRange
           "maybe'end"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _EnumDescriptorProto'EnumReservedRange'end
               (\ x__ y__ ->
                  x__{_EnumDescriptorProto'EnumReservedRange'end = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message
           EnumDescriptorProto'EnumReservedRange
         where
        messageName _
          = Data.Text.pack
              "google.protobuf.EnumDescriptorProto.EnumReservedRange"
        fieldsByTag
          = let start__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "start"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'start"))
                      ::
                      Data.ProtoLens.FieldDescriptor
                        EnumDescriptorProto'EnumReservedRange
                end__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "end"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'end"))
                      ::
                      Data.ProtoLens.FieldDescriptor
                        EnumDescriptorProto'EnumReservedRange
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, start__field_descriptor),
                 (Data.ProtoLens.Tag 2, end__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens
              _EnumDescriptorProto'EnumReservedRange'_unknownFields
              (\ x__ y__ ->
                 x__{_EnumDescriptorProto'EnumReservedRange'_unknownFields = y__})
        defMessage
          = EnumDescriptorProto'EnumReservedRange{_EnumDescriptorProto'EnumReservedRange'start
                                                    = Prelude.Nothing,
                                                  _EnumDescriptorProto'EnumReservedRange'end =
                                                    Prelude.Nothing,
                                                  _EnumDescriptorProto'EnumReservedRange'_unknownFields
                                                    = ([])}
        parseMessage
          = let loop ::
                     EnumDescriptorProto'EnumReservedRange ->
                       Data.ProtoLens.Encoding.Bytes.Parser
                         EnumDescriptorProto'EnumReservedRange
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "start"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"start") y
                                             x)
                                16 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "end"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"end") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "EnumReservedRange"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'start") _x of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
                                         Data.Monoid.<>
                                         ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                            Prelude.fromIntegral)
                                           _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'end") _x of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
                                           Data.Monoid.<>
                                           ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                              Prelude.fromIntegral)
                                             _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData
           EnumDescriptorProto'EnumReservedRange
         where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq
                 (_EnumDescriptorProto'EnumReservedRange'_unknownFields x__)
                 (Control.DeepSeq.deepseq
                    (_EnumDescriptorProto'EnumReservedRange'start x__)
                    (Control.DeepSeq.deepseq
                       (_EnumDescriptorProto'EnumReservedRange'end x__)
                       (()))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.allowAlias' @:: Lens' EnumOptions Prelude.Bool@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'allowAlias' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumOptions Prelude.Bool@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumOptions (Prelude.Maybe Prelude.Bool)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumOptions [UninterpretedOption]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' EnumOptions (Data.Vector.Vector UninterpretedOption)@
 -}
data EnumOptions = EnumOptions{_EnumOptions'allowAlias ::
                               !(Prelude.Maybe Prelude.Bool),
                               _EnumOptions'deprecated :: !(Prelude.Maybe Prelude.Bool),
                               _EnumOptions'uninterpretedOption ::
                               !(Data.Vector.Vector UninterpretedOption),
                               _EnumOptions'_unknownFields :: !Data.ProtoLens.FieldSet}
                     deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show EnumOptions where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField EnumOptions "allowAlias"
           (Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumOptions'allowAlias
               (\ x__ y__ -> x__{_EnumOptions'allowAlias = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField EnumOptions
           "maybe'allowAlias"
           (Prelude.Maybe Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumOptions'allowAlias
               (\ x__ y__ -> x__{_EnumOptions'allowAlias = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumOptions "deprecated"
           (Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumOptions'deprecated
               (\ x__ y__ -> x__{_EnumOptions'deprecated = y__}))
              Prelude.. Data.ProtoLens.maybeLens Prelude.False
instance Data.ProtoLens.Field.HasField EnumOptions
           "maybe'deprecated"
           (Prelude.Maybe Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumOptions'deprecated
               (\ x__ y__ -> x__{_EnumOptions'deprecated = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumOptions
           "uninterpretedOption"
           ([UninterpretedOption])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumOptions'uninterpretedOption
               (\ x__ y__ -> x__{_EnumOptions'uninterpretedOption = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField EnumOptions
           "vec'uninterpretedOption"
           (Data.Vector.Vector UninterpretedOption)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumOptions'uninterpretedOption
               (\ x__ y__ -> x__{_EnumOptions'uninterpretedOption = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message EnumOptions where
        messageName _ = Data.Text.pack "google.protobuf.EnumOptions"
        fieldsByTag
          = let allowAlias__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "allow_alias"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'allowAlias"))
                      :: Data.ProtoLens.FieldDescriptor EnumOptions
                deprecated__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "deprecated"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'deprecated"))
                      :: Data.ProtoLens.FieldDescriptor EnumOptions
                uninterpretedOption__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"uninterpretedOption"))
                      :: Data.ProtoLens.FieldDescriptor EnumOptions
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 2, allowAlias__field_descriptor),
                 (Data.ProtoLens.Tag 3, deprecated__field_descriptor),
                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _EnumOptions'_unknownFields
              (\ x__ y__ -> x__{_EnumOptions'_unknownFields = y__})
        defMessage
          = EnumOptions{_EnumOptions'allowAlias = Prelude.Nothing,
                        _EnumOptions'deprecated = Prelude.Nothing,
                        _EnumOptions'uninterpretedOption = Data.Vector.Generic.empty,
                        _EnumOptions'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     EnumOptions ->
                       Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                         Data.ProtoLens.Encoding.Growing.RealWorld
                         UninterpretedOption
                         -> Data.ProtoLens.Encoding.Bytes.Parser EnumOptions
                loop x mutable'uninterpretedOption
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                            (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                               mutable'uninterpretedOption)
                            let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 (Lens.Family2.set
                                    (Data.ProtoLens.Field.field @"vec'uninterpretedOption")
                                    frozen'uninterpretedOption
                                    x))
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                16 -> do y <- (Prelude.fmap ((Prelude./=) 0)
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "allow_alias"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"allowAlias")
                                              y
                                              x)
                                           mutable'uninterpretedOption
                                24 -> do y <- (Prelude.fmap ((Prelude./=) 0)
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "deprecated"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"deprecated")
                                              y
                                              x)
                                           mutable'uninterpretedOption
                                7994 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                     Data.ProtoLens.Encoding.Bytes.isolate
                                                       (Prelude.fromIntegral len)
                                                       Data.ProtoLens.parseMessage)
                                                   Data.ProtoLens.Encoding.Bytes.<?>
                                                   "uninterpreted_option"
                                           v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                  (Data.ProtoLens.Encoding.Growing.append
                                                     mutable'uninterpretedOption
                                                     y)
                                           loop x v
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
                                             mutable'uninterpretedOption
              in
              (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                   Data.ProtoLens.Encoding.Growing.new
                  loop Data.ProtoLens.defMessage mutable'uninterpretedOption)
                Data.ProtoLens.Encoding.Bytes.<?> "EnumOptions"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'allowAlias")
                    _x
                  of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
                                         Data.Monoid.<>
                                         ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                            (\ b -> if b then 1 else 0))
                                           _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'deprecated")
                      _x
                    of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
                                           Data.Monoid.<>
                                           ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                              (\ b -> if b then 1 else 0))
                                             _v)
                   Data.Monoid.<>
                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                      (\ _v ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) Data.Monoid.<>
                           (((\ bs ->
                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                   (Prelude.fromIntegral (Data.ByteString.length bs)))
                                  Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                              Prelude.. Data.ProtoLens.encodeMessage)
                             _v)
                      (Lens.Family2.view
                         (Data.ProtoLens.Field.field @"vec'uninterpretedOption")
                         _x))
                     Data.Monoid.<>
                     Data.ProtoLens.Encoding.Wire.buildFieldSet
                       (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData EnumOptions where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_EnumOptions'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_EnumOptions'allowAlias x__)
                    (Control.DeepSeq.deepseq (_EnumOptions'deprecated x__)
                       (Control.DeepSeq.deepseq (_EnumOptions'uninterpretedOption x__)
                          (())))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' EnumValueDescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' EnumValueDescriptorProto Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe Data.Int.Int32)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' EnumValueDescriptorProto EnumValueOptions@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' EnumValueDescriptorProto (Prelude.Maybe EnumValueOptions)@
 -}
data EnumValueDescriptorProto = EnumValueDescriptorProto{_EnumValueDescriptorProto'name
                                                         :: !(Prelude.Maybe Data.Text.Text),
                                                         _EnumValueDescriptorProto'number ::
                                                         !(Prelude.Maybe Data.Int.Int32),
                                                         _EnumValueDescriptorProto'options ::
                                                         !(Prelude.Maybe EnumValueOptions),
                                                         _EnumValueDescriptorProto'_unknownFields ::
                                                         !Data.ProtoLens.FieldSet}
                                  deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show EnumValueDescriptorProto where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto
           "name"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'name
               (\ x__ y__ -> x__{_EnumValueDescriptorProto'name = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto
           "maybe'name"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'name
               (\ x__ y__ -> x__{_EnumValueDescriptorProto'name = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto
           "number"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'number
               (\ x__ y__ -> x__{_EnumValueDescriptorProto'number = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto
           "maybe'number"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'number
               (\ x__ y__ -> x__{_EnumValueDescriptorProto'number = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto
           "options"
           (EnumValueOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'options
               (\ x__ y__ -> x__{_EnumValueDescriptorProto'options = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField EnumValueDescriptorProto
           "maybe'options"
           (Prelude.Maybe EnumValueOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueDescriptorProto'options
               (\ x__ y__ -> x__{_EnumValueDescriptorProto'options = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message EnumValueDescriptorProto where
        messageName _
          = Data.Text.pack "google.protobuf.EnumValueDescriptorProto"
        fieldsByTag
          = let name__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'name"))
                      :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto
                number__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "number"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'number"))
                      :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto
                options__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "options"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor EnumValueOptions)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'options"))
                      :: Data.ProtoLens.FieldDescriptor EnumValueDescriptorProto
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, name__field_descriptor),
                 (Data.ProtoLens.Tag 2, number__field_descriptor),
                 (Data.ProtoLens.Tag 3, options__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens
              _EnumValueDescriptorProto'_unknownFields
              (\ x__ y__ -> x__{_EnumValueDescriptorProto'_unknownFields = y__})
        defMessage
          = EnumValueDescriptorProto{_EnumValueDescriptorProto'name =
                                       Prelude.Nothing,
                                     _EnumValueDescriptorProto'number = Prelude.Nothing,
                                     _EnumValueDescriptorProto'options = Prelude.Nothing,
                                     _EnumValueDescriptorProto'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     EnumValueDescriptorProto ->
                       Data.ProtoLens.Encoding.Bytes.Parser EnumValueDescriptorProto
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "name"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y
                                              x)
                                16 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "number"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"number")
                                              y
                                              x)
                                26 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "options"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"options")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "EnumValueDescriptorProto"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
                                         Data.Monoid.<>
                                         (((\ bs ->
                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                                Data.Monoid.<>
                                                Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                            Prelude.. Data.Text.Encoding.encodeUtf8)
                                           _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'number") _x
                    of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 16)
                                           Data.Monoid.<>
                                           ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                              Prelude.fromIntegral)
                                             _v)
                   Data.Monoid.<>
                   (case
                      Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options") _x
                      of
                        (Prelude.Nothing) -> Data.Monoid.mempty
                        Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 26)
                                             Data.Monoid.<>
                                             (((\ bs ->
                                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                     (Prelude.fromIntegral
                                                        (Data.ByteString.length bs)))
                                                    Data.Monoid.<>
                                                    Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                                Prelude.. Data.ProtoLens.encodeMessage)
                                               _v)
                     Data.Monoid.<>
                     Data.ProtoLens.Encoding.Wire.buildFieldSet
                       (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData EnumValueDescriptorProto where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq
                 (_EnumValueDescriptorProto'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_EnumValueDescriptorProto'name x__)
                    (Control.DeepSeq.deepseq (_EnumValueDescriptorProto'number x__)
                       (Control.DeepSeq.deepseq (_EnumValueDescriptorProto'options x__)
                          (())))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.deprecated' @:: Lens' EnumValueOptions Prelude.Bool@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'deprecated' @:: Lens' EnumValueOptions (Prelude.Maybe Prelude.Bool)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' EnumValueOptions [UninterpretedOption]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' EnumValueOptions (Data.Vector.Vector UninterpretedOption)@
 -}
data EnumValueOptions = EnumValueOptions{_EnumValueOptions'deprecated
                                         :: !(Prelude.Maybe Prelude.Bool),
                                         _EnumValueOptions'uninterpretedOption ::
                                         !(Data.Vector.Vector UninterpretedOption),
                                         _EnumValueOptions'_unknownFields ::
                                         !Data.ProtoLens.FieldSet}
                          deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show EnumValueOptions where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField EnumValueOptions
           "deprecated"
           (Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueOptions'deprecated
               (\ x__ y__ -> x__{_EnumValueOptions'deprecated = y__}))
              Prelude.. Data.ProtoLens.maybeLens Prelude.False
instance Data.ProtoLens.Field.HasField EnumValueOptions
           "maybe'deprecated"
           (Prelude.Maybe Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _EnumValueOptions'deprecated
               (\ x__ y__ -> x__{_EnumValueOptions'deprecated = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField EnumValueOptions
           "uninterpretedOption"
           ([UninterpretedOption])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _EnumValueOptions'uninterpretedOption
               (\ x__ y__ -> x__{_EnumValueOptions'uninterpretedOption = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField EnumValueOptions
           "vec'uninterpretedOption"
           (Data.Vector.Vector UninterpretedOption)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _EnumValueOptions'uninterpretedOption
               (\ x__ y__ -> x__{_EnumValueOptions'uninterpretedOption = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message EnumValueOptions where
        messageName _ = Data.Text.pack "google.protobuf.EnumValueOptions"
        fieldsByTag
          = let deprecated__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "deprecated"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'deprecated"))
                      :: Data.ProtoLens.FieldDescriptor EnumValueOptions
                uninterpretedOption__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"uninterpretedOption"))
                      :: Data.ProtoLens.FieldDescriptor EnumValueOptions
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, deprecated__field_descriptor),
                 (Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _EnumValueOptions'_unknownFields
              (\ x__ y__ -> x__{_EnumValueOptions'_unknownFields = y__})
        defMessage
          = EnumValueOptions{_EnumValueOptions'deprecated = Prelude.Nothing,
                             _EnumValueOptions'uninterpretedOption = Data.Vector.Generic.empty,
                             _EnumValueOptions'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     EnumValueOptions ->
                       Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                         Data.ProtoLens.Encoding.Growing.RealWorld
                         UninterpretedOption
                         -> Data.ProtoLens.Encoding.Bytes.Parser EnumValueOptions
                loop x mutable'uninterpretedOption
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                            (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                               mutable'uninterpretedOption)
                            let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 (Lens.Family2.set
                                    (Data.ProtoLens.Field.field @"vec'uninterpretedOption")
                                    frozen'uninterpretedOption
                                    x))
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap ((Prelude./=) 0)
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "deprecated"
                                        loop
                                          (Lens.Family2.set
                                             (Data.ProtoLens.Field.field @"deprecated")
                                             y
                                             x)
                                          mutable'uninterpretedOption
                                7994 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                     Data.ProtoLens.Encoding.Bytes.isolate
                                                       (Prelude.fromIntegral len)
                                                       Data.ProtoLens.parseMessage)
                                                   Data.ProtoLens.Encoding.Bytes.<?>
                                                   "uninterpreted_option"
                                           v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                  (Data.ProtoLens.Encoding.Growing.append
                                                     mutable'uninterpretedOption
                                                     y)
                                           loop x v
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
                                             mutable'uninterpretedOption
              in
              (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                   Data.ProtoLens.Encoding.Growing.new
                  loop Data.ProtoLens.defMessage mutable'uninterpretedOption)
                Data.ProtoLens.Encoding.Bytes.<?> "EnumValueOptions"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'deprecated")
                    _x
                  of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 8)
                                         Data.Monoid.<>
                                         ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                            (\ b -> if b then 1 else 0))
                                           _v)
                 Data.Monoid.<>
                 (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                    (\ _v ->
                       (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) Data.Monoid.<>
                         (((\ bs ->
                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                            Prelude.. Data.ProtoLens.encodeMessage)
                           _v)
                    (Lens.Family2.view
                       (Data.ProtoLens.Field.field @"vec'uninterpretedOption")
                       _x))
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData EnumValueOptions where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_EnumValueOptions'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_EnumValueOptions'deprecated x__)
                    (Control.DeepSeq.deepseq
                       (_EnumValueOptions'uninterpretedOption x__)
                       (()))))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.uninterpretedOption' @:: Lens' ExtensionRangeOptions [UninterpretedOption]@
    * 'Proto.Google.Protobuf.Descriptor_Fields.vec'uninterpretedOption' @:: Lens' ExtensionRangeOptions
  (Data.Vector.Vector UninterpretedOption)@
 -}
data ExtensionRangeOptions = ExtensionRangeOptions{_ExtensionRangeOptions'uninterpretedOption
                                                   :: !(Data.Vector.Vector UninterpretedOption),
                                                   _ExtensionRangeOptions'_unknownFields ::
                                                   !Data.ProtoLens.FieldSet}
                               deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show ExtensionRangeOptions where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField ExtensionRangeOptions
           "uninterpretedOption"
           ([UninterpretedOption])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _ExtensionRangeOptions'uninterpretedOption
               (\ x__ y__ ->
                  x__{_ExtensionRangeOptions'uninterpretedOption = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField ExtensionRangeOptions
           "vec'uninterpretedOption"
           (Data.Vector.Vector UninterpretedOption)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens
               _ExtensionRangeOptions'uninterpretedOption
               (\ x__ y__ ->
                  x__{_ExtensionRangeOptions'uninterpretedOption = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message ExtensionRangeOptions where
        messageName _
          = Data.Text.pack "google.protobuf.ExtensionRangeOptions"
        fieldsByTag
          = let uninterpretedOption__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "uninterpreted_option"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor UninterpretedOption)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"uninterpretedOption"))
                      :: Data.ProtoLens.FieldDescriptor ExtensionRangeOptions
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 999, uninterpretedOption__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _ExtensionRangeOptions'_unknownFields
              (\ x__ y__ -> x__{_ExtensionRangeOptions'_unknownFields = y__})
        defMessage
          = ExtensionRangeOptions{_ExtensionRangeOptions'uninterpretedOption
                                    = Data.Vector.Generic.empty,
                                  _ExtensionRangeOptions'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     ExtensionRangeOptions ->
                       Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                         Data.ProtoLens.Encoding.Growing.RealWorld
                         UninterpretedOption
                         -> Data.ProtoLens.Encoding.Bytes.Parser ExtensionRangeOptions
                loop x mutable'uninterpretedOption
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do frozen'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                            (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                               mutable'uninterpretedOption)
                            let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 (Lens.Family2.set
                                    (Data.ProtoLens.Field.field @"vec'uninterpretedOption")
                                    frozen'uninterpretedOption
                                    x))
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                7994 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                     Data.ProtoLens.Encoding.Bytes.isolate
                                                       (Prelude.fromIntegral len)
                                                       Data.ProtoLens.parseMessage)
                                                   Data.ProtoLens.Encoding.Bytes.<?>
                                                   "uninterpreted_option"
                                           v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                  (Data.ProtoLens.Encoding.Growing.append
                                                     mutable'uninterpretedOption
                                                     y)
                                           loop x v
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
                                             mutable'uninterpretedOption
              in
              (do mutable'uninterpretedOption <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                   Data.ProtoLens.Encoding.Growing.new
                  loop Data.ProtoLens.defMessage mutable'uninterpretedOption)
                Data.ProtoLens.Encoding.Bytes.<?> "ExtensionRangeOptions"
        buildMessage
          = (\ _x ->
               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                  (\ _v ->
                     (Data.ProtoLens.Encoding.Bytes.putVarInt 7994) Data.Monoid.<>
                       (((\ bs ->
                            (Data.ProtoLens.Encoding.Bytes.putVarInt
                               (Prelude.fromIntegral (Data.ByteString.length bs)))
                              Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                          Prelude.. Data.ProtoLens.encodeMessage)
                         _v)
                  (Lens.Family2.view
                     (Data.ProtoLens.Field.field @"vec'uninterpretedOption")
                     _x))
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData ExtensionRangeOptions where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_ExtensionRangeOptions'_unknownFields x__)
                 (Control.DeepSeq.deepseq
                    (_ExtensionRangeOptions'uninterpretedOption x__)
                    (())))
{- | Fields :

    * 'Proto.Google.Protobuf.Descriptor_Fields.name' @:: Lens' FieldDescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'name' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.number' @:: Lens' FieldDescriptorProto Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'number' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.label' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Label@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'label' @:: Lens' FieldDescriptorProto
  (Prelude.Maybe FieldDescriptorProto'Label)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.type'' @:: Lens' FieldDescriptorProto FieldDescriptorProto'Type@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'type'' @:: Lens' FieldDescriptorProto
  (Prelude.Maybe FieldDescriptorProto'Type)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.typeName' @:: Lens' FieldDescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'typeName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.extendee' @:: Lens' FieldDescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'extendee' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.defaultValue' @:: Lens' FieldDescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'defaultValue' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.oneofIndex' @:: Lens' FieldDescriptorProto Data.Int.Int32@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'oneofIndex' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Int.Int32)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.jsonName' @:: Lens' FieldDescriptorProto Data.Text.Text@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'jsonName' @:: Lens' FieldDescriptorProto (Prelude.Maybe Data.Text.Text)@
    * 'Proto.Google.Protobuf.Descriptor_Fields.options' @:: Lens' FieldDescriptorProto FieldOptions@
    * 'Proto.Google.Protobuf.Descriptor_Fields.maybe'options' @:: Lens' FieldDescriptorProto (Prelude.Maybe FieldOptions)@
 -}
data FieldDescriptorProto = FieldDescriptorProto{_FieldDescriptorProto'name
                                                 :: !(Prelude.Maybe Data.Text.Text),
                                                 _FieldDescriptorProto'number ::
                                                 !(Prelude.Maybe Data.Int.Int32),
                                                 _FieldDescriptorProto'label ::
                                                 !(Prelude.Maybe FieldDescriptorProto'Label),
                                                 _FieldDescriptorProto'type' ::
                                                 !(Prelude.Maybe FieldDescriptorProto'Type),
                                                 _FieldDescriptorProto'typeName ::
                                                 !(Prelude.Maybe Data.Text.Text),
                                                 _FieldDescriptorProto'extendee ::
                                                 !(Prelude.Maybe Data.Text.Text),
                                                 _FieldDescriptorProto'defaultValue ::
                                                 !(Prelude.Maybe Data.Text.Text),
                                                 _FieldDescriptorProto'oneofIndex ::
                                                 !(Prelude.Maybe Data.Int.Int32),
                                                 _FieldDescriptorProto'jsonName ::
                                                 !(Prelude.Maybe Data.Text.Text),
                                                 _FieldDescriptorProto'options ::
                                                 !(Prelude.Maybe FieldOptions),
                                                 _FieldDescriptorProto'_unknownFields ::
                                                 !Data.ProtoLens.FieldSet}
                              deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show FieldDescriptorProto where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField FieldDescriptorProto "name"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'name
               (\ x__ y__ -> x__{_FieldDescriptorProto'name = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'name"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'name
               (\ x__ y__ -> x__{_FieldDescriptorProto'name = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "number"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'number
               (\ x__ y__ -> x__{_FieldDescriptorProto'number = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'number"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'number
               (\ x__ y__ -> x__{_FieldDescriptorProto'number = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto "label"
           (FieldDescriptorProto'Label)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'label
               (\ x__ y__ -> x__{_FieldDescriptorProto'label = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'label"
           (Prelude.Maybe FieldDescriptorProto'Label)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'label
               (\ x__ y__ -> x__{_FieldDescriptorProto'label = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto "type'"
           (FieldDescriptorProto'Type)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'type'
               (\ x__ y__ -> x__{_FieldDescriptorProto'type' = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'type'"
           (Prelude.Maybe FieldDescriptorProto'Type)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'type'
               (\ x__ y__ -> x__{_FieldDescriptorProto'type' = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "typeName"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'typeName
               (\ x__ y__ -> x__{_FieldDescriptorProto'typeName = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'typeName"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'typeName
               (\ x__ y__ -> x__{_FieldDescriptorProto'typeName = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "extendee"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'extendee
               (\ x__ y__ -> x__{_FieldDescriptorProto'extendee = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'extendee"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'extendee
               (\ x__ y__ -> x__{_FieldDescriptorProto'extendee = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "defaultValue"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'defaultValue
               (\ x__ y__ -> x__{_FieldDescriptorProto'defaultValue = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'defaultValue"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'defaultValue
               (\ x__ y__ -> x__{_FieldDescriptorProto'defaultValue = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "oneofIndex"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'oneofIndex
               (\ x__ y__ -> x__{_FieldDescriptorProto'oneofIndex = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'oneofIndex"
           (Prelude.Maybe Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'oneofIndex
               (\ x__ y__ -> x__{_FieldDescriptorProto'oneofIndex = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "jsonName"
           (Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'jsonName
               (\ x__ y__ -> x__{_FieldDescriptorProto'jsonName = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'jsonName"
           (Prelude.Maybe Data.Text.Text)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'jsonName
               (\ x__ y__ -> x__{_FieldDescriptorProto'jsonName = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "options"
           (FieldOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'options
               (\ x__ y__ -> x__{_FieldDescriptorProto'options = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField FieldDescriptorProto
           "maybe'options"
           (Prelude.Maybe FieldOptions)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _FieldDescriptorProto'options
               (\ x__ y__ -> x__{_FieldDescriptorProto'options = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message FieldDescriptorProto where
        messageName _
          = Data.Text.pack "google.protobuf.FieldDescriptorProto"
        fieldsByTag
          = let name__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'name"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                number__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "number"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'number"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                label__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "label"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Label)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'label"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                type'__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "type"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor FieldDescriptorProto'Type)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'type'"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                typeName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "type_name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'typeName"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                extendee__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "extendee"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'extendee"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                defaultValue__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "default_value"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'defaultValue"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                oneofIndex__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "oneof_index"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'oneofIndex"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                jsonName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "json_name"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'jsonName"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
                options__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "options"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor FieldOptions)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'options"))
                      :: Data.ProtoLens.FieldDescriptor FieldDescriptorProto
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, name__field_descriptor),
                 (Data.ProtoLens.Tag 3, number__field_descriptor),
                 (Data.ProtoLens.Tag 4, label__field_descriptor),
                 (Data.ProtoLens.Tag 5, type'__field_descriptor),
                 (Data.ProtoLens.Tag 6, typeName__field_descriptor),
                 (Data.ProtoLens.Tag 2, extendee__field_descriptor),
                 (Data.ProtoLens.Tag 7, defaultValue__field_descriptor),
                 (Data.ProtoLens.Tag 9, oneofIndex__field_descriptor),
                 (Data.ProtoLens.Tag 10, jsonName__field_descriptor),
                 (Data.ProtoLens.Tag 8, options__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _FieldDescriptorProto'_unknownFields
              (\ x__ y__ -> x__{_FieldDescriptorProto'_unknownFields = y__})
        defMessage
          = FieldDescriptorProto{_FieldDescriptorProto'name =
                                   Prelude.Nothing,
                                 _FieldDescriptorProto'number = Prelude.Nothing,
                                 _FieldDescriptorProto'label = Prelude.Nothing,
                                 _FieldDescriptorProto'type' = Prelude.Nothing,
                                 _FieldDescriptorProto'typeName = Prelude.Nothing,
                                 _FieldDescriptorProto'extendee = Prelude.Nothing,
                                 _FieldDescriptorProto'defaultValue = Prelude.Nothing,
                                 _FieldDescriptorProto'oneofIndex = Prelude.Nothing,
                                 _FieldDescriptorProto'jsonName = Prelude.Nothing,
                                 _FieldDescriptorProto'options = Prelude.Nothing,
                                 _FieldDescriptorProto'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     FieldDescriptorProto ->
                       Data.ProtoLens.Encoding.Bytes.Parser FieldDescriptorProto
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "name"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"name") y
                                              x)
                                24 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "number"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"number")
                                              y
                                              x)
                                32 -> do y <- (Prelude.fmap Prelude.toEnum
                                                 (Prelude.fmap Prelude.fromIntegral
                                                    Data.ProtoLens.Encoding.Bytes.getVarInt))
                                                Data.ProtoLens.Encoding.Bytes.<?> "label"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"label") y
                                              x)
                                40 -> do y <- (Prelude.fmap Prelude.toEnum
                                                 (Prelude.fmap Prelude.fromIntegral
                                                    Data.ProtoLens.Encoding.Bytes.getVarInt))
                                                Data.ProtoLens.Encoding.Bytes.<?> "type"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"type'") y
                                              x)
                                50 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "type_name"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"typeName")
                                              y
                                              x)
                                18 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "extendee"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"extendee")
                                              y
                                              x)
                                58 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "default_value"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"defaultValue")
                                              y
                                              x)
                                72 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "oneof_index"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"oneofIndex")
                                              y
                                              x)
                                82 -> do y <- (do value <- do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                              Data.ProtoLens.Encoding.Bytes.getBytes
                                                                (Prelude.fromIntegral len)
                                                  Data.ProtoLens.Encoding.Bytes.runEither
                                                    (case Data.Text.Encoding.decodeUtf8' value of
                                                         Prelude.Left err -> Prelude.Left
                                                                               (Prelude.show err)
                                                         Prelude.Right r -> Prelude.Right r))
                                                Data.ProtoLens.Encoding.Bytes.<?> "json_name"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"jsonName")
                                              y
                                              x)
                                66 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "options"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"options")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "FieldDescriptorProto"
        buildMessage
          = (\ _x ->
               (case
                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'name") _x of
                    (Prelude.Nothing) -> Data.Monoid.mempty
                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 10)
                                         Data.Monoid.<>
                                         (((\ bs ->
                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                 (Prelude.fromIntegral (Data.ByteString.length bs)))
                                                Data.Monoid.<>
                                                Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                            Prelude.. Data.Text.Encoding.encodeUtf8)
                                           _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'number") _x
                    of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 24)
                                           Data.Monoid.<>
                                           ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                              Prelude.fromIntegral)
                                             _v)
                   Data.Monoid.<>
                   (case
                      Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'label") _x of
                        (Prelude.Nothing) -> Data.Monoid.mempty
                        Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 32)
                                             Data.Monoid.<>
                                             (((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                                 Prelude.fromIntegral)
                                                Prelude.. Prelude.fromEnum)
                                               _v)
                     Data.Monoid.<>
                     (case
                        Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'type'") _x of
                          (Prelude.Nothing) -> Data.Monoid.mempty
                          Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 40)
                                               Data.Monoid.<>
                                               (((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                                                   Prelude.fromIntegral)
                                                  Prelude.. Prelude.fromEnum)
                                                 _v)
                       Data.Monoid.<>
                       (case
                          Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'typeName") _x
                          of
                            (Prelude.Nothing) -> Data.Monoid.mempty
                            Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 50)
                                                 Data.Monoid.<>
                                                 (((\ bs ->
                                                      (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                         (Prelude.fromIntegral
                                                            (Data.ByteString.length bs)))
                                                        Data.Monoid.<>
                                                        Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                                    Prelude.. Data.Text.Encoding.encodeUtf8)
                                                   _v)
                         Data.Monoid.<>
                         (case
                            Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'extendee") _x
                            of
                              (Prelude.Nothing) -> Data.Monoid.mempty
                              Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
                                                   Data.Monoid.<>
                                                   (((\ bs ->
                                                        (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                           (Prelude.fromIntegral
                                                              (Data.ByteString.length bs)))
                                                          Data.Monoid.<>
                                                          Data.ProtoLens.Encoding.Bytes.putBytes
                                                            bs))
                                                      Prelude.. Data.Text.Encoding.encodeUtf8)
                                                     _v)
                           Data.Monoid.<>
                           (case
                              Lens.Family2.view
                                (Data.ProtoLens.Field.field @"maybe'defaultValue")
                                _x
                              of
                                (Prelude.Nothing) -> Data.Monoid.mempty
                                Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 58)
                                                     Data.Monoid.<>
                                                     (((\ bs ->
                                                          (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                             (Prelude.fromIntegral
                                                                (Data.ByteString.length bs)))
                                                            Data.Monoid.<>
                                                            Data.ProtoLens.Encoding.Bytes.putBytes
                                                              bs))
                                                        Prelude.. Data.Text.Encoding.encodeUtf8)
                                                       _v)
                             Data.Monoid.<>
                             (case
                                Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'oneofIndex")
                                  _x
                                of
                                  (Prelude.Nothing) -> Data.Monoid.mempty
                                  Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 72)
                                                       Data.Monoid.<>
                                                       ((Data.ProtoLens.Encoding.Bytes.putVarInt)
                                                          Prelude.. Prelude.fromIntegral)
                                                         _v)
                               Data.Monoid.<>
                               (case
                                  Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'jsonName")
                                    _x
                                  of
                                    (Prelude.Nothing) -> Data.Monoid.mempty
                                    Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 82)
                                                         Data.Monoid.<>
                                                         (((\ bs ->
                                                              (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                                 (Prelude.fromIntegral
                                                                    (Data.ByteString.length bs)))
                                                                Data.Monoid.<>
                                                                Data.ProtoLens.Encoding.Bytes.putBytes
                                                                  bs))
                                                            Prelude.. Data.Text.Encoding.encodeUtf8)
                                                           _v)
                                 Data.Monoid.<>
                                 (case
                                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'options")
                                      _x
                                    of
                                      (Prelude.Nothing) -> Data.Monoid.mempty
                                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                            66)
                                                           Data.Monoid.<>
                                                           (((\ bs ->
                                                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                                   (Prelude.fromIntegral
                                                                      (Data.ByteString.length bs)))
                                                                  Data.Monoid.<>
                                                                  Data.ProtoLens.Encoding.Bytes.putBytes
                                                                    bs))
                                                              Prelude..
                                                              Data.ProtoLens.encodeMessage)
                                                             _v)
                                   Data.Monoid.<>
                                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData FieldDescriptorProto where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_FieldDescriptorProto'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_FieldDescriptorProto'name x__)
                    (Control.DeepSeq.deepseq (_FieldDescriptorProto'number x__)
                       (Control.DeepSeq.deepseq (_FieldDescriptorProto'label x__)
                          (Control.DeepSeq.deepseq (_FieldDescriptorProto'type' x__)
                             (Control.DeepSeq.deepseq (_FieldDescriptorProto'typeName x__)
                                (Control.DeepSeq.deepseq (_FieldDescriptorProto'extendee x__)
                                   (Control.DeepSeq.deepseq (_FieldDescriptorProto'defaultValue x__)
                                      (Control.DeepSeq.deepseq
                                         (_FieldDescriptorProto'oneofIndex x__)
                                         (Control.DeepSeq.deepseq
                                            (_FieldDescriptorProto'jsonName x__)
                                            (Control.DeepSeq.deepseq
                                               (_FieldDescriptorProto'options x__)
                                               (()))))))))))))
data FieldDescriptorProto'Label = FieldDescriptorProto'LABEL_OPTIONAL
                                | FieldDescriptorProto'LABEL_REQUIRED
                                | FieldDescriptorProto'LABEL_REPEATED
                                    deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)
instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Label
         where
        maybeToEnum 1 = Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL
        maybeToEnum 2 = Prelude.Just FieldDescriptorProto'LABEL_REQUIRED
        maybeToEnum 3 = Prelude.Just FieldDescriptorProto'LABEL_REPEATED
        maybeToEnum _ = Prelude.Nothing
        showEnum FieldDescriptorProto'LABEL_OPTIONAL = "LABEL_OPTIONAL"
        showEnum FieldDescriptorProto'LABEL_REQUIRED = "LABEL_REQUIRED"
        showEnum FieldDescriptorProto'LABEL_REPEATED = "LABEL_REPEATED"
        readEnum k
          | (k) Prelude.== "LABEL_OPTIONAL" =
            Prelude.Just FieldDescriptorProto'LABEL_OPTIONAL
          | (k) Prelude.== "LABEL_REQUIRED" =
            Prelude.Just FieldDescriptorProto'LABEL_REQUIRED
          | (k) Prelude.== "LABEL_REPEATED" =
            Prelude.Just FieldDescriptorProto'LABEL_REPEATED
        readEnum k
          = (Text.Read.readMaybe k) Prelude.>>= Data.ProtoLens.maybeToEnum
instance Prelude.Bounded FieldDescriptorProto'Label where
        minBound = FieldDescriptorProto'LABEL_OPTIONAL
        maxBound = FieldDescriptorProto'LABEL_REPEATED
instance Prelude.Enum FieldDescriptorProto'Label where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 (("toEnum: unknown value for enum Label: ") Prelude.++
                    Prelude.show k__))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum FieldDescriptorProto'LABEL_OPTIONAL = 1
        fromEnum FieldDescriptorProto'LABEL_REQUIRED = 2
        fromEnum FieldDescriptorProto'LABEL_REPEATED = 3
        succ FieldDescriptorProto'LABEL_REPEATED
          = Prelude.error
              "FieldDescriptorProto'Label.succ: bad argument FieldDescriptorProto'LABEL_REPEATED. This value would be out of bounds."
        succ FieldDescriptorProto'LABEL_OPTIONAL
          = FieldDescriptorProto'LABEL_REQUIRED
        succ FieldDescriptorProto'LABEL_REQUIRED
          = FieldDescriptorProto'LABEL_REPEATED
        pred FieldDescriptorProto'LABEL_OPTIONAL
          = Prelude.error
              "FieldDescriptorProto'Label.pred: bad argument FieldDescriptorProto'LABEL_OPTIONAL. This value would be out of bounds."
        pred FieldDescriptorProto'LABEL_REQUIRED
          = FieldDescriptorProto'LABEL_OPTIONAL
        pred FieldDescriptorProto'LABEL_REPEATED
          = FieldDescriptorProto'LABEL_REQUIRED
        enumFrom = Data.ProtoLens.Message.Enum.messageEnumFrom
        enumFromTo = Data.ProtoLens.Message.Enum.messageEnumFromTo
        enumFromThen = Data.ProtoLens.Message.Enum.messageEnumFromThen
        enumFromThenTo = Data.ProtoLens.Message.Enum.messageEnumFromThenTo
instance Data.ProtoLens.FieldDefault FieldDescriptorProto'Label
         where
        fieldDefault = FieldDescriptorProto'LABEL_OPTIONAL
instance Control.DeepSeq.NFData FieldDescriptorProto'Label where
        rnf x__ = Prelude.seq x__ (())
data FieldDescriptorProto'Type = FieldDescriptorProto'TYPE_DOUBLE
                               | FieldDescriptorProto'TYPE_FLOAT
                               | FieldDescriptorProto'TYPE_INT64
                               | FieldDescriptorProto'TYPE_UINT64
                               | FieldDescriptorProto'TYPE_INT32
                               | FieldDescriptorProto'TYPE_FIXED64
                               | FieldDescriptorProto'TYPE_FIXED32
                               | FieldDescriptorProto'TYPE_BOOL
                               | FieldDescriptorProto'TYPE_STRING
                               | FieldDescriptorProto'TYPE_GROUP
                               | FieldDescriptorProto'TYPE_MESSAGE
                               | FieldDescriptorProto'TYPE_BYTES
                               | FieldDescriptorProto'TYPE_UINT32
                               | FieldDescriptorProto'TYPE_ENUM
                               | FieldDescriptorProto'TYPE_SFIXED32
                               | FieldDescriptorProto'TYPE_SFIXED64
                               | FieldDescriptorProto'TYPE_SINT32
                               | FieldDescriptorProto'TYPE_SINT64
                                   deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)
instance Data.ProtoLens.MessageEnum FieldDescriptorProto'Type where
        maybeToEnum 1 = Prelude.Just FieldDescriptorProto'TYPE_DOUBLE
        maybeToEnum 2 = Prelude.Just FieldDescriptorProto'TYPE_FLOAT
        maybeToEnum 3 = Prelude.Just FieldDescriptorProto'TYPE_INT64
        maybeToEnum 4 = Prelude.Just FieldDescriptorProto'TYPE_UINT64
        maybeToEnum 5 = Prelude.Just FieldDescriptorProto'TYPE_INT32
        maybeToEnum 6 = Prelude.Just FieldDescriptorProto'TYPE_FIXED64
        maybeToEnum 7 = Prelude.Just FieldDescriptorProto'TYPE_FIXED32
        maybeToEnum 8 = Prelude.Just FieldDescriptorProto'TYPE_BOOL
        maybeToEnum 9 = Prelude.Just FieldDescriptorProto'TYPE_STRING
        maybeToEnum 10 = Prelude.Just FieldDescriptorProto'TYPE_GROUP
        maybeToEnum 11 = Prelude.Just FieldDescriptorProto'TYPE_MESSAGE
        maybeToEnum 12 = Prelude.Just FieldDescriptorProto'TYPE_BYTES
        maybeToEnum 13 = Prelude.Just FieldDescriptorProto'TYPE_UINT32
        maybeToEnum 14 = Prelude.Just FieldDescriptorProto'TYPE_ENUM
        maybeToEnum 15 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED32
        maybeToEnum 16 = Prelude.Just FieldDescriptorProto'TYPE_SFIXED64
        maybeToEnum 17 = Prelude.Just FieldDescriptorProto'TYPE_SINT32
        maybeToEnum 18 = Prelude.Just FieldDescriptorProto'TYPE_SINT64
        maybeToEnum _ = Prelude.Nothing
        showEnum FieldDescriptorProto'TYPE_DOUBLE = "TYPE_DOUBLE"
        showEnum FieldDescriptorProto'TYPE_FLOAT = "TYPE_FLOAT"
        showEnum FieldDescriptorProto'TYPE_INT64 = "TYPE_INT64"
        showEnum FieldDescriptorProto'TYPE_UINT64 = "TYPE_UINT64"
        showEnum FieldDescriptorProto'TYPE_INT32 = "TYPE_INT32"
        showEnum FieldDescriptorProto'TYPE_FIXED64 = "TYPE_FIXED64"
        showEnum FieldDescriptorProto'TYPE_FIXED32 = "TYPE_FIXED32"
        showEnum FieldDescriptorProto'TYPE_BOOL = "TYPE_BOOL"
        showEnum FieldDescriptorProto'TYPE_STRING = "TYPE_STRING"
        showEnum FieldDescriptorProto'TYPE_GROUP = "TYPE_GROUP"
        showEnum FieldDescriptorProto'TYPE_MESSAGE = "TYPE_MESSAGE"
        showEnum FieldDescriptorProto'TYPE_BYTES = "TYPE_BYTES"
        showEnum FieldDescriptorProto'TYPE_UINT32 = "TYPE_UINT32"
        showEnum FieldDescriptorProto'TYPE_ENUM = "TYPE_ENUM"
        showEnum FieldDescriptorProto'TYPE_SFIXED32 = "TYPE_SFIXED32"
        showEnum FieldDescriptorProto'TYPE_SFIXED64 = "TYPE_SFIXED64"
        showEnum FieldDescriptorProto'TYPE_SINT32 = "TYPE_SINT32"
        showEnum FieldDescriptorProto'TYPE_SINT64 = "TYPE_SINT64"
        readEnum k
          | (k) Prelude.== "TYPE_DOUBLE" =
            Prelude.Just FieldDescriptorProto'TYPE_DOUBLE
          | (k) Prelude.== "TYPE_FLOAT" =
            Prelude.Just FieldDescriptorProto'TYPE_FLOAT
          | (k) Prelude.== "TYPE_INT64" =
            Prelude.Just FieldDescriptorProto'TYPE_INT64
          | (k) Prelude.== "TYPE_UINT64" =
            Prelude.Just FieldDescriptorProto'TYPE_UINT64
          | (k) Prelude.== "TYPE_INT32" =
            Prelude.Just FieldDescriptorProto'TYPE_INT32
          | (k) Prelude.== "TYPE_FIXED64" =
            Prelude.Just FieldDescriptorProto'TYPE_FIXED64
          | (k) Prelude.== "TYPE_FIXED32" =
            Prelude.Just FieldDescriptorProto'TYPE_FIXED32
          | (k) Prelude.== "TYPE_BOOL" =
            Prelude.Just FieldDescriptorProto'TYPE_BOOL
          | (k) Prelude.== "TYPE_STRING" =
            Prelude.Just FieldDescriptorProto'TYPE_STRING
          | (k) Prelude.== "TYPE_GROUP" =
            Prelude.Just FieldDescriptorProto'TYPE_GROUP
          | (k) Prelude.== "TYPE_MESSAGE" =
            Prelude.Just FieldDescriptorProto'TYPE_MESSAGE
          | (k) Prelude.== "TYPE_BYTES" =
            Prelude.Just FieldDescriptorProto'TYPE_BYTES
          | (k) Prelude.== "TYPE_UINT32" =
            Prelude.Just FieldDescriptorProto'TYPE_UINT32
          | (k) Prelude.== "TYPE_ENUM" =
            Prelude.Just FieldDescriptorProto'TYPE_ENUM
          | (k) Prelude.== "TYPE_SFIXED32" =
            Prelude.Just FieldDescriptorProto'TYPE_SFIXED32
          | (k) Prelude.== "TYPE_SFIXED64" =
            Prelude.Just FieldDescriptorProto'TYPE_SFIXED64
          | (k) Prelude.== "TYPE_SINT32" =
            Prelude.Just FieldDescriptorProto'TYPE_SINT32
          | (k) Prelude.== "TYPE_SINT64" =
            Prelude.Just FieldDescriptorProto'TYPE_SINT64
        readEnum k
          = (Text.Read.readMaybe k) Prelude.>>= Data.ProtoLens.maybeToEnum
instance Prelude.Bounded FieldDescriptorProto'Type where
        minBound = FieldDescriptorProto'TYPE_DOUBLE
        maxBound = FieldDescriptorProto'TYPE_SINT64
instance Prelude.Enum FieldDescriptorProto'Type where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 (("toEnum: unknown value for enum Type: ") Prelude.++
                    Prelude.show k__))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum FieldDescriptorProto'TYPE_DOUBLE = 1
        fromEnum FieldDescriptorProto'TYPE_FLOAT = 2
        fromEnum FieldDescriptorProto'TYPE_INT64 = 3
        fromEnum FieldDescriptorProto'TYPE_UINT64 = 4
        fromEnum FieldDescriptorProto'TYPE_INT32 = 5
        fromEnum FieldDescriptorProto'TYPE_FIXED64 = 6
        fromEnum FieldDescriptorProto'TYPE_FIXED32 = 7
        fromEnum FieldDescriptorProto'TYPE_BOOL = 8
        fromEnum FieldDescriptorProto'TYPE_STRING = 9
        fromEnum FieldDescriptorProto'TYPE_GROUP = 10
        fromEnum FieldDescriptorProto'TYPE_MESSAGE = 11
        fromEnum FieldDescriptorProto'TYPE_BYTES = 12
        fromEnum FieldDescriptorProto'TYPE_UINT32 = 13
        fromEnum FieldDescriptorProto'TYPE_ENUM = 14
        fromEnum FieldDescriptorProto'TYPE_SFIXED32 = 15
        fromEnum FieldDescriptorProto'TYPE_SFIXED64 = 16
        fromEnum FieldDescriptorProto'TYPE_SINT32 = 17
        fromEnum FieldDescriptorProto'TYPE_SINT64 = 18
        succ FieldDescriptorProto'TYPE_SINT64
          = Prelude.error
              "FieldDescriptorProto'Type.succ: bad argument FieldDescriptorProto'TYPE_SINT64. This value would be out of bounds."
        succ FieldDescriptorProto'TYPE_DOUBLE
          = FieldDescriptorProto'TYPE_FLOAT
        succ FieldDescriptorProto'TYPE_FLOAT
          = FieldDescriptorProto'TYPE_INT64
        succ FieldDescriptorProto'TYPE_INT64
          = FieldDescriptorProto'TYPE_UINT64
        succ FieldDescriptorProto'TYPE_UINT64
          = FieldDescriptorProto'TYPE_INT32
        succ FieldDescriptorProto'TYPE_INT32
          = FieldDescriptorProto'TYPE_FIXED64
        succ FieldDescriptorProto'TYPE_FIXED64
          = FieldDescriptorProto'TYPE_FIXED32
        succ FieldDescriptorProto'TYPE_FIXED32
          = FieldDescriptorProto'TYPE_BOOL
        succ FieldDescriptorProto'TYPE_BOOL
          = FieldDescriptorProto'TYPE_STRING
        succ FieldDescriptorProto'TYPE_STRING
          = FieldDescriptorProto'TYPE_GROUP
        succ FieldDescriptorProto'TYPE_GROUP
          = FieldDescriptorProto'TYPE_MESSAGE
        succ FieldDescriptorProto'TYPE_MESSAGE
          = FieldDescriptorProto'TYPE_BYTES
        succ FieldDescriptorProto'TYPE_BYTES
          = FieldDescriptorProto'TYPE_UINT32
        succ FieldDescriptorProto'TYPE_UINT32
          = FieldDescriptorProto'TYPE_ENUM
        succ FieldDescriptorProto'TYPE_ENUM
          = FieldDescriptorProto'TYPE_SFIXED32
        succ FieldDescriptorProto'TYPE_SFIXED32
          = FieldDescriptorProto'TYPE_SFIXED64
        succ FieldDescriptorProto'TYPE_SFIXED64
          =