{-# 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.ListImageVersions
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Lists the versions of a specified image and their properties. The list
-- can be filtered by creation time or modified time.
--
-- This operation returns paginated results.
module Amazonka.SageMaker.ListImageVersions
  ( -- * Creating a Request
    ListImageVersions (..),
    newListImageVersions,

    -- * Request Lenses
    listImageVersions_creationTimeAfter,
    listImageVersions_creationTimeBefore,
    listImageVersions_lastModifiedTimeAfter,
    listImageVersions_lastModifiedTimeBefore,
    listImageVersions_maxResults,
    listImageVersions_nextToken,
    listImageVersions_sortBy,
    listImageVersions_sortOrder,
    listImageVersions_imageName,

    -- * Destructuring the Response
    ListImageVersionsResponse (..),
    newListImageVersionsResponse,

    -- * Response Lenses
    listImageVersionsResponse_imageVersions,
    listImageVersionsResponse_nextToken,
    listImageVersionsResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListImageVersions' smart constructor.
data ListImageVersions = ListImageVersions'
  { -- | A filter that returns only versions created on or after the specified
    -- time.
    ListImageVersions -> Maybe POSIX
creationTimeAfter :: Prelude.Maybe Data.POSIX,
    -- | A filter that returns only versions created on or before the specified
    -- time.
    ListImageVersions -> Maybe POSIX
creationTimeBefore :: Prelude.Maybe Data.POSIX,
    -- | A filter that returns only versions modified on or after the specified
    -- time.
    ListImageVersions -> Maybe POSIX
lastModifiedTimeAfter :: Prelude.Maybe Data.POSIX,
    -- | A filter that returns only versions modified on or before the specified
    -- time.
    ListImageVersions -> Maybe POSIX
lastModifiedTimeBefore :: Prelude.Maybe Data.POSIX,
    -- | The maximum number of versions to return in the response. The default
    -- value is 10.
    ListImageVersions -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | If the previous call to @ListImageVersions@ didn\'t return the full set
    -- of versions, the call returns a token for getting the next set of
    -- versions.
    ListImageVersions -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The property used to sort results. The default value is @CREATION_TIME@.
    ListImageVersions -> Maybe ImageVersionSortBy
sortBy :: Prelude.Maybe ImageVersionSortBy,
    -- | The sort order. The default value is @DESCENDING@.
    ListImageVersions -> Maybe ImageVersionSortOrder
sortOrder :: Prelude.Maybe ImageVersionSortOrder,
    -- | The name of the image to list the versions of.
    ListImageVersions -> Text
imageName :: Prelude.Text
  }
  deriving (ListImageVersions -> ListImageVersions -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListImageVersions -> ListImageVersions -> Bool
$c/= :: ListImageVersions -> ListImageVersions -> Bool
== :: ListImageVersions -> ListImageVersions -> Bool
$c== :: ListImageVersions -> ListImageVersions -> Bool
Prelude.Eq, ReadPrec [ListImageVersions]
ReadPrec ListImageVersions
Int -> ReadS ListImageVersions
ReadS [ListImageVersions]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListImageVersions]
$creadListPrec :: ReadPrec [ListImageVersions]
readPrec :: ReadPrec ListImageVersions
$creadPrec :: ReadPrec ListImageVersions
readList :: ReadS [ListImageVersions]
$creadList :: ReadS [ListImageVersions]
readsPrec :: Int -> ReadS ListImageVersions
$creadsPrec :: Int -> ReadS ListImageVersions
Prelude.Read, Int -> ListImageVersions -> ShowS
[ListImageVersions] -> ShowS
ListImageVersions -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListImageVersions] -> ShowS
$cshowList :: [ListImageVersions] -> ShowS
show :: ListImageVersions -> String
$cshow :: ListImageVersions -> String
showsPrec :: Int -> ListImageVersions -> ShowS
$cshowsPrec :: Int -> ListImageVersions -> ShowS
Prelude.Show, forall x. Rep ListImageVersions x -> ListImageVersions
forall x. ListImageVersions -> Rep ListImageVersions x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListImageVersions x -> ListImageVersions
$cfrom :: forall x. ListImageVersions -> Rep ListImageVersions x
Prelude.Generic)

-- |
-- Create a value of 'ListImageVersions' 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:
--
-- 'creationTimeAfter', 'listImageVersions_creationTimeAfter' - A filter that returns only versions created on or after the specified
-- time.
--
-- 'creationTimeBefore', 'listImageVersions_creationTimeBefore' - A filter that returns only versions created on or before the specified
-- time.
--
-- 'lastModifiedTimeAfter', 'listImageVersions_lastModifiedTimeAfter' - A filter that returns only versions modified on or after the specified
-- time.
--
-- 'lastModifiedTimeBefore', 'listImageVersions_lastModifiedTimeBefore' - A filter that returns only versions modified on or before the specified
-- time.
--
-- 'maxResults', 'listImageVersions_maxResults' - The maximum number of versions to return in the response. The default
-- value is 10.
--
-- 'nextToken', 'listImageVersions_nextToken' - If the previous call to @ListImageVersions@ didn\'t return the full set
-- of versions, the call returns a token for getting the next set of
-- versions.
--
-- 'sortBy', 'listImageVersions_sortBy' - The property used to sort results. The default value is @CREATION_TIME@.
--
-- 'sortOrder', 'listImageVersions_sortOrder' - The sort order. The default value is @DESCENDING@.
--
-- 'imageName', 'listImageVersions_imageName' - The name of the image to list the versions of.
newListImageVersions ::
  -- | 'imageName'
  Prelude.Text ->
  ListImageVersions
newListImageVersions :: Text -> ListImageVersions
newListImageVersions Text
pImageName_ =
  ListImageVersions'
    { $sel:creationTimeAfter:ListImageVersions' :: Maybe POSIX
creationTimeAfter =
        forall a. Maybe a
Prelude.Nothing,
      $sel:creationTimeBefore:ListImageVersions' :: Maybe POSIX
creationTimeBefore = forall a. Maybe a
Prelude.Nothing,
      $sel:lastModifiedTimeAfter:ListImageVersions' :: Maybe POSIX
lastModifiedTimeAfter = forall a. Maybe a
Prelude.Nothing,
      $sel:lastModifiedTimeBefore:ListImageVersions' :: Maybe POSIX
lastModifiedTimeBefore = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:ListImageVersions' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListImageVersions' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:sortBy:ListImageVersions' :: Maybe ImageVersionSortBy
sortBy = forall a. Maybe a
Prelude.Nothing,
      $sel:sortOrder:ListImageVersions' :: Maybe ImageVersionSortOrder
sortOrder = forall a. Maybe a
Prelude.Nothing,
      $sel:imageName:ListImageVersions' :: Text
imageName = Text
pImageName_
    }

