{-# 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.Athena.CreateNamedQuery
-- 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 named query in the specified workgroup. Requires that you have
-- access to the workgroup.
--
-- For code samples using the Amazon Web Services SDK for Java, see
-- <http://docs.aws.amazon.com/athena/latest/ug/code-samples.html Examples and Code Samples>
-- in the /Amazon Athena User Guide/.
module Amazonka.Athena.CreateNamedQuery
  ( -- * Creating a Request
    CreateNamedQuery (..),
    newCreateNamedQuery,

    -- * Request Lenses
    createNamedQuery_clientRequestToken,
    createNamedQuery_description,
    createNamedQuery_workGroup,
    createNamedQuery_name,
    createNamedQuery_database,
    createNamedQuery_queryString,

    -- * Destructuring the Response
    CreateNamedQueryResponse (..),
    newCreateNamedQueryResponse,

    -- * Response Lenses
    createNamedQueryResponse_namedQueryId,
    createNamedQueryResponse_httpStatus,
  )
where

import Amazonka.Athena.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:/ 'newCreateNamedQuery' smart constructor.
data CreateNamedQuery = CreateNamedQuery'
  { -- | A unique case-sensitive string used to ensure the request to create the
    -- query is idempotent (executes only once). If another @CreateNamedQuery@
    -- request is received, the same response is returned and another query is
    -- not created. If a parameter has changed, for example, the @QueryString@,
    -- an error is returned.
    --
    -- This token is listed as not required because Amazon Web Services SDKs
    -- (for example the Amazon Web Services SDK for Java) auto-generate the
    -- token for users. If you are not using the Amazon Web Services SDK or the
    -- Amazon Web Services CLI, you must provide this token or the action will
    -- fail.
    CreateNamedQuery -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | The query description.
    CreateNamedQuery -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The name of the workgroup in which the named query is being created.
    CreateNamedQuery -> Maybe Text
workGroup :: Prelude.Maybe Prelude.Text,
    -- | The query name.
    CreateNamedQuery -> Text
name :: Prelude.Text,
    -- | The database to which the query belongs.
    CreateNamedQuery -> Text
database :: Prelude.Text,
    -- | The contents of the query with all query statements.
    CreateNamedQuery -> Text
queryString :: Prelude.Text
  }
  deriving (CreateNamedQuery -> CreateNamedQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateNamedQuery -> CreateNamedQuery -> Bool
$c/= :: CreateNamedQuery -> CreateNamedQuery -> Bool
== :: CreateNamedQuery -> CreateNamedQuery -> Bool
$c== :: CreateNamedQuery -> CreateNamedQuery -> Bool
Prelude.Eq, ReadPrec [CreateNamedQuery]
ReadPrec CreateNamedQuery
Int -> ReadS CreateNamedQuery
ReadS [CreateNamedQuery]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateNamedQuery]
$creadListPrec :: ReadPrec [CreateNamedQuery]
readPrec :: ReadPrec CreateNamedQuery
$creadPrec :: ReadPrec CreateNamedQuery
readList :: ReadS [CreateNamedQuery]
$creadList :: ReadS [CreateNamedQuery]
readsPrec :: Int -> ReadS CreateNamedQuery
$creadsPrec :: Int -> ReadS CreateNamedQuery
Prelude.Read, Int -> CreateNamedQuery -> ShowS
[CreateNamedQuery] -> ShowS
CreateNamedQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateNamedQuery] -> ShowS
$cshowList :: [CreateNamedQuery] -> ShowS
show :: CreateNamedQuery -> String
$cshow :: CreateNamedQuery -> String
showsPrec :: Int -> CreateNamedQuery -> ShowS
$cshowsPrec :: Int -> CreateNamedQuery -> ShowS
Prelude.Show, forall x. Rep CreateNamedQuery x -> CreateNamedQuery
forall x. CreateNamedQuery -> Rep CreateNamedQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateNamedQuery x -> CreateNamedQuery
$cfrom :: forall x. CreateNamedQuery -> Rep CreateNamedQuery x
Prelude.Generic)

-- |
-- Create a value of 'CreateNamedQuery' 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:
--
-- 'clientRequestToken', 'createNamedQuery_clientRequestToken' - A unique case-sensitive string used to ensure the request to create the
-- query is idempotent (executes only once). If another @CreateNamedQuery@
-- request is received, the same response is returned and another query is
-- not created. If a parameter has changed, for example, the @QueryString@,
-- an error is returned.
--
-- This token is listed as not required because Amazon Web Services SDKs
-- (for example the Amazon Web Services SDK for Java) auto-generate the
-- token for users. If you are not using the Amazon Web Services SDK or the
-- Amazon Web Services CLI, you must provide this token or the action will
-- fail.
--
-- 'description', 'createNamedQuery_description' - The query description.
--
-- 'workGroup', 'createNamedQuery_workGroup' - The name of the workgroup in which the named query is being created.
--
-- 'name', 'createNamedQuery_name' - The query name.
--
-- 'database', 'createNamedQuery_database' - The database to which the query belongs.
--
-- 'queryString', 'createNamedQuery_queryString' - The contents of the query with all query statements.
newCreateNamedQuery ::
  -- | 'name'
  Prelude.Text ->
  -- | 'database'
  Prelude.Text ->
  -- | 'queryString'
  Prelude.Text ->
  CreateNamedQuery
newCreateNamedQuery :: Text -> Text -> Text -> CreateNamedQuery
newCreateNamedQuery Text
pName_ Text
pDatabase_ Text
pQueryString_ =
  CreateNamedQuery'
    { $sel:clientRequestToken:CreateNamedQuery' :: Maybe Text
clientRequestToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:description:CreateNamedQuery' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:workGroup:CreateNamedQuery' :: Maybe Text
workGroup = forall a. Maybe a
Prelude.Nothing,
      $sel:name:CreateNamedQuery' :: Text
name = Text
pName_,
      $sel:database:CreateNamedQuery' :: Text
database = Text
pDatabase_,
      $sel:queryString:CreateNamedQuery' :: Text
queryString = Text
pQueryString_
    }

-- | A unique case-sensitive string used to ensure the request to create the
-- query is idempotent (executes only once). If another @CreateNamedQuery@
-- request is received, the same response is returned and another query is
-- not created. If a parameter has changed, for example, the @QueryString@,
-- an error is returned.
--
-- This token is listed as not required because Amazon Web Services SDKs
-- (for example the Amazon Web Services SDK for Java) auto-generate the
-- token for users. If you are not using the Amazon Web Services SDK or the
-- Amazon Web Services CLI, you must provide this token or the action will
-- fail.
createNamedQuery_clientRequestToken :: Lens.Lens' CreateNamedQuery (Prelude.Maybe Prelude.Text)
createNamedQuery_clientRequestToken :: Lens' CreateNamedQuery (Maybe Text)
createNamedQuery_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamedQuery' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: CreateNamedQuery
s@CreateNamedQuery' {} Maybe Text
a -> CreateNamedQuery
s {$sel:clientRequestToken:CreateNamedQuery' :: Maybe Text
clientRequestToken = Maybe Text
a} :: CreateNamedQuery)

-- | The query description.
createNamedQuery_description :: Lens.Lens' CreateNamedQuery (Prelude.Maybe Prelude.Text)
createNamedQuery_description :: Lens' CreateNamedQuery (Maybe Text)
createNamedQuery_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamedQuery' {Maybe Text
description :: Maybe Text
$sel:description:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateNamedQuery
s@CreateNamedQuery' {} Maybe Text
a -> CreateNamedQuery
s {$sel:description:CreateNamedQuery' :: Maybe Text
description = Maybe Text
a} :: CreateNamedQuery)

-- | The name of the workgroup in which the named query is being created.
createNamedQuery_workGroup :: Lens.Lens' CreateNamedQuery (Prelude.Maybe Prelude.Text)
createNamedQuery_workGroup :: Lens' CreateNamedQuery (Maybe Text)
createNamedQuery_workGroup = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamedQuery' {Maybe Text
workGroup :: Maybe Text
$sel:workGroup:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
workGroup} -> Maybe Text
workGroup) (\s :: CreateNamedQuery
s@CreateNamedQuery' {} Maybe Text
a -> CreateNamedQuery
s {$sel:workGroup:CreateNamedQuery' :: Maybe Text
workGroup = Maybe Text
a} :: CreateNamedQuery)

-- | The query name.
createNamedQuery_name :: Lens.Lens' CreateNamedQuery Prelude.Text
createNamedQuery_name :: Lens' CreateNamedQuery Text
createNamedQuery_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamedQuery' {Text
name :: Text
$sel:name:CreateNamedQuery' :: CreateNamedQuery -> Text
name} -> Text
name) (\s :: CreateNamedQuery
s@CreateNamedQuery' {} Text
a -> CreateNamedQuery
s {$sel:name:CreateNamedQuery' :: Text
name = Text
a} :: CreateNamedQuery)

-- | The database to which the query belongs.
createNamedQuery_database :: Lens.Lens' CreateNamedQuery Prelude.Text
createNamedQuery_database :: Lens' CreateNamedQuery Text
createNamedQuery_database = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamedQuery' {Text
database :: Text
$sel:database:CreateNamedQuery' :: CreateNamedQuery -> Text
database} -> Text
database) (\s :: CreateNamedQuery
s@CreateNamedQuery' {} Text
a -> CreateNamedQuery
s {$sel:database:CreateNamedQuery' :: Text
database = Text
a} :: CreateNamedQuery)

-- | The contents of the query with all query statements.
createNamedQuery_queryString :: Lens.Lens' CreateNamedQuery Prelude.Text
createNamedQuery_queryString :: Lens' CreateNamedQuery Text
createNamedQuery_queryString = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamedQuery' {Text
queryString :: Text
$sel:queryString:CreateNamedQuery' :: CreateNamedQuery -> Text
queryString} -> Text
queryString) (\s :: CreateNamedQuery
s@CreateNamedQuery' {} Text
a -> CreateNamedQuery
s {$sel:queryString:CreateNamedQuery' :: Text
queryString = Text
a} :: CreateNamedQuery)

instance Core.AWSRequest CreateNamedQuery where
  type
    AWSResponse CreateNamedQuery =
      CreateNamedQueryResponse
  request :: (Service -> Service)
-> CreateNamedQuery -> Request CreateNamedQuery
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 CreateNamedQuery
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateNamedQuery)))
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 -> CreateNamedQueryResponse
CreateNamedQueryResponse'
            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
"NamedQueryId")
            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 CreateNamedQuery where
  hashWithSalt :: Int -> CreateNamedQuery -> Int
hashWithSalt Int
_salt CreateNamedQuery' {Maybe Text
Text
queryString :: Text
database :: Text
name :: Text
workGroup :: Maybe Text
description :: Maybe Text
clientRequestToken :: Maybe Text
$sel:queryString:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:database:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:name:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:workGroup:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
$sel:description:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
$sel:clientRequestToken:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
workGroup
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
database
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
queryString

instance Prelude.NFData CreateNamedQuery where
  rnf :: CreateNamedQuery -> ()
rnf CreateNamedQuery' {Maybe Text
Text
queryString :: Text
database :: Text
name :: Text
workGroup :: Maybe Text
description :: Maybe Text
clientRequestToken :: Maybe Text
$sel:queryString:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:database:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:name:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:workGroup:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
$sel:description:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
$sel:clientRequestToken:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
workGroup
      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
database
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
queryString

instance Data.ToHeaders CreateNamedQuery where
  toHeaders :: CreateNamedQuery -> 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
"AmazonAthena.CreateNamedQuery" ::
                          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 CreateNamedQuery where
  toJSON :: CreateNamedQuery -> Value
toJSON CreateNamedQuery' {Maybe Text
Text
queryString :: Text
database :: Text
name :: Text
workGroup :: Maybe Text
description :: Maybe Text
clientRequestToken :: Maybe Text
$sel:queryString:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:database:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:name:CreateNamedQuery' :: CreateNamedQuery -> Text
$sel:workGroup:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
$sel:description:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
$sel:clientRequestToken:CreateNamedQuery' :: CreateNamedQuery -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientRequestToken" 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
clientRequestToken,
            (Key
"Description" 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
description,
            (Key
"WorkGroup" 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
workGroup,
            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
"Database" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
database),
            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 CreateNamedQuery where
  toPath :: CreateNamedQuery -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

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

-- |
-- Create a value of 'CreateNamedQueryResponse' 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:
--
-- 'namedQueryId', 'createNamedQueryResponse_namedQueryId' - The unique ID of the query.
--
-- 'httpStatus', 'createNamedQueryResponse_httpStatus' - The response's http status code.
newCreateNamedQueryResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateNamedQueryResponse
newCreateNamedQueryResponse :: Int -> CreateNamedQueryResponse
newCreateNamedQueryResponse Int
pHttpStatus_ =
  CreateNamedQueryResponse'
    { $sel:namedQueryId:CreateNamedQueryResponse' :: Maybe Text
namedQueryId =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateNamedQueryResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The unique ID of the query.
createNamedQueryResponse_namedQueryId :: Lens.Lens' CreateNamedQueryResponse (Prelude.Maybe Prelude.Text)
createNamedQueryResponse_namedQueryId :: Lens' CreateNamedQueryResponse (Maybe Text)
createNamedQueryResponse_namedQueryId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateNamedQueryResponse' {Maybe Text
namedQueryId :: Maybe Text
$sel:namedQueryId:CreateNamedQueryResponse' :: CreateNamedQueryResponse -> Maybe Text
namedQueryId} -> Maybe Text
namedQueryId) (\s :: CreateNamedQueryResponse
s@CreateNamedQueryResponse' {} Maybe Text
a -> CreateNamedQueryResponse
s {$sel:namedQueryId:CreateNamedQueryResponse' :: Maybe Text
namedQueryId = Maybe Text
a} :: CreateNamedQueryResponse)

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

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