{-# 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.TimeStreamQuery.CreateScheduledQuery
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Create a scheduled query that will be run on your behalf at the
-- configured schedule. Timestream assumes the execution role provided as
-- part of the @ScheduledQueryExecutionRoleArn@ parameter to run the query.
-- You can use the @NotificationConfiguration@ parameter to configure
-- notification for your scheduled query operations.
module Amazonka.TimeStreamQuery.CreateScheduledQuery
  ( -- * Creating a Request
    CreateScheduledQuery (..),
    newCreateScheduledQuery,

    -- * Request Lenses
    createScheduledQuery_clientToken,
    createScheduledQuery_kmsKeyId,
    createScheduledQuery_tags,
    createScheduledQuery_targetConfiguration,
    createScheduledQuery_name,
    createScheduledQuery_queryString,
    createScheduledQuery_scheduleConfiguration,
    createScheduledQuery_notificationConfiguration,
    createScheduledQuery_scheduledQueryExecutionRoleArn,
    createScheduledQuery_errorReportConfiguration,

    -- * Destructuring the Response
    CreateScheduledQueryResponse (..),
    newCreateScheduledQueryResponse,

    -- * Response Lenses
    createScheduledQueryResponse_httpStatus,
    createScheduledQueryResponse_arn,
  )
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.TimeStreamQuery.Types

-- | /See:/ 'newCreateScheduledQuery' smart constructor.
data CreateScheduledQuery = CreateScheduledQuery'
  { -- | Using a ClientToken makes the call to CreateScheduledQuery idempotent,
    -- in other words, making the same request repeatedly will produce the same
    -- result. Making multiple identical CreateScheduledQuery requests has the
    -- same effect as making a single request.
    --
    -- -   If CreateScheduledQuery is called without a @ClientToken@, the Query
    --     SDK generates a @ClientToken@ on your behalf.
    --
    -- -   After 8 hours, any request with the same @ClientToken@ is treated as
    --     a new request.
    CreateScheduledQuery -> Maybe (Sensitive Text)
clientToken :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | The Amazon KMS key used to encrypt the scheduled query resource,
    -- at-rest. If the Amazon KMS key is not specified, the scheduled query
    -- resource will be encrypted with a Timestream owned Amazon KMS key. To
    -- specify a KMS key, use the key ID, key ARN, alias name, or alias ARN.
    -- When using an alias name, prefix the name with /alias\//
    --
    -- If ErrorReportConfiguration uses @SSE_KMS@ as encryption type, the same
    -- KmsKeyId is used to encrypt the error report at rest.
    CreateScheduledQuery -> Maybe Text
kmsKeyId :: Prelude.Maybe Prelude.Text,
    -- | A list of key-value pairs to label the scheduled query.
    CreateScheduledQuery -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | Configuration used for writing the result of a query.
    CreateScheduledQuery -> Maybe TargetConfiguration
targetConfiguration :: Prelude.Maybe TargetConfiguration,
    -- | Name of the scheduled query.
    CreateScheduledQuery -> Text
name :: Prelude.Text,
    -- | The query string to run. Parameter names can be specified in the query
    -- string @\@@ character followed by an identifier. The named Parameter
    -- @\@scheduled_runtime@ is reserved and can be used in the query to get
    -- the time at which the query is scheduled to run.
    --
    -- The timestamp calculated according to the ScheduleConfiguration
    -- parameter, will be the value of @\@scheduled_runtime@ paramater for each
    -- query run. For example, consider an instance of a scheduled query
    -- executing on 2021-12-01 00:00:00. For this instance, the
    -- @\@scheduled_runtime@ parameter is initialized to the timestamp
    -- 2021-12-01 00:00:00 when invoking the query.
    CreateScheduledQuery -> Sensitive Text
queryString :: Data.Sensitive Prelude.Text,
    -- | The schedule configuration for the query.
    CreateScheduledQuery -> ScheduleConfiguration
scheduleConfiguration :: ScheduleConfiguration,
    -- | Notification configuration for the scheduled query. A notification is
    -- sent by Timestream when a query run finishes, when the state is updated
    -- or when you delete it.
    CreateScheduledQuery -> NotificationConfiguration
notificationConfiguration :: NotificationConfiguration,
    -- | The ARN for the IAM role that Timestream will assume when running the
    -- scheduled query.
    CreateScheduledQuery -> Text
scheduledQueryExecutionRoleArn :: Prelude.Text,
    -- | Configuration for error reporting. Error reports will be generated when
    -- a problem is encountered when writing the query results.
    CreateScheduledQuery -> ErrorReportConfiguration
errorReportConfiguration :: ErrorReportConfiguration
  }
  deriving (CreateScheduledQuery -> CreateScheduledQuery -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateScheduledQuery -> CreateScheduledQuery -> Bool
$c/= :: CreateScheduledQuery -> CreateScheduledQuery -> Bool
== :: CreateScheduledQuery -> CreateScheduledQuery -> Bool
$c== :: CreateScheduledQuery -> CreateScheduledQuery -> Bool
Prelude.Eq, Int -> CreateScheduledQuery -> ShowS
[CreateScheduledQuery] -> ShowS
CreateScheduledQuery -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateScheduledQuery] -> ShowS
$cshowList :: [CreateScheduledQuery] -> ShowS
show :: CreateScheduledQuery -> String
$cshow :: CreateScheduledQuery -> String
showsPrec :: Int -> CreateScheduledQuery -> ShowS
$cshowsPrec :: Int -> CreateScheduledQuery -> ShowS
Prelude.Show, forall x. Rep CreateScheduledQuery x -> CreateScheduledQuery
forall x. CreateScheduledQuery -> Rep CreateScheduledQuery x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateScheduledQuery x -> CreateScheduledQuery
$cfrom :: forall x. CreateScheduledQuery -> Rep CreateScheduledQuery x
Prelude.Generic)

-- |
-- Create a value of 'CreateScheduledQuery' 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', 'createScheduledQuery_clientToken' - Using a ClientToken makes the call to CreateScheduledQuery idempotent,
-- in other words, making the same request repeatedly will produce the same
-- result. Making multiple identical CreateScheduledQuery requests has the
-- same effect as making a single request.
--
-- -   If CreateScheduledQuery is called without a @ClientToken@, the Query
--     SDK generates a @ClientToken@ on your behalf.
--
-- -   After 8 hours, any request with the same @ClientToken@ is treated as
--     a new request.
--
-- 'kmsKeyId', 'createScheduledQuery_kmsKeyId' - The Amazon KMS key used to encrypt the scheduled query resource,
-- at-rest. If the Amazon KMS key is not specified, the scheduled query
-- resource will be encrypted with a Timestream owned Amazon KMS key. To
-- specify a KMS key, use the key ID, key ARN, alias name, or alias ARN.
-- When using an alias name, prefix the name with /alias\//
--
-- If ErrorReportConfiguration uses @SSE_KMS@ as encryption type, the same
-- KmsKeyId is used to encrypt the error report at rest.
--
-- 'tags', 'createScheduledQuery_tags' - A list of key-value pairs to label the scheduled query.
--
-- 'targetConfiguration', 'createScheduledQuery_targetConfiguration' - Configuration used for writing the result of a query.
--
-- 'name', 'createScheduledQuery_name' - Name of the scheduled query.
--
-- 'queryString', 'createScheduledQuery_queryString' - The query string to run. Parameter names can be specified in the query
-- string @\@@ character followed by an identifier. The named Parameter
-- @\@scheduled_runtime@ is reserved and can be used in the query to get
-- the time at which the query is scheduled to run.
--
-- The timestamp calculated according to the ScheduleConfiguration
-- parameter, will be the value of @\@scheduled_runtime@ paramater for each
-- query run. For example, consider an instance of a scheduled query
-- executing on 2021-12-01 00:00:00. For this instance, the
-- @\@scheduled_runtime@ parameter is initialized to the timestamp
-- 2021-12-01 00:00:00 when invoking the query.
--
-- 'scheduleConfiguration', 'createScheduledQuery_scheduleConfiguration' - The schedule configuration for the query.
--
-- 'notificationConfiguration', 'createScheduledQuery_notificationConfiguration' - Notification configuration for the scheduled query. A notification is
-- sent by Timestream when a query run finishes, when the state is updated
-- or when you delete it.
--
-- 'scheduledQueryExecutionRoleArn', 'createScheduledQuery_scheduledQueryExecutionRoleArn' - The ARN for the IAM role that Timestream will assume when running the
-- scheduled query.
--
-- 'errorReportConfiguration', 'createScheduledQuery_errorReportConfiguration' - Configuration for error reporting. Error reports will be generated when
-- a problem is encountered when writing the query results.
newCreateScheduledQuery ::
  -- | 'name'
  Prelude.Text ->
  -- | 'queryString'
  Prelude.Text ->
  -- | 'scheduleConfiguration'
  ScheduleConfiguration ->
  -- | 'notificationConfiguration'
  NotificationConfiguration ->
  -- | 'scheduledQueryExecutionRoleArn'
  Prelude.Text ->
  -- | 'errorReportConfiguration'
  ErrorReportConfiguration ->
  CreateScheduledQuery
