{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-binds #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.SageMaker.ListFeatureGroups
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- List @FeatureGroup@s based on given filter and order.
--
-- This operation returns paginated results.
module Amazonka.SageMaker.ListFeatureGroups
  ( -- * Creating a Request
    ListFeatureGroups (..),
    newListFeatureGroups,

    -- * Request Lenses
    listFeatureGroups_nameContains,
    listFeatureGroups_creationTimeAfter,
    listFeatureGroups_nextToken,
    listFeatureGroups_sortOrder,
    listFeatureGroups_creationTimeBefore,
    listFeatureGroups_offlineStoreStatusEquals,
    listFeatureGroups_featureGroupStatusEquals,
    listFeatureGroups_maxResults,
    listFeatureGroups_sortBy,

    -- * Destructuring the Response
    ListFeatureGroupsResponse (..),
    newListFeatureGroupsResponse,

    -- * Response Lenses
    listFeatureGroupsResponse_nextToken,
    listFeatureGroupsResponse_httpStatus,
    listFeatureGroupsResponse_featureGroupSummaries,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response
import Amazonka.SageMaker.Types

-- | /See:/ 'newListFeatureGroups' smart constructor.
data ListFeatureGroups = ListFeatureGroups'
  { -- | A string that partially matches one or more @FeatureGroup@s names.
    -- Filters @FeatureGroup@s by name.
    ListFeatureGroups -> Maybe Text
nameContains :: Prelude.Maybe Prelude.Text,
    -- | Use this parameter to search for @FeatureGroups@s created after a
    -- specific date and time.
    ListFeatureGroups -> Maybe POSIX
creationTimeAfter :: Prelude.Maybe Core.POSIX,
    -- | A token to resume pagination of @ListFeatureGroups@ results.
    ListFeatureGroups -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The order in which feature groups are listed.
    ListFeatureGroups -> Maybe FeatureGroupSortOrder
sortOrder :: Prelude.Maybe FeatureGroupSortOrder,
    -- | Use this parameter to search for @FeatureGroups@s created before a
    -- specific date and time.
    ListFeatureGroups -> Maybe POSIX
creationTimeBefore :: Prelude.Maybe Core.POSIX,
    -- | An @OfflineStore@ status. Filters by @OfflineStore@ status.
    ListFeatureGroups -> Maybe OfflineStoreStatusValue
offlineStoreStatusEquals :: Prelude.Maybe OfflineStoreStatusValue,
    -- | A @FeatureGroup@ status. Filters by @FeatureGroup@ status.
    ListFeatureGroups -> Maybe FeatureGroupStatus
featureGroupStatusEquals :: Prelude.Maybe FeatureGroupStatus,
    -- | The maximum number of results returned by @ListFeatureGroups@.
    ListFeatureGroups -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The value on which the feature group list is sorted.
    ListFeatureGroups -> Maybe FeatureGroupSortBy
sortBy :: Prelude.Maybe FeatureGroupSortBy
  }
  deriving (ListFeatureGroups -> ListFeatureGroups -> Bool
(ListFeatureGroups -> ListFeatureGroups -> Bool)
-> (ListFeatureGroups -> ListFeatureGroups -> Bool)
-> Eq ListFeatureGroups
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListFeatureGroups -> ListFeatureGroups -> Bool
$c/= :: ListFeatureGroups -> ListFeatureGroups -> Bool
== :: ListFeatureGroups -> ListFeatureGroups -> Bool
$c== :: ListFeatureGroups -> ListFeatureGroups -> Bool
Prelude.Eq, ReadPrec [ListFeatureGroups]
ReadPrec ListFeatureGroups
Int -> ReadS ListFeatureGroups
ReadS [ListFeatureGroups]
(Int -> ReadS ListFeatureGroups)
-> ReadS [ListFeatureGroups]
-> ReadPrec ListFeatureGroups
-> ReadPrec [ListFeatureGroups]
-> Read ListFeatureGroups
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListFeatureGroups]
$creadListPrec :: ReadPrec [ListFeatureGroups]
readPrec :: ReadPrec ListFeatureGroups
$creadPrec :: ReadPrec ListFeatureGroups
readList :: ReadS [ListFeatureGroups]
$creadList :: ReadS [ListFeatureGroups]
readsPrec :: Int -> ReadS ListFeatureGroups
$creadsPrec :: Int -> ReadS ListFeatureGroups
Prelude.Read, Int -> ListFeatureGroups -> ShowS
[ListFeatureGroups] -> ShowS
ListFeatureGroups -> String
(Int -> ListFeatureGroups -> ShowS)
-> (ListFeatureGroups -> String)
-> ([ListFeatureGroups] -> ShowS)
-> Show ListFeatureGroups
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListFeatureGroups] -> ShowS
$cshowList :: [ListFeatureGroups] -> ShowS
show :: ListFeatureGroups -> String
$cshow :: ListFeatureGroups -> String
showsPrec :: Int -> ListFeatureGroups -> ShowS
$cshowsPrec :: Int -> ListFeatureGroups -> ShowS
Prelude.Show, (forall x. ListFeatureGroups -> Rep ListFeatureGroups x)
-> (forall x. Rep ListFeatureGroups x -> ListFeatureGroups)
-> Generic ListFeatureGroups
forall x. Rep ListFeatureGroups x -> ListFeatureGroups
forall x. ListFeatureGroups -> Rep ListFeatureGroups x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListFeatureGroups x -> ListFeatureGroups
$cfrom :: forall x. ListFeatureGroups -> Rep ListFeatureGroups x
Prelude.Generic)

-- |
-- Create a value of 'ListFeatureGroups' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'nameContains', 'listFeatureGroups_nameContains' - A string that partially matches one or more @FeatureGroup@s names.
-- Filters @FeatureGroup@s by name.
--
-- 'creationTimeAfter', 'listFeatureGroups_creationTimeAfter' - Use this parameter to search for @FeatureGroups@s created after a
-- specific date and time.
--
-- 'nextToken', 'listFeatureGroups_nextToken' - A token to resume pagination of @ListFeatureGroups@ results.
--
-- 'sortOrder', 'listFeatureGroups_sortOrder' - The order in which feature groups are listed.
--
-- 'creationTimeBefore', 'listFeatureGroups_creationTimeBefore' - Use this parameter to search for @FeatureGroups@s created before a
-- specific date and time.
--
-- 'offlineStoreStatusEquals', 'listFeatureGroups_offlineStoreStatusEquals' - An @OfflineStore@ status. Filters by @OfflineStore@ status.
--
-- 'featureGroupStatusEquals', 'listFeatureGroups_featureGroupStatusEquals' - A @FeatureGroup@ status. Filters by @FeatureGroup@ status.
--
-- 'maxResults', 'listFeatureGroups_maxResults' - The maximum number of results returned by @ListFeatureGroups@.
--
-- 'sortBy', 'listFeatureGroups_sortBy' - The value on which the feature group list is sorted.
newListFeatureGroups ::
  ListFeatureGroups
newListFeatureGroups :: ListFeatureGroups
newListFeatureGroups =
  ListFeatureGroups' :: Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe FeatureGroupSortOrder
-> Maybe POSIX
-> Maybe OfflineStoreStatusValue
-> Maybe FeatureGroupStatus
-> Maybe Natural
-> Maybe FeatureGroupSortBy
-> ListFeatureGroups
ListFeatureGroups'
    { $sel:nameContains:ListFeatureGroups' :: Maybe Text
nameContains = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:creationTimeAfter:ListFeatureGroups' :: Maybe POSIX
creationTimeAfter = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListFeatureGroups' :: Maybe Text
nextToken = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:sortOrder:ListFeatureGroups' :: Maybe FeatureGroupSortOrder
sortOrder = Maybe FeatureGroupSortOrder
forall a. Maybe a
Prelude.Nothing,
      $sel:creationTimeBefore:ListFeatureGroups' :: Maybe POSIX
creationTimeBefore = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:offlineStoreStatusEquals:ListFeatureGroups' :: Maybe OfflineStoreStatusValue
offlineStoreStatusEquals = Maybe OfflineStoreStatusValue
forall a. Maybe a
Prelude.Nothing,
      $sel:featureGroupStatusEquals:ListFeatureGroups' :: Maybe FeatureGroupStatus
featureGroupStatusEquals = Maybe FeatureGroupStatus
forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListFeatureGroups' :: Maybe Natural
maxResults = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:sortBy:ListFeatureGroups' :: Maybe FeatureGroupSortBy
sortBy = Maybe FeatureGroupSortBy
forall a. Maybe a
Prelude.Nothing
    }

-- | A string that partially matches one or more @FeatureGroup@s names.
-- Filters @FeatureGroup@s by name.
listFeatureGroups_nameContains :: Lens.Lens' ListFeatureGroups (Prelude.Maybe Prelude.Text)
listFeatureGroups_nameContains :: (Maybe Text -> f (Maybe Text))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_nameContains = (ListFeatureGroups -> Maybe Text)
-> (ListFeatureGroups -> Maybe Text -> ListFeatureGroups)
-> Lens
     ListFeatureGroups ListFeatureGroups (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe Text
nameContains :: Maybe Text
$sel:nameContains:ListFeatureGroups' :: ListFeatureGroups -> Maybe Text
nameContains} -> Maybe Text
nameContains) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe Text
a -> ListFeatureGroups
s {$sel:nameContains:ListFeatureGroups' :: Maybe Text
nameContains = Maybe Text
a} :: ListFeatureGroups)

-- | Use this parameter to search for @FeatureGroups@s created after a
-- specific date and time.
listFeatureGroups_creationTimeAfter :: Lens.Lens' ListFeatureGroups (Prelude.Maybe Prelude.UTCTime)
listFeatureGroups_creationTimeAfter :: (Maybe UTCTime -> f (Maybe UTCTime))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_creationTimeAfter = (ListFeatureGroups -> Maybe POSIX)
-> (ListFeatureGroups -> Maybe POSIX -> ListFeatureGroups)
-> Lens
     ListFeatureGroups ListFeatureGroups (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe POSIX
creationTimeAfter :: Maybe POSIX
$sel:creationTimeAfter:ListFeatureGroups' :: ListFeatureGroups -> Maybe POSIX
creationTimeAfter} -> Maybe POSIX
creationTimeAfter) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe POSIX
a -> ListFeatureGroups
s {$sel:creationTimeAfter:ListFeatureGroups' :: Maybe POSIX
creationTimeAfter = Maybe POSIX
a} :: ListFeatureGroups) ((Maybe POSIX -> f (Maybe POSIX))
 -> ListFeatureGroups -> f ListFeatureGroups)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> ListFeatureGroups
-> f ListFeatureGroups
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | A token to resume pagination of @ListFeatureGroups@ results.
listFeatureGroups_nextToken :: Lens.Lens' ListFeatureGroups (Prelude.Maybe Prelude.Text)
listFeatureGroups_nextToken :: (Maybe Text -> f (Maybe Text))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_nextToken = (ListFeatureGroups -> Maybe Text)
-> (ListFeatureGroups -> Maybe Text -> ListFeatureGroups)
-> Lens
     ListFeatureGroups ListFeatureGroups (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListFeatureGroups' :: ListFeatureGroups -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe Text
a -> ListFeatureGroups
s {$sel:nextToken:ListFeatureGroups' :: Maybe Text
nextToken = Maybe Text
a} :: ListFeatureGroups)

-- | The order in which feature groups are listed.
listFeatureGroups_sortOrder :: Lens.Lens' ListFeatureGroups (Prelude.Maybe FeatureGroupSortOrder)
listFeatureGroups_sortOrder :: (Maybe FeatureGroupSortOrder -> f (Maybe FeatureGroupSortOrder))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_sortOrder = (ListFeatureGroups -> Maybe FeatureGroupSortOrder)
-> (ListFeatureGroups
    -> Maybe FeatureGroupSortOrder -> ListFeatureGroups)
-> Lens
     ListFeatureGroups
     ListFeatureGroups
     (Maybe FeatureGroupSortOrder)
     (Maybe FeatureGroupSortOrder)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe FeatureGroupSortOrder
sortOrder :: Maybe FeatureGroupSortOrder
$sel:sortOrder:ListFeatureGroups' :: ListFeatureGroups -> Maybe FeatureGroupSortOrder
sortOrder} -> Maybe FeatureGroupSortOrder
sortOrder) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe FeatureGroupSortOrder
a -> ListFeatureGroups
s {$sel:sortOrder:ListFeatureGroups' :: Maybe FeatureGroupSortOrder
sortOrder = Maybe FeatureGroupSortOrder
a} :: ListFeatureGroups)

-- | Use this parameter to search for @FeatureGroups@s created before a
-- specific date and time.
listFeatureGroups_creationTimeBefore :: Lens.Lens' ListFeatureGroups (Prelude.Maybe Prelude.UTCTime)
listFeatureGroups_creationTimeBefore :: (Maybe UTCTime -> f (Maybe UTCTime))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_creationTimeBefore = (ListFeatureGroups -> Maybe POSIX)
-> (ListFeatureGroups -> Maybe POSIX -> ListFeatureGroups)
-> Lens
     ListFeatureGroups ListFeatureGroups (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe POSIX
creationTimeBefore :: Maybe POSIX
$sel:creationTimeBefore:ListFeatureGroups' :: ListFeatureGroups -> Maybe POSIX
creationTimeBefore} -> Maybe POSIX
creationTimeBefore) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe POSIX
a -> ListFeatureGroups
s {$sel:creationTimeBefore:ListFeatureGroups' :: Maybe POSIX
creationTimeBefore = Maybe POSIX
a} :: ListFeatureGroups) ((Maybe POSIX -> f (Maybe POSIX))
 -> ListFeatureGroups -> f ListFeatureGroups)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> ListFeatureGroups
-> f ListFeatureGroups
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping AnIso POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | An @OfflineStore@ status. Filters by @OfflineStore@ status.
listFeatureGroups_offlineStoreStatusEquals :: Lens.Lens' ListFeatureGroups (Prelude.Maybe OfflineStoreStatusValue)
listFeatureGroups_offlineStoreStatusEquals :: (Maybe OfflineStoreStatusValue
 -> f (Maybe OfflineStoreStatusValue))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_offlineStoreStatusEquals = (ListFeatureGroups -> Maybe OfflineStoreStatusValue)
-> (ListFeatureGroups
    -> Maybe OfflineStoreStatusValue -> ListFeatureGroups)
-> Lens
     ListFeatureGroups
     ListFeatureGroups
     (Maybe OfflineStoreStatusValue)
     (Maybe OfflineStoreStatusValue)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe OfflineStoreStatusValue
offlineStoreStatusEquals :: Maybe OfflineStoreStatusValue
$sel:offlineStoreStatusEquals:ListFeatureGroups' :: ListFeatureGroups -> Maybe OfflineStoreStatusValue
offlineStoreStatusEquals} -> Maybe OfflineStoreStatusValue
offlineStoreStatusEquals) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe OfflineStoreStatusValue
a -> ListFeatureGroups
s {$sel:offlineStoreStatusEquals:ListFeatureGroups' :: Maybe OfflineStoreStatusValue
offlineStoreStatusEquals = Maybe OfflineStoreStatusValue
a} :: ListFeatureGroups)

-- | A @FeatureGroup@ status. Filters by @FeatureGroup@ status.
listFeatureGroups_featureGroupStatusEquals :: Lens.Lens' ListFeatureGroups (Prelude.Maybe FeatureGroupStatus)
listFeatureGroups_featureGroupStatusEquals :: (Maybe FeatureGroupStatus -> f (Maybe FeatureGroupStatus))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_featureGroupStatusEquals = (ListFeatureGroups -> Maybe FeatureGroupStatus)
-> (ListFeatureGroups
    -> Maybe FeatureGroupStatus -> ListFeatureGroups)
-> Lens
     ListFeatureGroups
     ListFeatureGroups
     (Maybe FeatureGroupStatus)
     (Maybe FeatureGroupStatus)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe FeatureGroupStatus
featureGroupStatusEquals :: Maybe FeatureGroupStatus
$sel:featureGroupStatusEquals:ListFeatureGroups' :: ListFeatureGroups -> Maybe FeatureGroupStatus
featureGroupStatusEquals} -> Maybe FeatureGroupStatus
featureGroupStatusEquals) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe FeatureGroupStatus
a -> ListFeatureGroups
s {$sel:featureGroupStatusEquals:ListFeatureGroups' :: Maybe FeatureGroupStatus
featureGroupStatusEquals = Maybe FeatureGroupStatus
a} :: ListFeatureGroups)

-- | The maximum number of results returned by @ListFeatureGroups@.
listFeatureGroups_maxResults :: Lens.Lens' ListFeatureGroups (Prelude.Maybe Prelude.Natural)
listFeatureGroups_maxResults :: (Maybe Natural -> f (Maybe Natural))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_maxResults = (ListFeatureGroups -> Maybe Natural)
-> (ListFeatureGroups -> Maybe Natural -> ListFeatureGroups)
-> Lens
     ListFeatureGroups ListFeatureGroups (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListFeatureGroups' :: ListFeatureGroups -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe Natural
a -> ListFeatureGroups
s {$sel:maxResults:ListFeatureGroups' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListFeatureGroups)

-- | The value on which the feature group list is sorted.
listFeatureGroups_sortBy :: Lens.Lens' ListFeatureGroups (Prelude.Maybe FeatureGroupSortBy)
listFeatureGroups_sortBy :: (Maybe FeatureGroupSortBy -> f (Maybe FeatureGroupSortBy))
-> ListFeatureGroups -> f ListFeatureGroups
listFeatureGroups_sortBy = (ListFeatureGroups -> Maybe FeatureGroupSortBy)
-> (ListFeatureGroups
    -> Maybe FeatureGroupSortBy -> ListFeatureGroups)
-> Lens
     ListFeatureGroups
     ListFeatureGroups
     (Maybe FeatureGroupSortBy)
     (Maybe FeatureGroupSortBy)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroups' {Maybe FeatureGroupSortBy
sortBy :: Maybe FeatureGroupSortBy
$sel:sortBy:ListFeatureGroups' :: ListFeatureGroups -> Maybe FeatureGroupSortBy
sortBy} -> Maybe FeatureGroupSortBy
sortBy) (\s :: ListFeatureGroups
s@ListFeatureGroups' {} Maybe FeatureGroupSortBy
a -> ListFeatureGroups
s {$sel:sortBy:ListFeatureGroups' :: Maybe FeatureGroupSortBy
sortBy = Maybe FeatureGroupSortBy
a} :: ListFeatureGroups)

instance Core.AWSPager ListFeatureGroups where
  page :: ListFeatureGroups
-> AWSResponse ListFeatureGroups -> Maybe ListFeatureGroups
page ListFeatureGroups
rq AWSResponse ListFeatureGroups
rs
    | Maybe Text -> Bool
forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListFeatureGroups
ListFeatureGroupsResponse
rs
            ListFeatureGroupsResponse
-> Getting (First Text) ListFeatureGroupsResponse Text
-> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? (Maybe Text -> Const (First Text) (Maybe Text))
-> ListFeatureGroupsResponse
-> Const (First Text) ListFeatureGroupsResponse
Lens' ListFeatureGroupsResponse (Maybe Text)
listFeatureGroupsResponse_nextToken
              ((Maybe Text -> Const (First Text) (Maybe Text))
 -> ListFeatureGroupsResponse
 -> Const (First Text) ListFeatureGroupsResponse)
-> ((Text -> Const (First Text) Text)
    -> Maybe Text -> Const (First Text) (Maybe Text))
-> Getting (First Text) ListFeatureGroupsResponse Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (Text -> Const (First Text) Text)
-> Maybe Text -> Const (First Text) (Maybe Text)
forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
      Maybe ListFeatureGroups
forall a. Maybe a
Prelude.Nothing
    | [FeatureGroupSummary] -> Bool
forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListFeatureGroups
ListFeatureGroupsResponse
rs
            ListFeatureGroupsResponse
-> Getting
     [FeatureGroupSummary]
     ListFeatureGroupsResponse
     [FeatureGroupSummary]
-> [FeatureGroupSummary]
forall s a. s -> Getting a s a -> a
Lens.^. Getting
  [FeatureGroupSummary]
  ListFeatureGroupsResponse
  [FeatureGroupSummary]
Lens' ListFeatureGroupsResponse [FeatureGroupSummary]
listFeatureGroupsResponse_featureGroupSummaries
        ) =
      Maybe ListFeatureGroups
forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
      ListFeatureGroups -> Maybe ListFeatureGroups
forall a. a -> Maybe a
Prelude.Just (ListFeatureGroups -> Maybe ListFeatureGroups)
-> ListFeatureGroups -> Maybe ListFeatureGroups
forall a b. (a -> b) -> a -> b
Prelude.$
        ListFeatureGroups
rq
          ListFeatureGroups
-> (ListFeatureGroups -> ListFeatureGroups) -> ListFeatureGroups
forall a b. a -> (a -> b) -> b
Prelude.& (Maybe Text -> Identity (Maybe Text))
-> ListFeatureGroups -> Identity ListFeatureGroups
Lens ListFeatureGroups ListFeatureGroups (Maybe Text) (Maybe Text)
listFeatureGroups_nextToken
          ((Maybe Text -> Identity (Maybe Text))
 -> ListFeatureGroups -> Identity ListFeatureGroups)
-> Maybe Text -> ListFeatureGroups -> ListFeatureGroups
forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListFeatureGroups
ListFeatureGroupsResponse
rs
          ListFeatureGroupsResponse
-> Getting (First Text) ListFeatureGroupsResponse Text
-> Maybe Text
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? (Maybe Text -> Const (First Text) (Maybe Text))
-> ListFeatureGroupsResponse
-> Const (First Text) ListFeatureGroupsResponse
Lens' ListFeatureGroupsResponse (Maybe Text)
listFeatureGroupsResponse_nextToken
            ((Maybe Text -> Const (First Text) (Maybe Text))
 -> ListFeatureGroupsResponse
 -> Const (First Text) ListFeatureGroupsResponse)
-> ((Text -> Const (First Text) Text)
    -> Maybe Text -> Const (First Text) (Maybe Text))
-> Getting (First Text) ListFeatureGroupsResponse Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (Text -> Const (First Text) Text)
-> Maybe Text -> Const (First Text) (Maybe Text)
forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest ListFeatureGroups where
  type
    AWSResponse ListFeatureGroups =
      ListFeatureGroupsResponse
  request :: ListFeatureGroups -> Request ListFeatureGroups
request = Service -> ListFeatureGroups -> Request ListFeatureGroups
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy ListFeatureGroups
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListFeatureGroups)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse ListFeatureGroups))
-> Logger
-> Service
-> Proxy ListFeatureGroups
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListFeatureGroups)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Int -> [FeatureGroupSummary] -> ListFeatureGroupsResponse
ListFeatureGroupsResponse'
            (Maybe Text
 -> Int -> [FeatureGroupSummary] -> ListFeatureGroupsResponse)
