{-# 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.Route53Resolver.CreateResolverQueryLogConfig
-- 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 Resolver query logging configuration, which defines where you
-- want Resolver to save DNS query logs that originate in your VPCs.
-- Resolver can log queries only for VPCs that are in the same Region as
-- the query logging configuration.
--
-- To specify which VPCs you want to log queries for, you use
-- @AssociateResolverQueryLogConfig@. For more information, see
-- <https://docs.aws.amazon.com/Route53/latest/APIReference/API_route53resolver_AssociateResolverQueryLogConfig.html AssociateResolverQueryLogConfig>.
--
-- You can optionally use Resource Access Manager (RAM) to share a query
-- logging configuration with other Amazon Web Services accounts. The other
-- accounts can then associate VPCs with the configuration. The query logs
-- that Resolver creates for a configuration include all DNS queries that
-- originate in all VPCs that are associated with the configuration.
module Amazonka.Route53Resolver.CreateResolverQueryLogConfig
  ( -- * Creating a Request
    CreateResolverQueryLogConfig (..),
    newCreateResolverQueryLogConfig,

    -- * Request Lenses
    createResolverQueryLogConfig_tags,
    createResolverQueryLogConfig_name,
    createResolverQueryLogConfig_destinationArn,
    createResolverQueryLogConfig_creatorRequestId,

    -- * Destructuring the Response
    CreateResolverQueryLogConfigResponse (..),
    newCreateResolverQueryLogConfigResponse,

    -- * Response Lenses
    createResolverQueryLogConfigResponse_resolverQueryLogConfig,
    createResolverQueryLogConfigResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateResolverQueryLogConfig' smart constructor.
data CreateResolverQueryLogConfig = CreateResolverQueryLogConfig'
  { -- | A list of the tag keys and values that you want to associate with the
    -- query logging configuration.
    CreateResolverQueryLogConfig -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name that you want to give the query logging configuration.
    CreateResolverQueryLogConfig -> Text
name :: Prelude.Text,
    -- | The ARN of the resource that you want Resolver to send query logs. You
    -- can send query logs to an S3 bucket, a CloudWatch Logs log group, or a
    -- Kinesis Data Firehose delivery stream. Examples of valid values include
    -- the following:
    --
    -- -   __S3 bucket__:
    --
    --     @arn:aws:s3:::examplebucket@
    --
    --     You can optionally append a file prefix to the end of the ARN.
    --
    --     @arn:aws:s3:::examplebucket\/development\/@
    --
    -- -   __CloudWatch Logs log group__:
    --
    --     @arn:aws:logs:us-west-1:123456789012:log-group:\/mystack-testgroup-12ABC1AB12A1:*@
    --
    -- -   __Kinesis Data Firehose delivery stream__:
    --
    --     @arn:aws:kinesis:us-east-2:0123456789:stream\/my_stream_name@
    CreateResolverQueryLogConfig -> Text
destinationArn :: Prelude.Text,
    -- | A unique string that identifies the request and that allows failed
    -- requests to be retried without the risk of running the operation twice.
    -- @CreatorRequestId@ can be any unique string, for example, a date\/time
    -- stamp.
    CreateResolverQueryLogConfig -> Text
creatorRequestId :: Prelude.Text
  }
  deriving (CreateResolverQueryLogConfig
-> CreateResolverQueryLogConfig -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResolverQueryLogConfig
-> CreateResolverQueryLogConfig -> Bool
$c/= :: CreateResolverQueryLogConfig
-> CreateResolverQueryLogConfig -> Bool
== :: CreateResolverQueryLogConfig
-> CreateResolverQueryLogConfig -> Bool
$c== :: CreateResolverQueryLogConfig
-> CreateResolverQueryLogConfig -> Bool
Prelude.Eq, ReadPrec [CreateResolverQueryLogConfig]
ReadPrec CreateResolverQueryLogConfig
Int -> ReadS CreateResolverQueryLogConfig
ReadS [CreateResolverQueryLogConfig]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResolverQueryLogConfig]
$creadListPrec :: ReadPrec [CreateResolverQueryLogConfig]
readPrec :: ReadPrec CreateResolverQueryLogConfig
$creadPrec :: ReadPrec CreateResolverQueryLogConfig
readList :: ReadS [CreateResolverQueryLogConfig]
$creadList :: ReadS [CreateResolverQueryLogConfig]
readsPrec :: Int -> ReadS CreateResolverQueryLogConfig
$creadsPrec :: Int -> ReadS CreateResolverQueryLogConfig
Prelude.Read, Int -> CreateResolverQueryLogConfig -> ShowS
[CreateResolverQueryLogConfig] -> ShowS
CreateResolverQueryLogConfig -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResolverQueryLogConfig] -> ShowS
$cshowList :: [CreateResolverQueryLogConfig] -> ShowS
show :: CreateResolverQueryLogConfig -> String
$cshow :: CreateResolverQueryLogConfig -> String
showsPrec :: Int -> CreateResolverQueryLogConfig -> ShowS
$cshowsPrec :: Int -> CreateResolverQueryLogConfig -> ShowS
Prelude.Show, forall x.
Rep CreateResolverQueryLogConfig x -> CreateResolverQueryLogConfig
forall x.
CreateResolverQueryLogConfig -> Rep CreateResolverQueryLogConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateResolverQueryLogConfig x -> CreateResolverQueryLogConfig
$cfrom :: forall x.
CreateResolverQueryLogConfig -> Rep CreateResolverQueryLogConfig x
Prelude.Generic)

-- |
-- Create a value of 'CreateResolverQueryLogConfig' 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:
--
-- 'tags', 'createResolverQueryLogConfig_tags' - A list of the tag keys and values that you want to associate with the
-- query logging configuration.
--
-- 'name', 'createResolverQueryLogConfig_name' - The name that you want to give the query logging configuration.
--
-- 'destinationArn', 'createResolverQueryLogConfig_destinationArn' - The ARN of the resource that you want Resolver to send query logs. You
-- can send query logs to an S3 bucket, a CloudWatch Logs log group, or a
-- Kinesis Data Firehose delivery stream. Examples of valid values include
-- the following:
--
-- -   __S3 bucket__:
--
--     @arn:aws:s3:::examplebucket@
--
--     You can optionally append a file prefix to the end of the ARN.
--
--     @arn:aws:s3:::examplebucket\/development\/@
--
-- -   __CloudWatch Logs log group__:
--
--     @arn:aws:logs:us-west-1:123456789012:log-group:\/mystack-testgroup-12ABC1AB12A1:*@
--
-- -   __Kinesis Data Firehose delivery stream__:
--
--     @arn:aws:kinesis:us-east-2:0123456789:stream\/my_stream_name@
--
-- 'creatorRequestId', 'createResolverQueryLogConfig_creatorRequestId' - A unique string that identifies the request and that allows failed
-- requests to be retried without the risk of running the operation twice.
-- @CreatorRequestId@ can be any unique string, for example, a date\/time
-- stamp.
newCreateResolverQueryLogConfig ::
  -- | 'name'
  Prelude.Text ->
  -- | 'destinationArn'
  Prelude.Text ->
  -- | 'creatorRequestId'
  Prelude.Text ->
  CreateResolverQueryLogConfig
newCreateResolverQueryLogConfig :: Text -> Text -> Text -> CreateResolverQueryLogConfig
newCreateResolverQueryLogConfig
  Text
pName_
  Text
pDestinationArn_
  Text
pCreatorRequestId_ =
    CreateResolverQueryLogConfig'
      { $sel:tags:CreateResolverQueryLogConfig' :: Maybe [Tag]
tags =
          forall a. Maybe a
Prelude.Nothing,
        $sel:name:CreateResolverQueryLogConfig' :: Text
name = Text
pName_,
        $sel:destinationArn:CreateResolverQueryLogConfig' :: Text
destinationArn = Text
pDestinationArn_,
        $sel:creatorRequestId:CreateResolverQueryLogConfig' :: Text
creatorRequestId = Text
pCreatorRequestId_
      }

-- | A list of the tag keys and values that you want to associate with the
-- query logging configuration.
createResolverQueryLogConfig_tags :: Lens.Lens' CreateResolverQueryLogConfig (Prelude.Maybe [Tag])
createResolverQueryLogConfig_tags :: Lens' CreateResolverQueryLogConfig (Maybe [Tag])
createResolverQueryLogConfig_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverQueryLogConfig' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateResolverQueryLogConfig
s@CreateResolverQueryLogConfig' {} Maybe [Tag]
a -> CreateResolverQueryLogConfig
s {$sel:tags:CreateResolverQueryLogConfig' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateResolverQueryLogConfig) 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 name that you want to give the query logging configuration.
createResolverQueryLogConfig_name :: Lens.Lens' CreateResolverQueryLogConfig Prelude.Text
createResolverQueryLogConfig_name :: Lens' CreateResolverQueryLogConfig Text
createResolverQueryLogConfig_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverQueryLogConfig' {Text
name :: Text
$sel:name:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
name} -> Text
name) (\s :: CreateResolverQueryLogConfig
s@CreateResolverQueryLogConfig' {} Text
a -> CreateResolverQueryLogConfig
s {$sel:name:CreateResolverQueryLogConfig' :: Text
name = Text
a} :: CreateResolverQueryLogConfig)

-- | The ARN of the resource that you want Resolver to send query logs. You
-- can send query logs to an S3 bucket, a CloudWatch Logs log group, or a
-- Kinesis Data Firehose delivery stream. Examples of valid values include
-- the following:
--
-- -   __S3 bucket__:
--
--     @arn:aws:s3:::examplebucket@
--
--     You can optionally append a file prefix to the end of the ARN.
--
--     @arn:aws:s3:::examplebucket\/development\/@
--
-- -   __CloudWatch Logs log group__:
--
--     @arn:aws:logs:us-west-1:123456789012:log-group:\/mystack-testgroup-12ABC1AB12A1:*@
--
-- -   __Kinesis Data Firehose delivery stream__:
--
--     @arn:aws:kinesis:us-east-2:0123456789:stream\/my_stream_name@
createResolverQueryLogConfig_destinationArn :: Lens.Lens' CreateResolverQueryLogConfig Prelude.Text
createResolverQueryLogConfig_destinationArn :: Lens' CreateResolverQueryLogConfig Text
createResolverQueryLogConfig_destinationArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverQueryLogConfig' {Text
destinationArn :: Text
$sel:destinationArn:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
destinationArn} -> Text
destinationArn) (\s :: CreateResolverQueryLogConfig
s@CreateResolverQueryLogConfig' {} Text
a -> CreateResolverQueryLogConfig
s {$sel:destinationArn:CreateResolverQueryLogConfig' :: Text
destinationArn = Text
a} :: CreateResolverQueryLogConfig)

-- | A unique string that identifies the request and that allows failed
-- requests to be retried without the risk of running the operation twice.
-- @CreatorRequestId@ can be any unique string, for example, a date\/time
-- stamp.
createResolverQueryLogConfig_creatorRequestId :: Lens.Lens' CreateResolverQueryLogConfig Prelude.Text
createResolverQueryLogConfig_creatorRequestId :: Lens' CreateResolverQueryLogConfig Text
createResolverQueryLogConfig_creatorRequestId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverQueryLogConfig' {Text
creatorRequestId :: Text
$sel:creatorRequestId:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
creatorRequestId} -> Text
creatorRequestId) (\s :: CreateResolverQueryLogConfig
s@CreateResolverQueryLogConfig' {} Text
a -> CreateResolverQueryLogConfig
s {$sel:creatorRequestId:CreateResolverQueryLogConfig' :: Text
creatorRequestId = Text
a} :: CreateResolverQueryLogConfig)

instance Core.AWSRequest CreateResolverQueryLogConfig where
  type
    AWSResponse CreateResolverQueryLogConfig =
      CreateResolverQueryLogConfigResponse
  request :: (Service -> Service)
-> CreateResolverQueryLogConfig
-> Request CreateResolverQueryLogConfig
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 CreateResolverQueryLogConfig
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateResolverQueryLogConfig)))
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 ResolverQueryLogConfig
-> Int -> CreateResolverQueryLogConfigResponse
CreateResolverQueryLogConfigResponse'
            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
"ResolverQueryLogConfig")
            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
    CreateResolverQueryLogConfig
  where
  hashWithSalt :: Int -> CreateResolverQueryLogConfig -> Int
hashWithSalt Int
_salt CreateResolverQueryLogConfig' {Maybe [Tag]
Text
creatorRequestId :: Text
destinationArn :: Text
name :: Text
tags :: Maybe [Tag]
$sel:creatorRequestId:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:destinationArn:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:name:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:tags:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Maybe [Tag]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
destinationArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
creatorRequestId

instance Prelude.NFData CreateResolverQueryLogConfig where
  rnf :: CreateResolverQueryLogConfig -> ()
rnf CreateResolverQueryLogConfig' {Maybe [Tag]
Text
creatorRequestId :: Text
destinationArn :: Text
name :: Text
tags :: Maybe [Tag]
$sel:creatorRequestId:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:destinationArn:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:name:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:tags:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Maybe [Tag]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
destinationArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
creatorRequestId

instance Data.ToHeaders CreateResolverQueryLogConfig where
  toHeaders :: CreateResolverQueryLogConfig -> 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
"Route53Resolver.CreateResolverQueryLogConfig" ::
                          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 CreateResolverQueryLogConfig where
  toJSON :: CreateResolverQueryLogConfig -> Value
toJSON CreateResolverQueryLogConfig' {Maybe [Tag]
Text
creatorRequestId :: Text
destinationArn :: Text
name :: Text
tags :: Maybe [Tag]
$sel:creatorRequestId:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:destinationArn:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:name:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Text
$sel:tags:CreateResolverQueryLogConfig' :: CreateResolverQueryLogConfig -> Maybe [Tag]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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 [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"DestinationArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
destinationArn),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"CreatorRequestId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
creatorRequestId)
          ]
      )

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

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

-- | /See:/ 'newCreateResolverQueryLogConfigResponse' smart constructor.
data CreateResolverQueryLogConfigResponse = CreateResolverQueryLogConfigResponse'
  { -- | Information about the @CreateResolverQueryLogConfig@ request, including
    -- the status of the request.
    CreateResolverQueryLogConfigResponse
-> Maybe ResolverQueryLogConfig
resolverQueryLogConfig :: Prelude.Maybe ResolverQueryLogConfig,
    -- | The response's http status code.
    CreateResolverQueryLogConfigResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateResolverQueryLogConfigResponse
-> CreateResolverQueryLogConfigResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateResolverQueryLogConfigResponse
-> CreateResolverQueryLogConfigResponse -> Bool
$c/= :: CreateResolverQueryLogConfigResponse
-> CreateResolverQueryLogConfigResponse -> Bool
== :: CreateResolverQueryLogConfigResponse
-> CreateResolverQueryLogConfigResponse -> Bool
$c== :: CreateResolverQueryLogConfigResponse
-> CreateResolverQueryLogConfigResponse -> Bool
Prelude.Eq, ReadPrec [CreateResolverQueryLogConfigResponse]
ReadPrec CreateResolverQueryLogConfigResponse
Int -> ReadS CreateResolverQueryLogConfigResponse
ReadS [CreateResolverQueryLogConfigResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateResolverQueryLogConfigResponse]
$creadListPrec :: ReadPrec [CreateResolverQueryLogConfigResponse]
readPrec :: ReadPrec CreateResolverQueryLogConfigResponse
$creadPrec :: ReadPrec CreateResolverQueryLogConfigResponse
readList :: ReadS [CreateResolverQueryLogConfigResponse]
$creadList :: ReadS [CreateResolverQueryLogConfigResponse]
readsPrec :: Int -> ReadS CreateResolverQueryLogConfigResponse
$creadsPrec :: Int -> ReadS CreateResolverQueryLogConfigResponse
Prelude.Read, Int -> CreateResolverQueryLogConfigResponse -> ShowS
[CreateResolverQueryLogConfigResponse] -> ShowS
CreateResolverQueryLogConfigResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateResolverQueryLogConfigResponse] -> ShowS
$cshowList :: [CreateResolverQueryLogConfigResponse] -> ShowS
show :: CreateResolverQueryLogConfigResponse -> String
$cshow :: CreateResolverQueryLogConfigResponse -> String
showsPrec :: Int -> CreateResolverQueryLogConfigResponse -> ShowS
$cshowsPrec :: Int -> CreateResolverQueryLogConfigResponse -> ShowS
Prelude.Show, forall x.
Rep CreateResolverQueryLogConfigResponse x
-> CreateResolverQueryLogConfigResponse
forall x.
CreateResolverQueryLogConfigResponse
-> Rep CreateResolverQueryLogConfigResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateResolverQueryLogConfigResponse x
-> CreateResolverQueryLogConfigResponse
$cfrom :: forall x.
CreateResolverQueryLogConfigResponse
-> Rep CreateResolverQueryLogConfigResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateResolverQueryLogConfigResponse' 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:
--
-- 'resolverQueryLogConfig', 'createResolverQueryLogConfigResponse_resolverQueryLogConfig' - Information about the @CreateResolverQueryLogConfig@ request, including
-- the status of the request.
--
-- 'httpStatus', 'createResolverQueryLogConfigResponse_httpStatus' - The response's http status code.
newCreateResolverQueryLogConfigResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateResolverQueryLogConfigResponse
newCreateResolverQueryLogConfigResponse :: Int -> CreateResolverQueryLogConfigResponse
newCreateResolverQueryLogConfigResponse Int
pHttpStatus_ =
  CreateResolverQueryLogConfigResponse'
    { $sel:resolverQueryLogConfig:CreateResolverQueryLogConfigResponse' :: Maybe ResolverQueryLogConfig
resolverQueryLogConfig =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateResolverQueryLogConfigResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the @CreateResolverQueryLogConfig@ request, including
-- the status of the request.
createResolverQueryLogConfigResponse_resolverQueryLogConfig :: Lens.Lens' CreateResolverQueryLogConfigResponse (Prelude.Maybe ResolverQueryLogConfig)
createResolverQueryLogConfigResponse_resolverQueryLogConfig :: Lens'
  CreateResolverQueryLogConfigResponse (Maybe ResolverQueryLogConfig)
createResolverQueryLogConfigResponse_resolverQueryLogConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateResolverQueryLogConfigResponse' {Maybe ResolverQueryLogConfig
resolverQueryLogConfig :: Maybe ResolverQueryLogConfig
$sel:resolverQueryLogConfig:CreateResolverQueryLogConfigResponse' :: CreateResolverQueryLogConfigResponse
-> Maybe ResolverQueryLogConfig
resolverQueryLogConfig} -> Maybe ResolverQueryLogConfig
resolverQueryLogConfig) (\s :: CreateResolverQueryLogConfigResponse
s@CreateResolverQueryLogConfigResponse' {} Maybe ResolverQueryLogConfig
a -> CreateResolverQueryLogConfigResponse
s {$sel:resolverQueryLogConfig:CreateResolverQueryLogConfigResponse' :: Maybe ResolverQueryLogConfig
resolverQueryLogConfig = Maybe ResolverQueryLogConfig
a} :: CreateResolverQueryLogConfigResponse)

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

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