newCreateScheduledQuery :: Text
-> Text
-> ScheduleConfiguration
-> NotificationConfiguration
-> Text
-> ErrorReportConfiguration
-> CreateScheduledQuery
newCreateScheduledQuery
  Text
pName_
  Text
pQueryString_
  ScheduleConfiguration
pScheduleConfiguration_
  NotificationConfiguration
pNotificationConfiguration_
  Text
pScheduledQueryExecutionRoleArn_
  ErrorReportConfiguration
pErrorReportConfiguration_ =
    CreateScheduledQuery'
      { $sel:clientToken:CreateScheduledQuery' :: Maybe (Sensitive Text)
clientToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:kmsKeyId:CreateScheduledQuery' :: Maybe Text
kmsKeyId = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:CreateScheduledQuery' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:targetConfiguration:CreateScheduledQuery' :: Maybe TargetConfiguration
targetConfiguration = forall a. Maybe a
Prelude.Nothing,
        $sel:name:CreateScheduledQuery' :: Text
name = Text
pName_,
        $sel:queryString:CreateScheduledQuery' :: Sensitive Text
queryString = forall a. Iso' (Sensitive a) a
Data._Sensitive forall t b. AReview t b -> b -> t
Lens.# Text
pQueryString_,
        $sel:scheduleConfiguration:CreateScheduledQuery' :: ScheduleConfiguration
scheduleConfiguration = ScheduleConfiguration
pScheduleConfiguration_,
        $sel:notificationConfiguration:CreateScheduledQuery' :: NotificationConfiguration
notificationConfiguration =
          NotificationConfiguration
pNotificationConfiguration_,
        $sel:scheduledQueryExecutionRoleArn:CreateScheduledQuery' :: Text
scheduledQueryExecutionRoleArn =
          Text
pScheduledQueryExecutionRoleArn_,
        $sel:errorReportConfiguration:CreateScheduledQuery' :: ErrorReportConfiguration
errorReportConfiguration =
          ErrorReportConfiguration
pErrorReportConfiguration_
      }

-- | Using a ClientToken makes the call to CreateScheduledQuery idempotent,
-- in other words, making the same request repeatedly will produce the same
-- result. Making multiple identical CreateScheduledQuery requests has the
-- same effect as making a single request.
--
-- -   If CreateScheduledQuery is called without a @ClientToken@, the Query
--     SDK generates a @ClientToken@ on your behalf.
--
-- -   After 8 hours, any request with the same @ClientToken@ is treated as
--     a new request.
createScheduledQuery_clientToken :: Lens.Lens' CreateScheduledQuery (Prelude.Maybe Prelude.Text)
createScheduledQuery_clientToken :: Lens' CreateScheduledQuery (Maybe Text)
createScheduledQuery_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {Maybe (Sensitive Text)
clientToken :: Maybe (Sensitive Text)
$sel:clientToken:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe (Sensitive Text)
clientToken} -> Maybe (Sensitive Text)
clientToken) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} Maybe (Sensitive Text)
a -> CreateScheduledQuery
s {$sel:clientToken:CreateScheduledQuery' :: Maybe (Sensitive Text)
clientToken = Maybe (Sensitive Text)
a} :: CreateScheduledQuery) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall a. Iso' (Sensitive a) a
Data._Sensitive

-- | The Amazon KMS key used to encrypt the scheduled query resource,
-- at-rest. If the Amazon KMS key is not specified, the scheduled query
-- resource will be encrypted with a Timestream owned Amazon KMS key. To
-- specify a KMS key, use the key ID, key ARN, alias name, or alias ARN.
-- When using an alias name, prefix the name with /alias\//
--
-- If ErrorReportConfiguration uses @SSE_KMS@ as encryption type, the same
-- KmsKeyId is used to encrypt the error report at rest.
createScheduledQuery_kmsKeyId :: Lens.Lens' CreateScheduledQuery (Prelude.Maybe Prelude.Text)
createScheduledQuery_kmsKeyId :: Lens' CreateScheduledQuery (Maybe Text)
createScheduledQuery_kmsKeyId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {Maybe Text
kmsKeyId :: Maybe Text
$sel:kmsKeyId:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe Text
kmsKeyId} -> Maybe Text
kmsKeyId) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} Maybe Text
a -> CreateScheduledQuery
s {$sel:kmsKeyId:CreateScheduledQuery' :: Maybe Text
kmsKeyId = Maybe Text
a} :: CreateScheduledQuery)

-- | A list of key-value pairs to label the scheduled query.
createScheduledQuery_tags :: Lens.Lens' CreateScheduledQuery (Prelude.Maybe [Tag])
createScheduledQuery_tags :: Lens' CreateScheduledQuery (Maybe [Tag])
createScheduledQuery_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} Maybe [Tag]
a -> CreateScheduledQuery
s {$sel:tags:CreateScheduledQuery' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateScheduledQuery) 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

-- | Configuration used for writing the result of a query.
createScheduledQuery_targetConfiguration :: Lens.Lens' CreateScheduledQuery (Prelude.Maybe TargetConfiguration)
createScheduledQuery_targetConfiguration :: Lens' CreateScheduledQuery (Maybe TargetConfiguration)
createScheduledQuery_targetConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {Maybe TargetConfiguration
targetConfiguration :: Maybe TargetConfiguration
$sel:targetConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe TargetConfiguration
targetConfiguration} -> Maybe TargetConfiguration
targetConfiguration) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} Maybe TargetConfiguration
a -> CreateScheduledQuery
s {$sel:targetConfiguration:CreateScheduledQuery' :: Maybe TargetConfiguration
targetConfiguration = Maybe TargetConfiguration
a} :: CreateScheduledQuery)

-- | Name of the scheduled query.
createScheduledQuery_name :: Lens.Lens' CreateScheduledQuery Prelude.Text
createScheduledQuery_name :: Lens' CreateScheduledQuery Text
createScheduledQuery_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {Text
name :: Text
$sel:name:CreateScheduledQuery' :: CreateScheduledQuery -> Text
name} -> Text
name) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} Text
a -> CreateScheduledQuery
s {$sel:name:CreateScheduledQuery' :: Text
name = Text
a} :: CreateScheduledQuery)

-- | The query string to run. Parameter names can be specified in the query
-- string @\@@ character followed by an identifier. The named Parameter
-- @\@scheduled_runtime@ is reserved and can be used in the query to get
-- the time at which the query is scheduled to run.
--
-- The timestamp calculated according to the ScheduleConfiguration
-- parameter, will be the value of @\@scheduled_runtime@ paramater for each
-- query run. For example, consider an instance of a scheduled query
-- executing on 2021-12-01 00:00:00. For this instance, the
-- @\@scheduled_runtime@ parameter is initialized to the timestamp
-- 2021-12-01 00:00:00 when invoking the query.
createScheduledQuery_queryString :: Lens.Lens' CreateScheduledQuery Prelude.Text
createScheduledQuery_queryString :: Lens' CreateScheduledQuery Text
createScheduledQuery_queryString = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {Sensitive Text
queryString :: Sensitive Text
$sel:queryString:CreateScheduledQuery' :: CreateScheduledQuery -> Sensitive Text
queryString} -> Sensitive Text
queryString) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} Sensitive Text
a -> CreateScheduledQuery
s {$sel:queryString:CreateScheduledQuery' :: Sensitive Text
queryString = Sensitive Text
a} :: CreateScheduledQuery) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall a. Iso' (Sensitive a) a
Data._Sensitive

-- | The schedule configuration for the query.
createScheduledQuery_scheduleConfiguration :: Lens.Lens' CreateScheduledQuery ScheduleConfiguration
createScheduledQuery_scheduleConfiguration :: Lens' CreateScheduledQuery ScheduleConfiguration
createScheduledQuery_scheduleConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {ScheduleConfiguration
scheduleConfiguration :: ScheduleConfiguration
$sel:scheduleConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ScheduleConfiguration
scheduleConfiguration} -> ScheduleConfiguration
scheduleConfiguration) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} ScheduleConfiguration
a -> CreateScheduledQuery
s {$sel:scheduleConfiguration:CreateScheduledQuery' :: ScheduleConfiguration
scheduleConfiguration = ScheduleConfiguration
a} :: CreateScheduledQuery)

-- | Notification configuration for the scheduled query. A notification is
-- sent by Timestream when a query run finishes, when the state is updated
-- or when you delete it.
createScheduledQuery_notificationConfiguration :: Lens.Lens' CreateScheduledQuery NotificationConfiguration
createScheduledQuery_notificationConfiguration :: Lens' CreateScheduledQuery NotificationConfiguration
createScheduledQuery_notificationConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {NotificationConfiguration
notificationConfiguration :: NotificationConfiguration
$sel:notificationConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> NotificationConfiguration
notificationConfiguration} -> NotificationConfiguration
notificationConfiguration) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} NotificationConfiguration
a -> CreateScheduledQuery
s {$sel:notificationConfiguration:CreateScheduledQuery' :: NotificationConfiguration
notificationConfiguration = NotificationConfiguration
a} :: CreateScheduledQuery)

-- | The ARN for the IAM role that Timestream will assume when running the
-- scheduled query.
createScheduledQuery_scheduledQueryExecutionRoleArn :: Lens.Lens' CreateScheduledQuery Prelude.Text
createScheduledQuery_scheduledQueryExecutionRoleArn :: Lens' CreateScheduledQuery Text
createScheduledQuery_scheduledQueryExecutionRoleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {Text
scheduledQueryExecutionRoleArn :: Text
$sel:scheduledQueryExecutionRoleArn:CreateScheduledQuery' :: CreateScheduledQuery -> Text
scheduledQueryExecutionRoleArn} -> Text
scheduledQueryExecutionRoleArn) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} Text
a -> CreateScheduledQuery
s {$sel:scheduledQueryExecutionRoleArn:CreateScheduledQuery' :: Text
scheduledQueryExecutionRoleArn = Text
a} :: CreateScheduledQuery)

-- | Configuration for error reporting. Error reports will be generated when
-- a problem is encountered when writing the query results.
createScheduledQuery_errorReportConfiguration :: Lens.Lens' CreateScheduledQuery ErrorReportConfiguration
createScheduledQuery_errorReportConfiguration :: Lens' CreateScheduledQuery ErrorReportConfiguration
createScheduledQuery_errorReportConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQuery' {ErrorReportConfiguration
errorReportConfiguration :: ErrorReportConfiguration
$sel:errorReportConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ErrorReportConfiguration
errorReportConfiguration} -> ErrorReportConfiguration
errorReportConfiguration) (\s :: CreateScheduledQuery
s@CreateScheduledQuery' {} ErrorReportConfiguration
a -> CreateScheduledQuery
s {$sel:errorReportConfiguration:CreateScheduledQuery' :: ErrorReportConfiguration
errorReportConfiguration = ErrorReportConfiguration
a} :: CreateScheduledQuery)

instance Core.AWSRequest CreateScheduledQuery where
  type
    AWSResponse CreateScheduledQuery =
      CreateScheduledQueryResponse
  request :: (Service -> Service)
-> CreateScheduledQuery -> Request CreateScheduledQuery
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 CreateScheduledQuery
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateScheduledQuery)))
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 ->
          Int -> Text -> CreateScheduledQueryResponse
CreateScheduledQueryResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"Arn")
      )

instance Prelude.Hashable CreateScheduledQuery where
  hashWithSalt :: Int -> CreateScheduledQuery -> Int
hashWithSalt Int
_salt CreateScheduledQuery' {Maybe [Tag]
Maybe Text
Maybe (Sensitive Text)
Maybe TargetConfiguration
Text
Sensitive Text
ErrorReportConfiguration
ScheduleConfiguration
NotificationConfiguration
errorReportConfiguration :: ErrorReportConfiguration
scheduledQueryExecutionRoleArn :: Text
notificationConfiguration :: NotificationConfiguration
scheduleConfiguration :: ScheduleConfiguration
queryString :: Sensitive Text
name :: Text
targetConfiguration :: Maybe TargetConfiguration
tags :: Maybe [Tag]
kmsKeyId :: Maybe Text
clientToken :: Maybe (Sensitive Text)
$sel:errorReportConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ErrorReportConfiguration
$sel:scheduledQueryExecutionRoleArn:CreateScheduledQuery' :: CreateScheduledQuery -> Text
$sel:notificationConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> NotificationConfiguration
$sel:scheduleConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ScheduleConfiguration
$sel:queryString:CreateScheduledQuery' :: CreateScheduledQuery -> Sensitive Text
$sel:name:CreateScheduledQuery' :: CreateScheduledQuery -> Text
$sel:targetConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe TargetConfiguration
$sel:tags:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe [Tag]
$sel:kmsKeyId:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe Text
$sel:clientToken:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe (Sensitive Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive Text)
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
kmsKeyId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TargetConfiguration
targetConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Sensitive Text
queryString
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ScheduleConfiguration
scheduleConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NotificationConfiguration
notificationConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
scheduledQueryExecutionRoleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ErrorReportConfiguration
errorReportConfiguration

instance Prelude.NFData CreateScheduledQuery where
  rnf :: CreateScheduledQuery -> ()
rnf CreateScheduledQuery' {Maybe [Tag]
Maybe Text
Maybe (Sensitive Text)
Maybe TargetConfiguration
Text
Sensitive Text
ErrorReportConfiguration
ScheduleConfiguration
NotificationConfiguration
errorReportConfiguration :: ErrorReportConfiguration
scheduledQueryExecutionRoleArn :: Text
notificationConfiguration :: NotificationConfiguration
scheduleConfiguration :: ScheduleConfiguration
queryString :: Sensitive Text
name :: Text
targetConfiguration :: Maybe TargetConfiguration
tags :: Maybe [Tag]
kmsKeyId :: Maybe Text
clientToken :: Maybe (Sensitive Text)
$sel:errorReportConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ErrorReportConfiguration
$sel:scheduledQueryExecutionRoleArn:CreateScheduledQuery' :: CreateScheduledQuery -> Text
$sel:notificationConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> NotificationConfiguration
$sel:scheduleConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ScheduleConfiguration
$sel:queryString:CreateScheduledQuery' :: CreateScheduledQuery -> Sensitive Text
$sel:name:CreateScheduledQuery' :: CreateScheduledQuery -> Text
$sel:targetConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe TargetConfiguration
$sel:tags:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe [Tag]
$sel:kmsKeyId:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe Text
$sel:clientToken:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe (Sensitive Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
kmsKeyId
      seq :: forall a b. a -> b -> b
`Prelude.seq` 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 Maybe TargetConfiguration
targetConfiguration
      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 Sensitive Text
queryString
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ScheduleConfiguration
scheduleConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NotificationConfiguration
notificationConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
scheduledQueryExecutionRoleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ErrorReportConfiguration
errorReportConfiguration

instance Data.ToHeaders CreateScheduledQuery where
  toHeaders :: CreateScheduledQuery -> 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
"Timestream_20181101.CreateScheduledQuery" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateScheduledQuery where
  toJSON :: CreateScheduledQuery -> Value
toJSON CreateScheduledQuery' {Maybe [Tag]
Maybe Text
Maybe (Sensitive Text)
Maybe TargetConfiguration
Text
Sensitive Text
ErrorReportConfiguration
ScheduleConfiguration
NotificationConfiguration
errorReportConfiguration :: ErrorReportConfiguration
scheduledQueryExecutionRoleArn :: Text
notificationConfiguration :: NotificationConfiguration
scheduleConfiguration :: ScheduleConfiguration
queryString :: Sensitive Text
name :: Text
targetConfiguration :: Maybe TargetConfiguration
tags :: Maybe [Tag]
kmsKeyId :: Maybe Text
clientToken :: Maybe (Sensitive Text)
$sel:errorReportConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ErrorReportConfiguration
$sel:scheduledQueryExecutionRoleArn:CreateScheduledQuery' :: CreateScheduledQuery -> Text
$sel:notificationConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> NotificationConfiguration
$sel:scheduleConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> ScheduleConfiguration
$sel:queryString:CreateScheduledQuery' :: CreateScheduledQuery -> Sensitive Text
$sel:name:CreateScheduledQuery' :: CreateScheduledQuery -> Text
$sel:targetConfiguration:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe TargetConfiguration
$sel:tags:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe [Tag]
$sel:kmsKeyId:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe Text
$sel:clientToken:CreateScheduledQuery' :: CreateScheduledQuery -> Maybe (Sensitive 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 (Sensitive Text)
clientToken,
            (Key
"KmsKeyId" 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
kmsKeyId,
            (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,
            (Key
"TargetConfiguration" 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 TargetConfiguration
targetConfiguration,
            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..= Sensitive Text
queryString),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"ScheduleConfiguration"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ScheduleConfiguration
scheduleConfiguration
              ),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"NotificationConfiguration"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NotificationConfiguration
notificationConfiguration
              ),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"ScheduledQueryExecutionRoleArn"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
scheduledQueryExecutionRoleArn
              ),
            forall a. a -> Maybe a
Prelude.Just
              ( Key
"ErrorReportConfiguration"
                  forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ErrorReportConfiguration
errorReportConfiguration
              )
          ]
      )

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

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

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

-- |
-- Create a value of 'CreateScheduledQueryResponse' 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:
--
-- 'httpStatus', 'createScheduledQueryResponse_httpStatus' - The response's http status code.
--
-- 'arn', 'createScheduledQueryResponse_arn' - ARN for the created scheduled query.
newCreateScheduledQueryResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'arn'
  Prelude.Text ->
  CreateScheduledQueryResponse
newCreateScheduledQueryResponse :: Int -> Text -> CreateScheduledQueryResponse
newCreateScheduledQueryResponse Int
pHttpStatus_ Text
pArn_ =
  CreateScheduledQueryResponse'
    { $sel:httpStatus:CreateScheduledQueryResponse' :: Int
httpStatus =
        Int
pHttpStatus_,
      $sel:arn:CreateScheduledQueryResponse' :: Text
arn = Text
pArn_
    }

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

-- | ARN for the created scheduled query.
createScheduledQueryResponse_arn :: Lens.Lens' CreateScheduledQueryResponse Prelude.Text
createScheduledQueryResponse_arn :: Lens' CreateScheduledQueryResponse Text
createScheduledQueryResponse_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduledQueryResponse' {Text
arn :: Text
$sel:arn:CreateScheduledQueryResponse' :: CreateScheduledQueryResponse -> Text
arn} -> Text
arn) (\s :: CreateScheduledQueryResponse
s@CreateScheduledQueryResponse' {} Text
a -> CreateScheduledQueryResponse
s {$sel:arn:CreateScheduledQueryResponse' :: Text
arn = Text
a} :: CreateScheduledQueryResponse)

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