{-# 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.StartExportTask
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Begins the export of discovered data to an S3 bucket.
--
-- If you specify @agentIds@ in a filter, the task exports up to 72 hours
-- of detailed data collected by the identified Application Discovery
-- Agent, including network, process, and performance details. A time range
-- for exported agent data may be set by using @startTime@ and @endTime@.
-- Export of detailed agent data is limited to five concurrently running
-- exports.
--
-- If you do not include an @agentIds@ filter, summary data is exported
-- that includes both Amazon Web Services Agentless Discovery Connector
-- data and summary data from Amazon Web Services Discovery Agents. Export
-- of summary data is limited to two exports per day.
module Amazonka.Discovery.StartExportTask
  ( -- * Creating a Request
    StartExportTask (..),
    newStartExportTask,

    -- * Request Lenses
    startExportTask_endTime,
    startExportTask_exportDataFormat,
    startExportTask_filters,
    startExportTask_startTime,

    -- * Destructuring the Response
    StartExportTaskResponse (..),
    newStartExportTaskResponse,

    -- * Response Lenses
    startExportTaskResponse_exportId,
    startExportTaskResponse_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:/ 'newStartExportTask' smart constructor.
data StartExportTask = StartExportTask'
  { -- | The end timestamp for exported data from the single Application
    -- Discovery Agent selected in the filters. If no value is specified,
    -- exported data includes the most recent data collected by the agent.
    StartExportTask -> Maybe POSIX
endTime :: Prelude.Maybe Data.POSIX,
    -- | The file format for the returned export data. Default value is @CSV@.
    -- __Note:__ /The/ @GRAPHML@ /option has been deprecated./
    StartExportTask -> Maybe [ExportDataFormat]
exportDataFormat :: Prelude.Maybe [ExportDataFormat],
    -- | If a filter is present, it selects the single @agentId@ of the
    -- Application Discovery Agent for which data is exported. The @agentId@
    -- can be found in the results of the @DescribeAgents@ API or CLI. If no
    -- filter is present, @startTime@ and @endTime@ are ignored and exported
    -- data includes both Agentless Discovery Connector data and summary data
    -- from Application Discovery agents.
    StartExportTask -> Maybe [ExportFilter]
filters :: Prelude.Maybe [ExportFilter],
    -- | The start timestamp for exported data from the single Application
    -- Discovery Agent selected in the filters. If no value is specified, data
    -- is exported starting from the first data collected by the agent.
    StartExportTask -> Maybe POSIX
startTime :: Prelude.Maybe Data.POSIX
  }
  deriving (StartExportTask -> StartExportTask -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartExportTask -> StartExportTask -> Bool
$c/= :: StartExportTask -> StartExportTask -> Bool
== :: StartExportTask -> StartExportTask -> Bool
$c== :: StartExportTask -> StartExportTask -> Bool
Prelude.Eq, ReadPrec [StartExportTask]
ReadPrec StartExportTask
Int -> ReadS StartExportTask
ReadS [StartExportTask]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartExportTask]
$creadListPrec :: ReadPrec [StartExportTask]
readPrec :: ReadPrec StartExportTask
$creadPrec :: ReadPrec StartExportTask
readList :: ReadS [StartExportTask]
$creadList :: ReadS [StartExportTask]
readsPrec :: Int -> ReadS StartExportTask
$creadsPrec :: Int -> ReadS StartExportTask
Prelude.Read, Int -> StartExportTask -> ShowS
[StartExportTask] -> ShowS
StartExportTask -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartExportTask] -> ShowS
$cshowList :: [StartExportTask] -> ShowS
show :: StartExportTask -> String
$cshow :: StartExportTask -> String
showsPrec :: Int -> StartExportTask -> ShowS
$cshowsPrec :: Int -> StartExportTask -> ShowS
Prelude.Show, forall x. Rep StartExportTask x -> StartExportTask
forall x. StartExportTask -> Rep StartExportTask x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartExportTask x -> StartExportTask
$cfrom :: forall x. StartExportTask -> Rep StartExportTask x
Prelude.Generic)

