{-# 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.PutQueryDefinition
-- 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 or updates a query definition for CloudWatch Logs Insights. For
-- more information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/AnalyzingLogData.html Analyzing Log Data with CloudWatch Logs Insights>.
--
-- To update a query definition, specify its @queryDefinitionId@ in your
-- request. The values of @name@, @queryString@, and @logGroupNames@ are
-- changed to the values that you specify in your update operation. No
-- current values are retained from the current query definition. For
-- example, imagine updating a current query definition that includes log
-- groups. If you don\'t specify the @logGroupNames@ parameter in your
-- update operation, the query definition changes to contain no log groups.
--
-- You must have the @logs:PutQueryDefinition@ permission to be able to
-- perform this operation.
module Amazonka.CloudWatchLogs.PutQueryDefinition
  ( -- * Creating a Request
    PutQueryDefinition (..),
    newPutQueryDefinition,

    -- * Request Lenses
    putQueryDefinition_logGroupNames,
    putQueryDefinition_queryDefinitionId,
    putQueryDefinition_name,
    putQueryDefinition_queryString,

    -- * Destructuring the Response
    PutQueryDefinitionResponse (..),
    newPutQueryDefinitionResponse,

    -- * Response Lenses
    putQueryDefinitionResponse_queryDefinitionId,
    putQueryDefinitionResponse_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:/ 'newPutQueryDefinition' smart constructor.
data PutQueryDefinition = PutQueryDefinition'
  { -- | Use this parameter to include specific log groups as part of your query
    -- definition.
    --
    -- If you are updating a query definition and you omit this parameter, then
    -- the updated definition will contain no log groups.
    PutQueryDefinition -> Maybe [Text]
logGroupNames :: Prelude.Maybe [Prelude.Text],
    -- | If you are updating a query definition, use this parameter to specify
    -- the ID of the query definition that you want to update. You can use
    -- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html DescribeQueryDefinitions>
    -- to retrieve the IDs of your saved query definitions.
    --
    -- If you are creating a query definition, do not specify this parameter.
    -- CloudWatch generates a unique ID for the new query definition and
    -- include it in the response to this operation.
    PutQueryDefinition -> Maybe Text
queryDefinitionId :: Prelude.Maybe Prelude.Text,
    -- | A name for the query definition. If you are saving numerous query
    -- definitions, we recommend that you name them. This way, you can find the
    -- ones you want by using the first part of the name as a filter in the
    -- @queryDefinitionNamePrefix@ parameter of
    -- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html DescribeQueryDefinitions>.
    PutQueryDefinition -> Text
name :: Prelude.Text,
    -- | The query string to use for this definition. For more information, see
    -- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html CloudWatch Logs Insights Query Syntax>.
    PutQueryDefinition -> Text
queryString :: Prelude.Text
  }
  deriving (PutQueryDefinition -> PutQueryDefinition -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutQueryDefinition -> PutQueryDefinition -> Bool
$c/= :: PutQueryDefinition -> PutQueryDefinition -> Bool
== :: PutQueryDefinition -> PutQueryDefinition -> Bool
$c== :: PutQueryDefinition -> PutQueryDefinition -> Bool
Prelude.Eq, ReadPrec [PutQueryDefinition]
ReadPrec PutQueryDefinition
Int -> ReadS PutQueryDefinition
ReadS [PutQueryDefinition]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutQueryDefinition]
$creadListPrec :: ReadPrec [PutQueryDefinition]
readPrec :: ReadPrec PutQueryDefinition
$creadPrec :: ReadPrec PutQueryDefinition
readList :: ReadS [PutQueryDefinition]
$creadList :: ReadS [PutQueryDefinition]
readsPrec :: Int -> ReadS PutQueryDefinition
$creadsPrec :: Int -> ReadS PutQueryDefinition
Prelude.Read, Int -> PutQueryDefinition -> ShowS
[PutQueryDefinition] -> ShowS
PutQueryDefinition -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutQueryDefinition] -> ShowS
$cshowList :: [PutQueryDefinition] -> ShowS
show :: PutQueryDefinition -> String
$cshow :: PutQueryDefinition -> String
showsPrec :: Int -> PutQueryDefinition -> ShowS
$cshowsPrec :: Int -> PutQueryDefinition -> ShowS
Prelude.Show, forall x. Rep PutQueryDefinition x -> PutQueryDefinition
forall x. PutQueryDefinition -> Rep PutQueryDefinition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PutQueryDefinition x -> PutQueryDefinition
$cfrom :: forall x. PutQueryDefinition -> Rep PutQueryDefinition x
Prelude.Generic)

-- |
-- Create a value of 'PutQueryDefinition' 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:
--
-- 'logGroupNames', 'putQueryDefinition_logGroupNames' - Use this parameter to include specific log groups as part of your query
-- definition.
--
-- If you are updating a query definition and you omit this parameter, then
-- the updated definition will contain no log groups.
--
-- 'queryDefinitionId', 'putQueryDefinition_queryDefinitionId' - If you are updating a query definition, use this parameter to specify
-- the ID of the query definition that you want to update. You can use
-- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html DescribeQueryDefinitions>
-- to retrieve the IDs of your saved query definitions.
--
-- If you are creating a query definition, do not specify this parameter.
-- CloudWatch generates a unique ID for the new query definition and
-- include it in the response to this operation.
--
-- 'name', 'putQueryDefinition_name' - A name for the query definition. If you are saving numerous query
-- definitions, we recommend that you name them. This way, you can find the
-- ones you want by using the first part of the name as a filter in the
-- @queryDefinitionNamePrefix@ parameter of
-- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html DescribeQueryDefinitions>.
--
-- 'queryString', 'putQueryDefinition_queryString' - The query string to use for this definition. For more information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html CloudWatch Logs Insights Query Syntax>.
newPutQueryDefinition ::
  -- | 'name'
  Prelude.Text ->
  -- | 'queryString'
  Prelude.Text ->
  PutQueryDefinition
newPutQueryDefinition :: Text -> Text -> PutQueryDefinition
newPutQueryDefinition Text
pName_ Text
pQueryString_ =
  PutQueryDefinition'
    { $sel:logGroupNames:PutQueryDefinition' :: Maybe [Text]
logGroupNames =
        forall a. Maybe a
Prelude.Nothing,
      $sel:queryDefinitionId:PutQueryDefinition' :: Maybe Text
queryDefinitionId = forall a. Maybe a
Prelude.Nothing,
      $sel:name:PutQueryDefinition' :: Text
name = Text
pName_,
      $sel:queryString:PutQueryDefinition' :: Text
queryString = Text
pQueryString_
    }

-- | Use this parameter to include specific log groups as part of your query
-- definition.
--
-- If you are updating a query definition and you omit this parameter, then
-- the updated definition will contain no log groups.
putQueryDefinition_logGroupNames :: Lens.Lens' PutQueryDefinition (Prelude.Maybe [Prelude.Text])
putQueryDefinition_logGroupNames :: Lens' PutQueryDefinition (Maybe [Text])
putQueryDefinition_logGroupNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutQueryDefinition' {Maybe [Text]
logGroupNames :: Maybe [Text]
$sel:logGroupNames:PutQueryDefinition' :: PutQueryDefinition -> Maybe [Text]
logGroupNames} -> Maybe [Text]
logGroupNames) (\s :: PutQueryDefinition
s@PutQueryDefinition' {} Maybe [Text]
a -> PutQueryDefinition
s {$sel:logGroupNames:PutQueryDefinition' :: Maybe [Text]
logGroupNames = Maybe [Text]
a} :: PutQueryDefinition) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | If you are updating a query definition, use this parameter to specify
-- the ID of the query definition that you want to update. You can use
-- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html DescribeQueryDefinitions>
-- to retrieve the IDs of your saved query definitions.
--
-- If you are creating a query definition, do not specify this parameter.
-- CloudWatch generates a unique ID for the new query definition and
-- include it in the response to this operation.
putQueryDefinition_queryDefinitionId :: Lens.Lens' PutQueryDefinition (Prelude.Maybe Prelude.Text)
putQueryDefinition_queryDefinitionId :: Lens' PutQueryDefinition (Maybe Text)
putQueryDefinition_queryDefinitionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutQueryDefinition' {Maybe Text
queryDefinitionId :: Maybe Text
$sel:queryDefinitionId:PutQueryDefinition' :: PutQueryDefinition -> Maybe Text
queryDefinitionId} -> Maybe Text
queryDefinitionId) (\s :: PutQueryDefinition
s@PutQueryDefinition' {} Maybe Text
a -> PutQueryDefinition
s {$sel:queryDefinitionId:PutQueryDefinition' :: Maybe Text
queryDefinitionId = Maybe Text
a} :: PutQueryDefinition)

-- | A name for the query definition. If you are saving numerous query
-- definitions, we recommend that you name them. This way, you can find the
-- ones you want by using the first part of the name as a filter in the
-- @queryDefinitionNamePrefix@ parameter of
-- <https://docs.aws.amazon.com/AmazonCloudWatchLogs/latest/APIReference/API_DescribeQueryDefinitions.html DescribeQueryDefinitions>.
putQueryDefinition_name :: Lens.Lens' PutQueryDefinition Prelude.Text
putQueryDefinition_name :: Lens' PutQueryDefinition Text
putQueryDefinition_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutQueryDefinition' {Text
name :: Text
$sel:name:PutQueryDefinition' :: PutQueryDefinition -> Text
name} -> Text
name) (\s :: PutQueryDefinition
s@PutQueryDefinition' {} Text
a -> PutQueryDefinition
s {$sel:name:PutQueryDefinition' :: Text
name = Text
a} :: PutQueryDefinition)

-- | The query string to use for this definition. For more information, see
-- <https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/CWL_QuerySyntax.html CloudWatch Logs Insights Query Syntax>.
putQueryDefinition_queryString :: Lens.Lens' PutQueryDefinition Prelude.Text
putQueryDefinition_queryString :: Lens' PutQueryDefinition Text
putQueryDefinition_queryString = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutQueryDefinition' {Text
queryString :: Text
$sel:queryString:PutQueryDefinition' :: PutQueryDefinition -> Text
queryString} -> Text
queryString) (\s :: PutQueryDefinition
s@PutQueryDefinition' {} Text
a -> PutQueryDefinition
s {$sel:queryString:PutQueryDefinition' :: Text
queryString = Text
a} :: PutQueryDefinition)

instance Core.AWSRequest PutQueryDefinition where
  type
    AWSResponse PutQueryDefinition =
      PutQueryDefinitionResponse
  request :: (Service -> Service)
-> PutQueryDefinition -> Request PutQueryDefinition
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 PutQueryDefinition
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse PutQueryDefinition)))
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 -> PutQueryDefinitionResponse
PutQueryDefinitionResponse'
            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
"queryDefinitionId")
            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 PutQueryDefinition where
  hashWithSalt :: Int -> PutQueryDefinition -> Int
hashWithSalt Int
_salt PutQueryDefinition' {Maybe [Text]
Maybe Text
Text
queryString :: Text
name :: Text
queryDefinitionId :: Maybe Text
logGroupNames :: Maybe [Text]
$sel:queryString:PutQueryDefinition' :: PutQueryDefinition -> Text
$sel:name:PutQueryDefinition' :: PutQueryDefinition -> Text
$sel:queryDefinitionId:PutQueryDefinition' :: PutQueryDefinition -> Maybe Text
$sel:logGroupNames:PutQueryDefinition' :: PutQueryDefinition -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
logGroupNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
queryDefinitionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
queryString

instance Prelude.NFData PutQueryDefinition where
  rnf :: PutQueryDefinition -> ()
rnf PutQueryDefinition' {Maybe [Text]
Maybe Text
Text
queryString :: Text
name :: Text
queryDefinitionId :: Maybe Text
logGroupNames :: Maybe [Text]
$sel:queryString:PutQueryDefinition' :: PutQueryDefinition -> Text
$sel:name:PutQueryDefinition' :: PutQueryDefinition -> Text
$sel:queryDefinitionId:PutQueryDefinition' :: PutQueryDefinition -> Maybe Text
$sel:logGroupNames:PutQueryDefinition' :: PutQueryDefinition -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
logGroupNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
queryDefinitionId
      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
queryString

instance Data.ToHeaders PutQueryDefinition where
  toHeaders :: PutQueryDefinition -> 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.PutQueryDefinition" ::
                          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 PutQueryDefinition where
  toJSON :: PutQueryDefinition -> Value
toJSON PutQueryDefinition' {Maybe [Text]
Maybe Text
Text
queryString :: Text
name :: Text
queryDefinitionId :: Maybe Text
logGroupNames :: Maybe [Text]
$sel:queryString:PutQueryDefinition' :: PutQueryDefinition -> Text
$sel:name:PutQueryDefinition' :: PutQueryDefinition -> Text
$sel:queryDefinitionId:PutQueryDefinition' :: PutQueryDefinition -> Maybe Text
$sel:logGroupNames:PutQueryDefinition' :: PutQueryDefinition -> Maybe [Text]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"logGroupNames" 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]
logGroupNames,
            (Key
"queryDefinitionId" 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
queryDefinitionId,
            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
"queryString" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
queryString)
          ]
      )

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

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

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

-- |
-- Create a value of 'PutQueryDefinitionResponse' 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:
--
-- 'queryDefinitionId', 'putQueryDefinitionResponse_queryDefinitionId' - The ID of the query definition.
--
-- 'httpStatus', 'putQueryDefinitionResponse_httpStatus' - The response's http status code.
newPutQueryDefinitionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PutQueryDefinitionResponse
newPutQueryDefinitionResponse :: Int -> PutQueryDefinitionResponse
newPutQueryDefinitionResponse Int
pHttpStatus_ =
  PutQueryDefinitionResponse'
    { $sel:queryDefinitionId:PutQueryDefinitionResponse' :: Maybe Text
queryDefinitionId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:PutQueryDefinitionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ID of the query definition.
putQueryDefinitionResponse_queryDefinitionId :: Lens.Lens' PutQueryDefinitionResponse (Prelude.Maybe Prelude.Text)
putQueryDefinitionResponse_queryDefinitionId :: Lens' PutQueryDefinitionResponse (Maybe Text)
putQueryDefinitionResponse_queryDefinitionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutQueryDefinitionResponse' {Maybe Text
queryDefinitionId :: Maybe Text
$sel:queryDefinitionId:PutQueryDefinitionResponse' :: PutQueryDefinitionResponse -> Maybe Text
queryDefinitionId} -> Maybe Text
queryDefinitionId) (\s :: PutQueryDefinitionResponse
s@PutQueryDefinitionResponse' {} Maybe Text
a -> PutQueryDefinitionResponse
s {$sel:queryDefinitionId:PutQueryDefinitionResponse' :: Maybe Text
queryDefinitionId = Maybe Text
a} :: PutQueryDefinitionResponse)

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

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