{- This file was auto-generated from enum.proto by the proto-lens-protoc program. -}
{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,
  UndecidableInstances, GeneralizedNewtypeDeriving,
  MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,
  PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports#-}
module Proto.Enum
       (Alias(..), Alias(Alias2a), Bar(..), Bar(), Baz(..), Baz(),
        Foo(..), Foo'Baz(..), Foo'Baz())
       where
import qualified Data.ProtoLens.Reexport.Lens.Labels.Prism
       as Lens.Labels.Prism
import qualified Data.ProtoLens.Reexport.Prelude as Prelude
import qualified Data.ProtoLens.Reexport.Data.Int as Data.Int
import qualified Data.ProtoLens.Reexport.Data.Word as Data.Word
import qualified Data.ProtoLens.Reexport.Data.ProtoLens
       as Data.ProtoLens
import qualified
       Data.ProtoLens.Reexport.Data.ProtoLens.Message.Enum
       as Data.ProtoLens.Message.Enum
import qualified
       Data.ProtoLens.Reexport.Data.ProtoLens.Service.Types
       as Data.ProtoLens.Service.Types
import qualified Data.ProtoLens.Reexport.Lens.Family2
       as Lens.Family2
import qualified Data.ProtoLens.Reexport.Lens.Family2.Unchecked
       as Lens.Family2.Unchecked
import qualified Data.ProtoLens.Reexport.Data.Default.Class
       as Data.Default.Class
import qualified Data.ProtoLens.Reexport.Data.Text as Data.Text
import qualified Data.ProtoLens.Reexport.Data.Map as Data.Map
import qualified Data.ProtoLens.Reexport.Data.ByteString
       as Data.ByteString
import qualified Data.ProtoLens.Reexport.Data.ByteString.Char8
       as Data.ByteString.Char8
import qualified Data.ProtoLens.Reexport.Lens.Labels as Lens.Labels
import qualified Data.ProtoLens.Reexport.Text.Read as Text.Read

data Alias = Alias1
           | Alias2
           | Alias3
               deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)
instance Data.Default.Class.Default Alias where
        def = Alias1
instance Data.ProtoLens.FieldDefault Alias where
        fieldDefault = Alias1
instance Data.ProtoLens.MessageEnum Alias where
        maybeToEnum 1 = Prelude.Just Alias1
        maybeToEnum 2 = Prelude.Just Alias2
        maybeToEnum 3 = Prelude.Just Alias3
        maybeToEnum _ = Prelude.Nothing
        showEnum Alias1 = "Alias1"
        showEnum Alias2 = "Alias2"
        showEnum Alias3 = "Alias3"
        readEnum "Alias1" = Prelude.Just Alias1
        readEnum "Alias2" = Prelude.Just Alias2
        readEnum "Alias3" = Prelude.Just Alias3
        readEnum _ = Prelude.Nothing
instance Prelude.Enum Alias where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum Alias: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum Alias1 = 1
        fromEnum Alias2 = 2
        fromEnum Alias3 = 3
        succ Alias3
          = Prelude.error
              "Alias.succ: bad argument Alias3. This value would be out of bounds."
        succ Alias1 = Alias2
        succ Alias2 = Alias3
        pred Alias1
          = Prelude.error
              "Alias.pred: bad argument Alias1. This value would be out of bounds."
        pred Alias2 = Alias1
        pred Alias3 = Alias2
        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 Prelude.Bounded Alias where
        minBound = Alias1
        maxBound = Alias3
pattern Alias2a :: Alias
pattern Alias2a = Alias2
data Bar = NEGATIVE
         | BAR3
         | BAR5
             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)
instance Data.Default.Class.Default Bar where
        def = NEGATIVE
instance Data.ProtoLens.FieldDefault Bar where
        fieldDefault = NEGATIVE
instance Data.ProtoLens.MessageEnum Bar where
        maybeToEnum (-1) = Prelude.Just NEGATIVE
        maybeToEnum 3 = Prelude.Just BAR3
        maybeToEnum 5 = Prelude.Just BAR5
        maybeToEnum _ = Prelude.Nothing
        showEnum NEGATIVE = "NEGATIVE"
        showEnum BAR3 = "BAR3"
        showEnum BAR5 = "BAR5"
        readEnum "NEGATIVE" = Prelude.Just NEGATIVE
        readEnum "BAR3" = Prelude.Just BAR3
        readEnum "BAR5" = Prelude.Just BAR5
        readEnum _ = Prelude.Nothing
instance Prelude.Enum Bar where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum Bar: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum NEGATIVE = -1
        fromEnum BAR3 = 3
        fromEnum BAR5 = 5
        succ BAR5
          = Prelude.error
              "Bar.succ: bad argument BAR5. This value would be out of bounds."
        succ NEGATIVE = BAR3
        succ BAR3 = BAR5
        pred NEGATIVE
          = Prelude.error
              "Bar.pred: bad argument NEGATIVE. This value would be out of bounds."
        pred BAR3 = NEGATIVE
        pred BAR5 = BAR3
        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 Prelude.Bounded Bar where
        minBound = NEGATIVE
        maxBound = BAR5
data Baz = BAZ1
         | BAZ2
         | BAZ3
         | BAZ4
         | BAZ5
         | BAZ6
         | BAZ7
         | BAZ8
             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)
instance Data.Default.Class.Default Baz where
        def = BAZ1
instance Data.ProtoLens.FieldDefault Baz where
        fieldDefault = BAZ1
instance Data.ProtoLens.MessageEnum Baz where
        maybeToEnum 1 = Prelude.Just BAZ1
        maybeToEnum 2 = Prelude.Just BAZ2
        maybeToEnum 4 = Prelude.Just BAZ3
        maybeToEnum 6 = Prelude.Just BAZ4
        maybeToEnum 7 = Prelude.Just BAZ5
        maybeToEnum 9 = Prelude.Just BAZ6
        maybeToEnum 10 = Prelude.Just BAZ7
        maybeToEnum 12 = Prelude.Just BAZ8
        maybeToEnum _ = Prelude.Nothing
        showEnum BAZ1 = "BAZ1"
        showEnum BAZ2 = "BAZ2"
        showEnum BAZ3 = "BAZ3"
        showEnum BAZ4 = "BAZ4"
        showEnum BAZ5 = "BAZ5"
        showEnum BAZ6 = "BAZ6"
        showEnum BAZ7 = "BAZ7"
        showEnum BAZ8 = "BAZ8"
        readEnum "BAZ1" = Prelude.Just BAZ1
        readEnum "BAZ2" = Prelude.Just BAZ2
        readEnum "BAZ3" = Prelude.Just BAZ3
        readEnum "BAZ4" = Prelude.Just BAZ4
        readEnum "BAZ5" = Prelude.Just BAZ5
        readEnum "BAZ6" = Prelude.Just BAZ6
        readEnum "BAZ7" = Prelude.Just BAZ7
        readEnum "BAZ8" = Prelude.Just BAZ8
        readEnum _ = Prelude.Nothing
instance Prelude.Enum Baz where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum Baz: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum BAZ1 = 1
        fromEnum BAZ2 = 2
        fromEnum BAZ3 = 4
        fromEnum BAZ4 = 6
        fromEnum BAZ5 = 7
        fromEnum BAZ6 = 9
        fromEnum BAZ7 = 10
        fromEnum BAZ8 = 12
        succ BAZ8
          = Prelude.error
              "Baz.succ: bad argument BAZ8. This value would be out of bounds."
        succ BAZ1 = BAZ2
        succ BAZ2 = BAZ3
        succ BAZ3 = BAZ4
        succ BAZ4 = BAZ5
        succ BAZ5 = BAZ6
        succ BAZ6 = BAZ7
        succ BAZ7 = BAZ8
        pred BAZ1
          = Prelude.error
              "Baz.pred: bad argument BAZ1. This value would be out of bounds."
        pred BAZ2 = BAZ1
        pred BAZ3 = BAZ2
        pred BAZ4 = BAZ3
        pred BAZ5 = BAZ4
        pred BAZ6 = BAZ5
        pred BAZ7 = BAZ6
        pred BAZ8 = BAZ7
        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 Prelude.Bounded Baz where
        minBound = BAZ1
        maxBound = BAZ8
{- | Fields :

    * 'Proto.Enum_Fields.bar' @:: Lens' Foo Bar@
    * 'Proto.Enum_Fields.maybe'bar' @:: Lens' Foo (Prelude.Maybe Bar)@
    * 'Proto.Enum_Fields.baz' @:: Lens' Foo Foo'Baz@
    * 'Proto.Enum_Fields.maybe'baz' @:: Lens' Foo (Prelude.Maybe Foo'Baz)@
    * 'Proto.Enum_Fields.barDefaulted' @:: Lens' Foo Bar@
    * 'Proto.Enum_Fields.maybe'barDefaulted' @:: Lens' Foo (Prelude.Maybe Bar)@
    * 'Proto.Enum_Fields.bazDefaulted' @:: Lens' Foo Foo'Baz@
    * 'Proto.Enum_Fields.maybe'bazDefaulted' @:: Lens' Foo (Prelude.Maybe Foo'Baz)@
    * 'Proto.Enum_Fields.trueDefaulted' @:: Lens' Foo Prelude.Bool@
    * 'Proto.Enum_Fields.maybe'trueDefaulted' @:: Lens' Foo (Prelude.Maybe Prelude.Bool)@
    * 'Proto.Enum_Fields.falseDefaulted' @:: Lens' Foo Prelude.Bool@
    * 'Proto.Enum_Fields.maybe'falseDefaulted' @:: Lens' Foo (Prelude.Maybe Prelude.Bool)@
 -}
data Foo = Foo{_Foo'bar :: !(Prelude.Maybe Bar),
               _Foo'baz :: !(Prelude.Maybe Foo'Baz),
               _Foo'barDefaulted :: !(Prelude.Maybe Bar),
               _Foo'bazDefaulted :: !(Prelude.Maybe Foo'Baz),
               _Foo'trueDefaulted :: !(Prelude.Maybe Prelude.Bool),
               _Foo'falseDefaulted :: !(Prelude.Maybe Prelude.Bool),
               _Foo'_unknownFields :: !Data.ProtoLens.FieldSet}
             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)