-- |
-- Create a value of 'StartExportTask' 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:
--
-- 'endTime', 'startExportTask_endTime' - The end timestamp for exported data from the single Application
-- Discovery Agent selected in the filters. If no value is specified,
-- exported data includes the most recent data collected by the agent.
--
-- 'exportDataFormat', 'startExportTask_exportDataFormat' - The file format for the returned export data. Default value is @CSV@.
-- __Note:__ /The/ @GRAPHML@ /option has been deprecated./
--
-- 'filters', 'startExportTask_filters' - If a filter is present, it selects the single @agentId@ of the
-- Application Discovery Agent for which data is exported. The @agentId@
-- can be found in the results of the @DescribeAgents@ API or CLI. If no
-- filter is present, @startTime@ and @endTime@ are ignored and exported
-- data includes both Agentless Discovery Connector data and summary data
-- from Application Discovery agents.
--
-- 'startTime', 'startExportTask_startTime' - The start timestamp for exported data from the single Application
-- Discovery Agent selected in the filters. If no value is specified, data
-- is exported starting from the first data collected by the agent.
newStartExportTask ::
  StartExportTask
newStartExportTask :: StartExportTask
newStartExportTask =
  StartExportTask'
    { $sel:endTime:StartExportTask' :: Maybe POSIX
endTime = forall a. Maybe a
Prelude.Nothing,
      $sel:exportDataFormat:StartExportTask' :: Maybe [ExportDataFormat]
exportDataFormat = forall a. Maybe a
Prelude.Nothing,
      $sel:filters:StartExportTask' :: Maybe [ExportFilter]
filters = forall a. Maybe a
Prelude.Nothing,
      $sel:startTime:StartExportTask' :: Maybe POSIX
startTime = forall a. Maybe a
Prelude.Nothing
    }

-- | The end timestamp for exported data from the single Application
-- Discovery Agent selected in the filters. If no value is specified,
-- exported data includes the most recent data collected by the agent.
startExportTask_endTime :: Lens.Lens' StartExportTask (Prelude.Maybe Prelude.UTCTime)
startExportTask_endTime :: Lens' StartExportTask (Maybe UTCTime)
startExportTask_endTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartExportTask' {Maybe POSIX
endTime :: Maybe POSIX
$sel:endTime:StartExportTask' :: StartExportTask -> Maybe POSIX
endTime} -> Maybe POSIX
endTime) (\s :: StartExportTask
s@StartExportTask' {} Maybe POSIX
a -> StartExportTask
s {$sel:endTime:StartExportTask' :: Maybe POSIX
endTime = Maybe POSIX
a} :: StartExportTask) 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 file format for the returned export data. Default value is @CSV@.
-- __Note:__ /The/ @GRAPHML@ /option has been deprecated./
startExportTask_exportDataFormat :: Lens.Lens' StartExportTask (Prelude.Maybe [ExportDataFormat])
startExportTask_exportDataFormat :: Lens' StartExportTask (Maybe [ExportDataFormat])
startExportTask_exportDataFormat = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartExportTask' {Maybe [ExportDataFormat]
exportDataFormat :: Maybe [ExportDataFormat]
$sel:exportDataFormat:StartExportTask' :: StartExportTask -> Maybe [ExportDataFormat]
exportDataFormat} -> Maybe [ExportDataFormat]
exportDataFormat) (\s :: StartExportTask
s@StartExportTask' {} Maybe [ExportDataFormat]
a -> StartExportTask
s {$sel:exportDataFormat:StartExportTask' :: Maybe [ExportDataFormat]
exportDataFormat = Maybe [ExportDataFormat]
a} :: StartExportTask) 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

-- | If a filter is present, it selects the single @agentId@ of the
-- Application Discovery Agent for which data is exported. The @agentId@
-- can be found in the results of the @DescribeAgents@ API or CLI. If no
-- filter is present, @startTime@ and @endTime@ are ignored and exported
-- data includes both Agentless Discovery Connector data and summary data
-- from Application Discovery agents.
startExportTask_filters :: Lens.Lens' StartExportTask (Prelude.Maybe [ExportFilter])
startExportTask_filters :: Lens' StartExportTask (Maybe [ExportFilter])
startExportTask_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartExportTask' {Maybe [ExportFilter]
filters :: Maybe [ExportFilter]
$sel:filters:StartExportTask' :: StartExportTask -> Maybe [ExportFilter]
filters} -> Maybe [ExportFilter]
filters) (\s :: StartExportTask
s@StartExportTask' {} Maybe [ExportFilter]
a -> StartExportTask
s {$sel:filters:StartExportTask' :: Maybe [ExportFilter]
filters = Maybe [ExportFilter]
a} :: StartExportTask) 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 start timestamp for exported data from the single Application
-- Discovery Agent selected in the filters. If no value is specified, data
-- is exported starting from the first data collected by the agent.
startExportTask_startTime :: Lens.Lens' StartExportTask (Prelude.Maybe Prelude.UTCTime)
startExportTask_startTime :: Lens' StartExportTask (Maybe UTCTime)
startExportTask_startTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartExportTask' {Maybe POSIX
startTime :: Maybe POSIX
$sel:startTime:StartExportTask' :: StartExportTask -> Maybe POSIX
startTime} -> Maybe POSIX
startTime) (\s :: StartExportTask
s@StartExportTask' {} Maybe POSIX
a -> StartExportTask
s {$sel:startTime:StartExportTask' :: Maybe POSIX
startTime = Maybe POSIX
a} :: StartExportTask) 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

instance Core.AWSRequest StartExportTask where
  type
    AWSResponse StartExportTask =
      StartExportTaskResponse
  request :: (Service -> Service) -> StartExportTask -> Request StartExportTask
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 StartExportTask
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse StartExportTask)))
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 -> StartExportTaskResponse
StartExportTaskResponse'
            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
"exportId")
            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 StartExportTask where
  hashWithSalt :: Int -> StartExportTask -> Int
hashWithSalt Int
_salt StartExportTask' {Maybe [ExportDataFormat]
Maybe [ExportFilter]
Maybe POSIX
startTime :: Maybe POSIX
filters :: Maybe [ExportFilter]
exportDataFormat :: Maybe [ExportDataFormat]
endTime :: Maybe POSIX
$sel:startTime:StartExportTask' :: StartExportTask -> Maybe POSIX
$sel:filters:StartExportTask' :: StartExportTask -> Maybe [ExportFilter]
$sel:exportDataFormat:StartExportTask' :: StartExportTask -> Maybe [ExportDataFormat]
$sel:endTime:StartExportTask' :: StartExportTask -> Maybe POSIX
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
endTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ExportDataFormat]
exportDataFormat
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ExportFilter]
filters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
startTime

instance Prelude.NFData StartExportTask where
  rnf :: StartExportTask -> ()
rnf StartExportTask' {Maybe [ExportDataFormat]
Maybe [ExportFilter]
Maybe POSIX
startTime :: Maybe POSIX
filters :: Maybe [ExportFilter]
exportDataFormat :: Maybe [ExportDataFormat]
endTime :: Maybe POSIX
$sel:startTime:StartExportTask' :: StartExportTask -> Maybe POSIX
$sel:filters:StartExportTask' :: StartExportTask -> Maybe [ExportFilter]
$sel:exportDataFormat:StartExportTask' :: StartExportTask -> Maybe [ExportDataFormat]
$sel:endTime:StartExportTask' :: StartExportTask -> Maybe POSIX
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
endTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ExportDataFormat]
exportDataFormat
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ExportFilter]
filters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
startTime

instance Data.ToHeaders StartExportTask where
  toHeaders :: StartExportTask -> 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.StartExportTask" ::
                          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 StartExportTask where
  toJSON :: StartExportTask -> Value
toJSON StartExportTask' {Maybe [ExportDataFormat]
Maybe [ExportFilter]
Maybe POSIX
startTime :: Maybe POSIX
filters :: Maybe [ExportFilter]
exportDataFormat :: Maybe [ExportDataFormat]
endTime :: Maybe POSIX
$sel:startTime:StartExportTask' :: StartExportTask -> Maybe POSIX
$sel:filters:StartExportTask' :: StartExportTask -> Maybe [ExportFilter]
$sel:exportDataFormat:StartExportTask' :: StartExportTask -> Maybe [ExportDataFormat]
$sel:endTime:StartExportTask' :: StartExportTask -> Maybe POSIX
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"endTime" 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
endTime,
            (Key
"exportDataFormat" 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 [ExportDataFormat]
exportDataFormat,
            (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 [ExportFilter]
filters,
            (Key
"startTime" 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
startTime
          ]
      )

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

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

-- | /See:/ 'newStartExportTaskResponse' smart constructor.
data StartExportTaskResponse = StartExportTaskResponse'
  { -- | A unique identifier used to query the status of an export request.
    StartExportTaskResponse -> Maybe Text
exportId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    StartExportTaskResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartExportTaskResponse -> StartExportTaskResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartExportTaskResponse -> StartExportTaskResponse -> Bool
$c/= :: StartExportTaskResponse -> StartExportTaskResponse -> Bool
== :: StartExportTaskResponse -> StartExportTaskResponse -> Bool
$c== :: StartExportTaskResponse -> StartExportTaskResponse -> Bool
Prelude.Eq, ReadPrec [StartExportTaskResponse]
ReadPrec StartExportTaskResponse
Int -> ReadS StartExportTaskResponse
ReadS [StartExportTaskResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartExportTaskResponse]
$creadListPrec :: ReadPrec [StartExportTaskResponse]
readPrec :: ReadPrec StartExportTaskResponse
$creadPrec :: ReadPrec StartExportTaskResponse
readList :: ReadS [StartExportTaskResponse]
$creadList :: ReadS [StartExportTaskResponse]
readsPrec :: Int -> ReadS StartExportTaskResponse
$creadsPrec :: Int -> ReadS StartExportTaskResponse
Prelude.Read, Int -> StartExportTaskResponse -> ShowS
[StartExportTaskResponse] -> ShowS
StartExportTaskResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartExportTaskResponse] -> ShowS
$cshowList :: [StartExportTaskResponse] -> ShowS
show :: StartExportTaskResponse -> String
$cshow :: StartExportTaskResponse -> String
showsPrec :: Int -> StartExportTaskResponse -> ShowS
$cshowsPrec :: Int -> StartExportTaskResponse -> ShowS
Prelude.Show, forall x. Rep StartExportTaskResponse x -> StartExportTaskResponse
forall x. StartExportTaskResponse -> Rep StartExportTaskResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartExportTaskResponse x -> StartExportTaskResponse
$cfrom :: forall x. StartExportTaskResponse -> Rep StartExportTaskResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartExportTaskResponse' 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:
--
-- 'exportId', 'startExportTaskResponse_exportId' - A unique identifier used to query the status of an export request.
--
-- 'httpStatus', 'startExportTaskResponse_httpStatus' - The response's http status code.
newStartExportTaskResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartExportTaskResponse
newStartExportTaskResponse :: Int -> StartExportTaskResponse
newStartExportTaskResponse Int
pHttpStatus_ =
  StartExportTaskResponse'
    { $sel:exportId:StartExportTaskResponse' :: Maybe Text
exportId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartExportTaskResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A unique identifier used to query the status of an export request.
startExportTaskResponse_exportId :: Lens.Lens' StartExportTaskResponse (Prelude.Maybe Prelude.Text)
startExportTaskResponse_exportId :: Lens' StartExportTaskResponse (Maybe Text)
startExportTaskResponse_exportId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartExportTaskResponse' {Maybe Text
exportId :: Maybe Text
$sel:exportId:StartExportTaskResponse' :: StartExportTaskResponse -> Maybe Text
exportId} -> Maybe Text
exportId) (\s :: StartExportTaskResponse
s@StartExportTaskResponse' {} Maybe Text
a -> StartExportTaskResponse
s {$sel:exportId:StartExportTaskResponse' :: Maybe Text
exportId = Maybe Text
a} :: StartExportTaskResponse)

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

instance Prelude.NFData StartExportTaskResponse where
  rnf :: StartExportTaskResponse -> ()
rnf StartExportTaskResponse' {Int
Maybe Text
httpStatus :: Int
exportId :: Maybe Text
$sel:httpStatus:StartExportTaskResponse' :: StartExportTaskResponse -> Int
$sel:exportId:StartExportTaskResponse' :: StartExportTaskResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
exportId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus