{-# 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.Scheduler.CreateSchedule
-- 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 the specified schedule.
module Amazonka.Scheduler.CreateSchedule
  ( -- * Creating a Request
    CreateSchedule (..),
    newCreateSchedule,

    -- * Request Lenses
    createSchedule_clientToken,
    createSchedule_description,
    createSchedule_endDate,
    createSchedule_groupName,
    createSchedule_kmsKeyArn,
    createSchedule_scheduleExpressionTimezone,
    createSchedule_startDate,
    createSchedule_state,
    createSchedule_flexibleTimeWindow,
    createSchedule_name,
    createSchedule_scheduleExpression,
    createSchedule_target,

    -- * Destructuring the Response
    CreateScheduleResponse (..),
    newCreateScheduleResponse,

    -- * Response Lenses
    createScheduleResponse_httpStatus,
    createScheduleResponse_scheduleArn,
  )
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.Scheduler.Types

-- | /See:/ 'newCreateSchedule' smart constructor.
data CreateSchedule = CreateSchedule'
  { -- | Unique, case-sensitive identifier you provide to ensure the idempotency
    -- of the request. If you do not specify a client token, EventBridge
    -- Scheduler uses a randomly generated token for the request to ensure
    -- idempotency.
    CreateSchedule -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The description you specify for the schedule.
    CreateSchedule -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The date, in UTC, before which the schedule can invoke its target.
    -- Depending on the schedule\'s recurrence expression, invocations might
    -- stop on, or before, the @EndDate@ you specify. EventBridge Scheduler
    -- ignores @EndDate@ for one-time schedules.
    CreateSchedule -> Maybe POSIX
endDate :: Prelude.Maybe Data.POSIX,
    -- | The name of the schedule group to associate with this schedule. If you
    -- omit this, the default schedule group is used.
    CreateSchedule -> Maybe Text
groupName :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) for the customer managed KMS key that
    -- EventBridge Scheduler will use to encrypt and decrypt your data.
    CreateSchedule -> Maybe Text
kmsKeyArn :: Prelude.Maybe Prelude.Text,
    -- | The timezone in which the scheduling expression is evaluated.
    CreateSchedule -> Maybe Text
scheduleExpressionTimezone :: Prelude.Maybe Prelude.Text,
    -- | The date, in UTC, after which the schedule can begin invoking its
    -- target. Depending on the schedule\'s recurrence expression, invocations
    -- might occur on, or after, the @StartDate@ you specify. EventBridge
    -- Scheduler ignores @StartDate@ for one-time schedules.
    CreateSchedule -> Maybe POSIX
startDate :: Prelude.Maybe Data.POSIX,
    -- | Specifies whether the schedule is enabled or disabled.
    CreateSchedule -> Maybe ScheduleState
state :: Prelude.Maybe ScheduleState,
    -- | Allows you to configure a time window during which EventBridge Scheduler
    -- invokes the schedule.
    CreateSchedule -> FlexibleTimeWindow
flexibleTimeWindow :: FlexibleTimeWindow,
    -- | The name of the schedule that you are creating.
    CreateSchedule -> Text
name :: Prelude.Text,
    -- | The expression that defines when the schedule runs. The following
    -- formats are supported.
    --
    -- -   @at@ expression - @at(yyyy-mm-ddThh:mm:ss)@
    --
    -- -   @rate@ expression - @rate(unit value)@
    --
    -- -   @cron@ expression - @cron(fields)@
    --
    -- You can use @at@ expressions to create one-time schedules that invoke a
    -- target once, at the time and in the time zone, that you specify. You can
    -- use @rate@ and @cron@ expressions to create recurring schedules.
    -- Rate-based schedules are useful when you want to invoke a target at
    -- regular intervals, such as every 15 minutes or every five days.
    -- Cron-based schedules are useful when you want to invoke a target
    -- periodically at a specific time, such as at 8:00 am (UTC+0) every 1st
    -- day of the month.
    --
    -- A @cron@ expression consists of six fields separated by white spaces:
    -- @(minutes hours day_of_month month day_of_week year)@.
    --
    -- A @rate@ expression consists of a /value/ as a positive integer, and a
    -- /unit/ with the following options: @minute@ | @minutes@ | @hour@ |
    -- @hours@ | @day@ | @days@
    --
    -- For more information and examples, see
    -- <https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html Schedule types on EventBridge Scheduler>
    -- in the /EventBridge Scheduler User Guide/.
    CreateSchedule -> Text
scheduleExpression :: Prelude.Text,
    -- | The schedule\'s target.
    CreateSchedule -> Target
target :: Target
  }
  deriving (CreateSchedule -> CreateSchedule -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateSchedule -> CreateSchedule -> Bool
$c/= :: CreateSchedule -> CreateSchedule -> Bool
== :: CreateSchedule -> CreateSchedule -> Bool
$c== :: CreateSchedule -> CreateSchedule -> Bool
Prelude.Eq, ReadPrec [CreateSchedule]
ReadPrec CreateSchedule
Int -> ReadS CreateSchedule
ReadS [CreateSchedule]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateSchedule]
$creadListPrec :: ReadPrec [CreateSchedule]
readPrec :: ReadPrec CreateSchedule
$creadPrec :: ReadPrec CreateSchedule
readList :: ReadS [CreateSchedule]
$creadList :: ReadS [CreateSchedule]
readsPrec :: Int -> ReadS CreateSchedule
$creadsPrec :: Int -> ReadS CreateSchedule
Prelude.Read, Int -> CreateSchedule -> ShowS
[CreateSchedule] -> ShowS
CreateSchedule -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateSchedule] -> ShowS
$cshowList :: [CreateSchedule] -> ShowS
show :: CreateSchedule -> String
$cshow :: CreateSchedule -> String
showsPrec :: Int -> CreateSchedule -> ShowS
$cshowsPrec :: Int -> CreateSchedule -> ShowS
Prelude.Show, forall x. Rep CreateSchedule x -> CreateSchedule
forall x. CreateSchedule -> Rep CreateSchedule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateSchedule x -> CreateSchedule
$cfrom :: forall x. CreateSchedule -> Rep CreateSchedule x
Prelude.Generic)

-- |
-- Create a value of 'CreateSchedule' 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', 'createSchedule_clientToken' - Unique, case-sensitive identifier you provide to ensure the idempotency
-- of the request. If you do not specify a client token, EventBridge
-- Scheduler uses a randomly generated token for the request to ensure
-- idempotency.
--
-- 'description', 'createSchedule_description' - The description you specify for the schedule.
--
-- 'endDate', 'createSchedule_endDate' - The date, in UTC, before which the schedule can invoke its target.
-- Depending on the schedule\'s recurrence expression, invocations might
-- stop on, or before, the @EndDate@ you specify. EventBridge Scheduler
-- ignores @EndDate@ for one-time schedules.
--
-- 'groupName', 'createSchedule_groupName' - The name of the schedule group to associate with this schedule. If you
-- omit this, the default schedule group is used.
--
-- 'kmsKeyArn', 'createSchedule_kmsKeyArn' - The Amazon Resource Name (ARN) for the customer managed KMS key that
-- EventBridge Scheduler will use to encrypt and decrypt your data.
--
-- 'scheduleExpressionTimezone', 'createSchedule_scheduleExpressionTimezone' - The timezone in which the scheduling expression is evaluated.
--
-- 'startDate', 'createSchedule_startDate' - The date, in UTC, after which the schedule can begin invoking its
-- target. Depending on the schedule\'s recurrence expression, invocations
-- might occur on, or after, the @StartDate@ you specify. EventBridge
-- Scheduler ignores @StartDate@ for one-time schedules.
--
-- 'state', 'createSchedule_state' - Specifies whether the schedule is enabled or disabled.
--
-- 'flexibleTimeWindow', 'createSchedule_flexibleTimeWindow' - Allows you to configure a time window during which EventBridge Scheduler
-- invokes the schedule.
--
-- 'name', 'createSchedule_name' - The name of the schedule that you are creating.
--
-- 'scheduleExpression', 'createSchedule_scheduleExpression' - The expression that defines when the schedule runs. The following
-- formats are supported.
--
-- -   @at@ expression - @at(yyyy-mm-ddThh:mm:ss)@
--
-- -   @rate@ expression - @rate(unit value)@
--
-- -   @cron@ expression - @cron(fields)@
--
-- You can use @at@ expressions to create one-time schedules that invoke a
-- target once, at the time and in the time zone, that you specify. You can
-- use @rate@ and @cron@ expressions to create recurring schedules.
-- Rate-based schedules are useful when you want to invoke a target at
-- regular intervals, such as every 15 minutes or every five days.
-- Cron-based schedules are useful when you want to invoke a target
-- periodically at a specific time, such as at 8:00 am (UTC+0) every 1st
-- day of the month.
--
-- A @cron@ expression consists of six fields separated by white spaces:
-- @(minutes hours day_of_month month day_of_week year)@.
--
-- A @rate@ expression consists of a /value/ as a positive integer, and a
-- /unit/ with the following options: @minute@ | @minutes@ | @hour@ |
-- @hours@ | @day@ | @days@
--
-- For more information and examples, see
-- <https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html Schedule types on EventBridge Scheduler>
-- in the /EventBridge Scheduler User Guide/.
--
-- 'target', 'createSchedule_target' - The schedule\'s target.
newCreateSchedule ::
  -- | 'flexibleTimeWindow'
  FlexibleTimeWindow ->
  -- | 'name'
  Prelude.Text ->
  -- | 'scheduleExpression'
  Prelude.Text ->
  -- | 'target'
  Target ->
  CreateSchedule