-- | A filter that returns only versions created on or after the specified
-- time.
listImageVersions_creationTimeAfter :: Lens.Lens' ListImageVersions (Prelude.Maybe Prelude.UTCTime)
listImageVersions_creationTimeAfter :: Lens' ListImageVersions (Maybe UTCTime)
listImageVersions_creationTimeAfter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe POSIX
creationTimeAfter :: Maybe POSIX
$sel:creationTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
creationTimeAfter} -> Maybe POSIX
creationTimeAfter) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe POSIX
a -> ListImageVersions
s {$sel:creationTimeAfter:ListImageVersions' :: Maybe POSIX
creationTimeAfter = Maybe POSIX
a} :: ListImageVersions) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A filter that returns only versions created on or before the specified
-- time.
listImageVersions_creationTimeBefore :: Lens.Lens' ListImageVersions (Prelude.Maybe Prelude.UTCTime)
listImageVersions_creationTimeBefore :: Lens' ListImageVersions (Maybe UTCTime)
listImageVersions_creationTimeBefore = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe POSIX
creationTimeBefore :: Maybe POSIX
$sel:creationTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
creationTimeBefore} -> Maybe POSIX
creationTimeBefore) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe POSIX
a -> ListImageVersions
s {$sel:creationTimeBefore:ListImageVersions' :: Maybe POSIX
creationTimeBefore = Maybe POSIX
a} :: ListImageVersions) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A filter that returns only versions modified on or after the specified
-- time.
listImageVersions_lastModifiedTimeAfter :: Lens.Lens' ListImageVersions (Prelude.Maybe Prelude.UTCTime)
listImageVersions_lastModifiedTimeAfter :: Lens' ListImageVersions (Maybe UTCTime)
listImageVersions_lastModifiedTimeAfter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe POSIX
lastModifiedTimeAfter :: Maybe POSIX
$sel:lastModifiedTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
lastModifiedTimeAfter} -> Maybe POSIX
lastModifiedTimeAfter) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe POSIX
a -> ListImageVersions
s {$sel:lastModifiedTimeAfter:ListImageVersions' :: Maybe POSIX
lastModifiedTimeAfter = Maybe POSIX
a} :: ListImageVersions) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | A filter that returns only versions modified on or before the specified
-- time.
listImageVersions_lastModifiedTimeBefore :: Lens.Lens' ListImageVersions (Prelude.Maybe Prelude.UTCTime)
listImageVersions_lastModifiedTimeBefore :: Lens' ListImageVersions (Maybe UTCTime)
listImageVersions_lastModifiedTimeBefore = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe POSIX
lastModifiedTimeBefore :: Maybe POSIX
$sel:lastModifiedTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
lastModifiedTimeBefore} -> Maybe POSIX
lastModifiedTimeBefore) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe POSIX
a -> ListImageVersions
s {$sel:lastModifiedTimeBefore:ListImageVersions' :: Maybe POSIX
lastModifiedTimeBefore = Maybe POSIX
a} :: ListImageVersions) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The maximum number of versions to return in the response. The default
-- value is 10.
listImageVersions_maxResults :: Lens.Lens' ListImageVersions (Prelude.Maybe Prelude.Natural)
listImageVersions_maxResults :: Lens' ListImageVersions (Maybe Natural)
listImageVersions_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:ListImageVersions' :: ListImageVersions -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe Natural
a -> ListImageVersions
s {$sel:maxResults:ListImageVersions' :: Maybe Natural
maxResults = Maybe Natural
a} :: ListImageVersions)

-- | If the previous call to @ListImageVersions@ didn\'t return the full set
-- of versions, the call returns a token for getting the next set of
-- versions.
listImageVersions_nextToken :: Lens.Lens' ListImageVersions (Prelude.Maybe Prelude.Text)
listImageVersions_nextToken :: Lens' ListImageVersions (Maybe Text)
listImageVersions_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListImageVersions' :: ListImageVersions -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe Text
a -> ListImageVersions
s {$sel:nextToken:ListImageVersions' :: Maybe Text
nextToken = Maybe Text
a} :: ListImageVersions)

-- | The property used to sort results. The default value is @CREATION_TIME@.
listImageVersions_sortBy :: Lens.Lens' ListImageVersions (Prelude.Maybe ImageVersionSortBy)
listImageVersions_sortBy :: Lens' ListImageVersions (Maybe ImageVersionSortBy)
listImageVersions_sortBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe ImageVersionSortBy
sortBy :: Maybe ImageVersionSortBy
$sel:sortBy:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortBy
sortBy} -> Maybe ImageVersionSortBy
sortBy) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe ImageVersionSortBy
a -> ListImageVersions
s {$sel:sortBy:ListImageVersions' :: Maybe ImageVersionSortBy
sortBy = Maybe ImageVersionSortBy
a} :: ListImageVersions)

-- | The sort order. The default value is @DESCENDING@.
listImageVersions_sortOrder :: Lens.Lens' ListImageVersions (Prelude.Maybe ImageVersionSortOrder)
listImageVersions_sortOrder :: Lens' ListImageVersions (Maybe ImageVersionSortOrder)
listImageVersions_sortOrder = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Maybe ImageVersionSortOrder
sortOrder :: Maybe ImageVersionSortOrder
$sel:sortOrder:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortOrder
sortOrder} -> Maybe ImageVersionSortOrder
sortOrder) (\s :: ListImageVersions
s@ListImageVersions' {} Maybe ImageVersionSortOrder
a -> ListImageVersions
s {$sel:sortOrder:ListImageVersions' :: Maybe ImageVersionSortOrder
sortOrder = Maybe ImageVersionSortOrder
a} :: ListImageVersions)

-- | The name of the image to list the versions of.
listImageVersions_imageName :: Lens.Lens' ListImageVersions Prelude.Text
listImageVersions_imageName :: Lens' ListImageVersions Text
listImageVersions_imageName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersions' {Text
imageName :: Text
$sel:imageName:ListImageVersions' :: ListImageVersions -> Text
imageName} -> Text
imageName) (\s :: ListImageVersions
s@ListImageVersions' {} Text
a -> ListImageVersions
s {$sel:imageName:ListImageVersions' :: Text
imageName = Text
a} :: ListImageVersions)

instance Core.AWSPager ListImageVersions where
  page :: ListImageVersions
-> AWSResponse ListImageVersions -> Maybe ListImageVersions
page ListImageVersions
rq AWSResponse ListImageVersions
rs
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListImageVersions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListImageVersionsResponse (Maybe Text)
listImageVersionsResponse_nextToken
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse ListImageVersions
rs
            forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListImageVersionsResponse (Maybe [ImageVersion])
listImageVersionsResponse_imageVersions
            forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
        forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
        forall a. a -> Maybe a
Prelude.Just
          forall a b. (a -> b) -> a -> b
Prelude.$ ListImageVersions
rq
          forall a b. a -> (a -> b) -> b
Prelude.& Lens' ListImageVersions (Maybe Text)
listImageVersions_nextToken
          forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse ListImageVersions
rs
          forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? Lens' ListImageVersionsResponse (Maybe Text)
listImageVersionsResponse_nextToken
          forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest ListImageVersions where
  type
    AWSResponse ListImageVersions =
      ListImageVersionsResponse
  request :: (Service -> Service)
-> ListImageVersions -> Request ListImageVersions
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 ListImageVersions
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListImageVersions)))
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 [ImageVersion]
-> Maybe Text -> Int -> ListImageVersionsResponse
ListImageVersionsResponse'
            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
"ImageVersions" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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
"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))
      )

instance Prelude.Hashable ListImageVersions where
  hashWithSalt :: Int -> ListImageVersions -> Int
hashWithSalt Int
_salt ListImageVersions' {Maybe Natural
Maybe Text
Maybe POSIX
Maybe ImageVersionSortBy
Maybe ImageVersionSortOrder
Text
imageName :: Text
sortOrder :: Maybe ImageVersionSortOrder
sortBy :: Maybe ImageVersionSortBy
nextToken :: Maybe Text
maxResults :: Maybe Natural
lastModifiedTimeBefore :: Maybe POSIX
lastModifiedTimeAfter :: Maybe POSIX
creationTimeBefore :: Maybe POSIX
creationTimeAfter :: Maybe POSIX
$sel:imageName:ListImageVersions' :: ListImageVersions -> Text
$sel:sortOrder:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortOrder
$sel:sortBy:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortBy
$sel:nextToken:ListImageVersions' :: ListImageVersions -> Maybe Text
$sel:maxResults:ListImageVersions' :: ListImageVersions -> Maybe Natural
$sel:lastModifiedTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:lastModifiedTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:creationTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:creationTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
creationTimeAfter
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
creationTimeBefore
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastModifiedTimeAfter
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastModifiedTimeBefore
      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 ImageVersionSortBy
sortBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ImageVersionSortOrder
sortOrder
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
imageName

instance Prelude.NFData ListImageVersions where
  rnf :: ListImageVersions -> ()
rnf ListImageVersions' {Maybe Natural
Maybe Text
Maybe POSIX
Maybe ImageVersionSortBy
Maybe ImageVersionSortOrder
Text
imageName :: Text
sortOrder :: Maybe ImageVersionSortOrder
sortBy :: Maybe ImageVersionSortBy
nextToken :: Maybe Text
maxResults :: Maybe Natural
lastModifiedTimeBefore :: Maybe POSIX
lastModifiedTimeAfter :: Maybe POSIX
creationTimeBefore :: Maybe POSIX
creationTimeAfter :: Maybe POSIX
$sel:imageName:ListImageVersions' :: ListImageVersions -> Text
$sel:sortOrder:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortOrder
$sel:sortBy:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortBy
$sel:nextToken:ListImageVersions' :: ListImageVersions -> Maybe Text
$sel:maxResults:ListImageVersions' :: ListImageVersions -> Maybe Natural
$sel:lastModifiedTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:lastModifiedTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:creationTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:creationTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
creationTimeAfter
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
creationTimeBefore
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastModifiedTimeAfter
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastModifiedTimeBefore
      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 ImageVersionSortBy
sortBy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ImageVersionSortOrder
sortOrder
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
imageName

instance Data.ToHeaders ListImageVersions where
  toHeaders :: ListImageVersions -> 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
"SageMaker.ListImageVersions" ::
                          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 ListImageVersions where
  toJSON :: ListImageVersions -> Value
toJSON ListImageVersions' {Maybe Natural
Maybe Text
Maybe POSIX
Maybe ImageVersionSortBy
Maybe ImageVersionSortOrder
Text
imageName :: Text
sortOrder :: Maybe ImageVersionSortOrder
sortBy :: Maybe ImageVersionSortBy
nextToken :: Maybe Text
maxResults :: Maybe Natural
lastModifiedTimeBefore :: Maybe POSIX
lastModifiedTimeAfter :: Maybe POSIX
creationTimeBefore :: Maybe POSIX
creationTimeAfter :: Maybe POSIX
$sel:imageName:ListImageVersions' :: ListImageVersions -> Text
$sel:sortOrder:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortOrder
$sel:sortBy:ListImageVersions' :: ListImageVersions -> Maybe ImageVersionSortBy
$sel:nextToken:ListImageVersions' :: ListImageVersions -> Maybe Text
$sel:maxResults:ListImageVersions' :: ListImageVersions -> Maybe Natural
$sel:lastModifiedTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:lastModifiedTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:creationTimeBefore:ListImageVersions' :: ListImageVersions -> Maybe POSIX
$sel:creationTimeAfter:ListImageVersions' :: ListImageVersions -> Maybe POSIX
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CreationTimeAfter" 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 POSIX
creationTimeAfter,
            (Key
"CreationTimeBefore" 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 POSIX
creationTimeBefore,
            (Key
"LastModifiedTimeAfter" 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 POSIX
lastModifiedTimeAfter,
            (Key
"LastModifiedTimeBefore" 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 POSIX
lastModifiedTimeBefore,
            (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
"SortBy" 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 ImageVersionSortBy
sortBy,
            (Key
"SortOrder" 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 ImageVersionSortOrder
sortOrder,
            forall a. a -> Maybe a
Prelude.Just (Key
"ImageName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
imageName)
          ]
      )

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

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

-- | /See:/ 'newListImageVersionsResponse' smart constructor.
data ListImageVersionsResponse = ListImageVersionsResponse'
  { -- | A list of versions and their properties.
    ListImageVersionsResponse -> Maybe [ImageVersion]
imageVersions :: Prelude.Maybe [ImageVersion],
    -- | A token for getting the next set of versions, if there are any.
    ListImageVersionsResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ListImageVersionsResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListImageVersionsResponse -> ListImageVersionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListImageVersionsResponse -> ListImageVersionsResponse -> Bool
$c/= :: ListImageVersionsResponse -> ListImageVersionsResponse -> Bool
== :: ListImageVersionsResponse -> ListImageVersionsResponse -> Bool
$c== :: ListImageVersionsResponse -> ListImageVersionsResponse -> Bool
Prelude.Eq, ReadPrec [ListImageVersionsResponse]
ReadPrec ListImageVersionsResponse
Int -> ReadS ListImageVersionsResponse
ReadS [ListImageVersionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListImageVersionsResponse]
$creadListPrec :: ReadPrec [ListImageVersionsResponse]
readPrec :: ReadPrec ListImageVersionsResponse
$creadPrec :: ReadPrec ListImageVersionsResponse
readList :: ReadS [ListImageVersionsResponse]
$creadList :: ReadS [ListImageVersionsResponse]
readsPrec :: Int -> ReadS ListImageVersionsResponse
$creadsPrec :: Int -> ReadS ListImageVersionsResponse
Prelude.Read, Int -> ListImageVersionsResponse -> ShowS
[ListImageVersionsResponse] -> ShowS
ListImageVersionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListImageVersionsResponse] -> ShowS
$cshowList :: [ListImageVersionsResponse] -> ShowS
show :: ListImageVersionsResponse -> String
$cshow :: ListImageVersionsResponse -> String
showsPrec :: Int -> ListImageVersionsResponse -> ShowS
$cshowsPrec :: Int -> ListImageVersionsResponse -> ShowS
Prelude.Show, forall x.
Rep ListImageVersionsResponse x -> ListImageVersionsResponse
forall x.
ListImageVersionsResponse -> Rep ListImageVersionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListImageVersionsResponse x -> ListImageVersionsResponse
$cfrom :: forall x.
ListImageVersionsResponse -> Rep ListImageVersionsResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListImageVersionsResponse' 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:
--
-- 'imageVersions', 'listImageVersionsResponse_imageVersions' - A list of versions and their properties.
--
-- 'nextToken', 'listImageVersionsResponse_nextToken' - A token for getting the next set of versions, if there are any.
--
-- 'httpStatus', 'listImageVersionsResponse_httpStatus' - The response's http status code.
newListImageVersionsResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListImageVersionsResponse
newListImageVersionsResponse :: Int -> ListImageVersionsResponse
newListImageVersionsResponse Int
pHttpStatus_ =
  ListImageVersionsResponse'
    { $sel:imageVersions:ListImageVersionsResponse' :: Maybe [ImageVersion]
imageVersions =
        forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:ListImageVersionsResponse' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListImageVersionsResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of versions and their properties.
listImageVersionsResponse_imageVersions :: Lens.Lens' ListImageVersionsResponse (Prelude.Maybe [ImageVersion])
listImageVersionsResponse_imageVersions :: Lens' ListImageVersionsResponse (Maybe [ImageVersion])
listImageVersionsResponse_imageVersions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersionsResponse' {Maybe [ImageVersion]
imageVersions :: Maybe [ImageVersion]
$sel:imageVersions:ListImageVersionsResponse' :: ListImageVersionsResponse -> Maybe [ImageVersion]
imageVersions} -> Maybe [ImageVersion]
imageVersions) (\s :: ListImageVersionsResponse
s@ListImageVersionsResponse' {} Maybe [ImageVersion]
a -> ListImageVersionsResponse
s {$sel:imageVersions:ListImageVersionsResponse' :: Maybe [ImageVersion]
imageVersions = Maybe [ImageVersion]
a} :: ListImageVersionsResponse) 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

-- | A token for getting the next set of versions, if there are any.
listImageVersionsResponse_nextToken :: Lens.Lens' ListImageVersionsResponse (Prelude.Maybe Prelude.Text)
listImageVersionsResponse_nextToken :: Lens' ListImageVersionsResponse (Maybe Text)
listImageVersionsResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListImageVersionsResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:ListImageVersionsResponse' :: ListImageVersionsResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: ListImageVersionsResponse
s@ListImageVersionsResponse' {} Maybe Text
a -> ListImageVersionsResponse
s {$sel:nextToken:ListImageVersionsResponse' :: Maybe Text
nextToken = Maybe Text
a} :: ListImageVersionsResponse)

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

instance Prelude.NFData ListImageVersionsResponse where
  rnf :: ListImageVersionsResponse -> ()
rnf ListImageVersionsResponse' {Int
Maybe [ImageVersion]
Maybe Text
httpStatus :: Int
nextToken :: Maybe Text
imageVersions :: Maybe [ImageVersion]
$sel:httpStatus:ListImageVersionsResponse' :: ListImageVersionsResponse -> Int
$sel:nextToken:ListImageVersionsResponse' :: ListImageVersionsResponse -> Maybe Text
$sel:imageVersions:ListImageVersionsResponse' :: ListImageVersionsResponse -> Maybe [ImageVersion]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ImageVersion]
imageVersions
      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 Int
httpStatus