{-# 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.CloudWatchLogs.CreateExportTask
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates an export task so that you can efficiently export data from a
-- log group to an Amazon S3 bucket. When you perform a @CreateExportTask@
-- operation, you must use credentials that have permission to write to the
-- S3 bucket that you specify as the destination.
--
-- Exporting log data to S3 buckets that are encrypted by KMS is supported.
-- Exporting log data to Amazon S3 buckets that have S3 Object Lock enabled
-- with a retention period is also supported.
--
-- Exporting to S3 buckets that are encrypted with AES-256 is supported.
--
-- This is an asynchronous call. If all the required information is
-- provided, this operation initiates an export task and responds with the
-- ID of the task. After the task has started, you can use
-- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeExportTasks.html DescribeExportTasks>
-- to get the status of the export task. Each account can only have one
-- active (@RUNNING@ or @PENDING@) export task at a time. To cancel an
-- export task, use
-- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_CancelExportTask.html CancelExportTask>.
--
-- You can export logs from multiple log groups or multiple time ranges to
-- the same S3 bucket. To separate log data for each export task, specify a
-- prefix to be used as the Amazon S3 key prefix for all exported objects.
--
-- Time-based sorting on chunks of log data inside an exported file is not
-- guaranteed. You can sort the exported log field data by using Linux
-- utilities.
module Amazonka.CloudWatchLogs.CreateExportTask
  ( -- * Creating a Request
    CreateExportTask (..),
    newCreateExportTask,

    -- * Request Lenses
    createExportTask_destinationPrefix,
    createExportTask_logStreamNamePrefix,
    createExportTask_taskName,
    createExportTask_logGroupName,
    createExportTask_from,
    createExportTask_to,
    createExportTask_destination,

    -- * Destructuring the Response
    CreateExportTaskResponse (..),
    newCreateExportTaskResponse,

    -- * Response Lenses
    createExportTaskResponse_taskId,
    createExportTaskResponse_httpStatus,
  )
where

import Amazonka.CloudWatchLogs.Types
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

-- | /See:/ 'newCreateExportTask' smart constructor.
data CreateExportTask = CreateExportTask'
  { -- | The prefix used as the start of the key for every object exported. If
    -- you don\'t specify a value, the default is @exportedlogs@.
    CreateExportTask -> Maybe Text
destinationPrefix :: Prelude.Maybe Prelude.Text,
    -- | Export only log streams that match the provided prefix. If you don\'t
    -- specify a value, no prefix filter is applied.
    CreateExportTask -> Maybe Text
logStreamNamePrefix :: Prelude.Maybe Prelude.Text,
    -- | The name of the export task.
    CreateExportTask -> Maybe Text
taskName :: Prelude.Maybe Prelude.Text,
    -- | The name of the log group.
    CreateExportTask -> Text
logGroupName :: Prelude.Text,
    -- | The start time of the range for the request, expressed as the number of
    -- milliseconds after @Jan 1, 1970 00:00:00 UTC@. Events with a timestamp
    -- earlier than this time are not exported.
    CreateExportTask -> Natural
from :: Prelude.Natural,
    -- | The end time of the range for the request, expressed as the number of
    -- milliseconds after @Jan 1, 1970 00:00:00 UTC@. Events with a timestamp
    -- later than this time are not exported.
    --
    -- You must specify a time that is not earlier than when this log group was
    -- created.
    CreateExportTask -> Natural
to :: Prelude.Natural,
    -- | The name of S3 bucket for the exported log data. The bucket must be in
    -- the same Amazon Web Services Region.
    CreateExportTask -> Text
destination :: Prelude.Text
  }
  deriving (CreateExportTask -> CreateExportTask -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateExportTask -> CreateExportTask -> Bool
$c/= :: CreateExportTask -> CreateExportTask -> Bool
== :: CreateExportTask -> CreateExportTask -> Bool
$c== :: CreateExportTask -> CreateExportTask -> Bool
Prelude.Eq, ReadPrec [CreateExportTask]
ReadPrec CreateExportTask
Int -> ReadS CreateExportTask
ReadS [CreateExportTask]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateExportTask]
$creadListPrec :: ReadPrec [CreateExportTask]
readPrec :: ReadPrec CreateExportTask
$creadPrec :: ReadPrec CreateExportTask
readList :: ReadS [CreateExportTask]
$creadList :: ReadS [CreateExportTask]
readsPrec :: Int -> ReadS CreateExportTask
$creadsPrec :: Int -> ReadS CreateExportTask
Prelude.Read, Int -> CreateExportTask -> ShowS
[CreateExportTask] -> ShowS
CreateExportTask -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateExportTask] -> ShowS
$cshowList :: [CreateExportTask] -> ShowS
show :: CreateExportTask -> String
$cshow :: CreateExportTask -> String
showsPrec :: Int -> CreateExportTask -> ShowS
$cshowsPrec :: Int -> CreateExportTask -> ShowS
Prelude.Show, forall x. Rep CreateExportTask x -> CreateExportTask
forall x. CreateExportTask -> Rep CreateExportTask x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateExportTask x -> CreateExportTask
$cfrom :: forall x. CreateExportTask -> Rep CreateExportTask x
Prelude.Generic)

-- |
-- Create a value of 'CreateExportTask' 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:
--
-- 'destinationPrefix', 'createExportTask_destinationPrefix' - The prefix used as the start of the key for every object exported. If
-- you don\'t specify a value, the default is @exportedlogs@.
--
-- 'logStreamNamePrefix', 'createExportTask_logStreamNamePrefix' - Export only log streams that match the provided prefix. If you don\'t
-- specify a value, no prefix filter is applied.
--
-- 'taskName', 'createExportTask_taskName' - The name of the export task.
--
-- 'logGroupName', 'createExportTask_logGroupName' - The name of the log group.
--
-- 'from', 'createExportTask_from' - The start time of the range for the request, expressed as the number of
-- milliseconds after @Jan 1, 1970 00:00:00 UTC@. Events with a timestamp
-- earlier than this time are not exported.
--
-- 'to', 'createExportTask_to' - The end time of the range for the request, expressed as the number of
-- milliseconds after @Jan 1, 1970 00:00:00 UTC@. Events with a timestamp
-- later than this time are not exported.
--
-- You must specify a time that is not earlier than when this log group was
-- created.
--
-- 'destination', 'createExportTask_destination' - The name of S3 bucket for the exported log data. The bucket must be in
-- the same Amazon Web Services Region.
newCreateExportTask ::
  -- | 'logGroupName'
  Prelude.Text ->
  -- | 'from'
  Prelude.Natural ->
  -- | 'to'
  Prelude.Natural ->
  -- | 'destination'
  Prelude.Text ->
  CreateExportTask
newCreateExportTask :: Text -> Natural -> Natural -> Text -> CreateExportTask
newCreateExportTask
  Text
pLogGroupName_
  Natural
pFrom_
  Natural
pTo_
  Text
pDestination_ =
    CreateExportTask'
      { $sel:destinationPrefix:CreateExportTask' :: Maybe Text
destinationPrefix =
          forall a. Maybe a
Prelude.Nothing,
        $sel:logStreamNamePrefix:CreateExportTask' :: Maybe Text
logStreamNamePrefix = forall a. Maybe a
Prelude.Nothing,
        $sel:taskName:CreateExportTask' :: Maybe Text
taskName = forall a. Maybe a
Prelude.Nothing,
        $sel:logGroupName:CreateExportTask' :: Text
logGroupName = Text
pLogGroupName_,
        $sel:from:CreateExportTask' :: Natural
from = Natural
pFrom_,
        $sel:to:CreateExportTask' :: Natural
to = Natural
pTo_,
        $sel:destination:CreateExportTask' :: Text
destination = Text
pDestination_
      }

-- | The prefix used as the start of the key for every object exported. If
-- you don\'t specify a value, the default is @exportedlogs@.
createExportTask_destinationPrefix :: Lens.Lens' CreateExportTask (Prelude.Maybe Prelude.Text)
createExportTask_destinationPrefix :: Lens' CreateExportTask (Maybe Text)
createExportTask_destinationPrefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTask' {Maybe Text
destinationPrefix :: Maybe Text
$sel:destinationPrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
destinationPrefix} -> Maybe Text
destinationPrefix) (\s :: CreateExportTask
s@CreateExportTask' {} Maybe Text
a -> CreateExportTask
s {$sel:destinationPrefix:CreateExportTask' :: Maybe Text
destinationPrefix = Maybe Text
a} :: CreateExportTask)