instance (Lens.Labels.HasLens' f Foo x a, a ~ b) =>
         Lens.Labels.HasLens f Foo Foo x a b
         where
        lensOf = Lens.Labels.lensOf'
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "bar" (Bar)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'bar
                 (\ x__ y__ -> x__{_Foo'bar = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "maybe'bar" (Prelude.Maybe Bar)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'bar
                 (\ x__ y__ -> x__{_Foo'bar = y__}))
              Prelude.id
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "baz" (Foo'Baz)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'baz
                 (\ x__ y__ -> x__{_Foo'baz = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "maybe'baz" (Prelude.Maybe Foo'Baz)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'baz
                 (\ x__ y__ -> x__{_Foo'baz = y__}))
              Prelude.id
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "barDefaulted" (Bar)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'barDefaulted
                 (\ x__ y__ -> x__{_Foo'barDefaulted = y__}))
              (Data.ProtoLens.maybeLens BAR5)
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "maybe'barDefaulted" (Prelude.Maybe Bar)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'barDefaulted
                 (\ x__ y__ -> x__{_Foo'barDefaulted = y__}))
              Prelude.id
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "bazDefaulted" (Foo'Baz)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'bazDefaulted
                 (\ x__ y__ -> x__{_Foo'bazDefaulted = y__}))
              (Data.ProtoLens.maybeLens Foo'BAZ4)
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "maybe'bazDefaulted"
           (Prelude.Maybe Foo'Baz)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'bazDefaulted
                 (\ x__ y__ -> x__{_Foo'bazDefaulted = y__}))
              Prelude.id
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "trueDefaulted" (Prelude.Bool)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'trueDefaulted
                 (\ x__ y__ -> x__{_Foo'trueDefaulted = y__}))
              (Data.ProtoLens.maybeLens Prelude.True)
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "maybe'trueDefaulted"
           (Prelude.Maybe Prelude.Bool)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'trueDefaulted
                 (\ x__ y__ -> x__{_Foo'trueDefaulted = y__}))
              Prelude.id
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "falseDefaulted" (Prelude.Bool)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'falseDefaulted
                 (\ x__ y__ -> x__{_Foo'falseDefaulted = y__}))
              (Data.ProtoLens.maybeLens Prelude.False)
instance Prelude.Functor f =>
         Lens.Labels.HasLens' f Foo "maybe'falseDefaulted"
           (Prelude.Maybe Prelude.Bool)
         where
        lensOf' _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Foo'falseDefaulted
                 (\ x__ y__ -> x__{_Foo'falseDefaulted = y__}))
              Prelude.id
instance Data.Default.Class.Default Foo where
        def
          = Foo{_Foo'bar = Prelude.Nothing, _Foo'baz = Prelude.Nothing,
                _Foo'barDefaulted = Prelude.Nothing,
                _Foo'bazDefaulted = Prelude.Nothing,
                _Foo'trueDefaulted = Prelude.Nothing,
                _Foo'falseDefaulted = Prelude.Nothing, _Foo'_unknownFields = ([])}
instance Data.ProtoLens.Message Foo where
        messageName _ = Data.Text.pack "enums.Foo"
        fieldsByTag
          = let bar__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "bar"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor Bar)
                      (Data.ProtoLens.OptionalField
                         (Lens.Labels.lensOf
                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'bar")))
                      :: Data.ProtoLens.FieldDescriptor Foo
                baz__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "baz"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor Foo'Baz)
                      (Data.ProtoLens.OptionalField
                         (Lens.Labels.lensOf
                            ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'baz")))
                      :: Data.ProtoLens.FieldDescriptor Foo
                barDefaulted__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "bar_defaulted"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor Bar)
                      (Data.ProtoLens.OptionalField
                         (Lens.Labels.lensOf
                            ((Lens.Labels.proxy#) ::
                               (Lens.Labels.Proxy#) "maybe'barDefaulted")))
                      :: Data.ProtoLens.FieldDescriptor Foo
                bazDefaulted__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "baz_defaulted"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor Foo'Baz)
                      (Data.ProtoLens.OptionalField
                         (Lens.Labels.lensOf
                            ((Lens.Labels.proxy#) ::
                               (Lens.Labels.Proxy#) "maybe'bazDefaulted")))
                      :: Data.ProtoLens.FieldDescriptor Foo
                trueDefaulted__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "true_defaulted"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.OptionalField
                         (Lens.Labels.lensOf
                            ((Lens.Labels.proxy#) ::
                               (Lens.Labels.Proxy#) "maybe'trueDefaulted")))
                      :: Data.ProtoLens.FieldDescriptor Foo
                falseDefaulted__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "false_defaulted"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.OptionalField
                         (Lens.Labels.lensOf
                            ((Lens.Labels.proxy#) ::
                               (Lens.Labels.Proxy#) "maybe'falseDefaulted")))
                      :: Data.ProtoLens.FieldDescriptor Foo
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, bar__field_descriptor),
                 (Data.ProtoLens.Tag 2, baz__field_descriptor),
                 (Data.ProtoLens.Tag 3, barDefaulted__field_descriptor),
                 (Data.ProtoLens.Tag 4, bazDefaulted__field_descriptor),
                 (Data.ProtoLens.Tag 5, trueDefaulted__field_descriptor),
                 (Data.ProtoLens.Tag 6, falseDefaulted__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _Foo'_unknownFields
              (\ x__ y__ -> x__{_Foo'_unknownFields = y__})
data Foo'Baz = Foo'BAZ2
             | Foo'BAZ4
                 deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)
instance Data.Default.Class.Default Foo'Baz where
        def = Foo'BAZ2
instance Data.ProtoLens.FieldDefault Foo'Baz where
        fieldDefault = Foo'BAZ2
instance Data.ProtoLens.MessageEnum Foo'Baz where
        maybeToEnum 2 = Prelude.Just Foo'BAZ2
        maybeToEnum 4 = Prelude.Just Foo'BAZ4
        maybeToEnum _ = Prelude.Nothing
        showEnum Foo'BAZ2 = "BAZ2"
        showEnum Foo'BAZ4 = "BAZ4"
        readEnum "BAZ2" = Prelude.Just Foo'BAZ2
        readEnum "BAZ4" = Prelude.Just Foo'BAZ4
        readEnum _ = Prelude.Nothing
instance Prelude.Enum Foo'Baz where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum Baz: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum Foo'BAZ2 = 2
        fromEnum Foo'BAZ4 = 4
        succ Foo'BAZ4
          = Prelude.error
              "Foo'Baz.succ: bad argument Foo'BAZ4. This value would be out of bounds."
        succ Foo'BAZ2 = Foo'BAZ4
        pred Foo'BAZ2
          = Prelude.error
              "Foo'Baz.pred: bad argument Foo'BAZ2. This value would be out of bounds."
        pred Foo'BAZ4 = Foo'BAZ2
        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 Prelude.Bounded Foo'Baz where
        minBound = Foo'BAZ2
        maxBound = Foo'BAZ4