{- This file was auto-generated from tensorflow/core/util/event.proto by the proto-lens-protoc program. -}
{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,
  UndecidableInstances, MultiParamTypeClasses, FlexibleContexts,
  FlexibleInstances, PatternSynonyms, MagicHash, NoImplicitPrelude
  #-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}
module Proto.Tensorflow.Core.Util.Event where
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.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.Lens.Labels as Lens.Labels
import qualified Proto.Tensorflow.Core.Framework.Summary

data Event = Event{_Event'wallTime :: !Prelude.Double,
                   _Event'step :: !Data.Int.Int64,
                   _Event'what :: !(Prelude.Maybe Event'What)}
           deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

data Event'What = Event'FileVersion !Data.Text.Text
                | Event'GraphDef !Data.ByteString.ByteString
                | Event'Summary !Proto.Tensorflow.Core.Framework.Summary.Summary
                | Event'LogMessage !LogMessage
                | Event'SessionLog !SessionLog
                | Event'TaggedRunMetadata !TaggedRunMetadata
                | Event'MetaGraphDef !Data.ByteString.ByteString
                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Prelude.Double, b ~ Prelude.Double,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "wallTime" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'wallTime
                 (\ x__ y__ -> x__{_Event'wallTime = y__}))
              Prelude.id

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "step" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'step
                 (\ x__ y__ -> x__{_Event'step = y__}))
              Prelude.id

instance (a ~ Prelude.Maybe Event'What,
          b ~ Prelude.Maybe Event'What, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'what" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              Prelude.id

instance (a ~ Prelude.Maybe Data.Text.Text,
          b ~ Prelude.Maybe Data.Text.Text, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'fileVersion" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Event'FileVersion x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Event'FileVersion y__))

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "fileVersion" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just (Event'FileVersion x__val) -> Prelude.Just x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap Event'FileVersion y__))
                 (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault))

instance (a ~ Prelude.Maybe Data.ByteString.ByteString,
          b ~ Prelude.Maybe Data.ByteString.ByteString, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'graphDef" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Event'GraphDef x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Event'GraphDef y__))

instance (a ~ Data.ByteString.ByteString,
          b ~ Data.ByteString.ByteString, Prelude.Functor f) =>
         Lens.Labels.HasLens "graphDef" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just (Event'GraphDef x__val) -> Prelude.Just x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap Event'GraphDef y__))
                 (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault))

instance (a ~
            Prelude.Maybe Proto.Tensorflow.Core.Framework.Summary.Summary,
          b ~ Prelude.Maybe Proto.Tensorflow.Core.Framework.Summary.Summary,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'summary" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Event'Summary x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Event'Summary y__))

instance (a ~ Proto.Tensorflow.Core.Framework.Summary.Summary,
          b ~ Proto.Tensorflow.Core.Framework.Summary.Summary,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "summary" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just (Event'Summary x__val) -> Prelude.Just x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap Event'Summary y__))
                 (Data.ProtoLens.maybeLens Data.Default.Class.def))

instance (a ~ Prelude.Maybe LogMessage,
          b ~ Prelude.Maybe LogMessage, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'logMessage" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Event'LogMessage x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Event'LogMessage y__))

instance (a ~ LogMessage, b ~ LogMessage, Prelude.Functor f) =>
         Lens.Labels.HasLens "logMessage" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just (Event'LogMessage x__val) -> Prelude.Just x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap Event'LogMessage y__))
                 (Data.ProtoLens.maybeLens Data.Default.Class.def))

instance (a ~ Prelude.Maybe SessionLog,
          b ~ Prelude.Maybe SessionLog, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'sessionLog" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Event'SessionLog x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Event'SessionLog y__))

instance (a ~ SessionLog, b ~ SessionLog, Prelude.Functor f) =>
         Lens.Labels.HasLens "sessionLog" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just (Event'SessionLog x__val) -> Prelude.Just x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap Event'SessionLog y__))
                 (Data.ProtoLens.maybeLens Data.Default.Class.def))

instance (a ~ Prelude.Maybe TaggedRunMetadata,
          b ~ Prelude.Maybe TaggedRunMetadata, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'taggedRunMetadata" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Event'TaggedRunMetadata x__val) -> Prelude.Just
                                                                           x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Event'TaggedRunMetadata y__))

instance (a ~ TaggedRunMetadata, b ~ TaggedRunMetadata,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "taggedRunMetadata" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just (Event'TaggedRunMetadata x__val) -> Prelude.Just
                                                                              x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap Event'TaggedRunMetadata y__))
                 (Data.ProtoLens.maybeLens Data.Default.Class.def))

instance (a ~ Prelude.Maybe Data.ByteString.ByteString,
          b ~ Prelude.Maybe Data.ByteString.ByteString, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'metaGraphDef" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Event'MetaGraphDef x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Event'MetaGraphDef y__))

instance (a ~ Data.ByteString.ByteString,
          b ~ Data.ByteString.ByteString, Prelude.Functor f) =>
         Lens.Labels.HasLens "metaGraphDef" f Event Event a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Event'what
                 (\ x__ y__ -> x__{_Event'what = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just (Event'MetaGraphDef x__val) -> Prelude.Just x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap Event'MetaGraphDef y__))
                 (Data.ProtoLens.maybeLens Data.ProtoLens.fieldDefault))

instance Data.Default.Class.Default Event where
        def
          = Event{_Event'wallTime = Data.ProtoLens.fieldDefault,
                  _Event'step = Data.ProtoLens.fieldDefault,
                  _Event'what = Prelude.Nothing}

instance Data.ProtoLens.Message Event where
        descriptor
          = let wallTime__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "wall_time"
                      (Data.ProtoLens.DoubleField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Double)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional wallTime)
                      :: Data.ProtoLens.FieldDescriptor Event
                step__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "step"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional step)
                      :: Data.ProtoLens.FieldDescriptor Event
                fileVersion__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "file_version"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.OptionalField maybe'fileVersion)
                      :: Data.ProtoLens.FieldDescriptor Event
                graphDef__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "graph_def"
                      (Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.OptionalField maybe'graphDef)
                      :: Data.ProtoLens.FieldDescriptor Event
                summary__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "summary"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.Summary.Summary)
                      (Data.ProtoLens.OptionalField maybe'summary)
                      :: Data.ProtoLens.FieldDescriptor Event
                logMessage__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "log_message"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor LogMessage)
                      (Data.ProtoLens.OptionalField maybe'logMessage)
                      :: Data.ProtoLens.FieldDescriptor Event
                sessionLog__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "session_log"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor SessionLog)
                      (Data.ProtoLens.OptionalField maybe'sessionLog)
                      :: Data.ProtoLens.FieldDescriptor Event
                taggedRunMetadata__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "tagged_run_metadata"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor TaggedRunMetadata)
                      (Data.ProtoLens.OptionalField maybe'taggedRunMetadata)
                      :: Data.ProtoLens.FieldDescriptor Event
                metaGraphDef__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "meta_graph_def"
                      (Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.OptionalField maybe'metaGraphDef)
                      :: Data.ProtoLens.FieldDescriptor Event
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.Event")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, wallTime__field_descriptor),
                    (Data.ProtoLens.Tag 2, step__field_descriptor),
                    (Data.ProtoLens.Tag 3, fileVersion__field_descriptor),
                    (Data.ProtoLens.Tag 4, graphDef__field_descriptor),
                    (Data.ProtoLens.Tag 5, summary__field_descriptor),
                    (Data.ProtoLens.Tag 6, logMessage__field_descriptor),
                    (Data.ProtoLens.Tag 7, sessionLog__field_descriptor),
                    (Data.ProtoLens.Tag 8, taggedRunMetadata__field_descriptor),
                    (Data.ProtoLens.Tag 9, metaGraphDef__field_descriptor)])
                (Data.Map.fromList
                   [("wall_time", wallTime__field_descriptor),
                    ("step", step__field_descriptor),
                    ("file_version", fileVersion__field_descriptor),
                    ("graph_def", graphDef__field_descriptor),
                    ("summary", summary__field_descriptor),
                    ("log_message", logMessage__field_descriptor),
                    ("session_log", sessionLog__field_descriptor),
                    ("tagged_run_metadata", taggedRunMetadata__field_descriptor),
                    ("meta_graph_def", metaGraphDef__field_descriptor)])

data LogMessage = LogMessage{_LogMessage'level ::
                             !LogMessage'Level,
                             _LogMessage'message :: !Data.Text.Text}
                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ LogMessage'Level, b ~ LogMessage'Level,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "level" f LogMessage LogMessage a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _LogMessage'level
                 (\ x__ y__ -> x__{_LogMessage'level = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "message" f LogMessage LogMessage a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _LogMessage'message
                 (\ x__ y__ -> x__{_LogMessage'message = y__}))
              Prelude.id

instance Data.Default.Class.Default LogMessage where
        def
          = LogMessage{_LogMessage'level = Data.Default.Class.def,
                       _LogMessage'message = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message LogMessage where
        descriptor
          = let level__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "level"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor LogMessage'Level)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional level)
                      :: Data.ProtoLens.FieldDescriptor LogMessage
                message__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "message"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional message)
                      :: Data.ProtoLens.FieldDescriptor LogMessage
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.LogMessage")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, level__field_descriptor),
                    (Data.ProtoLens.Tag 2, message__field_descriptor)])
                (Data.Map.fromList
                   [("level", level__field_descriptor),
                    ("message", message__field_descriptor)])

data LogMessage'Level = LogMessage'UNKNOWN
                      | LogMessage'DEBUGGING
                      | LogMessage'INFO
                      | LogMessage'WARN
                      | LogMessage'ERROR
                      | LogMessage'FATAL
                      deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance Data.Default.Class.Default LogMessage'Level where
        def = LogMessage'UNKNOWN

instance Data.ProtoLens.FieldDefault LogMessage'Level where
        fieldDefault = LogMessage'UNKNOWN

instance Data.ProtoLens.MessageEnum LogMessage'Level where
        maybeToEnum 0 = Prelude.Just LogMessage'UNKNOWN
        maybeToEnum 10 = Prelude.Just LogMessage'DEBUGGING
        maybeToEnum 20 = Prelude.Just LogMessage'INFO
        maybeToEnum 30 = Prelude.Just LogMessage'WARN
        maybeToEnum 40 = Prelude.Just LogMessage'ERROR
        maybeToEnum 50 = Prelude.Just LogMessage'FATAL
        maybeToEnum _ = Prelude.Nothing
        showEnum LogMessage'UNKNOWN = "UNKNOWN"
        showEnum LogMessage'DEBUGGING = "DEBUGGING"
        showEnum LogMessage'INFO = "INFO"
        showEnum LogMessage'WARN = "WARN"
        showEnum LogMessage'ERROR = "ERROR"
        showEnum LogMessage'FATAL = "FATAL"
        readEnum "UNKNOWN" = Prelude.Just LogMessage'UNKNOWN
        readEnum "DEBUGGING" = Prelude.Just LogMessage'DEBUGGING
        readEnum "INFO" = Prelude.Just LogMessage'INFO
        readEnum "WARN" = Prelude.Just LogMessage'WARN
        readEnum "ERROR" = Prelude.Just LogMessage'ERROR
        readEnum "FATAL" = Prelude.Just LogMessage'FATAL
        readEnum _ = Prelude.Nothing

instance Prelude.Enum LogMessage'Level where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum Level: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum LogMessage'UNKNOWN = 0
        fromEnum LogMessage'DEBUGGING = 10
        fromEnum LogMessage'INFO = 20
        fromEnum LogMessage'WARN = 30
        fromEnum LogMessage'ERROR = 40
        fromEnum LogMessage'FATAL = 50
        succ LogMessage'FATAL
          = Prelude.error
              "LogMessage'Level.succ: bad argument LogMessage'FATAL. This value would be out of bounds."
        succ LogMessage'UNKNOWN = LogMessage'DEBUGGING
        succ LogMessage'DEBUGGING = LogMessage'INFO
        succ LogMessage'INFO = LogMessage'WARN
        succ LogMessage'WARN = LogMessage'ERROR
        succ LogMessage'ERROR = LogMessage'FATAL
        pred LogMessage'UNKNOWN
          = Prelude.error
              "LogMessage'Level.pred: bad argument LogMessage'UNKNOWN. This value would be out of bounds."
        pred LogMessage'DEBUGGING = LogMessage'UNKNOWN
        pred LogMessage'INFO = LogMessage'DEBUGGING
        pred LogMessage'WARN = LogMessage'INFO
        pred LogMessage'ERROR = LogMessage'WARN
        pred LogMessage'FATAL = LogMessage'ERROR
        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 LogMessage'Level where
        minBound = LogMessage'UNKNOWN
        maxBound = LogMessage'FATAL

data SessionLog = SessionLog{_SessionLog'status ::
                             !SessionLog'SessionStatus,
                             _SessionLog'checkpointPath :: !Data.Text.Text,
                             _SessionLog'msg :: !Data.Text.Text}
                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ SessionLog'SessionStatus,
          b ~ SessionLog'SessionStatus, Prelude.Functor f) =>
         Lens.Labels.HasLens "status" f SessionLog SessionLog a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _SessionLog'status
                 (\ x__ y__ -> x__{_SessionLog'status = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "checkpointPath" f SessionLog SessionLog a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _SessionLog'checkpointPath
                 (\ x__ y__ -> x__{_SessionLog'checkpointPath = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "msg" f SessionLog SessionLog a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _SessionLog'msg
                 (\ x__ y__ -> x__{_SessionLog'msg = y__}))
              Prelude.id

instance Data.Default.Class.Default SessionLog where
        def
          = SessionLog{_SessionLog'status = Data.Default.Class.def,
                       _SessionLog'checkpointPath = Data.ProtoLens.fieldDefault,
                       _SessionLog'msg = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message SessionLog where
        descriptor
          = let status__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "status"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor SessionLog'SessionStatus)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional status)
                      :: Data.ProtoLens.FieldDescriptor SessionLog
                checkpointPath__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "checkpoint_path"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional checkpointPath)
                      :: Data.ProtoLens.FieldDescriptor SessionLog
                msg__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "msg"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional msg)
                      :: Data.ProtoLens.FieldDescriptor SessionLog
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.SessionLog")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, status__field_descriptor),
                    (Data.ProtoLens.Tag 2, checkpointPath__field_descriptor),
                    (Data.ProtoLens.Tag 3, msg__field_descriptor)])
                (Data.Map.fromList
                   [("status", status__field_descriptor),
                    ("checkpoint_path", checkpointPath__field_descriptor),
                    ("msg", msg__field_descriptor)])

data SessionLog'SessionStatus = SessionLog'STATUS_UNSPECIFIED
                              | SessionLog'START
                              | SessionLog'STOP
                              | SessionLog'CHECKPOINT
                              deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance Data.Default.Class.Default SessionLog'SessionStatus where
        def = SessionLog'STATUS_UNSPECIFIED

instance Data.ProtoLens.FieldDefault SessionLog'SessionStatus where
        fieldDefault = SessionLog'STATUS_UNSPECIFIED

instance Data.ProtoLens.MessageEnum SessionLog'SessionStatus where
        maybeToEnum 0 = Prelude.Just SessionLog'STATUS_UNSPECIFIED
        maybeToEnum 1 = Prelude.Just SessionLog'START
        maybeToEnum 2 = Prelude.Just SessionLog'STOP
        maybeToEnum 3 = Prelude.Just SessionLog'CHECKPOINT
        maybeToEnum _ = Prelude.Nothing
        showEnum SessionLog'STATUS_UNSPECIFIED = "STATUS_UNSPECIFIED"
        showEnum SessionLog'START = "START"
        showEnum SessionLog'STOP = "STOP"
        showEnum SessionLog'CHECKPOINT = "CHECKPOINT"
        readEnum "STATUS_UNSPECIFIED"
          = Prelude.Just SessionLog'STATUS_UNSPECIFIED
        readEnum "START" = Prelude.Just SessionLog'START
        readEnum "STOP" = Prelude.Just SessionLog'STOP
        readEnum "CHECKPOINT" = Prelude.Just SessionLog'CHECKPOINT
        readEnum _ = Prelude.Nothing

instance Prelude.Enum SessionLog'SessionStatus where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum SessionStatus: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum SessionLog'STATUS_UNSPECIFIED = 0
        fromEnum SessionLog'START = 1
        fromEnum SessionLog'STOP = 2
        fromEnum SessionLog'CHECKPOINT = 3
        succ SessionLog'CHECKPOINT
          = Prelude.error
              "SessionLog'SessionStatus.succ: bad argument SessionLog'CHECKPOINT. This value would be out of bounds."
        succ SessionLog'STATUS_UNSPECIFIED = SessionLog'START
        succ SessionLog'START = SessionLog'STOP
        succ SessionLog'STOP = SessionLog'CHECKPOINT
        pred SessionLog'STATUS_UNSPECIFIED
          = Prelude.error
              "SessionLog'SessionStatus.pred: bad argument SessionLog'STATUS_UNSPECIFIED. This value would be out of bounds."
        pred SessionLog'START = SessionLog'STATUS_UNSPECIFIED
        pred SessionLog'STOP = SessionLog'START
        pred SessionLog'CHECKPOINT = SessionLog'STOP
        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 SessionLog'SessionStatus where
        minBound = SessionLog'STATUS_UNSPECIFIED
        maxBound = SessionLog'CHECKPOINT

data TaggedRunMetadata = TaggedRunMetadata{_TaggedRunMetadata'tag
                                           :: !Data.Text.Text,
                                           _TaggedRunMetadata'runMetadata ::
                                           !Data.ByteString.ByteString}
                       deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "tag" f TaggedRunMetadata TaggedRunMetadata a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _TaggedRunMetadata'tag
                 (\ x__ y__ -> x__{_TaggedRunMetadata'tag = y__}))
              Prelude.id

instance (a ~ Data.ByteString.ByteString,
          b ~ Data.ByteString.ByteString, Prelude.Functor f) =>
         Lens.Labels.HasLens "runMetadata" f TaggedRunMetadata
           TaggedRunMetadata
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _TaggedRunMetadata'runMetadata
                 (\ x__ y__ -> x__{_TaggedRunMetadata'runMetadata = y__}))
              Prelude.id

instance Data.Default.Class.Default TaggedRunMetadata where
        def
          = TaggedRunMetadata{_TaggedRunMetadata'tag =
                                Data.ProtoLens.fieldDefault,
                              _TaggedRunMetadata'runMetadata = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message TaggedRunMetadata where
        descriptor
          = let tag__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "tag"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional tag)
                      :: Data.ProtoLens.FieldDescriptor TaggedRunMetadata
                runMetadata__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "run_metadata"
                      (Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional runMetadata)
                      :: Data.ProtoLens.FieldDescriptor TaggedRunMetadata
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.TaggedRunMetadata")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, tag__field_descriptor),
                    (Data.ProtoLens.Tag 2, runMetadata__field_descriptor)])
                (Data.Map.fromList
                   [("tag", tag__field_descriptor),
                    ("run_metadata", runMetadata__field_descriptor)])

data WatchdogConfig = WatchdogConfig{_WatchdogConfig'timeoutMs ::
                                     !Data.Int.Int64}
                    deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Data.Int.Int64, b ~ Data.Int.Int64,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "timeoutMs" f WatchdogConfig WatchdogConfig a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _WatchdogConfig'timeoutMs
                 (\ x__ y__ -> x__{_WatchdogConfig'timeoutMs = y__}))
              Prelude.id

instance Data.Default.Class.Default WatchdogConfig where
        def
          = WatchdogConfig{_WatchdogConfig'timeoutMs =
                             Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message WatchdogConfig where
        descriptor
          = let timeoutMs__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "timeout_ms"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional timeoutMs)
                      :: Data.ProtoLens.FieldDescriptor WatchdogConfig
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.WatchdogConfig")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, timeoutMs__field_descriptor)])
                (Data.Map.fromList [("timeout_ms", timeoutMs__field_descriptor)])

data WorkerHealth = OK
                  | RECEIVED_SHUTDOWN_SIGNAL
                  | INTERNAL_ERROR
                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance Data.Default.Class.Default WorkerHealth where
        def = OK

instance Data.ProtoLens.FieldDefault WorkerHealth where
        fieldDefault = OK

instance Data.ProtoLens.MessageEnum WorkerHealth where
        maybeToEnum 0 = Prelude.Just OK
        maybeToEnum 1 = Prelude.Just RECEIVED_SHUTDOWN_SIGNAL
        maybeToEnum 2 = Prelude.Just INTERNAL_ERROR
        maybeToEnum _ = Prelude.Nothing
        showEnum OK = "OK"
        showEnum RECEIVED_SHUTDOWN_SIGNAL = "RECEIVED_SHUTDOWN_SIGNAL"
        showEnum INTERNAL_ERROR = "INTERNAL_ERROR"
        readEnum "OK" = Prelude.Just OK
        readEnum "RECEIVED_SHUTDOWN_SIGNAL"
          = Prelude.Just RECEIVED_SHUTDOWN_SIGNAL
        readEnum "INTERNAL_ERROR" = Prelude.Just INTERNAL_ERROR
        readEnum _ = Prelude.Nothing

instance Prelude.Enum WorkerHealth where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum WorkerHealth: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum OK = 0
        fromEnum RECEIVED_SHUTDOWN_SIGNAL = 1
        fromEnum INTERNAL_ERROR = 2
        succ INTERNAL_ERROR
          = Prelude.error
              "WorkerHealth.succ: bad argument INTERNAL_ERROR. This value would be out of bounds."
        succ OK = RECEIVED_SHUTDOWN_SIGNAL
        succ RECEIVED_SHUTDOWN_SIGNAL = INTERNAL_ERROR
        pred OK
          = Prelude.error
              "WorkerHealth.pred: bad argument OK. This value would be out of bounds."
        pred RECEIVED_SHUTDOWN_SIGNAL = OK
        pred INTERNAL_ERROR = RECEIVED_SHUTDOWN_SIGNAL
        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 WorkerHealth where
        minBound = OK
        maxBound = INTERNAL_ERROR

data WorkerHeartbeatRequest = WorkerHeartbeatRequest{_WorkerHeartbeatRequest'shutdownMode
                                                     :: !WorkerShutdownMode,
                                                     _WorkerHeartbeatRequest'watchdogConfig ::
                                                     !(Prelude.Maybe WatchdogConfig)}
                            deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ WorkerShutdownMode, b ~ WorkerShutdownMode,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "shutdownMode" f WorkerHeartbeatRequest
           WorkerHeartbeatRequest
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _WorkerHeartbeatRequest'shutdownMode
                 (\ x__ y__ -> x__{_WorkerHeartbeatRequest'shutdownMode = y__}))
              Prelude.id

instance (a ~ WatchdogConfig, b ~ WatchdogConfig,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "watchdogConfig" f WorkerHeartbeatRequest
           WorkerHeartbeatRequest
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _WorkerHeartbeatRequest'watchdogConfig
                 (\ x__ y__ -> x__{_WorkerHeartbeatRequest'watchdogConfig = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~ Prelude.Maybe WatchdogConfig,
          b ~ Prelude.Maybe WatchdogConfig, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'watchdogConfig" f WorkerHeartbeatRequest
           WorkerHeartbeatRequest
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _WorkerHeartbeatRequest'watchdogConfig
                 (\ x__ y__ -> x__{_WorkerHeartbeatRequest'watchdogConfig = y__}))
              Prelude.id

instance Data.Default.Class.Default WorkerHeartbeatRequest where
        def
          = WorkerHeartbeatRequest{_WorkerHeartbeatRequest'shutdownMode =
                                     Data.Default.Class.def,
                                   _WorkerHeartbeatRequest'watchdogConfig = Prelude.Nothing}

instance Data.ProtoLens.Message WorkerHeartbeatRequest where
        descriptor
          = let shutdownMode__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "shutdown_mode"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor WorkerShutdownMode)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional shutdownMode)
                      :: Data.ProtoLens.FieldDescriptor WorkerHeartbeatRequest
                watchdogConfig__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "watchdog_config"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor WatchdogConfig)
                      (Data.ProtoLens.OptionalField maybe'watchdogConfig)
                      :: Data.ProtoLens.FieldDescriptor WorkerHeartbeatRequest
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.WorkerHeartbeatRequest")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, shutdownMode__field_descriptor),
                    (Data.ProtoLens.Tag 2, watchdogConfig__field_descriptor)])
                (Data.Map.fromList
                   [("shutdown_mode", shutdownMode__field_descriptor),
                    ("watchdog_config", watchdogConfig__field_descriptor)])

data WorkerHeartbeatResponse = WorkerHeartbeatResponse{_WorkerHeartbeatResponse'healthStatus
                                                       :: !WorkerHealth,
                                                       _WorkerHeartbeatResponse'workerLog ::
                                                       ![Event],
                                                       _WorkerHeartbeatResponse'hostname ::
                                                       !Data.Text.Text}
                             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ WorkerHealth, b ~ WorkerHealth, Prelude.Functor f) =>
         Lens.Labels.HasLens "healthStatus" f WorkerHeartbeatResponse
           WorkerHeartbeatResponse
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _WorkerHeartbeatResponse'healthStatus
                 (\ x__ y__ -> x__{_WorkerHeartbeatResponse'healthStatus = y__}))
              Prelude.id

instance (a ~ [Event], b ~ [Event], Prelude.Functor f) =>
         Lens.Labels.HasLens "workerLog" f WorkerHeartbeatResponse
           WorkerHeartbeatResponse
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _WorkerHeartbeatResponse'workerLog
                 (\ x__ y__ -> x__{_WorkerHeartbeatResponse'workerLog = y__}))
              Prelude.id

instance (a ~ Data.Text.Text, b ~ Data.Text.Text,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "hostname" f WorkerHeartbeatResponse
           WorkerHeartbeatResponse
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _WorkerHeartbeatResponse'hostname
                 (\ x__ y__ -> x__{_WorkerHeartbeatResponse'hostname = y__}))
              Prelude.id

instance Data.Default.Class.Default WorkerHeartbeatResponse where
        def
          = WorkerHeartbeatResponse{_WorkerHeartbeatResponse'healthStatus =
                                      Data.Default.Class.def,
                                    _WorkerHeartbeatResponse'workerLog = [],
                                    _WorkerHeartbeatResponse'hostname = Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message WorkerHeartbeatResponse where
        descriptor
          = let healthStatus__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "health_status"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor WorkerHealth)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional healthStatus)
                      :: Data.ProtoLens.FieldDescriptor WorkerHeartbeatResponse
                workerLog__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "worker_log"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor Event)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked workerLog)
                      :: Data.ProtoLens.FieldDescriptor WorkerHeartbeatResponse
                hostname__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "hostname"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional hostname)
                      :: Data.ProtoLens.FieldDescriptor WorkerHeartbeatResponse
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.WorkerHeartbeatResponse")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, healthStatus__field_descriptor),
                    (Data.ProtoLens.Tag 2, workerLog__field_descriptor),
                    (Data.ProtoLens.Tag 3, hostname__field_descriptor)])
                (Data.Map.fromList
                   [("health_status", healthStatus__field_descriptor),
                    ("worker_log", workerLog__field_descriptor),
                    ("hostname", hostname__field_descriptor)])

data WorkerShutdownMode = DEFAULT
                        | SHUTDOWN_IMMEDIATELY
                        | WAIT_FOR_COORDINATOR
                        deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance Data.Default.Class.Default WorkerShutdownMode where
        def = DEFAULT

instance Data.ProtoLens.FieldDefault WorkerShutdownMode where
        fieldDefault = DEFAULT

instance Data.ProtoLens.MessageEnum WorkerShutdownMode where
        maybeToEnum 0 = Prelude.Just DEFAULT
        maybeToEnum 1 = Prelude.Just SHUTDOWN_IMMEDIATELY
        maybeToEnum 2 = Prelude.Just WAIT_FOR_COORDINATOR
        maybeToEnum _ = Prelude.Nothing
        showEnum DEFAULT = "DEFAULT"
        showEnum SHUTDOWN_IMMEDIATELY = "SHUTDOWN_IMMEDIATELY"
        showEnum WAIT_FOR_COORDINATOR = "WAIT_FOR_COORDINATOR"
        readEnum "DEFAULT" = Prelude.Just DEFAULT
        readEnum "SHUTDOWN_IMMEDIATELY" = Prelude.Just SHUTDOWN_IMMEDIATELY
        readEnum "WAIT_FOR_COORDINATOR" = Prelude.Just WAIT_FOR_COORDINATOR
        readEnum _ = Prelude.Nothing

instance Prelude.Enum WorkerShutdownMode where
        toEnum k__
          = Prelude.maybe
              (Prelude.error
                 ((Prelude.++) "toEnum: unknown value for enum WorkerShutdownMode: "
                    (Prelude.show k__)))
              Prelude.id
              (Data.ProtoLens.maybeToEnum k__)
        fromEnum DEFAULT = 0
        fromEnum SHUTDOWN_IMMEDIATELY = 1
        fromEnum WAIT_FOR_COORDINATOR = 2
        succ WAIT_FOR_COORDINATOR
          = Prelude.error
              "WorkerShutdownMode.succ: bad argument WAIT_FOR_COORDINATOR. This value would be out of bounds."
        succ DEFAULT = SHUTDOWN_IMMEDIATELY
        succ SHUTDOWN_IMMEDIATELY = WAIT_FOR_COORDINATOR
        pred DEFAULT
          = Prelude.error
              "WorkerShutdownMode.pred: bad argument DEFAULT. This value would be out of bounds."
        pred SHUTDOWN_IMMEDIATELY = DEFAULT
        pred WAIT_FOR_COORDINATOR = SHUTDOWN_IMMEDIATELY
        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 WorkerShutdownMode where
        minBound = DEFAULT
        maxBound = WAIT_FOR_COORDINATOR

checkpointPath ::
               forall f s t a b .
                 (Lens.Labels.HasLens "checkpointPath" f s t a b) =>
                 Lens.Family2.LensLike f s t a b
checkpointPath
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "checkpointPath")

fileVersion ::
            forall f s t a b . (Lens.Labels.HasLens "fileVersion" f s t a b) =>
              Lens.Family2.LensLike f s t a b
fileVersion
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "fileVersion")

graphDef ::
         forall f s t a b . (Lens.Labels.HasLens "graphDef" f s t a b) =>
           Lens.Family2.LensLike f s t a b
graphDef
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "graphDef")

healthStatus ::
             forall f s t a b .
               (Lens.Labels.HasLens "healthStatus" f s t a b) =>
               Lens.Family2.LensLike f s t a b
healthStatus
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "healthStatus")

hostname ::
         forall f s t a b . (Lens.Labels.HasLens "hostname" f s t a b) =>
           Lens.Family2.LensLike f s t a b
hostname
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "hostname")

level ::
      forall f s t a b . (Lens.Labels.HasLens "level" f s t a b) =>
        Lens.Family2.LensLike f s t a b
level
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "level")

logMessage ::
           forall f s t a b . (Lens.Labels.HasLens "logMessage" f s t a b) =>
             Lens.Family2.LensLike f s t a b
logMessage
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "logMessage")

maybe'fileVersion ::
                  forall f s t a b .
                    (Lens.Labels.HasLens "maybe'fileVersion" f s t a b) =>
                    Lens.Family2.LensLike f s t a b
maybe'fileVersion
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'fileVersion")

maybe'graphDef ::
               forall f s t a b .
                 (Lens.Labels.HasLens "maybe'graphDef" f s t a b) =>
                 Lens.Family2.LensLike f s t a b
maybe'graphDef
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'graphDef")

maybe'logMessage ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "maybe'logMessage" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
maybe'logMessage
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'logMessage")

maybe'metaGraphDef ::
                   forall f s t a b .
                     (Lens.Labels.HasLens "maybe'metaGraphDef" f s t a b) =>
                     Lens.Family2.LensLike f s t a b
maybe'metaGraphDef
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'metaGraphDef")

maybe'sessionLog ::
                 forall f s t a b .
                   (Lens.Labels.HasLens "maybe'sessionLog" f s t a b) =>
                   Lens.Family2.LensLike f s t a b
maybe'sessionLog
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'sessionLog")

maybe'summary ::
              forall f s t a b .
                (Lens.Labels.HasLens "maybe'summary" f s t a b) =>
                Lens.Family2.LensLike f s t a b
maybe'summary
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'summary")

maybe'taggedRunMetadata ::
                        forall f s t a b .
                          (Lens.Labels.HasLens "maybe'taggedRunMetadata" f s t a b) =>
                          Lens.Family2.LensLike f s t a b
maybe'taggedRunMetadata
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "maybe'taggedRunMetadata")

maybe'watchdogConfig ::
                     forall f s t a b .
                       (Lens.Labels.HasLens "maybe'watchdogConfig" f s t a b) =>
                       Lens.Family2.LensLike f s t a b
maybe'watchdogConfig
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) ::
         (Lens.Labels.Proxy#) "maybe'watchdogConfig")

maybe'what ::
           forall f s t a b . (Lens.Labels.HasLens "maybe'what" f s t a b) =>
             Lens.Family2.LensLike f s t a b
maybe'what
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'what")

message ::
        forall f s t a b . (Lens.Labels.HasLens "message" f s t a b) =>
          Lens.Family2.LensLike f s t a b
message
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "message")

metaGraphDef ::
             forall f s t a b .
               (Lens.Labels.HasLens "metaGraphDef" f s t a b) =>
               Lens.Family2.LensLike f s t a b
metaGraphDef
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "metaGraphDef")

msg ::
    forall f s t a b . (Lens.Labels.HasLens "msg" f s t a b) =>
      Lens.Family2.LensLike f s t a b
msg
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "msg")

runMetadata ::
            forall f s t a b . (Lens.Labels.HasLens "runMetadata" f s t a b) =>
              Lens.Family2.LensLike f s t a b
runMetadata
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "runMetadata")

sessionLog ::
           forall f s t a b . (Lens.Labels.HasLens "sessionLog" f s t a b) =>
             Lens.Family2.LensLike f s t a b
sessionLog
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "sessionLog")

shutdownMode ::
             forall f s t a b .
               (Lens.Labels.HasLens "shutdownMode" f s t a b) =>
               Lens.Family2.LensLike f s t a b
shutdownMode
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "shutdownMode")

status ::
       forall f s t a b . (Lens.Labels.HasLens "status" f s t a b) =>
         Lens.Family2.LensLike f s t a b
status
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "status")

step ::
     forall f s t a b . (Lens.Labels.HasLens "step" f s t a b) =>
       Lens.Family2.LensLike f s t a b
step
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "step")

summary ::
        forall f s t a b . (Lens.Labels.HasLens "summary" f s t a b) =>
          Lens.Family2.LensLike f s t a b
summary
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "summary")

tag ::
    forall f s t a b . (Lens.Labels.HasLens "tag" f s t a b) =>
      Lens.Family2.LensLike f s t a b
tag
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "tag")

taggedRunMetadata ::
                  forall f s t a b .
                    (Lens.Labels.HasLens "taggedRunMetadata" f s t a b) =>
                    Lens.Family2.LensLike f s t a b
taggedRunMetadata
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "taggedRunMetadata")

timeoutMs ::
          forall f s t a b . (Lens.Labels.HasLens "timeoutMs" f s t a b) =>
            Lens.Family2.LensLike f s t a b
timeoutMs
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "timeoutMs")

wallTime ::
         forall f s t a b . (Lens.Labels.HasLens "wallTime" f s t a b) =>
           Lens.Family2.LensLike f s t a b
wallTime
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "wallTime")

watchdogConfig ::
               forall f s t a b .
                 (Lens.Labels.HasLens "watchdogConfig" f s t a b) =>
                 Lens.Family2.LensLike f s t a b
watchdogConfig
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "watchdogConfig")

workerLog ::
          forall f s t a b . (Lens.Labels.HasLens "workerLog" f s t a b) =>
            Lens.Family2.LensLike f s t a b
workerLog
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "workerLog")