{-# 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.StartContinuousExport
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Start the continuous flow of agent\'s discovered data into Amazon
-- Athena.
module Amazonka.Discovery.StartContinuousExport
  ( -- * Creating a Request
    StartContinuousExport (..),
    newStartContinuousExport,

    -- * Destructuring the Response
    StartContinuousExportResponse (..),
    newStartContinuousExportResponse,

    -- * Response Lenses
    startContinuousExportResponse_dataSource,
    startContinuousExportResponse_exportId,
    startContinuousExportResponse_s3Bucket,
    startContinuousExportResponse_schemaStorageConfig,
    startContinuousExportResponse_startTime,
    startContinuousExportResponse_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:/ 'newStartContinuousExport' smart constructor.
data StartContinuousExport = StartContinuousExport'
  {
  }
  deriving (StartContinuousExport -> StartContinuousExport -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartContinuousExport -> StartContinuousExport -> Bool
$c/= :: StartContinuousExport -> StartContinuousExport -> Bool
== :: StartContinuousExport -> StartContinuousExport -> Bool
$c== :: StartContinuousExport -> StartContinuousExport -> Bool
Prelude.Eq, ReadPrec [StartContinuousExport]
ReadPrec StartContinuousExport
Int -> ReadS StartContinuousExport
ReadS [StartContinuousExport]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartContinuousExport]
$creadListPrec :: ReadPrec [StartContinuousExport]
readPrec :: ReadPrec StartContinuousExport
$creadPrec :: ReadPrec StartContinuousExport
readList :: ReadS [StartContinuousExport]
$creadList :: ReadS [StartContinuousExport]
readsPrec :: Int -> ReadS StartContinuousExport
$creadsPrec :: Int -> ReadS StartContinuousExport
Prelude.Read, Int -> StartContinuousExport -> ShowS
[StartContinuousExport] -> ShowS
StartContinuousExport -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartContinuousExport] -> ShowS
$cshowList :: [StartContinuousExport] -> ShowS
show :: StartContinuousExport -> String
$cshow :: StartContinuousExport -> String
showsPrec :: Int -> StartContinuousExport -> ShowS
$cshowsPrec :: Int -> StartContinuousExport -> ShowS
Prelude.Show, forall x. Rep StartContinuousExport x -> StartContinuousExport
forall x. StartContinuousExport -> Rep StartContinuousExport x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StartContinuousExport x -> StartContinuousExport
$cfrom :: forall x. StartContinuousExport -> Rep StartContinuousExport x
Prelude.Generic)

-- |
-- Create a value of 'StartContinuousExport' 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.
newStartContinuousExport ::
  StartContinuousExport
newStartContinuousExport :: StartContinuousExport
newStartContinuousExport = StartContinuousExport
StartContinuousExport'

instance Core.AWSRequest StartContinuousExport where
  type
    AWSResponse StartContinuousExport =
      StartContinuousExportResponse
  request :: (Service -> Service)
-> StartContinuousExport -> Request StartContinuousExport
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 StartContinuousExport
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse StartContinuousExport)))
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 DataSource
-> Maybe Text
-> Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe POSIX
-> Int
-> StartContinuousExportResponse
StartContinuousExportResponse'
            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
"dataSource")
            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
"exportId")
            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
"s3Bucket")
            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
"schemaStorageConfig"
                            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
"startTime")
            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 StartContinuousExport where
  hashWithSalt :: Int -> StartContinuousExport -> Int
hashWithSalt Int
_salt StartContinuousExport
_ =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ()

instance Prelude.NFData StartContinuousExport where
  rnf :: StartContinuousExport -> ()
rnf StartContinuousExport
_ = ()

instance Data.ToHeaders StartContinuousExport where
  toHeaders :: StartContinuousExport -> 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.StartContinuousExport" ::
                          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 StartContinuousExport where
  toJSON :: StartContinuousExport -> Value
toJSON = forall a b. a -> b -> a
Prelude.const (Object -> Value
Data.Object forall a. Monoid a => a
Prelude.mempty)

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

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

-- | /See:/ 'newStartContinuousExportResponse' smart constructor.
data StartContinuousExportResponse = StartContinuousExportResponse'
  { -- | The type of data collector used to gather this data (currently only
    -- offered for AGENT).
    StartContinuousExportResponse -> Maybe DataSource
dataSource :: Prelude.Maybe DataSource,
    -- | The unique ID assigned to this export.
    StartContinuousExportResponse -> Maybe Text
exportId :: Prelude.Maybe Prelude.Text,
    -- | The name of the s3 bucket where the export data parquet files are
    -- stored.
    StartContinuousExportResponse -> Maybe Text
s3Bucket :: Prelude.Maybe Prelude.Text,
    -- | A dictionary which describes how the data is stored.
    --
    -- -   @databaseName@ - the name of the Glue database used to store the
    --     schema.
    StartContinuousExportResponse -> Maybe (HashMap Text Text)
schemaStorageConfig :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The timestamp representing when the continuous export was started.
    StartContinuousExportResponse -> Maybe POSIX
startTime :: Prelude.Maybe Data.POSIX,
    -- | The response's http status code.
    StartContinuousExportResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (StartContinuousExportResponse
-> StartContinuousExportResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StartContinuousExportResponse
-> StartContinuousExportResponse -> Bool
$c/= :: StartContinuousExportResponse
-> StartContinuousExportResponse -> Bool
== :: StartContinuousExportResponse
-> StartContinuousExportResponse -> Bool
$c== :: StartContinuousExportResponse
-> StartContinuousExportResponse -> Bool
Prelude.Eq, ReadPrec [StartContinuousExportResponse]
ReadPrec StartContinuousExportResponse
Int -> ReadS StartContinuousExportResponse
ReadS [StartContinuousExportResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StartContinuousExportResponse]
$creadListPrec :: ReadPrec [StartContinuousExportResponse]
readPrec :: ReadPrec StartContinuousExportResponse
$creadPrec :: ReadPrec StartContinuousExportResponse
readList :: ReadS [StartContinuousExportResponse]
$creadList :: ReadS [StartContinuousExportResponse]
readsPrec :: Int -> ReadS StartContinuousExportResponse
$creadsPrec :: Int -> ReadS StartContinuousExportResponse
Prelude.Read, Int -> StartContinuousExportResponse -> ShowS
[StartContinuousExportResponse] -> ShowS
StartContinuousExportResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StartContinuousExportResponse] -> ShowS
$cshowList :: [StartContinuousExportResponse] -> ShowS
show :: StartContinuousExportResponse -> String
$cshow :: StartContinuousExportResponse -> String
showsPrec :: Int -> StartContinuousExportResponse -> ShowS
$cshowsPrec :: Int -> StartContinuousExportResponse -> ShowS
Prelude.Show, forall x.
Rep StartContinuousExportResponse x
-> StartContinuousExportResponse
forall x.
StartContinuousExportResponse
-> Rep StartContinuousExportResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep StartContinuousExportResponse x
-> StartContinuousExportResponse
$cfrom :: forall x.
StartContinuousExportResponse
-> Rep StartContinuousExportResponse x
Prelude.Generic)

-- |
-- Create a value of 'StartContinuousExportResponse' 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:
--
-- 'dataSource', 'startContinuousExportResponse_dataSource' - The type of data collector used to gather this data (currently only
-- offered for AGENT).
--
-- 'exportId', 'startContinuousExportResponse_exportId' - The unique ID assigned to this export.
--
-- 's3Bucket', 'startContinuousExportResponse_s3Bucket' - The name of the s3 bucket where the export data parquet files are
-- stored.
--
-- 'schemaStorageConfig', 'startContinuousExportResponse_schemaStorageConfig' - A dictionary which describes how the data is stored.
--
-- -   @databaseName@ - the name of the Glue database used to store the
--     schema.
--
-- 'startTime', 'startContinuousExportResponse_startTime' - The timestamp representing when the continuous export was started.
--
-- 'httpStatus', 'startContinuousExportResponse_httpStatus' - The response's http status code.
newStartContinuousExportResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  StartContinuousExportResponse
newStartContinuousExportResponse :: Int -> StartContinuousExportResponse
newStartContinuousExportResponse Int
pHttpStatus_ =
  StartContinuousExportResponse'
    { $sel:dataSource:StartContinuousExportResponse' :: Maybe DataSource
dataSource =
        forall a. Maybe a
Prelude.Nothing,
      $sel:exportId:StartContinuousExportResponse' :: Maybe Text
exportId = forall a. Maybe a
Prelude.Nothing,
      $sel:s3Bucket:StartContinuousExportResponse' :: Maybe Text
s3Bucket = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaStorageConfig:StartContinuousExportResponse' :: Maybe (HashMap Text Text)
schemaStorageConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:startTime:StartContinuousExportResponse' :: Maybe POSIX
startTime = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:StartContinuousExportResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The type of data collector used to gather this data (currently only
-- offered for AGENT).
startContinuousExportResponse_dataSource :: Lens.Lens' StartContinuousExportResponse (Prelude.Maybe DataSource)
startContinuousExportResponse_dataSource :: Lens' StartContinuousExportResponse (Maybe DataSource)
startContinuousExportResponse_dataSource = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartContinuousExportResponse' {Maybe DataSource
dataSource :: Maybe DataSource
$sel:dataSource:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe DataSource
dataSource} -> Maybe DataSource
dataSource) (\s :: StartContinuousExportResponse
s@StartContinuousExportResponse' {} Maybe DataSource
a -> StartContinuousExportResponse
s {$sel:dataSource:StartContinuousExportResponse' :: Maybe DataSource
dataSource = Maybe DataSource
a} :: StartContinuousExportResponse)

-- | The unique ID assigned to this export.
startContinuousExportResponse_exportId :: Lens.Lens' StartContinuousExportResponse (Prelude.Maybe Prelude.Text)
startContinuousExportResponse_exportId :: Lens' StartContinuousExportResponse (Maybe Text)
startContinuousExportResponse_exportId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartContinuousExportResponse' {Maybe Text
exportId :: Maybe Text
$sel:exportId:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe Text
exportId} -> Maybe Text
exportId) (\s :: StartContinuousExportResponse
s@StartContinuousExportResponse' {} Maybe Text
a -> StartContinuousExportResponse
s {$sel:exportId:StartContinuousExportResponse' :: Maybe Text
exportId = Maybe Text
a} :: StartContinuousExportResponse)

-- | The name of the s3 bucket where the export data parquet files are
-- stored.
startContinuousExportResponse_s3Bucket :: Lens.Lens' StartContinuousExportResponse (Prelude.Maybe Prelude.Text)
startContinuousExportResponse_s3Bucket :: Lens' StartContinuousExportResponse (Maybe Text)
startContinuousExportResponse_s3Bucket = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartContinuousExportResponse' {Maybe Text
s3Bucket :: Maybe Text
$sel:s3Bucket:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe Text
s3Bucket} -> Maybe Text
s3Bucket) (\s :: StartContinuousExportResponse
s@StartContinuousExportResponse' {} Maybe Text
a -> StartContinuousExportResponse
s {$sel:s3Bucket:StartContinuousExportResponse' :: Maybe Text
s3Bucket = Maybe Text
a} :: StartContinuousExportResponse)

-- | A dictionary which describes how the data is stored.
--
-- -   @databaseName@ - the name of the Glue database used to store the
--     schema.
startContinuousExportResponse_schemaStorageConfig :: Lens.Lens' StartContinuousExportResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
startContinuousExportResponse_schemaStorageConfig :: Lens' StartContinuousExportResponse (Maybe (HashMap Text Text))
startContinuousExportResponse_schemaStorageConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartContinuousExportResponse' {Maybe (HashMap Text Text)
schemaStorageConfig :: Maybe (HashMap Text Text)
$sel:schemaStorageConfig:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe (HashMap Text Text)
schemaStorageConfig} -> Maybe (HashMap Text Text)
schemaStorageConfig) (\s :: StartContinuousExportResponse
s@StartContinuousExportResponse' {} Maybe (HashMap Text Text)
a -> StartContinuousExportResponse
s {$sel:schemaStorageConfig:StartContinuousExportResponse' :: Maybe (HashMap Text Text)
schemaStorageConfig = Maybe (HashMap Text Text)
a} :: StartContinuousExportResponse) 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 timestamp representing when the continuous export was started.
startContinuousExportResponse_startTime :: Lens.Lens' StartContinuousExportResponse (Prelude.Maybe Prelude.UTCTime)
startContinuousExportResponse_startTime :: Lens' StartContinuousExportResponse (Maybe UTCTime)
startContinuousExportResponse_startTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartContinuousExportResponse' {Maybe POSIX
startTime :: Maybe POSIX
$sel:startTime:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe POSIX
startTime} -> Maybe POSIX
startTime) (\s :: StartContinuousExportResponse
s@StartContinuousExportResponse' {} Maybe POSIX
a -> StartContinuousExportResponse
s {$sel:startTime:StartContinuousExportResponse' :: Maybe POSIX
startTime = Maybe POSIX
a} :: StartContinuousExportResponse) 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 response's http status code.
startContinuousExportResponse_httpStatus :: Lens.Lens' StartContinuousExportResponse Prelude.Int
startContinuousExportResponse_httpStatus :: Lens' StartContinuousExportResponse Int
startContinuousExportResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StartContinuousExportResponse' {Int
httpStatus :: Int
$sel:httpStatus:StartContinuousExportResponse' :: StartContinuousExportResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: StartContinuousExportResponse
s@StartContinuousExportResponse' {} Int
a -> StartContinuousExportResponse
s {$sel:httpStatus:StartContinuousExportResponse' :: Int
httpStatus = Int
a} :: StartContinuousExportResponse)

instance Prelude.NFData StartContinuousExportResponse where
  rnf :: StartContinuousExportResponse -> ()
rnf StartContinuousExportResponse' {Int
Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe DataSource
httpStatus :: Int
startTime :: Maybe POSIX
schemaStorageConfig :: Maybe (HashMap Text Text)
s3Bucket :: Maybe Text
exportId :: Maybe Text
dataSource :: Maybe DataSource
$sel:httpStatus:StartContinuousExportResponse' :: StartContinuousExportResponse -> Int
$sel:startTime:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe POSIX
$sel:schemaStorageConfig:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe (HashMap Text Text)
$sel:s3Bucket:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe Text
$sel:exportId:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe Text
$sel:dataSource:StartContinuousExportResponse' :: StartContinuousExportResponse -> Maybe DataSource
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe DataSource
dataSource
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 Maybe Text
s3Bucket
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
schemaStorageConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
startTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus