{-# 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.GuardDuty.CreateDetector
-- 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 a single Amazon GuardDuty detector. A detector is a resource
-- that represents the GuardDuty service. To start using GuardDuty, you
-- must create a detector in each Region where you enable the service. You
-- can have only one detector per account per Region. All data sources are
-- enabled in a new detector by default.
module Amazonka.GuardDuty.CreateDetector
  ( -- * Creating a Request
    CreateDetector (..),
    newCreateDetector,

    -- * Request Lenses
    createDetector_clientToken,
    createDetector_dataSources,
    createDetector_findingPublishingFrequency,
    createDetector_tags,
    createDetector_enable,

    -- * Destructuring the Response
    CreateDetectorResponse (..),
    newCreateDetectorResponse,

    -- * Response Lenses
    createDetectorResponse_detectorId,
    createDetectorResponse_unprocessedDataSources,
    createDetectorResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateDetector' smart constructor.
data CreateDetector = CreateDetector'
  { -- | The idempotency token for the create request.
    CreateDetector -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | Describes which data sources will be enabled for the detector.
    CreateDetector -> Maybe DataSourceConfigurations
dataSources :: Prelude.Maybe DataSourceConfigurations,
    -- | A value that specifies how frequently updated findings are exported.
    CreateDetector -> Maybe FindingPublishingFrequency
findingPublishingFrequency :: Prelude.Maybe FindingPublishingFrequency,
    -- | The tags to be added to a new detector resource.
    CreateDetector -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | A Boolean value that specifies whether the detector is to be enabled.
    CreateDetector -> Bool
enable :: Prelude.Bool
  }
  deriving (CreateDetector -> CreateDetector -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDetector -> CreateDetector -> Bool
$c/= :: CreateDetector -> CreateDetector -> Bool
== :: CreateDetector -> CreateDetector -> Bool
$c== :: CreateDetector -> CreateDetector -> Bool
Prelude.Eq, ReadPrec [CreateDetector]
ReadPrec CreateDetector
Int -> ReadS CreateDetector
ReadS [CreateDetector]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDetector]
$creadListPrec :: ReadPrec [CreateDetector]
readPrec :: ReadPrec CreateDetector
$creadPrec :: ReadPrec CreateDetector
readList :: ReadS [CreateDetector]
$creadList :: ReadS [CreateDetector]
readsPrec :: Int -> ReadS CreateDetector
$creadsPrec :: Int -> ReadS CreateDetector
Prelude.Read, Int -> CreateDetector -> ShowS
[CreateDetector] -> ShowS
CreateDetector -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDetector] -> ShowS
$cshowList :: [CreateDetector] -> ShowS
show :: CreateDetector -> String
$cshow :: CreateDetector -> String
showsPrec :: Int -> CreateDetector -> ShowS
$cshowsPrec :: Int -> CreateDetector -> ShowS
Prelude.Show, forall x. Rep CreateDetector x -> CreateDetector
forall x. CreateDetector -> Rep CreateDetector x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDetector x -> CreateDetector
$cfrom :: forall x. CreateDetector -> Rep CreateDetector x
Prelude.Generic)

-- |
-- Create a value of 'CreateDetector' 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:
--
-- 'clientToken', 'createDetector_clientToken' - The idempotency token for the create request.
--
-- 'dataSources', 'createDetector_dataSources' - Describes which data sources will be enabled for the detector.
--
-- 'findingPublishingFrequency', 'createDetector_findingPublishingFrequency' - A value that specifies how frequently updated findings are exported.
--
-- 'tags', 'createDetector_tags' - The tags to be added to a new detector resource.
--
-- 'enable', 'createDetector_enable' - A Boolean value that specifies whether the detector is to be enabled.
newCreateDetector ::
  -- | 'enable'
  Prelude.Bool ->
  CreateDetector
newCreateDetector :: Bool -> CreateDetector
newCreateDetector Bool
pEnable_ =
  CreateDetector'
    { $sel:clientToken:CreateDetector' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:dataSources:CreateDetector' :: Maybe DataSourceConfigurations
dataSources = forall a. Maybe a
Prelude.Nothing,
      $sel:findingPublishingFrequency:CreateDetector' :: Maybe FindingPublishingFrequency
findingPublishingFrequency = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateDetector' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:enable:CreateDetector' :: Bool
enable = Bool
pEnable_
    }

-- | The idempotency token for the create request.
createDetector_clientToken :: Lens.Lens' CreateDetector (Prelude.Maybe Prelude.Text)
createDetector_clientToken :: Lens' CreateDetector (Maybe Text)
createDetector_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetector' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateDetector' :: CreateDetector -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateDetector
s@CreateDetector' {} Maybe Text
a -> CreateDetector
s {$sel:clientToken:CreateDetector' :: Maybe Text
clientToken = Maybe Text
a} :: CreateDetector)

-- | Describes which data sources will be enabled for the detector.
createDetector_dataSources :: Lens.Lens' CreateDetector (Prelude.Maybe DataSourceConfigurations)
createDetector_dataSources :: Lens' CreateDetector (Maybe DataSourceConfigurations)
createDetector_dataSources = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetector' {Maybe DataSourceConfigurations
dataSources :: Maybe DataSourceConfigurations
$sel:dataSources:CreateDetector' :: CreateDetector -> Maybe DataSourceConfigurations
dataSources} -> Maybe DataSourceConfigurations
dataSources) (\s :: CreateDetector
s@CreateDetector' {} Maybe DataSourceConfigurations
a -> CreateDetector
s {$sel:dataSources:CreateDetector' :: Maybe DataSourceConfigurations
dataSources = Maybe DataSourceConfigurations
a} :: CreateDetector)

-- | A value that specifies how frequently updated findings are exported.
createDetector_findingPublishingFrequency :: Lens.Lens' CreateDetector (Prelude.Maybe FindingPublishingFrequency)
createDetector_findingPublishingFrequency :: Lens' CreateDetector (Maybe FindingPublishingFrequency)
createDetector_findingPublishingFrequency = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetector' {Maybe FindingPublishingFrequency
findingPublishingFrequency :: Maybe FindingPublishingFrequency
$sel:findingPublishingFrequency:CreateDetector' :: CreateDetector -> Maybe FindingPublishingFrequency
findingPublishingFrequency} -> Maybe FindingPublishingFrequency
findingPublishingFrequency) (\s :: CreateDetector
s@CreateDetector' {} Maybe FindingPublishingFrequency
a -> CreateDetector
s {$sel:findingPublishingFrequency:CreateDetector' :: Maybe FindingPublishingFrequency
findingPublishingFrequency = Maybe FindingPublishingFrequency
a} :: CreateDetector)

-- | The tags to be added to a new detector resource.
createDetector_tags :: Lens.Lens' CreateDetector (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
createDetector_tags :: Lens' CreateDetector (Maybe (HashMap Text Text))
createDetector_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetector' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:CreateDetector' :: CreateDetector -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: CreateDetector
s@CreateDetector' {} Maybe (HashMap Text Text)
a -> CreateDetector
s {$sel:tags:CreateDetector' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: CreateDetector) 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 Boolean value that specifies whether the detector is to be enabled.
createDetector_enable :: Lens.Lens' CreateDetector Prelude.Bool
createDetector_enable :: Lens' CreateDetector Bool
createDetector_enable = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetector' {Bool
enable :: Bool
$sel:enable:CreateDetector' :: CreateDetector -> Bool
enable} -> Bool
enable) (\s :: CreateDetector
s@CreateDetector' {} Bool
a -> CreateDetector
s {$sel:enable:CreateDetector' :: Bool
enable = Bool
a} :: CreateDetector)

instance Core.AWSRequest CreateDetector where
  type
    AWSResponse CreateDetector =
      CreateDetectorResponse
  request :: (Service -> Service) -> CreateDetector -> Request CreateDetector
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 CreateDetector
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateDetector)))
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 UnprocessedDataSourcesResult
-> Int
-> CreateDetectorResponse
CreateDetectorResponse'
            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
"detectorId")
            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
"unprocessedDataSources")
            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 CreateDetector where
  hashWithSalt :: Int -> CreateDetector -> Int
hashWithSalt Int
_salt CreateDetector' {Bool
Maybe Text
Maybe (HashMap Text Text)
Maybe FindingPublishingFrequency
Maybe DataSourceConfigurations
enable :: Bool
tags :: Maybe (HashMap Text Text)
findingPublishingFrequency :: Maybe FindingPublishingFrequency
dataSources :: Maybe DataSourceConfigurations
clientToken :: Maybe Text
$sel:enable:CreateDetector' :: CreateDetector -> Bool
$sel:tags:CreateDetector' :: CreateDetector -> Maybe (HashMap Text Text)
$sel:findingPublishingFrequency:CreateDetector' :: CreateDetector -> Maybe FindingPublishingFrequency
$sel:dataSources:CreateDetector' :: CreateDetector -> Maybe DataSourceConfigurations
$sel:clientToken:CreateDetector' :: CreateDetector -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DataSourceConfigurations
dataSources
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FindingPublishingFrequency
findingPublishingFrequency
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Bool
enable

instance Prelude.NFData CreateDetector where
  rnf :: CreateDetector -> ()
rnf CreateDetector' {Bool
Maybe Text
Maybe (HashMap Text Text)
Maybe FindingPublishingFrequency
Maybe DataSourceConfigurations
enable :: Bool
tags :: Maybe (HashMap Text Text)
findingPublishingFrequency :: Maybe FindingPublishingFrequency
dataSources :: Maybe DataSourceConfigurations
clientToken :: Maybe Text
$sel:enable:CreateDetector' :: CreateDetector -> Bool
$sel:tags:CreateDetector' :: CreateDetector -> Maybe (HashMap Text Text)
$sel:findingPublishingFrequency:CreateDetector' :: CreateDetector -> Maybe FindingPublishingFrequency
$sel:dataSources:CreateDetector' :: CreateDetector -> Maybe DataSourceConfigurations
$sel:clientToken:CreateDetector' :: CreateDetector -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DataSourceConfigurations
dataSources
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FindingPublishingFrequency
findingPublishingFrequency
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Bool
enable

instance Data.ToHeaders CreateDetector where
  toHeaders :: CreateDetector -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateDetector where
  toJSON :: CreateDetector -> Value
toJSON CreateDetector' {Bool
Maybe Text
Maybe (HashMap Text Text)
Maybe FindingPublishingFrequency
Maybe DataSourceConfigurations
enable :: Bool
tags :: Maybe (HashMap Text Text)
findingPublishingFrequency :: Maybe FindingPublishingFrequency
dataSources :: Maybe DataSourceConfigurations
clientToken :: Maybe Text
$sel:enable:CreateDetector' :: CreateDetector -> Bool
$sel:tags:CreateDetector' :: CreateDetector -> Maybe (HashMap Text Text)
$sel:findingPublishingFrequency:CreateDetector' :: CreateDetector -> Maybe FindingPublishingFrequency
$sel:dataSources:CreateDetector' :: CreateDetector -> Maybe DataSourceConfigurations
$sel:clientToken:CreateDetector' :: CreateDetector -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"clientToken" 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
clientToken,
            (Key
"dataSources" 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 DataSourceConfigurations
dataSources,
            (Key
"findingPublishingFrequency" 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 FindingPublishingFrequency
findingPublishingFrequency,
            (Key
"tags" 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 (HashMap Text Text)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"enable" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Bool
enable)
          ]
      )

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

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

-- | /See:/ 'newCreateDetectorResponse' smart constructor.
data CreateDetectorResponse = CreateDetectorResponse'
  { -- | The unique ID of the created detector.
    CreateDetectorResponse -> Maybe Text
detectorId :: Prelude.Maybe Prelude.Text,
    -- | Specifies the data sources that couldn\'t be enabled when GuardDuty was
    -- enabled for the first time.
    CreateDetectorResponse -> Maybe UnprocessedDataSourcesResult
unprocessedDataSources :: Prelude.Maybe UnprocessedDataSourcesResult,
    -- | The response's http status code.
    CreateDetectorResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateDetectorResponse -> CreateDetectorResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDetectorResponse -> CreateDetectorResponse -> Bool
$c/= :: CreateDetectorResponse -> CreateDetectorResponse -> Bool
== :: CreateDetectorResponse -> CreateDetectorResponse -> Bool
$c== :: CreateDetectorResponse -> CreateDetectorResponse -> Bool
Prelude.Eq, ReadPrec [CreateDetectorResponse]
ReadPrec CreateDetectorResponse
Int -> ReadS CreateDetectorResponse
ReadS [CreateDetectorResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDetectorResponse]
$creadListPrec :: ReadPrec [CreateDetectorResponse]
readPrec :: ReadPrec CreateDetectorResponse
$creadPrec :: ReadPrec CreateDetectorResponse
readList :: ReadS [CreateDetectorResponse]
$creadList :: ReadS [CreateDetectorResponse]
readsPrec :: Int -> ReadS CreateDetectorResponse
$creadsPrec :: Int -> ReadS CreateDetectorResponse
Prelude.Read, Int -> CreateDetectorResponse -> ShowS
[CreateDetectorResponse] -> ShowS
CreateDetectorResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDetectorResponse] -> ShowS
$cshowList :: [CreateDetectorResponse] -> ShowS
show :: CreateDetectorResponse -> String
$cshow :: CreateDetectorResponse -> String
showsPrec :: Int -> CreateDetectorResponse -> ShowS
$cshowsPrec :: Int -> CreateDetectorResponse -> ShowS
Prelude.Show, forall x. Rep CreateDetectorResponse x -> CreateDetectorResponse
forall x. CreateDetectorResponse -> Rep CreateDetectorResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDetectorResponse x -> CreateDetectorResponse
$cfrom :: forall x. CreateDetectorResponse -> Rep CreateDetectorResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateDetectorResponse' 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:
--
-- 'detectorId', 'createDetectorResponse_detectorId' - The unique ID of the created detector.
--
-- 'unprocessedDataSources', 'createDetectorResponse_unprocessedDataSources' - Specifies the data sources that couldn\'t be enabled when GuardDuty was
-- enabled for the first time.
--
-- 'httpStatus', 'createDetectorResponse_httpStatus' - The response's http status code.
newCreateDetectorResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateDetectorResponse
newCreateDetectorResponse :: Int -> CreateDetectorResponse
newCreateDetectorResponse Int
pHttpStatus_ =
  CreateDetectorResponse'
    { $sel:detectorId:CreateDetectorResponse' :: Maybe Text
detectorId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:unprocessedDataSources:CreateDetectorResponse' :: Maybe UnprocessedDataSourcesResult
unprocessedDataSources = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateDetectorResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The unique ID of the created detector.
createDetectorResponse_detectorId :: Lens.Lens' CreateDetectorResponse (Prelude.Maybe Prelude.Text)
createDetectorResponse_detectorId :: Lens' CreateDetectorResponse (Maybe Text)
createDetectorResponse_detectorId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorResponse' {Maybe Text
detectorId :: Maybe Text
$sel:detectorId:CreateDetectorResponse' :: CreateDetectorResponse -> Maybe Text
detectorId} -> Maybe Text
detectorId) (\s :: CreateDetectorResponse
s@CreateDetectorResponse' {} Maybe Text
a -> CreateDetectorResponse
s {$sel:detectorId:CreateDetectorResponse' :: Maybe Text
detectorId = Maybe Text
a} :: CreateDetectorResponse)

-- | Specifies the data sources that couldn\'t be enabled when GuardDuty was
-- enabled for the first time.
createDetectorResponse_unprocessedDataSources :: Lens.Lens' CreateDetectorResponse (Prelude.Maybe UnprocessedDataSourcesResult)
createDetectorResponse_unprocessedDataSources :: Lens' CreateDetectorResponse (Maybe UnprocessedDataSourcesResult)
createDetectorResponse_unprocessedDataSources = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDetectorResponse' {Maybe UnprocessedDataSourcesResult
unprocessedDataSources :: Maybe UnprocessedDataSourcesResult
$sel:unprocessedDataSources:CreateDetectorResponse' :: CreateDetectorResponse -> Maybe UnprocessedDataSourcesResult
unprocessedDataSources} -> Maybe UnprocessedDataSourcesResult
unprocessedDataSources) (\s :: CreateDetectorResponse
s@CreateDetectorResponse' {} Maybe UnprocessedDataSourcesResult
a -> CreateDetectorResponse
s {$sel:unprocessedDataSources:CreateDetectorResponse' :: Maybe UnprocessedDataSourcesResult
unprocessedDataSources = Maybe UnprocessedDataSourcesResult
a} :: CreateDetectorResponse)

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

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