newCreateSchedule :: FlexibleTimeWindow -> Text -> Text -> Target -> CreateSchedule
newCreateSchedule
  FlexibleTimeWindow
pFlexibleTimeWindow_
  Text
pName_
  Text
pScheduleExpression_
  Target
pTarget_ =
    CreateSchedule'
      { $sel:clientToken:CreateSchedule' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
        $sel:description:CreateSchedule' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
        $sel:endDate:CreateSchedule' :: Maybe POSIX
endDate = forall a. Maybe a
Prelude.Nothing,
        $sel:groupName:CreateSchedule' :: Maybe Text
groupName = forall a. Maybe a
Prelude.Nothing,
        $sel:kmsKeyArn:CreateSchedule' :: Maybe Text
kmsKeyArn = forall a. Maybe a
Prelude.Nothing,
        $sel:scheduleExpressionTimezone:CreateSchedule' :: Maybe Text
scheduleExpressionTimezone = forall a. Maybe a
Prelude.Nothing,
        $sel:startDate:CreateSchedule' :: Maybe POSIX
startDate = forall a. Maybe a
Prelude.Nothing,
        $sel:state:CreateSchedule' :: Maybe ScheduleState
state = forall a. Maybe a
Prelude.Nothing,
        $sel:flexibleTimeWindow:CreateSchedule' :: FlexibleTimeWindow
flexibleTimeWindow = FlexibleTimeWindow
pFlexibleTimeWindow_,
        $sel:name:CreateSchedule' :: Text
name = Text
pName_,
        $sel:scheduleExpression:CreateSchedule' :: Text
scheduleExpression = Text
pScheduleExpression_,
        $sel:target:CreateSchedule' :: Target
target = Target
pTarget_
      }

-- | Unique, case-sensitive identifier you provide to ensure the idempotency
-- of the request. If you do not specify a client token, EventBridge
-- Scheduler uses a randomly generated token for the request to ensure
-- idempotency.
createSchedule_clientToken :: Lens.Lens' CreateSchedule (Prelude.Maybe Prelude.Text)
createSchedule_clientToken :: Lens' CreateSchedule (Maybe Text)
createSchedule_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:CreateSchedule' :: CreateSchedule -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe Text
a -> CreateSchedule
s {$sel:clientToken:CreateSchedule' :: Maybe Text
clientToken = Maybe Text
a} :: CreateSchedule)

-- | The description you specify for the schedule.
createSchedule_description :: Lens.Lens' CreateSchedule (Prelude.Maybe Prelude.Text)
createSchedule_description :: Lens' CreateSchedule (Maybe Text)
createSchedule_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe Text
description :: Maybe Text
$sel:description:CreateSchedule' :: CreateSchedule -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe Text
a -> CreateSchedule
s {$sel:description:CreateSchedule' :: Maybe Text
description = Maybe Text
a} :: CreateSchedule)

-- | The date, in UTC, before which the schedule can invoke its target.
-- Depending on the schedule\'s recurrence expression, invocations might
-- stop on, or before, the @EndDate@ you specify. EventBridge Scheduler
-- ignores @EndDate@ for one-time schedules.
createSchedule_endDate :: Lens.Lens' CreateSchedule (Prelude.Maybe Prelude.UTCTime)
createSchedule_endDate :: Lens' CreateSchedule (Maybe UTCTime)
createSchedule_endDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe POSIX
endDate :: Maybe POSIX
$sel:endDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
endDate} -> Maybe POSIX
endDate) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe POSIX
a -> CreateSchedule
s {$sel:endDate:CreateSchedule' :: Maybe POSIX
endDate = Maybe POSIX
a} :: CreateSchedule) 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 :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The name of the schedule group to associate with this schedule. If you
-- omit this, the default schedule group is used.
createSchedule_groupName :: Lens.Lens' CreateSchedule (Prelude.Maybe Prelude.Text)
createSchedule_groupName :: Lens' CreateSchedule (Maybe Text)
createSchedule_groupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe Text
groupName :: Maybe Text
$sel:groupName:CreateSchedule' :: CreateSchedule -> Maybe Text
groupName} -> Maybe Text
groupName) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe Text
a -> CreateSchedule
s {$sel:groupName:CreateSchedule' :: Maybe Text
groupName = Maybe Text
a} :: CreateSchedule)

-- | The Amazon Resource Name (ARN) for the customer managed KMS key that
-- EventBridge Scheduler will use to encrypt and decrypt your data.
createSchedule_kmsKeyArn :: Lens.Lens' CreateSchedule (Prelude.Maybe Prelude.Text)
createSchedule_kmsKeyArn :: Lens' CreateSchedule (Maybe Text)
createSchedule_kmsKeyArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe Text
kmsKeyArn :: Maybe Text
$sel:kmsKeyArn:CreateSchedule' :: CreateSchedule -> Maybe Text
kmsKeyArn} -> Maybe Text
kmsKeyArn) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe Text
a -> CreateSchedule
s {$sel:kmsKeyArn:CreateSchedule' :: Maybe Text
kmsKeyArn = Maybe Text
a} :: CreateSchedule)

-- | The timezone in which the scheduling expression is evaluated.
createSchedule_scheduleExpressionTimezone :: Lens.Lens' CreateSchedule (Prelude.Maybe Prelude.Text)
createSchedule_scheduleExpressionTimezone :: Lens' CreateSchedule (Maybe Text)
createSchedule_scheduleExpressionTimezone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe Text
scheduleExpressionTimezone :: Maybe Text
$sel:scheduleExpressionTimezone:CreateSchedule' :: CreateSchedule -> Maybe Text
scheduleExpressionTimezone} -> Maybe Text
scheduleExpressionTimezone) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe Text
a -> CreateSchedule
s {$sel:scheduleExpressionTimezone:CreateSchedule' :: Maybe Text
scheduleExpressionTimezone = Maybe Text
a} :: CreateSchedule)

-- | The date, in UTC, after which the schedule can begin invoking its
-- target. Depending on the schedule\'s recurrence expression, invocations
-- might occur on, or after, the @StartDate@ you specify. EventBridge
-- Scheduler ignores @StartDate@ for one-time schedules.
createSchedule_startDate :: Lens.Lens' CreateSchedule (Prelude.Maybe Prelude.UTCTime)
createSchedule_startDate :: Lens' CreateSchedule (Maybe UTCTime)
createSchedule_startDate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe POSIX
startDate :: Maybe POSIX
$sel:startDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
startDate} -> Maybe POSIX
startDate) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe POSIX
a -> CreateSchedule
s {$sel:startDate:CreateSchedule' :: Maybe POSIX
startDate = Maybe POSIX
a} :: CreateSchedule) 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 :: Format). Iso' (Time a) UTCTime
Data._Time

-- | Specifies whether the schedule is enabled or disabled.
createSchedule_state :: Lens.Lens' CreateSchedule (Prelude.Maybe ScheduleState)
createSchedule_state :: Lens' CreateSchedule (Maybe ScheduleState)
createSchedule_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Maybe ScheduleState
state :: Maybe ScheduleState
$sel:state:CreateSchedule' :: CreateSchedule -> Maybe ScheduleState
state} -> Maybe ScheduleState
state) (\s :: CreateSchedule
s@CreateSchedule' {} Maybe ScheduleState
a -> CreateSchedule
s {$sel:state:CreateSchedule' :: Maybe ScheduleState
state = Maybe ScheduleState
a} :: CreateSchedule)