-> Either String (Maybe Text)
-> Either
     String (Int -> [FeatureGroupSummary] -> ListFeatureGroupsResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"NextToken")
            Either
  String (Int -> [FeatureGroupSummary] -> ListFeatureGroupsResponse)
-> Either String Int
-> Either
     String ([FeatureGroupSummary] -> ListFeatureGroupsResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
            Either String ([FeatureGroupSummary] -> ListFeatureGroupsResponse)
-> Either String [FeatureGroupSummary]
-> Either String ListFeatureGroupsResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Either String (Maybe [FeatureGroupSummary])
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"FeatureGroupSummaries"
                            Either String (Maybe [FeatureGroupSummary])
-> [FeatureGroupSummary] -> Either String [FeatureGroupSummary]
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ [FeatureGroupSummary]
forall a. Monoid a => a
Prelude.mempty
                        )
      )

instance Prelude.Hashable ListFeatureGroups

instance Prelude.NFData ListFeatureGroups

instance Core.ToHeaders ListFeatureGroups where
  toHeaders :: ListFeatureGroups -> ResponseHeaders
toHeaders =
    ResponseHeaders -> ListFeatureGroups -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"SageMaker.ListFeatureGroups" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON ListFeatureGroups where
  toJSON :: ListFeatureGroups -> Value
toJSON ListFeatureGroups' {Maybe Natural
Maybe Text
Maybe POSIX
Maybe FeatureGroupSortBy
Maybe FeatureGroupSortOrder
Maybe FeatureGroupStatus
Maybe OfflineStoreStatusValue
sortBy :: Maybe FeatureGroupSortBy
maxResults :: Maybe Natural
featureGroupStatusEquals :: Maybe FeatureGroupStatus
offlineStoreStatusEquals :: Maybe OfflineStoreStatusValue
creationTimeBefore :: Maybe POSIX
sortOrder :: Maybe FeatureGroupSortOrder
nextToken :: Maybe Text
creationTimeAfter :: Maybe POSIX
nameContains :: Maybe Text
$sel:sortBy:ListFeatureGroups' :: ListFeatureGroups -> Maybe FeatureGroupSortBy
$sel:maxResults:ListFeatureGroups' :: ListFeatureGroups -> Maybe Natural
$sel:featureGroupStatusEquals:ListFeatureGroups' :: ListFeatureGroups -> Maybe FeatureGroupStatus
$sel:offlineStoreStatusEquals:ListFeatureGroups' :: ListFeatureGroups -> Maybe OfflineStoreStatusValue
$sel:creationTimeBefore:ListFeatureGroups' :: ListFeatureGroups -> Maybe POSIX
$sel:sortOrder:ListFeatureGroups' :: ListFeatureGroups -> Maybe FeatureGroupSortOrder
$sel:nextToken:ListFeatureGroups' :: ListFeatureGroups -> Maybe Text
$sel:creationTimeAfter:ListFeatureGroups' :: ListFeatureGroups -> Maybe POSIX
$sel:nameContains:ListFeatureGroups' :: ListFeatureGroups -> Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"NameContains" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nameContains,
            (Text
"CreationTimeAfter" Text -> POSIX -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (POSIX -> Pair) -> Maybe POSIX -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe POSIX
creationTimeAfter,
            (Text
"NextToken" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextToken,
            (Text
"SortOrder" Text -> FeatureGroupSortOrder -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (FeatureGroupSortOrder -> Pair)
-> Maybe FeatureGroupSortOrder -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe FeatureGroupSortOrder
sortOrder,
            (Text
"CreationTimeBefore" Text -> POSIX -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (POSIX -> Pair) -> Maybe POSIX -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe POSIX
creationTimeBefore,
            (Text
"OfflineStoreStatusEquals" Text -> OfflineStoreStatusValue -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (OfflineStoreStatusValue -> Pair)
-> Maybe OfflineStoreStatusValue -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe OfflineStoreStatusValue
offlineStoreStatusEquals,
            (Text
"FeatureGroupStatusEquals" Text -> FeatureGroupStatus -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (FeatureGroupStatus -> Pair)
-> Maybe FeatureGroupStatus -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe FeatureGroupStatus
featureGroupStatusEquals,
            (Text
"MaxResults" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxResults,
            (Text
"SortBy" Text -> FeatureGroupSortBy -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (FeatureGroupSortBy -> Pair)
-> Maybe FeatureGroupSortBy -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe FeatureGroupSortBy
sortBy
          ]
      )

instance Core.ToPath ListFeatureGroups where
  toPath :: ListFeatureGroups -> ByteString
toPath = ByteString -> ListFeatureGroups -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Core.ToQuery ListFeatureGroups where
  toQuery :: ListFeatureGroups -> QueryString
toQuery = QueryString -> ListFeatureGroups -> QueryString
forall a b. a -> b -> a
Prelude.const QueryString
forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newListFeatureGroupsResponse' smart constructor.
data ListFeatureGroupsResponse = ListFeatureGroupsResponse'
  { -- | A token to resume pagination of @ListFeatureGroups@ results.
    ListFeatureGroupsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListFeatureGroupsResponse -> Int
httpStatus :: Prelude.Int,
    -- | A summary of feature groups.
    ListFeatureGroupsResponse -> [FeatureGroupSummary]
featureGroupSummaries :: [FeatureGroupSummary]
  }
  deriving (ListFeatureGroupsResponse -> ListFeatureGroupsResponse -> Bool
(ListFeatureGroupsResponse -> ListFeatureGroupsResponse -> Bool)
-> (ListFeatureGroupsResponse -> ListFeatureGroupsResponse -> Bool)
-> Eq ListFeatureGroupsResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListFeatureGroupsResponse -> ListFeatureGroupsResponse -> Bool
$c/= :: ListFeatureGroupsResponse -> ListFeatureGroupsResponse -> Bool
== :: ListFeatureGroupsResponse -> ListFeatureGroupsResponse -> Bool
$c== :: ListFeatureGroupsResponse -> ListFeatureGroupsResponse -> Bool
Prelude.Eq, ReadPrec [ListFeatureGroupsResponse]
ReadPrec ListFeatureGroupsResponse
Int -> ReadS ListFeatureGroupsResponse
ReadS [ListFeatureGroupsResponse]
(Int -> ReadS ListFeatureGroupsResponse)
-> ReadS [ListFeatureGroupsResponse]
-> ReadPrec ListFeatureGroupsResponse
-> ReadPrec [ListFeatureGroupsResponse]
-> Read ListFeatureGroupsResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListFeatureGroupsResponse]
$creadListPrec :: ReadPrec [ListFeatureGroupsResponse]
readPrec :: ReadPrec ListFeatureGroupsResponse
$creadPrec :: ReadPrec ListFeatureGroupsResponse
readList :: ReadS [ListFeatureGroupsResponse]
$creadList :: ReadS [ListFeatureGroupsResponse]
readsPrec :: Int -> ReadS ListFeatureGroupsResponse
$creadsPrec :: Int -> ReadS ListFeatureGroupsResponse
Prelude.Read, Int -> ListFeatureGroupsResponse -> ShowS
[ListFeatureGroupsResponse] -> ShowS
ListFeatureGroupsResponse -> String
(Int -> ListFeatureGroupsResponse -> ShowS)
-> (ListFeatureGroupsResponse -> String)
-> ([ListFeatureGroupsResponse] -> ShowS)
-> Show ListFeatureGroupsResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListFeatureGroupsResponse] -> ShowS
$cshowList :: [ListFeatureGroupsResponse] -> ShowS
show :: ListFeatureGroupsResponse -> String
$cshow :: ListFeatureGroupsResponse -> String
showsPrec :: Int -> ListFeatureGroupsResponse -> ShowS
$cshowsPrec :: Int -> ListFeatureGroupsResponse -> ShowS
Prelude.Show, (forall x.
 ListFeatureGroupsResponse -> Rep ListFeatureGroupsResponse x)
-> (forall x.
    Rep ListFeatureGroupsResponse x -> ListFeatureGroupsResponse)
-> Generic ListFeatureGroupsResponse
forall x.
Rep ListFeatureGroupsResponse x -> ListFeatureGroupsResponse
forall x.
ListFeatureGroupsResponse -> Rep ListFeatureGroupsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListFeatureGroupsResponse x -> ListFeatureGroupsResponse
$cfrom :: forall x.
ListFeatureGroupsResponse -> Rep ListFeatureGroupsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListFeatureGroupsResponse' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'nextToken', 'listFeatureGroupsResponse_nextToken' - A token to resume pagination of @ListFeatureGroups@ results.
--
-- 'httpStatus', 'listFeatureGroupsResponse_httpStatus' - The response's http status code.
--
-- 'featureGroupSummaries', 'listFeatureGroupsResponse_featureGroupSummaries' - A summary of feature groups.
newListFeatureGroupsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListFeatureGroupsResponse
newListFeatureGroupsResponse :: Int -> ListFeatureGroupsResponse
newListFeatureGroupsResponse Int
pHttpStatus_ =
  ListFeatureGroupsResponse' :: Maybe Text
-> Int -> [FeatureGroupSummary] -> ListFeatureGroupsResponse
ListFeatureGroupsResponse'
    { $sel:nextToken:ListFeatureGroupsResponse' :: Maybe Text
nextToken =
        Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListFeatureGroupsResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:featureGroupSummaries:ListFeatureGroupsResponse' :: [FeatureGroupSummary]
featureGroupSummaries = [FeatureGroupSummary]
forall a. Monoid a => a
Prelude.mempty
    }

-- | A token to resume pagination of @ListFeatureGroups@ results.
listFeatureGroupsResponse_nextToken :: Lens.Lens' ListFeatureGroupsResponse (Prelude.Maybe Prelude.Text)
listFeatureGroupsResponse_nextToken :: (Maybe Text -> f (Maybe Text))
-> ListFeatureGroupsResponse -> f ListFeatureGroupsResponse
listFeatureGroupsResponse_nextToken = (ListFeatureGroupsResponse -> Maybe Text)
-> (ListFeatureGroupsResponse
    -> Maybe Text -> ListFeatureGroupsResponse)
-> Lens' ListFeatureGroupsResponse (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroupsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListFeatureGroupsResponse' :: ListFeatureGroupsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListFeatureGroupsResponse
s@ListFeatureGroupsResponse' {} Maybe Text
a -> ListFeatureGroupsResponse
s {$sel:nextToken:ListFeatureGroupsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListFeatureGroupsResponse)

-- | The response's http status code.
listFeatureGroupsResponse_httpStatus :: Lens.Lens' ListFeatureGroupsResponse Prelude.Int
listFeatureGroupsResponse_httpStatus :: (Int -> f Int)
-> ListFeatureGroupsResponse -> f ListFeatureGroupsResponse
listFeatureGroupsResponse_httpStatus = (ListFeatureGroupsResponse -> Int)
-> (ListFeatureGroupsResponse -> Int -> ListFeatureGroupsResponse)
-> Lens ListFeatureGroupsResponse ListFeatureGroupsResponse Int Int
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroupsResponse' {Int
httpStatus :: Int
$sel:httpStatus:ListFeatureGroupsResponse' :: ListFeatureGroupsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: ListFeatureGroupsResponse
s@ListFeatureGroupsResponse' {} Int
a -> ListFeatureGroupsResponse
s {$sel:httpStatus:ListFeatureGroupsResponse' :: Int
httpStatus = Int
a} :: ListFeatureGroupsResponse)

-- | A summary of feature groups.
listFeatureGroupsResponse_featureGroupSummaries :: Lens.Lens' ListFeatureGroupsResponse [FeatureGroupSummary]
listFeatureGroupsResponse_featureGroupSummaries :: ([FeatureGroupSummary] -> f [FeatureGroupSummary])
-> ListFeatureGroupsResponse -> f ListFeatureGroupsResponse
listFeatureGroupsResponse_featureGroupSummaries = (ListFeatureGroupsResponse -> [FeatureGroupSummary])
-> (ListFeatureGroupsResponse
    -> [FeatureGroupSummary] -> ListFeatureGroupsResponse)
-> Lens' ListFeatureGroupsResponse [FeatureGroupSummary]
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListFeatureGroupsResponse' {[FeatureGroupSummary]
featureGroupSummaries :: [FeatureGroupSummary]
$sel:featureGroupSummaries:ListFeatureGroupsResponse' :: ListFeatureGroupsResponse -> [FeatureGroupSummary]
featureGroupSummaries} -> [FeatureGroupSummary]
featureGroupSummaries) (\s :: ListFeatureGroupsResponse
s@ListFeatureGroupsResponse' {} [FeatureGroupSummary]
a -> ListFeatureGroupsResponse
s {$sel:featureGroupSummaries:ListFeatureGroupsResponse' :: [FeatureGroupSummary]
featureGroupSummaries = [FeatureGroupSummary]
a} :: ListFeatureGroupsResponse) (([FeatureGroupSummary] -> f [FeatureGroupSummary])
 -> ListFeatureGroupsResponse -> f ListFeatureGroupsResponse)
-> (([FeatureGroupSummary] -> f [FeatureGroupSummary])
    -> [FeatureGroupSummary] -> f [FeatureGroupSummary])
-> ([FeatureGroupSummary] -> f [FeatureGroupSummary])
-> ListFeatureGroupsResponse
-> f ListFeatureGroupsResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. ([FeatureGroupSummary] -> f [FeatureGroupSummary])
-> [FeatureGroupSummary] -> f [FeatureGroupSummary]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Prelude.NFData ListFeatureGroupsResponse