{-# 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.Discovery.DescribeImportTasks
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns an array of import tasks for your account, including status
-- information, times, IDs, the Amazon S3 Object URL for the import file,
-- and more.
module Amazonka.Discovery.DescribeImportTasks
  ( -- * Creating a Request
    DescribeImportTasks (..),
    newDescribeImportTasks,

    -- * Request Lenses
    describeImportTasks_filters,
    describeImportTasks_maxResults,
    describeImportTasks_nextToken,

    -- * Destructuring the Response
    DescribeImportTasksResponse (..),
    newDescribeImportTasksResponse,

    -- * Response Lenses
    describeImportTasksResponse_nextToken,
    describeImportTasksResponse_tasks,
    describeImportTasksResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDescribeImportTasks' smart constructor.
data DescribeImportTasks = DescribeImportTasks'
  { -- | An array of name-value pairs that you provide to filter the results for
    -- the @DescribeImportTask@ request to a specific subset of results.
    -- Currently, wildcard values aren\'t supported for filters.
    DescribeImportTasks -> Maybe [ImportTaskFilter]
filters :: Prelude.Maybe [ImportTaskFilter],
    -- | The maximum number of results that you want this request to return, up
    -- to 100.
    DescribeImportTasks -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The token to request a specific page of results.
    DescribeImportTasks -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text
  }
  deriving (DescribeImportTasks -> DescribeImportTasks -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeImportTasks -> DescribeImportTasks -> Bool
$c/= :: DescribeImportTasks -> DescribeImportTasks -> Bool
== :: DescribeImportTasks -> DescribeImportTasks -> Bool
$c== :: DescribeImportTasks -> DescribeImportTasks -> Bool
Prelude.Eq, ReadPrec [DescribeImportTasks]
ReadPrec DescribeImportTasks
Int -> ReadS DescribeImportTasks
ReadS [DescribeImportTasks]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeImportTasks]
$creadListPrec :: ReadPrec [DescribeImportTasks]
readPrec :: ReadPrec DescribeImportTasks
$creadPrec :: ReadPrec DescribeImportTasks
readList :: ReadS [DescribeImportTasks]
$creadList :: ReadS [DescribeImportTasks]
readsPrec :: Int -> ReadS DescribeImportTasks
$creadsPrec :: Int -> ReadS DescribeImportTasks
Prelude.Read, Int -> DescribeImportTasks -> ShowS
[DescribeImportTasks] -> ShowS
DescribeImportTasks -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeImportTasks] -> ShowS
$cshowList :: [DescribeImportTasks] -> ShowS
show :: DescribeImportTasks -> String
$cshow :: DescribeImportTasks -> String
showsPrec :: Int -> DescribeImportTasks -> ShowS
$cshowsPrec :: Int -> DescribeImportTasks -> ShowS
Prelude.Show, forall x. Rep DescribeImportTasks x -> DescribeImportTasks
forall x. DescribeImportTasks -> Rep DescribeImportTasks x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DescribeImportTasks x -> DescribeImportTasks
$cfrom :: forall x. DescribeImportTasks -> Rep DescribeImportTasks x
Prelude.Generic)

-- |
-- Create a value of 'DescribeImportTasks' 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:
--
-- 'filters', 'describeImportTasks_filters' - An array of name-value pairs that you provide to filter the results for
-- the @DescribeImportTask@ request to a specific subset of results.
-- Currently, wildcard values aren\'t supported for filters.
--
-- 'maxResults', 'describeImportTasks_maxResults' - The maximum number of results that you want this request to return, up
-- to 100.
--
-- 'nextToken', 'describeImportTasks_nextToken' - The token to request a specific page of results.
newDescribeImportTasks ::
  DescribeImportTasks
newDescribeImportTasks :: DescribeImportTasks
newDescribeImportTasks =
  DescribeImportTasks'
    { $sel:filters:DescribeImportTasks' :: Maybe [ImportTaskFilter]
filters = forall a. Maybe a
Prelude.Nothing,
      $sel:maxResults:DescribeImportTasks' :: Maybe Natural
maxResults = forall a. Maybe a
Prelude.Nothing,
      $sel:nextToken:DescribeImportTasks' :: Maybe Text
nextToken = forall a. Maybe a
Prelude.Nothing
    }

-- | An array of name-value pairs that you provide to filter the results for
-- the @DescribeImportTask@ request to a specific subset of results.
-- Currently, wildcard values aren\'t supported for filters.
describeImportTasks_filters :: Lens.Lens' DescribeImportTasks (Prelude.Maybe [ImportTaskFilter])
describeImportTasks_filters :: Lens' DescribeImportTasks (Maybe [ImportTaskFilter])
describeImportTasks_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeImportTasks' {Maybe [ImportTaskFilter]
filters :: Maybe [ImportTaskFilter]
$sel:filters:DescribeImportTasks' :: DescribeImportTasks -> Maybe [ImportTaskFilter]
filters} -> Maybe [ImportTaskFilter]
filters) (\s :: DescribeImportTasks
s@DescribeImportTasks' {} Maybe [ImportTaskFilter]
a -> DescribeImportTasks
s {$sel:filters:DescribeImportTasks' :: Maybe [ImportTaskFilter]
filters = Maybe [ImportTaskFilter]
a} :: DescribeImportTasks) 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

