{-# 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.Glue.ListMLTransforms
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieves a sortable, filterable list of existing Glue machine learning
-- transforms in this Amazon Web Services account, or the resources with
-- the specified tag. This operation takes the optional @Tags@ field, which
-- you can use as a filter of the responses so that tagged resources can be
-- retrieved as a group. If you choose to use tag filtering, only resources
-- with the tags are retrieved.
module Amazonka.Glue.ListMLTransforms
  ( -- * Creating a Request
    ListMLTransforms (..),
    newListMLTransforms,

    -- * Request Lenses
    listMLTransforms_filter,
    listMLTransforms_maxResults,
    listMLTransforms_nextToken,
    listMLTransforms_sort,
    listMLTransforms_tags,

    -- * Destructuring the Response
    ListMLTransformsResponse (..),
    newListMLTransformsResponse,

    -- * Response Lenses
    listMLTransformsResponse_nextToken,
    listMLTransformsResponse_httpStatus,
    listMLTransformsResponse_transformIds,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Glue.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newListMLTransforms' smart constructor.
data ListMLTransforms = ListMLTransforms'
  { -- | A @TransformFilterCriteria@ used to filter the machine learning
    -- transforms.
    ListMLTransforms -> Maybe TransformFilterCriteria
filter' :: Prelude.Maybe TransformFilterCriteria,
    -- | The maximum size of a list to return.
    ListMLTransforms -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | A continuation token, if this is a continuation request.
    ListMLTransforms -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A @TransformSortCriteria@ used to sort the machine learning transforms.
    ListMLTransforms -> Maybe TransformSortCriteria
sort :: Prelude.Maybe TransformSortCriteria,
    -- | Specifies to return only these tagged resources.
    ListMLTransforms -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text)
  }
  deriving (ListMLTransforms -> ListMLTransforms -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListMLTransforms -> ListMLTransforms -> Bool
$c/= :: ListMLTransforms -> ListMLTransforms -> Bool
== :: ListMLTransforms -> ListMLTransforms -> Bool
$c== :: ListMLTransforms -> ListMLTransforms -> Bool
Prelude.Eq, ReadPrec [ListMLTransforms]
ReadPrec ListMLTransforms
Int -> ReadS ListMLTransforms
ReadS [ListMLTransforms]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListMLTransforms]
$creadListPrec :: ReadPrec [ListMLTransforms]
readPrec :: ReadPrec ListMLTransforms
$creadPrec :: ReadPrec ListMLTransforms
readList :: ReadS [ListMLTransforms]
$creadList :: ReadS [ListMLTransforms]
readsPrec :: Int -> ReadS ListMLTransforms
$creadsPrec :: Int -> ReadS ListMLTransforms
Prelude.Read, Int -> ListMLTransforms -> ShowS
[ListMLTransforms] -> ShowS
ListMLTransforms -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListMLTransforms] -> ShowS
$cshowList :: [ListMLTransforms] -> ShowS
show :: ListMLTransforms -> String
$cshow :: ListMLTransforms -> String
showsPrec :: Int -> ListMLTransforms -> ShowS
$cshowsPrec :: Int -> ListMLTransforms -> ShowS
Prelude.Show, forall x. Rep ListMLTransforms x -> ListMLTransforms
forall x. ListMLTransforms -> Rep ListMLTransforms x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListMLTransforms x -> ListMLTransforms
$cfrom :: forall x. ListMLTransforms -> Rep ListMLTransforms x
Prelude.Generic)

-- |
-- Create a value of 'ListMLTransforms' 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:
--
-- 'filter'', 'listMLTransforms_filter' - A @TransformFilterCriteria@ used to filter the machine learning
-- transforms.
--
-- 'maxResults', 'listMLTransforms_maxResults' - The maximum size of a list to return.
--
-- 'nextToken', 'listMLTransforms_nextToken' - A continuation token, if this is a continuation request.
--
-- 'sort', 'listMLTransforms_sort' - A @TransformSortCriteria@ used to sort the machine learning transforms.
--
-- 'tags', 'listMLTransforms_tags' - Specifies to return only these tagged resources.
newListMLTransforms ::
  ListMLTransforms
newListMLTransforms :: ListMLTransforms
newListMLTransforms =
  ListMLTransforms'
    { $sel:filter':ListMLTransforms' :: Maybe TransformFilterCriteria
filter' = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListMLTransforms' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListMLTransforms' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:sort:ListMLTransforms' :: Maybe TransformSortCriteria
sort = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:ListMLTransforms' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing
    }

-- | A @TransformFilterCriteria@ used to filter the machine learning
-- transforms.
listMLTransforms_filter :: Lens.Lens' ListMLTransforms (Prelude.Maybe TransformFilterCriteria)
listMLTransforms_filter :: Lens' ListMLTransforms (Maybe TransformFilterCriteria)
listMLTransforms_filter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMLTransforms' {Maybe TransformFilterCriteria
filter' :: Maybe TransformFilterCriteria
$sel:filter':ListMLTransforms' :: ListMLTransforms -> Maybe TransformFilterCriteria
filter'} -> Maybe TransformFilterCriteria
filter') (\s :: ListMLTransforms
s@ListMLTransforms' {} Maybe TransformFilterCriteria
a -> ListMLTransforms
s {$sel:filter':ListMLTransforms' :: Maybe TransformFilterCriteria
filter' = Maybe TransformFilterCriteria
a} :: ListMLTransforms)

-- | The maximum size of a list to return.
listMLTransforms_maxResults :: Lens.Lens' ListMLTransforms (Prelude.Maybe Prelude.Natural)
listMLTransforms_maxResults :: Lens' ListMLTransforms (Maybe Natural)
listMLTransforms_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMLTransforms' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListMLTransforms' :: ListMLTransforms -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListMLTransforms
s@ListMLTransforms' {} Maybe Natural
a -> ListMLTransforms
s {$sel:maxResults:ListMLTransforms' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListMLTransforms)

-- | A continuation token, if this is a continuation request.
listMLTransforms_nextToken :: Lens.Lens' ListMLTransforms (Prelude.Maybe Prelude.Text)
listMLTransforms_nextToken :: Lens' ListMLTransforms (Maybe Text)
listMLTransforms_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMLTransforms' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListMLTransforms' :: ListMLTransforms -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListMLTransforms
s@ListMLTransforms' {} Maybe Text
a -> ListMLTransforms
s {$sel:nextToken:ListMLTransforms' :: Maybe Text
nextToken = Maybe Text
a} :: ListMLTransforms)

-- | A @TransformSortCriteria@ used to sort the machine learning transforms.
listMLTransforms_sort :: Lens.Lens' ListMLTransforms (Prelude.Maybe TransformSortCriteria)
listMLTransforms_sort :: Lens' ListMLTransforms (Maybe TransformSortCriteria)
listMLTransforms_sort = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMLTransforms' {Maybe TransformSortCriteria
sort :: Maybe TransformSortCriteria
$sel:sort:ListMLTransforms' :: ListMLTransforms -> Maybe TransformSortCriteria
sort} -> Maybe TransformSortCriteria
sort) (\s :: ListMLTransforms
s@ListMLTransforms' {} Maybe TransformSortCriteria
a -> ListMLTransforms
s {$sel:sort:ListMLTransforms' :: Maybe TransformSortCriteria
sort = Maybe TransformSortCriteria
a} :: ListMLTransforms)

-- | Specifies to return only these tagged resources.
listMLTransforms_tags :: Lens.Lens' ListMLTransforms (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
listMLTransforms_tags :: Lens' ListMLTransforms (Maybe (HashMap Text Text))
listMLTransforms_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMLTransforms' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:ListMLTransforms' :: ListMLTransforms -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: ListMLTransforms
s@ListMLTransforms' {} Maybe (HashMap Text Text)
a -> ListMLTransforms
s {$sel:tags:ListMLTransforms' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: ListMLTransforms) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Prelude.Hashable ListMLTransforms where
  hashWithSalt :: Int -> ListMLTransforms -> Int
hashWithSalt Int
_salt ListMLTransforms' {Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe TransformSortCriteria
Maybe TransformFilterCriteria
tags :: Maybe (HashMap Text Text)
sort :: Maybe TransformSortCriteria
nextToken :: Maybe Text
maxResults :: Maybe Natural
filter' :: Maybe TransformFilterCriteria
$sel:tags:ListMLTransforms' :: ListMLTransforms -> Maybe (HashMap Text Text)
$sel:sort:ListMLTransforms' :: ListMLTransforms -> Maybe TransformSortCriteria
$sel:nextToken:ListMLTransforms' :: ListMLTransforms -> Maybe Text
$sel:maxResults:ListMLTransforms' :: ListMLTransforms -> Maybe Natural
$sel:filter':ListMLTransforms' :: ListMLTransforms -> Maybe TransformFilterCriteria
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TransformFilterCriteria
filter'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TransformSortCriteria
sort
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags

instance Prelude.NFData ListMLTransforms where
  rnf :: ListMLTransforms -> ()
rnf ListMLTransforms' {Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe TransformSortCriteria
Maybe TransformFilterCriteria
tags :: Maybe (HashMap Text Text)
sort :: Maybe TransformSortCriteria
nextToken :: Maybe Text
maxResults :: Maybe Natural
filter' :: Maybe TransformFilterCriteria
$sel:tags:ListMLTransforms' :: ListMLTransforms -> Maybe (HashMap Text Text)
$sel:sort:ListMLTransforms' :: ListMLTransforms -> Maybe TransformSortCriteria
$sel:nextToken:ListMLTransforms' :: ListMLTransforms -> Maybe Text
$sel:maxResults:ListMLTransforms' :: ListMLTransforms -> Maybe Natural
$sel:filter':ListMLTransforms' :: ListMLTransforms -> Maybe TransformFilterCriteria
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe TransformFilterCriteria
filter'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
maxResults
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TransformSortCriteria
sort
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags

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

instance Data.ToJSON ListMLTransforms where
  toJSON :: ListMLTransforms -> Value
toJSON ListMLTransforms' {Maybe Natural
Maybe Text
Maybe (HashMap Text Text)
Maybe TransformSortCriteria
Maybe TransformFilterCriteria
tags :: Maybe (HashMap Text Text)
sort :: Maybe TransformSortCriteria
nextToken :: Maybe Text
maxResults :: Maybe Natural
filter' :: Maybe TransformFilterCriteria
$sel:tags:ListMLTransforms' :: ListMLTransforms -> Maybe (HashMap Text Text)
$sel:sort:ListMLTransforms' :: ListMLTransforms -> Maybe TransformSortCriteria
$sel:nextToken:ListMLTransforms' :: ListMLTransforms -> Maybe Text
$sel:maxResults:ListMLTransforms' :: ListMLTransforms -> Maybe Natural
$sel:filter':ListMLTransforms' :: ListMLTransforms -> Maybe TransformFilterCriteria
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Filter" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe TransformFilterCriteria
filter',
            (Key
"MaxResults" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxResults,
            (Key
"NextToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
nextToken,
            (Key
"Sort" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe TransformSortCriteria
sort,
            (Key
"Tags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
tags
          ]
      )

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

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

-- | /See:/ 'newListMLTransformsResponse' smart constructor.
data ListMLTransformsResponse = ListMLTransformsResponse'
  { -- | A continuation token, if the returned list does not contain the last
    -- metric available.
    ListMLTransformsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListMLTransformsResponse -> Int
httpStatus :: Prelude.Int,
    -- | The identifiers of all the machine learning transforms in the account,
    -- or the machine learning transforms with the specified tags.
    ListMLTransformsResponse -> [Text]
transformIds :: [Prelude.Text]
  }
  deriving (ListMLTransformsResponse -> ListMLTransformsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListMLTransformsResponse -> ListMLTransformsResponse -> Bool
$c/= :: ListMLTransformsResponse -> ListMLTransformsResponse -> Bool
== :: ListMLTransformsResponse -> ListMLTransformsResponse -> Bool
$c== :: ListMLTransformsResponse -> ListMLTransformsResponse -> Bool
Prelude.Eq, ReadPrec [ListMLTransformsResponse]
ReadPrec ListMLTransformsResponse
Int -> ReadS ListMLTransformsResponse
ReadS [ListMLTransformsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListMLTransformsResponse]
$creadListPrec :: ReadPrec [ListMLTransformsResponse]
readPrec :: ReadPrec ListMLTransformsResponse
$creadPrec :: ReadPrec ListMLTransformsResponse
readList :: ReadS [ListMLTransformsResponse]
$creadList :: ReadS [ListMLTransformsResponse]
readsPrec :: Int -> ReadS ListMLTransformsResponse
$creadsPrec :: Int -> ReadS ListMLTransformsResponse
Prelude.Read, Int -> ListMLTransformsResponse -> ShowS
[ListMLTransformsResponse] -> ShowS
ListMLTransformsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListMLTransformsResponse] -> ShowS
$cshowList :: [ListMLTransformsResponse] -> ShowS
show :: ListMLTransformsResponse -> String
$cshow :: ListMLTransformsResponse -> String
showsPrec :: Int -> ListMLTransformsResponse -> ShowS
$cshowsPrec :: Int -> ListMLTransformsResponse -> ShowS
Prelude.Show, forall x.
Rep ListMLTransformsResponse x -> ListMLTransformsResponse
forall x.
ListMLTransformsResponse -> Rep ListMLTransformsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListMLTransformsResponse x -> ListMLTransformsResponse
$cfrom :: forall x.
ListMLTransformsResponse -> Rep ListMLTransformsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListMLTransformsResponse' 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', 'listMLTransformsResponse_nextToken' - A continuation token, if the returned list does not contain the last
-- metric available.
--
-- 'httpStatus', 'listMLTransformsResponse_httpStatus' - The response's http status code.
--
-- 'transformIds', 'listMLTransformsResponse_transformIds' - The identifiers of all the machine learning transforms in the account,
-- or the machine learning transforms with the specified tags.
newListMLTransformsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListMLTransformsResponse
newListMLTransformsResponse :: Int -> ListMLTransformsResponse
newListMLTransformsResponse Int
pHttpStatus_ =
  ListMLTransformsResponse'
    { $sel:nextToken:ListMLTransformsResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListMLTransformsResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:transformIds:ListMLTransformsResponse' :: [Text]
transformIds = forall a. Monoid a => a
Prelude.mempty
    }

-- | A continuation token, if the returned list does not contain the last
-- metric available.
listMLTransformsResponse_nextToken :: Lens.Lens' ListMLTransformsResponse (Prelude.Maybe Prelude.Text)
listMLTransformsResponse_nextToken :: Lens' ListMLTransformsResponse (Maybe Text)
listMLTransformsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMLTransformsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListMLTransformsResponse' :: ListMLTransformsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListMLTransformsResponse
s@ListMLTransformsResponse' {} Maybe Text
a -> ListMLTransformsResponse
s {$sel:nextToken:ListMLTransformsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListMLTransformsResponse)

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

-- | The identifiers of all the machine learning transforms in the account,
-- or the machine learning transforms with the specified tags.
listMLTransformsResponse_transformIds :: Lens.Lens' ListMLTransformsResponse [Prelude.Text]
listMLTransformsResponse_transformIds :: Lens' ListMLTransformsResponse [Text]
listMLTransformsResponse_transformIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListMLTransformsResponse' {[Text]
transformIds :: [Text]
$sel:transformIds:ListMLTransformsResponse' :: ListMLTransformsResponse -> [Text]
transformIds} -> [Text]
transformIds) (\s :: ListMLTransformsResponse
s@ListMLTransformsResponse' {} [Text]
a -> ListMLTransformsResponse
s {$sel:transformIds:ListMLTransformsResponse' :: [Text]
transformIds = [Text]
a} :: ListMLTransformsResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Prelude.NFData ListMLTransformsResponse where
  rnf :: ListMLTransformsResponse -> ()
rnf ListMLTransformsResponse' {Int
[Text]
Maybe Text
transformIds :: [Text]
httpStatus :: Int
nextToken :: Maybe Text
$sel:transformIds:ListMLTransformsResponse' :: ListMLTransformsResponse -> [Text]
$sel:httpStatus:ListMLTransformsResponse' :: ListMLTransformsResponse -> Int
$sel:nextToken:ListMLTransformsResponse' :: ListMLTransformsResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nextToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
transformIds