-- | Allows you to configure a time window during which EventBridge Scheduler
-- invokes the schedule.
createSchedule_flexibleTimeWindow :: Lens.Lens' CreateSchedule FlexibleTimeWindow
createSchedule_flexibleTimeWindow :: Lens' CreateSchedule FlexibleTimeWindow
createSchedule_flexibleTimeWindow = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {FlexibleTimeWindow
flexibleTimeWindow :: FlexibleTimeWindow
$sel:flexibleTimeWindow:CreateSchedule' :: CreateSchedule -> FlexibleTimeWindow
flexibleTimeWindow} -> FlexibleTimeWindow
flexibleTimeWindow) (\s :: CreateSchedule
s@CreateSchedule' {} FlexibleTimeWindow
a -> CreateSchedule
s {$sel:flexibleTimeWindow:CreateSchedule' :: FlexibleTimeWindow
flexibleTimeWindow = FlexibleTimeWindow
a} :: CreateSchedule)

-- | The name of the schedule that you are creating.
createSchedule_name :: Lens.Lens' CreateSchedule Prelude.Text
createSchedule_name :: Lens' CreateSchedule Text
createSchedule_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Text
name :: Text
$sel:name:CreateSchedule' :: CreateSchedule -> Text
name} -> Text
name) (\s :: CreateSchedule
s@CreateSchedule' {} Text
a -> CreateSchedule
s {$sel:name:CreateSchedule' :: Text
name = Text
a} :: CreateSchedule)

-- | The expression that defines when the schedule runs. The following
-- formats are supported.
--
-- -   @at@ expression - @at(yyyy-mm-ddThh:mm:ss)@
--
-- -   @rate@ expression - @rate(unit value)@
--
-- -   @cron@ expression - @cron(fields)@
--
-- You can use @at@ expressions to create one-time schedules that invoke a
-- target once, at the time and in the time zone, that you specify. You can
-- use @rate@ and @cron@ expressions to create recurring schedules.
-- Rate-based schedules are useful when you want to invoke a target at
-- regular intervals, such as every 15 minutes or every five days.
-- Cron-based schedules are useful when you want to invoke a target
-- periodically at a specific time, such as at 8:00 am (UTC+0) every 1st
-- day of the month.
--
-- A @cron@ expression consists of six fields separated by white spaces:
-- @(minutes hours day_of_month month day_of_week year)@.
--
-- A @rate@ expression consists of a /value/ as a positive integer, and a
-- /unit/ with the following options: @minute@ | @minutes@ | @hour@ |
-- @hours@ | @day@ | @days@
--
-- For more information and examples, see
-- <https://docs.aws.amazon.com/scheduler/latest/UserGuide/schedule-types.html Schedule types on EventBridge Scheduler>
-- in the /EventBridge Scheduler User Guide/.
createSchedule_scheduleExpression :: Lens.Lens' CreateSchedule Prelude.Text
createSchedule_scheduleExpression :: Lens' CreateSchedule Text
createSchedule_scheduleExpression = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Text
scheduleExpression :: Text
$sel:scheduleExpression:CreateSchedule' :: CreateSchedule -> Text
scheduleExpression} -> Text
scheduleExpression) (\s :: CreateSchedule
s@CreateSchedule' {} Text
a -> CreateSchedule
s {$sel:scheduleExpression:CreateSchedule' :: Text
scheduleExpression = Text
a} :: CreateSchedule)

-- | The schedule\'s target.
createSchedule_target :: Lens.Lens' CreateSchedule Target
createSchedule_target :: Lens' CreateSchedule Target
createSchedule_target = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateSchedule' {Target
target :: Target
$sel:target:CreateSchedule' :: CreateSchedule -> Target
target} -> Target
target) (\s :: CreateSchedule
s@CreateSchedule' {} Target
a -> CreateSchedule
s {$sel:target:CreateSchedule' :: Target
target = Target
a} :: CreateSchedule)

instance Core.AWSRequest CreateSchedule where
  type
    AWSResponse CreateSchedule =
      CreateScheduleResponse
  request :: (Service -> Service) -> CreateSchedule -> Request CreateSchedule
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 CreateSchedule
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateSchedule)))
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 -> CreateScheduleResponse
CreateScheduleResponse'
            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