-- | The maximum number of results that you want this request to return, up
-- to 100.
describeImportTasks_maxResults :: Lens.Lens' DescribeImportTasks (Prelude.Maybe Prelude.Natural)
describeImportTasks_maxResults :: Lens' DescribeImportTasks (Maybe Natural)
describeImportTasks_maxResults = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeImportTasks' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:DescribeImportTasks' :: DescribeImportTasks -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: DescribeImportTasks
s@DescribeImportTasks' {} Maybe Natural
a -> DescribeImportTasks
s {$sel:maxResults:DescribeImportTasks' :: Maybe Natural
maxResults = Maybe Natural
a} :: DescribeImportTasks)

-- | The token to request a specific page of results.
describeImportTasks_nextToken :: Lens.Lens' DescribeImportTasks (Prelude.Maybe Prelude.Text)
describeImportTasks_nextToken :: Lens' DescribeImportTasks (Maybe Text)
describeImportTasks_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeImportTasks' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeImportTasks' :: DescribeImportTasks -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeImportTasks
s@DescribeImportTasks' {} Maybe Text
a -> DescribeImportTasks
s {$sel:nextToken:DescribeImportTasks' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeImportTasks)

instance Core.AWSRequest DescribeImportTasks where
  type
    AWSResponse DescribeImportTasks =
      DescribeImportTasksResponse
  request :: (Service -> Service)
-> DescribeImportTasks -> Request DescribeImportTasks
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 DescribeImportTasks
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DescribeImportTasks)))
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
-> Maybe [ImportTask] -> Int -> DescribeImportTasksResponse
DescribeImportTasksResponse'
            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.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"tasks" 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.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable DescribeImportTasks where
  hashWithSalt :: Int -> DescribeImportTasks -> Int
hashWithSalt Int
_salt DescribeImportTasks' {Maybe Natural
Maybe [ImportTaskFilter]
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [ImportTaskFilter]
$sel:nextToken:DescribeImportTasks' :: DescribeImportTasks -> Maybe Text
$sel:maxResults:DescribeImportTasks' :: DescribeImportTasks -> Maybe Natural
$sel:filters:DescribeImportTasks' :: DescribeImportTasks -> Maybe [ImportTaskFilter]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ImportTaskFilter]
filters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
maxResults
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nextToken

instance Prelude.NFData DescribeImportTasks where
  rnf :: DescribeImportTasks -> ()
rnf DescribeImportTasks' {Maybe Natural
Maybe [ImportTaskFilter]
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [ImportTaskFilter]
$sel:nextToken:DescribeImportTasks' :: DescribeImportTasks -> Maybe Text
$sel:maxResults:DescribeImportTasks' :: DescribeImportTasks -> Maybe Natural
$sel:filters:DescribeImportTasks' :: DescribeImportTasks -> Maybe [ImportTaskFilter]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [ImportTaskFilter]
filters
      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

instance Data.ToHeaders DescribeImportTasks where
  toHeaders :: DescribeImportTasks -> 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
"AWSPoseidonService_V2015_11_01.DescribeImportTasks" ::
                          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 DescribeImportTasks where
  toJSON :: DescribeImportTasks -> Value
toJSON DescribeImportTasks' {Maybe Natural
Maybe [ImportTaskFilter]
Maybe Text
nextToken :: Maybe Text
maxResults :: Maybe Natural
filters :: Maybe [ImportTaskFilter]
$sel:nextToken:DescribeImportTasks' :: DescribeImportTasks -> Maybe Text
$sel:maxResults:DescribeImportTasks' :: DescribeImportTasks -> Maybe Natural
$sel:filters:DescribeImportTasks' :: DescribeImportTasks -> Maybe [ImportTaskFilter]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"filters" 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 [ImportTaskFilter]
filters,
            (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
          ]
      )

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

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

-- | /See:/ 'newDescribeImportTasksResponse' smart constructor.
data DescribeImportTasksResponse = DescribeImportTasksResponse'
  { -- | The token to request the next page of results.
    DescribeImportTasksResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | A returned array of import tasks that match any applied filters, up to
    -- the specified number of maximum results.
    DescribeImportTasksResponse -> Maybe [ImportTask]
tasks :: Prelude.Maybe [ImportTask],
    -- | The response's http status code.
    DescribeImportTasksResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (DescribeImportTasksResponse -> DescribeImportTasksResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DescribeImportTasksResponse -> DescribeImportTasksResponse -> Bool
$c/= :: DescribeImportTasksResponse -> DescribeImportTasksResponse -> Bool
== :: DescribeImportTasksResponse -> DescribeImportTasksResponse -> Bool
$c== :: DescribeImportTasksResponse -> DescribeImportTasksResponse -> Bool
Prelude.Eq, ReadPrec [DescribeImportTasksResponse]
ReadPrec DescribeImportTasksResponse
Int -> ReadS DescribeImportTasksResponse
ReadS [DescribeImportTasksResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DescribeImportTasksResponse]
$creadListPrec :: ReadPrec [DescribeImportTasksResponse]
readPrec :: ReadPrec DescribeImportTasksResponse
$creadPrec :: ReadPrec DescribeImportTasksResponse
readList :: ReadS [DescribeImportTasksResponse]
$creadList :: ReadS [DescribeImportTasksResponse]
readsPrec :: Int -> ReadS DescribeImportTasksResponse
$creadsPrec :: Int -> ReadS DescribeImportTasksResponse
Prelude.Read, Int -> DescribeImportTasksResponse -> ShowS
[DescribeImportTasksResponse] -> ShowS
DescribeImportTasksResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DescribeImportTasksResponse] -> ShowS
$cshowList :: [DescribeImportTasksResponse] -> ShowS
show :: DescribeImportTasksResponse -> String
$cshow :: DescribeImportTasksResponse -> String
showsPrec :: Int -> DescribeImportTasksResponse -> ShowS
$cshowsPrec :: Int -> DescribeImportTasksResponse -> ShowS
Prelude.Show, forall x.
Rep DescribeImportTasksResponse x -> DescribeImportTasksResponse
forall x.
DescribeImportTasksResponse -> Rep DescribeImportTasksResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep DescribeImportTasksResponse x -> DescribeImportTasksResponse
$cfrom :: forall x.
DescribeImportTasksResponse -> Rep DescribeImportTasksResponse x
Prelude.Generic)

-- |
-- Create a value of 'DescribeImportTasksResponse' 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', 'describeImportTasksResponse_nextToken' - The token to request the next page of results.
--
-- 'tasks', 'describeImportTasksResponse_tasks' - A returned array of import tasks that match any applied filters, up to
-- the specified number of maximum results.
--
-- 'httpStatus', 'describeImportTasksResponse_httpStatus' - The response's http status code.
newDescribeImportTasksResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DescribeImportTasksResponse
newDescribeImportTasksResponse :: Int -> DescribeImportTasksResponse
newDescribeImportTasksResponse Int
pHttpStatus_ =
  DescribeImportTasksResponse'
    { $sel:nextToken:DescribeImportTasksResponse' :: Maybe Text
nextToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:tasks:DescribeImportTasksResponse' :: Maybe [ImportTask]
tasks = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:DescribeImportTasksResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The token to request the next page of results.
describeImportTasksResponse_nextToken :: Lens.Lens' DescribeImportTasksResponse (Prelude.Maybe Prelude.Text)
describeImportTasksResponse_nextToken :: Lens' DescribeImportTasksResponse (Maybe Text)
describeImportTasksResponse_nextToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeImportTasksResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:DescribeImportTasksResponse' :: DescribeImportTasksResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: DescribeImportTasksResponse
s@DescribeImportTasksResponse' {} Maybe Text
a -> DescribeImportTasksResponse
s {$sel:nextToken:DescribeImportTasksResponse' :: Maybe Text
nextToken = Maybe Text
a} :: DescribeImportTasksResponse)

-- | A returned array of import tasks that match any applied filters, up to
-- the specified number of maximum results.
describeImportTasksResponse_tasks :: Lens.Lens' DescribeImportTasksResponse (Prelude.Maybe [ImportTask])
describeImportTasksResponse_tasks :: Lens' DescribeImportTasksResponse (Maybe [ImportTask])
describeImportTasksResponse_tasks = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DescribeImportTasksResponse' {Maybe [ImportTask]
tasks :: Maybe [ImportTask]
$sel:tasks:DescribeImportTasksResponse' :: DescribeImportTasksResponse -> Maybe [ImportTask]
tasks} -> Maybe [ImportTask]
tasks) (\s :: DescribeImportTasksResponse
s@DescribeImportTasksResponse' {} Maybe [ImportTask]
a -> DescribeImportTasksResponse
s {$sel:tasks:DescribeImportTasksResponse' :: Maybe [ImportTask]
tasks = Maybe [ImportTask]
a} :: DescribeImportTasksResponse) 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

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

instance Prelude.NFData DescribeImportTasksResponse where
  rnf :: DescribeImportTasksResponse -> ()
rnf DescribeImportTasksResponse' {Int
Maybe [ImportTask]
Maybe Text
httpStatus :: Int
tasks :: Maybe [ImportTask]
nextToken :: Maybe Text
$sel:httpStatus:DescribeImportTasksResponse' :: DescribeImportTasksResponse -> Int
$sel:tasks:DescribeImportTasksResponse' :: DescribeImportTasksResponse -> Maybe [ImportTask]
$sel:nextToken:DescribeImportTasksResponse' :: DescribeImportTasksResponse -> 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 Maybe [ImportTask]
tasks
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus