{- This file was auto-generated from tensorflow/core/example/example_parser_configuration.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.Example.ExampleParserConfiguration
       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.Tensor
import qualified Proto.Tensorflow.Core.Framework.TensorShape
import qualified Proto.Tensorflow.Core.Framework.Types

data ExampleParserConfiguration = ExampleParserConfiguration{_ExampleParserConfiguration'featureMap
                                                             ::
                                                             !(Data.Map.Map Data.Text.Text
                                                                 FeatureConfiguration)}
                                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance Data.Default.Class.Default ExampleParserConfiguration
         where
        def
          = ExampleParserConfiguration{_ExampleParserConfiguration'featureMap
                                         = Data.Map.empty}

instance Data.ProtoLens.Message ExampleParserConfiguration where
        descriptor
          = let featureMap__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "feature_map"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           ExampleParserConfiguration'FeatureMapEntry)
                      (Data.ProtoLens.MapField key value featureMap)
                      :: Data.ProtoLens.FieldDescriptor ExampleParserConfiguration
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.ExampleParserConfiguration")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, featureMap__field_descriptor)])
                (Data.Map.fromList [("feature_map", featureMap__field_descriptor)])

data ExampleParserConfiguration'FeatureMapEntry = ExampleParserConfiguration'FeatureMapEntry{_ExampleParserConfiguration'FeatureMapEntry'key
                                                                                             ::
                                                                                             !Data.Text.Text,
                                                                                             _ExampleParserConfiguration'FeatureMapEntry'value
                                                                                             ::
                                                                                             !(Prelude.Maybe
                                                                                                 FeatureConfiguration)}
                                                deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

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

instance (a ~ Prelude.Maybe FeatureConfiguration,
          b ~ Prelude.Maybe FeatureConfiguration, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'value" f
           ExampleParserConfiguration'FeatureMapEntry
           ExampleParserConfiguration'FeatureMapEntry
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens
                 _ExampleParserConfiguration'FeatureMapEntry'value
                 (\ x__ y__ ->
                    x__{_ExampleParserConfiguration'FeatureMapEntry'value = y__}))
              Prelude.id

instance Data.Default.Class.Default
           ExampleParserConfiguration'FeatureMapEntry
         where
        def
          = ExampleParserConfiguration'FeatureMapEntry{_ExampleParserConfiguration'FeatureMapEntry'key
                                                         = Data.ProtoLens.fieldDefault,
                                                       _ExampleParserConfiguration'FeatureMapEntry'value
                                                         = Prelude.Nothing}

instance Data.ProtoLens.Message
           ExampleParserConfiguration'FeatureMapEntry
         where
        descriptor
          = let key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional key)
                      ::
                      Data.ProtoLens.FieldDescriptor
                        ExampleParserConfiguration'FeatureMapEntry
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor FeatureConfiguration)
                      (Data.ProtoLens.OptionalField maybe'value)
                      ::
                      Data.ProtoLens.FieldDescriptor
                        ExampleParserConfiguration'FeatureMapEntry
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack
                   "tensorflow.ExampleParserConfiguration.FeatureMapEntry")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, key__field_descriptor),
                    (Data.ProtoLens.Tag 2, value__field_descriptor)])
                (Data.Map.fromList
                   [("key", key__field_descriptor),
                    ("value", value__field_descriptor)])

data FeatureConfiguration = FeatureConfiguration{_FeatureConfiguration'config
                                                 :: !(Prelude.Maybe FeatureConfiguration'Config)}
                          deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

data FeatureConfiguration'Config = FeatureConfiguration'FixedLenFeature !FixedLenFeatureProto
                                 | FeatureConfiguration'VarLenFeature !VarLenFeatureProto
                                 deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance (a ~ Prelude.Maybe FixedLenFeatureProto,
          b ~ Prelude.Maybe FixedLenFeatureProto, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'fixedLenFeature" f FeatureConfiguration
           FeatureConfiguration
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FeatureConfiguration'config
                 (\ x__ y__ -> x__{_FeatureConfiguration'config = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just
                          (FeatureConfiguration'FixedLenFeature x__val) -> Prelude.Just
                                                                             x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap FeatureConfiguration'FixedLenFeature y__))

instance (a ~ FixedLenFeatureProto, b ~ FixedLenFeatureProto,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "fixedLenFeature" f FeatureConfiguration
           FeatureConfiguration
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FeatureConfiguration'config
                 (\ x__ y__ -> x__{_FeatureConfiguration'config = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just
                             (FeatureConfiguration'FixedLenFeature x__val) -> Prelude.Just
                                                                                x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap FeatureConfiguration'FixedLenFeature y__))
                 (Data.ProtoLens.maybeLens Data.Default.Class.def))

instance (a ~ Prelude.Maybe VarLenFeatureProto,
          b ~ Prelude.Maybe VarLenFeatureProto, Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'varLenFeature" f FeatureConfiguration
           FeatureConfiguration
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FeatureConfiguration'config
                 (\ x__ y__ -> x__{_FeatureConfiguration'config = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just
                          (FeatureConfiguration'VarLenFeature x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap FeatureConfiguration'VarLenFeature y__))

instance (a ~ VarLenFeatureProto, b ~ VarLenFeatureProto,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "varLenFeature" f FeatureConfiguration
           FeatureConfiguration
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FeatureConfiguration'config
                 (\ x__ y__ -> x__{_FeatureConfiguration'config = y__}))
              ((Prelude..)
                 (Lens.Family2.Unchecked.lens
                    (\ x__ ->
                       case x__ of
                           Prelude.Just
                             (FeatureConfiguration'VarLenFeature x__val) -> Prelude.Just x__val
                           _otherwise -> Prelude.Nothing)
                    (\ _ y__ -> Prelude.fmap FeatureConfiguration'VarLenFeature y__))
                 (Data.ProtoLens.maybeLens Data.Default.Class.def))

instance Data.Default.Class.Default FeatureConfiguration where
        def
          = FeatureConfiguration{_FeatureConfiguration'config =
                                   Prelude.Nothing}

instance Data.ProtoLens.Message FeatureConfiguration where
        descriptor
          = let fixedLenFeature__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "fixed_len_feature"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor FixedLenFeatureProto)
                      (Data.ProtoLens.OptionalField maybe'fixedLenFeature)
                      :: Data.ProtoLens.FieldDescriptor FeatureConfiguration
                varLenFeature__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "var_len_feature"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor VarLenFeatureProto)
                      (Data.ProtoLens.OptionalField maybe'varLenFeature)
                      :: Data.ProtoLens.FieldDescriptor FeatureConfiguration
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.FeatureConfiguration")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, fixedLenFeature__field_descriptor),
                    (Data.ProtoLens.Tag 2, varLenFeature__field_descriptor)])
                (Data.Map.fromList
                   [("fixed_len_feature", fixedLenFeature__field_descriptor),
                    ("var_len_feature", varLenFeature__field_descriptor)])

data FixedLenFeatureProto = FixedLenFeatureProto{_FixedLenFeatureProto'dtype
                                                 :: !Proto.Tensorflow.Core.Framework.Types.DataType,
                                                 _FixedLenFeatureProto'shape ::
                                                 !(Prelude.Maybe
                                                     Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto),
                                                 _FixedLenFeatureProto'defaultValue ::
                                                 !(Prelude.Maybe
                                                     Proto.Tensorflow.Core.Framework.Tensor.TensorProto),
                                                 _FixedLenFeatureProto'valuesOutputTensorName ::
                                                 !Data.Text.Text}
                          deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Proto.Tensorflow.Core.Framework.Types.DataType,
          b ~ Proto.Tensorflow.Core.Framework.Types.DataType,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "dtype" f FixedLenFeatureProto
           FixedLenFeatureProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FixedLenFeatureProto'dtype
                 (\ x__ y__ -> x__{_FixedLenFeatureProto'dtype = y__}))
              Prelude.id

instance (a ~
            Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto,
          b ~ Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "shape" f FixedLenFeatureProto
           FixedLenFeatureProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FixedLenFeatureProto'shape
                 (\ x__ y__ -> x__{_FixedLenFeatureProto'shape = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~
            Prelude.Maybe
              Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto,
          b ~
            Prelude.Maybe
              Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'shape" f FixedLenFeatureProto
           FixedLenFeatureProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FixedLenFeatureProto'shape
                 (\ x__ y__ -> x__{_FixedLenFeatureProto'shape = y__}))
              Prelude.id

instance (a ~ Proto.Tensorflow.Core.Framework.Tensor.TensorProto,
          b ~ Proto.Tensorflow.Core.Framework.Tensor.TensorProto,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "defaultValue" f FixedLenFeatureProto
           FixedLenFeatureProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FixedLenFeatureProto'defaultValue
                 (\ x__ y__ -> x__{_FixedLenFeatureProto'defaultValue = y__}))
              (Data.ProtoLens.maybeLens Data.Default.Class.def)

instance (a ~
            Prelude.Maybe Proto.Tensorflow.Core.Framework.Tensor.TensorProto,
          b ~
            Prelude.Maybe Proto.Tensorflow.Core.Framework.Tensor.TensorProto,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'defaultValue" f FixedLenFeatureProto
           FixedLenFeatureProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _FixedLenFeatureProto'defaultValue
                 (\ x__ y__ -> x__{_FixedLenFeatureProto'defaultValue = y__}))
              Prelude.id

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

instance Data.Default.Class.Default FixedLenFeatureProto where
        def
          = FixedLenFeatureProto{_FixedLenFeatureProto'dtype =
                                   Data.Default.Class.def,
                                 _FixedLenFeatureProto'shape = Prelude.Nothing,
                                 _FixedLenFeatureProto'defaultValue = Prelude.Nothing,
                                 _FixedLenFeatureProto'valuesOutputTensorName =
                                   Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message FixedLenFeatureProto where
        descriptor
          = let dtype__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "dtype"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.Types.DataType)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional dtype)
                      :: Data.ProtoLens.FieldDescriptor FixedLenFeatureProto
                shape__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "shape"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.TensorShape.TensorShapeProto)
                      (Data.ProtoLens.OptionalField maybe'shape)
                      :: Data.ProtoLens.FieldDescriptor FixedLenFeatureProto
                defaultValue__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "default_value"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.Tensor.TensorProto)
                      (Data.ProtoLens.OptionalField maybe'defaultValue)
                      :: Data.ProtoLens.FieldDescriptor FixedLenFeatureProto
                valuesOutputTensorName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "values_output_tensor_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         valuesOutputTensorName)
                      :: Data.ProtoLens.FieldDescriptor FixedLenFeatureProto
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.FixedLenFeatureProto")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, dtype__field_descriptor),
                    (Data.ProtoLens.Tag 2, shape__field_descriptor),
                    (Data.ProtoLens.Tag 3, defaultValue__field_descriptor),
                    (Data.ProtoLens.Tag 4, valuesOutputTensorName__field_descriptor)])
                (Data.Map.fromList
                   [("dtype", dtype__field_descriptor),
                    ("shape", shape__field_descriptor),
                    ("default_value", defaultValue__field_descriptor),
                    ("values_output_tensor_name",
                     valuesOutputTensorName__field_descriptor)])

data VarLenFeatureProto = VarLenFeatureProto{_VarLenFeatureProto'dtype
                                             :: !Proto.Tensorflow.Core.Framework.Types.DataType,
                                             _VarLenFeatureProto'valuesOutputTensorName ::
                                             !Data.Text.Text,
                                             _VarLenFeatureProto'indicesOutputTensorName ::
                                             !Data.Text.Text,
                                             _VarLenFeatureProto'shapesOutputTensorName ::
                                             !Data.Text.Text}
                        deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

instance (a ~ Proto.Tensorflow.Core.Framework.Types.DataType,
          b ~ Proto.Tensorflow.Core.Framework.Types.DataType,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "dtype" f VarLenFeatureProto VarLenFeatureProto
           a
           b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _VarLenFeatureProto'dtype
                 (\ x__ y__ -> x__{_VarLenFeatureProto'dtype = y__}))
              Prelude.id

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

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

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

instance Data.Default.Class.Default VarLenFeatureProto where
        def
          = VarLenFeatureProto{_VarLenFeatureProto'dtype =
                                 Data.Default.Class.def,
                               _VarLenFeatureProto'valuesOutputTensorName =
                                 Data.ProtoLens.fieldDefault,
                               _VarLenFeatureProto'indicesOutputTensorName =
                                 Data.ProtoLens.fieldDefault,
                               _VarLenFeatureProto'shapesOutputTensorName =
                                 Data.ProtoLens.fieldDefault}

instance Data.ProtoLens.Message VarLenFeatureProto where
        descriptor
          = let dtype__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "dtype"
                      (Data.ProtoLens.EnumField ::
                         Data.ProtoLens.FieldTypeDescriptor
                           Proto.Tensorflow.Core.Framework.Types.DataType)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional dtype)
                      :: Data.ProtoLens.FieldDescriptor VarLenFeatureProto
                valuesOutputTensorName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "values_output_tensor_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         valuesOutputTensorName)
                      :: Data.ProtoLens.FieldDescriptor VarLenFeatureProto
                indicesOutputTensorName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "indices_output_tensor_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         indicesOutputTensorName)
                      :: Data.ProtoLens.FieldDescriptor VarLenFeatureProto
                shapesOutputTensorName__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "shapes_output_tensor_name"
                      (Data.ProtoLens.StringField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Text.Text)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         shapesOutputTensorName)
                      :: Data.ProtoLens.FieldDescriptor VarLenFeatureProto
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.VarLenFeatureProto")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, dtype__field_descriptor),
                    (Data.ProtoLens.Tag 2, valuesOutputTensorName__field_descriptor),
                    (Data.ProtoLens.Tag 3, indicesOutputTensorName__field_descriptor),
                    (Data.ProtoLens.Tag 4, shapesOutputTensorName__field_descriptor)])
                (Data.Map.fromList
                   [("dtype", dtype__field_descriptor),
                    ("values_output_tensor_name",
                     valuesOutputTensorName__field_descriptor),
                    ("indices_output_tensor_name",
                     indicesOutputTensorName__field_descriptor),
                    ("shapes_output_tensor_name",
                     shapesOutputTensorName__field_descriptor)])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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