"ScheduleArn")
      )

instance Prelude.Hashable CreateSchedule where
  hashWithSalt :: Int -> CreateSchedule -> Int
hashWithSalt Int
_salt CreateSchedule' {Maybe Text
Maybe POSIX
Maybe ScheduleState
Text
FlexibleTimeWindow
Target
target :: Target
scheduleExpression :: Text
name :: Text
flexibleTimeWindow :: FlexibleTimeWindow
state :: Maybe ScheduleState
startDate :: Maybe POSIX
scheduleExpressionTimezone :: Maybe Text
kmsKeyArn :: Maybe Text
groupName :: Maybe Text
endDate :: Maybe POSIX
description :: Maybe Text
clientToken :: Maybe Text
$sel:target:CreateSchedule' :: CreateSchedule -> Target
$sel:scheduleExpression:CreateSchedule' :: CreateSchedule -> Text
$sel:name:CreateSchedule' :: CreateSchedule -> Text
$sel:flexibleTimeWindow:CreateSchedule' :: CreateSchedule -> FlexibleTimeWindow
$sel:state:CreateSchedule' :: CreateSchedule -> Maybe ScheduleState
$sel:startDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:scheduleExpressionTimezone:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:kmsKeyArn:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:groupName:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:endDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:description:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:clientToken:CreateSchedule' :: CreateSchedule -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
endDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
groupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
kmsKeyArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
scheduleExpressionTimezone
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
startDate
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ScheduleState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` FlexibleTimeWindow
flexibleTimeWindow
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
scheduleExpression
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Target
target

instance Prelude.NFData CreateSchedule where
  rnf :: CreateSchedule -> ()
rnf CreateSchedule' {Maybe Text
Maybe POSIX
Maybe ScheduleState
Text
FlexibleTimeWindow
Target
target :: Target
scheduleExpression :: Text
name :: Text
flexibleTimeWindow :: FlexibleTimeWindow
state :: Maybe ScheduleState
startDate :: Maybe POSIX
scheduleExpressionTimezone :: Maybe Text
kmsKeyArn :: Maybe Text
groupName :: Maybe Text
endDate :: Maybe POSIX
description :: Maybe Text
clientToken :: Maybe Text
$sel:target:CreateSchedule' :: CreateSchedule -> Target
$sel:scheduleExpression:CreateSchedule' :: CreateSchedule -> Text
$sel:name:CreateSchedule' :: CreateSchedule -> Text
$sel:flexibleTimeWindow:CreateSchedule' :: CreateSchedule -> FlexibleTimeWindow
$sel:state:CreateSchedule' :: CreateSchedule -> Maybe ScheduleState
$sel:startDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:scheduleExpressionTimezone:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:kmsKeyArn:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:groupName:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:endDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:description:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:clientToken:CreateSchedule' :: CreateSchedule -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
endDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
groupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
kmsKeyArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
scheduleExpressionTimezone
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
startDate
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ScheduleState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf FlexibleTimeWindow
flexibleTimeWindow
      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
scheduleExpression
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Target
target

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

instance Data.ToJSON CreateSchedule where
  toJSON :: CreateSchedule -> Value
toJSON CreateSchedule' {Maybe Text
Maybe POSIX
Maybe ScheduleState
Text
FlexibleTimeWindow
Target
target :: Target
scheduleExpression :: Text
name :: Text
flexibleTimeWindow :: FlexibleTimeWindow
state :: Maybe ScheduleState
startDate :: Maybe POSIX
scheduleExpressionTimezone :: Maybe Text
kmsKeyArn :: Maybe Text
groupName :: Maybe Text
endDate :: Maybe POSIX
description :: Maybe Text
clientToken :: Maybe Text
$sel:target:CreateSchedule' :: CreateSchedule -> Target
$sel:scheduleExpression:CreateSchedule' :: CreateSchedule -> Text
$sel:name:CreateSchedule' :: CreateSchedule -> Text
$sel:flexibleTimeWindow:CreateSchedule' :: CreateSchedule -> FlexibleTimeWindow
$sel:state:CreateSchedule' :: CreateSchedule -> Maybe ScheduleState
$sel:startDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:scheduleExpressionTimezone:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:kmsKeyArn:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:groupName:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:endDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:description:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:clientToken:CreateSchedule' :: CreateSchedule -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientToken" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
clientToken,
            (Key
"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
"EndDate" 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 POSIX
endDate,
            (Key
"GroupName" 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
groupName,
            (Key
"KmsKeyArn" 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
kmsKeyArn,
            (Key
"ScheduleExpressionTimezone" 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
scheduleExpressionTimezone,
            (Key
"StartDate" 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 POSIX
startDate,
            (Key
"State" 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 ScheduleState
state,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"FlexibleTimeWindow" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= FlexibleTimeWindow
flexibleTimeWindow),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"ScheduleExpression" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
scheduleExpression),
            forall a. a -> Maybe a
Prelude.Just (Key
"Target" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Target
target)
          ]
      )

instance Data.ToPath CreateSchedule where
  toPath :: CreateSchedule -> ByteString
toPath CreateSchedule' {Maybe Text
Maybe POSIX
Maybe ScheduleState
Text
FlexibleTimeWindow
Target
target :: Target
scheduleExpression :: Text
name :: Text
flexibleTimeWindow :: FlexibleTimeWindow
state :: Maybe ScheduleState
startDate :: Maybe POSIX
scheduleExpressionTimezone :: Maybe Text
kmsKeyArn :: Maybe Text
groupName :: Maybe Text
endDate :: Maybe POSIX
description :: Maybe Text
clientToken :: Maybe Text
$sel:target:CreateSchedule' :: CreateSchedule -> Target
$sel:scheduleExpression:CreateSchedule' :: CreateSchedule -> Text
$sel:name:CreateSchedule' :: CreateSchedule -> Text
$sel:flexibleTimeWindow:CreateSchedule' :: CreateSchedule -> FlexibleTimeWindow
$sel:state:CreateSchedule' :: CreateSchedule -> Maybe ScheduleState
$sel:startDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:scheduleExpressionTimezone:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:kmsKeyArn:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:groupName:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:endDate:CreateSchedule' :: CreateSchedule -> Maybe POSIX
$sel:description:CreateSchedule' :: CreateSchedule -> Maybe Text
$sel:clientToken:CreateSchedule' :: CreateSchedule -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat [ByteString
"/schedules/", forall a. ToByteString a => a -> ByteString
Data.toBS Text
name]

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

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

-- |
-- Create a value of 'CreateScheduleResponse' 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', 'createScheduleResponse_httpStatus' - The response's http status code.
--
-- 'scheduleArn', 'createScheduleResponse_scheduleArn' - The Amazon Resource Name (ARN) of the schedule.
newCreateScheduleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'scheduleArn'
  Prelude.Text ->
  CreateScheduleResponse
newCreateScheduleResponse :: Int -> Text -> CreateScheduleResponse
newCreateScheduleResponse Int
pHttpStatus_ Text
pScheduleArn_ =
  CreateScheduleResponse'
    { $sel:httpStatus:CreateScheduleResponse' :: Int
httpStatus = Int
pHttpStatus_,
      $sel:scheduleArn:CreateScheduleResponse' :: Text
scheduleArn = Text
pScheduleArn_
    }

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

-- | The Amazon Resource Name (ARN) of the schedule.
createScheduleResponse_scheduleArn :: Lens.Lens' CreateScheduleResponse Prelude.Text
createScheduleResponse_scheduleArn :: Lens' CreateScheduleResponse Text
createScheduleResponse_scheduleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateScheduleResponse' {Text
scheduleArn :: Text
$sel:scheduleArn:CreateScheduleResponse' :: CreateScheduleResponse -> Text
scheduleArn} -> Text
scheduleArn) (\s :: CreateScheduleResponse
s@CreateScheduleResponse' {} Text
a -> CreateScheduleResponse
s {$sel:scheduleArn:CreateScheduleResponse' :: Text
scheduleArn = Text
a} :: CreateScheduleResponse)

instance Prelude.NFData CreateScheduleResponse where
  rnf :: CreateScheduleResponse -> ()
rnf CreateScheduleResponse' {Int
Text
scheduleArn :: Text
httpStatus :: Int
$sel:scheduleArn:CreateScheduleResponse' :: CreateScheduleResponse -> Text
$sel:httpStatus:CreateScheduleResponse' :: CreateScheduleResponse -> 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
scheduleArn