-- | Export only log streams that match the provided prefix. If you don\'t
-- specify a value, no prefix filter is applied.
createExportTask_logStreamNamePrefix :: Lens.Lens' CreateExportTask (Prelude.Maybe Prelude.Text)
createExportTask_logStreamNamePrefix :: Lens' CreateExportTask (Maybe Text)
createExportTask_logStreamNamePrefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTask' {Maybe Text
logStreamNamePrefix :: Maybe Text
$sel:logStreamNamePrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
logStreamNamePrefix} -> Maybe Text
logStreamNamePrefix) (\s :: CreateExportTask
s@CreateExportTask' {} Maybe Text
a -> CreateExportTask
s {$sel:logStreamNamePrefix:CreateExportTask' :: Maybe Text
logStreamNamePrefix = Maybe Text
a} :: CreateExportTask)

-- | The name of the export task.
createExportTask_taskName :: Lens.Lens' CreateExportTask (Prelude.Maybe Prelude.Text)
createExportTask_taskName :: Lens' CreateExportTask (Maybe Text)
createExportTask_taskName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTask' {Maybe Text
taskName :: Maybe Text
$sel:taskName:CreateExportTask' :: CreateExportTask -> Maybe Text
taskName} -> Maybe Text
taskName) (\s :: CreateExportTask
s@CreateExportTask' {} Maybe Text
a -> CreateExportTask
s {$sel:taskName:CreateExportTask' :: Maybe Text
taskName = Maybe Text
a} :: CreateExportTask)

-- | The name of the log group.
createExportTask_logGroupName :: Lens.Lens' CreateExportTask Prelude.Text
createExportTask_logGroupName :: Lens' CreateExportTask Text
createExportTask_logGroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTask' {Text
logGroupName :: Text
$sel:logGroupName:CreateExportTask' :: CreateExportTask -> Text
logGroupName} -> Text
logGroupName) (\s :: CreateExportTask
s@CreateExportTask' {} Text
a -> CreateExportTask
s {$sel:logGroupName:CreateExportTask' :: Text
logGroupName = Text
a} :: CreateExportTask)

-- | The start time of the range for the request, expressed as the number of
-- milliseconds after @Jan 1, 1970 00:00:00 UTC@. Events with a timestamp
-- earlier than this time are not exported.
createExportTask_from :: Lens.Lens' CreateExportTask Prelude.Natural
createExportTask_from :: Lens' CreateExportTask Natural
createExportTask_from = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTask' {Natural
from :: Natural
$sel:from:CreateExportTask' :: CreateExportTask -> Natural
from} -> Natural
from) (\s :: CreateExportTask
s@CreateExportTask' {} Natural
a -> CreateExportTask
s {$sel:from:CreateExportTask' :: Natural
from = Natural
a} :: CreateExportTask)

-- | The end time of the range for the request, expressed as the number of
-- milliseconds after @Jan 1, 1970 00:00:00 UTC@. Events with a timestamp
-- later than this time are not exported.
--
-- You must specify a time that is not earlier than when this log group was
-- created.
createExportTask_to :: Lens.Lens' CreateExportTask Prelude.Natural
createExportTask_to :: Lens' CreateExportTask Natural
createExportTask_to = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTask' {Natural
to :: Natural
$sel:to:CreateExportTask' :: CreateExportTask -> Natural
to} -> Natural
to) (\s :: CreateExportTask
s@CreateExportTask' {} Natural
a -> CreateExportTask
s {$sel:to:CreateExportTask' :: Natural
to = Natural
a} :: CreateExportTask)

-- | The name of S3 bucket for the exported log data. The bucket must be in
-- the same Amazon Web Services Region.
createExportTask_destination :: Lens.Lens' CreateExportTask Prelude.Text
createExportTask_destination :: Lens' CreateExportTask Text
createExportTask_destination = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTask' {Text
destination :: Text
$sel:destination:CreateExportTask' :: CreateExportTask -> Text
destination} -> Text
destination) (\s :: CreateExportTask
s@CreateExportTask' {} Text
a -> CreateExportTask
s {$sel:destination:CreateExportTask' :: Text
destination = Text
a} :: CreateExportTask)

instance Core.AWSRequest CreateExportTask where
  type
    AWSResponse CreateExportTask =
      CreateExportTaskResponse
  request :: (Service -> Service)
-> CreateExportTask -> Request CreateExportTask
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 CreateExportTask
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateExportTask)))
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 -> CreateExportTaskResponse
CreateExportTaskResponse'
            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
"taskId")
            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 CreateExportTask where
  hashWithSalt :: Int -> CreateExportTask -> Int
hashWithSalt Int
_salt CreateExportTask' {Natural
Maybe Text
Text
destination :: Text
to :: Natural
from :: Natural
logGroupName :: Text
taskName :: Maybe Text
logStreamNamePrefix :: Maybe Text
destinationPrefix :: Maybe Text
$sel:destination:CreateExportTask' :: CreateExportTask -> Text
$sel:to:CreateExportTask' :: CreateExportTask -> Natural
$sel:from:CreateExportTask' :: CreateExportTask -> Natural
$sel:logGroupName:CreateExportTask' :: CreateExportTask -> Text
$sel:taskName:CreateExportTask' :: CreateExportTask -> Maybe Text
$sel:logStreamNamePrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
$sel:destinationPrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
destinationPrefix
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
logStreamNamePrefix
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
taskName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
logGroupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Natural
from
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Natural
to
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
destination

instance Prelude.NFData CreateExportTask where
  rnf :: CreateExportTask -> ()
rnf CreateExportTask' {Natural
Maybe Text
Text
destination :: Text
to :: Natural
from :: Natural
logGroupName :: Text
taskName :: Maybe Text
logStreamNamePrefix :: Maybe Text
destinationPrefix :: Maybe Text
$sel:destination:CreateExportTask' :: CreateExportTask -> Text
$sel:to:CreateExportTask' :: CreateExportTask -> Natural
$sel:from:CreateExportTask' :: CreateExportTask -> Natural
$sel:logGroupName:CreateExportTask' :: CreateExportTask -> Text
$sel:taskName:CreateExportTask' :: CreateExportTask -> Maybe Text
$sel:logStreamNamePrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
$sel:destinationPrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
destinationPrefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
logStreamNamePrefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
taskName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
logGroupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Natural
from
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Natural
to
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
destination

instance Data.ToHeaders CreateExportTask where
  toHeaders :: CreateExportTask -> 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
"Logs_20140328.CreateExportTask" ::
                          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 CreateExportTask where
  toJSON :: CreateExportTask -> Value
toJSON CreateExportTask' {Natural
Maybe Text
Text
destination :: Text
to :: Natural
from :: Natural
logGroupName :: Text
taskName :: Maybe Text
logStreamNamePrefix :: Maybe Text
destinationPrefix :: Maybe Text
$sel:destination:CreateExportTask' :: CreateExportTask -> Text
$sel:to:CreateExportTask' :: CreateExportTask -> Natural
$sel:from:CreateExportTask' :: CreateExportTask -> Natural
$sel:logGroupName:CreateExportTask' :: CreateExportTask -> Text
$sel:taskName:CreateExportTask' :: CreateExportTask -> Maybe Text
$sel:logStreamNamePrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
$sel:destinationPrefix:CreateExportTask' :: CreateExportTask -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"destinationPrefix" 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
destinationPrefix,
            (Key
"logStreamNamePrefix" 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
logStreamNamePrefix,
            (Key
"taskName" 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
taskName,
            forall a. a -> Maybe a
Prelude.Just (Key
"logGroupName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
logGroupName),
            forall a. a -> Maybe a
Prelude.Just (Key
"from" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Natural
from),
            forall a. a -> Maybe a
Prelude.Just (Key
"to" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Natural
to),
            forall a. a -> Maybe a
Prelude.Just (Key
"destination" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
destination)
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateExportTaskResponse' 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:
--
-- 'taskId', 'createExportTaskResponse_taskId' - The ID of the export task.
--
-- 'httpStatus', 'createExportTaskResponse_httpStatus' - The response's http status code.
newCreateExportTaskResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateExportTaskResponse
newCreateExportTaskResponse :: Int -> CreateExportTaskResponse
newCreateExportTaskResponse Int
pHttpStatus_ =
  CreateExportTaskResponse'
    { $sel:taskId:CreateExportTaskResponse' :: Maybe Text
taskId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateExportTaskResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ID of the export task.
createExportTaskResponse_taskId :: Lens.Lens' CreateExportTaskResponse (Prelude.Maybe Prelude.Text)
createExportTaskResponse_taskId :: Lens' CreateExportTaskResponse (Maybe Text)
createExportTaskResponse_taskId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateExportTaskResponse' {Maybe Text
taskId :: Maybe Text
$sel:taskId:CreateExportTaskResponse' :: CreateExportTaskResponse -> Maybe Text
taskId} -> Maybe Text
taskId) (\s :: CreateExportTaskResponse
s@CreateExportTaskResponse' {} Maybe Text
a -> CreateExportTaskResponse
s {$sel:taskId:CreateExportTaskResponse' :: Maybe Text
taskId = Maybe Text
a} :: CreateExportTaskResponse)

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

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