{- This file was auto-generated from tensorflow/core/example/feature.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.Feature 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

data BytesList = BytesList{_BytesList'value ::
                           ![Data.ByteString.ByteString]}
               deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance Data.Default.Class.Default BytesList where
        def = BytesList{_BytesList'value = []}

instance Data.ProtoLens.Message BytesList where
        descriptor
          = let value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked value)
                      :: Data.ProtoLens.FieldDescriptor BytesList
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.BytesList")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, value__field_descriptor)])
                (Data.Map.fromList [("value", value__field_descriptor)])

data Feature = Feature{_Feature'kind ::
                       !(Prelude.Maybe Feature'Kind)}
             deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

data Feature'Kind = Feature'BytesList !BytesList
                  | Feature'FloatList !FloatList
                  | Feature'Int64List !Int64List
                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance (a ~ Prelude.Maybe BytesList, b ~ Prelude.Maybe BytesList,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'bytesList" f Feature Feature a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Feature'kind
                 (\ x__ y__ -> x__{_Feature'kind = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Feature'BytesList x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Feature'BytesList y__))

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

instance (a ~ Prelude.Maybe FloatList, b ~ Prelude.Maybe FloatList,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'floatList" f Feature Feature a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Feature'kind
                 (\ x__ y__ -> x__{_Feature'kind = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Feature'FloatList x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Feature'FloatList y__))

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

instance (a ~ Prelude.Maybe Int64List, b ~ Prelude.Maybe Int64List,
          Prelude.Functor f) =>
         Lens.Labels.HasLens "maybe'int64List" f Feature Feature a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Feature'kind
                 (\ x__ y__ -> x__{_Feature'kind = y__}))
              (Lens.Family2.Unchecked.lens
                 (\ x__ ->
                    case x__ of
                        Prelude.Just (Feature'Int64List x__val) -> Prelude.Just x__val
                        _otherwise -> Prelude.Nothing)
                 (\ _ y__ -> Prelude.fmap Feature'Int64List y__))

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

instance Data.Default.Class.Default Feature where
        def = Feature{_Feature'kind = Prelude.Nothing}

instance Data.ProtoLens.Message Feature where
        descriptor
          = let bytesList__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "bytes_list"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor BytesList)
                      (Data.ProtoLens.OptionalField maybe'bytesList)
                      :: Data.ProtoLens.FieldDescriptor Feature
                floatList__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "float_list"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor FloatList)
                      (Data.ProtoLens.OptionalField maybe'floatList)
                      :: Data.ProtoLens.FieldDescriptor Feature
                int64List__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "int64_list"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor Int64List)
                      (Data.ProtoLens.OptionalField maybe'int64List)
                      :: Data.ProtoLens.FieldDescriptor Feature
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.Feature")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, bytesList__field_descriptor),
                    (Data.ProtoLens.Tag 2, floatList__field_descriptor),
                    (Data.ProtoLens.Tag 3, int64List__field_descriptor)])
                (Data.Map.fromList
                   [("bytes_list", bytesList__field_descriptor),
                    ("float_list", floatList__field_descriptor),
                    ("int64_list", int64List__field_descriptor)])

data FeatureList = FeatureList{_FeatureList'feature :: ![Feature]}
                 deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance Data.Default.Class.Default FeatureList where
        def = FeatureList{_FeatureList'feature = []}

instance Data.ProtoLens.Message FeatureList where
        descriptor
          = let feature__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "feature"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor Feature)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked feature)
                      :: Data.ProtoLens.FieldDescriptor FeatureList
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.FeatureList")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, feature__field_descriptor)])
                (Data.Map.fromList [("feature", feature__field_descriptor)])

data FeatureLists = FeatureLists{_FeatureLists'featureList ::
                                 !(Data.Map.Map Data.Text.Text FeatureList)}
                  deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance Data.Default.Class.Default FeatureLists where
        def = FeatureLists{_FeatureLists'featureList = Data.Map.empty}

instance Data.ProtoLens.Message FeatureLists where
        descriptor
          = let featureList__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "feature_list"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor FeatureLists'FeatureListEntry)
                      (Data.ProtoLens.MapField key value featureList)
                      :: Data.ProtoLens.FieldDescriptor FeatureLists
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.FeatureLists")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, featureList__field_descriptor)])
                (Data.Map.fromList
                   [("feature_list", featureList__field_descriptor)])

data FeatureLists'FeatureListEntry = FeatureLists'FeatureListEntry{_FeatureLists'FeatureListEntry'key
                                                                   :: !Data.Text.Text,
                                                                   _FeatureLists'FeatureListEntry'value
                                                                   :: !(Prelude.Maybe FeatureList)}
                                   deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

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

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

instance Data.Default.Class.Default FeatureLists'FeatureListEntry
         where
        def
          = FeatureLists'FeatureListEntry{_FeatureLists'FeatureListEntry'key
                                            = Data.ProtoLens.fieldDefault,
                                          _FeatureLists'FeatureListEntry'value = Prelude.Nothing}

instance Data.ProtoLens.Message FeatureLists'FeatureListEntry 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 FeatureLists'FeatureListEntry
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor FeatureList)
                      (Data.ProtoLens.OptionalField maybe'value)
                      :: Data.ProtoLens.FieldDescriptor FeatureLists'FeatureListEntry
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.FeatureLists.FeatureListEntry")
                (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 Features = Features{_Features'feature ::
                         !(Data.Map.Map Data.Text.Text Feature)}
              deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance Data.Default.Class.Default Features where
        def = Features{_Features'feature = Data.Map.empty}

instance Data.ProtoLens.Message Features where
        descriptor
          = let feature__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "feature"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor Features'FeatureEntry)
                      (Data.ProtoLens.MapField key value feature)
                      :: Data.ProtoLens.FieldDescriptor Features
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.Features")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, feature__field_descriptor)])
                (Data.Map.fromList [("feature", feature__field_descriptor)])

data Features'FeatureEntry = Features'FeatureEntry{_Features'FeatureEntry'key
                                                   :: !Data.Text.Text,
                                                   _Features'FeatureEntry'value ::
                                                   !(Prelude.Maybe Feature)}
                           deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

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

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

instance Data.Default.Class.Default Features'FeatureEntry where
        def
          = Features'FeatureEntry{_Features'FeatureEntry'key =
                                    Data.ProtoLens.fieldDefault,
                                  _Features'FeatureEntry'value = Prelude.Nothing}

instance Data.ProtoLens.Message Features'FeatureEntry 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 Features'FeatureEntry
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.MessageField ::
                         Data.ProtoLens.FieldTypeDescriptor Feature)
                      (Data.ProtoLens.OptionalField maybe'value)
                      :: Data.ProtoLens.FieldDescriptor Features'FeatureEntry
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.Features.FeatureEntry")
                (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 FloatList = FloatList{_FloatList'value :: ![Prelude.Float]}
               deriving (Prelude.Show, Prelude.Eq, Prelude.Ord)

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

instance Data.Default.Class.Default FloatList where
        def = FloatList{_FloatList'value = []}

instance Data.ProtoLens.Message FloatList where
        descriptor
          = let value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.FloatField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Float)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed value)
                      :: Data.ProtoLens.FieldDescriptor FloatList
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.FloatList")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, value__field_descriptor)])
                (Data.Map.fromList [("value", value__field_descriptor)])

data Int64List = Int64List{_Int64List'value :: ![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 "value" f Int64List Int64List a b
         where
        lensOf _
          = (Prelude..)
              (Lens.Family2.Unchecked.lens _Int64List'value
                 (\ x__ y__ -> x__{_Int64List'value = y__}))
              Prelude.id

instance Data.Default.Class.Default Int64List where
        def = Int64List{_Int64List'value = []}

instance Data.ProtoLens.Message Int64List where
        descriptor
          = let value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Packed value)
                      :: Data.ProtoLens.FieldDescriptor Int64List
              in
              Data.ProtoLens.MessageDescriptor
                (Data.Text.pack "tensorflow.Int64List")
                (Data.Map.fromList
                   [(Data.ProtoLens.Tag 1, value__field_descriptor)])
                (Data.Map.fromList [("value", value__field_descriptor)])

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

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

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

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

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

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'bytesList ::
                forall f s t a b .
                  (Lens.Labels.HasLens "maybe'bytesList" f s t a b) =>
                  Lens.Family2.LensLike f s t a b
maybe'bytesList
  = Lens.Labels.lensOf
      ((Lens.Labels.proxy#) :: (Lens.Labels.Proxy#) "maybe'bytesList")

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

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

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

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")

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")