{-# 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.CloudWatchEvents.PutRule
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates or updates the specified rule. Rules are enabled by default, or
-- based on value of the state. You can disable a rule using
-- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_DisableRule.html DisableRule>.
--
-- A single rule watches for events from a single event bus. Events
-- generated by Amazon Web Services services go to your account\'s default
-- event bus. Events generated by SaaS partner services or applications go
-- to the matching partner event bus. If you have custom applications or
-- services, you can specify whether their events go to your default event
-- bus or a custom event bus that you have created. For more information,
-- see
-- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_CreateEventBus.html CreateEventBus>.
--
-- If you are updating an existing rule, the rule is replaced with what you
-- specify in this @PutRule@ command. If you omit arguments in @PutRule@,
-- the old values for those arguments are not kept. Instead, they are
-- replaced with null values.
--
-- When you create or update a rule, incoming events might not immediately
-- start matching to new or updated rules. Allow a short period of time for
-- changes to take effect.
--
-- A rule must contain at least an EventPattern or ScheduleExpression.
-- Rules with EventPatterns are triggered when a matching event is
-- observed. Rules with ScheduleExpressions self-trigger based on the given
-- schedule. A rule can have both an EventPattern and a ScheduleExpression,
-- in which case the rule triggers on matching events as well as on a
-- schedule.
--
-- When you initially create a rule, you can optionally assign one or more
-- tags to the rule. Tags can help you organize and categorize your
-- resources. You can also use them to scope user permissions, by granting
-- a user permission to access or change only rules with certain tag
-- values. To use the @PutRule@ operation and assign tags, you must have
-- both the @events:PutRule@ and @events:TagResource@ permissions.
--
-- If you are updating an existing rule, any tags you specify in the
-- @PutRule@ operation are ignored. To update the tags of an existing rule,
-- use
-- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_TagResource.html TagResource>
-- and
-- <https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_UntagResource.html UntagResource>.
--
-- Most services in Amazon Web Services treat : or \/ as the same character
-- in Amazon Resource Names (ARNs). However, EventBridge uses an exact
-- match in event patterns and rules. Be sure to use the correct ARN
-- characters when creating event patterns so that they match the ARN
-- syntax in the event you want to match.
--
-- In EventBridge, it is possible to create rules that lead to infinite
-- loops, where a rule is fired repeatedly. For example, a rule might
-- detect that ACLs have changed on an S3 bucket, and trigger software to
-- change them to the desired state. If the rule is not written carefully,
-- the subsequent change to the ACLs fires the rule again, creating an
-- infinite loop.
--
-- To prevent this, write the rules so that the triggered actions do not
-- re-fire the same rule. For example, your rule could fire only if ACLs
-- are found to be in a bad state, instead of after any change.
--
-- An infinite loop can quickly cause higher than expected charges. We
-- recommend that you use budgeting, which alerts you when charges exceed
-- your specified limit. For more information, see
-- <https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/budgets-managing-costs.html Managing Your Costs with Budgets>.
module Amazonka.CloudWatchEvents.PutRule
  ( -- * Creating a Request
    PutRule (..),
    newPutRule,

    -- * Request Lenses
    putRule_description,
    putRule_eventBusName,
    putRule_eventPattern,
    putRule_roleArn,
    putRule_scheduleExpression,
    putRule_state,
    putRule_tags,
    putRule_name,

    -- * Destructuring the Response
    PutRuleResponse (..),
    newPutRuleResponse,

    -- * Response Lenses
    putRuleResponse_ruleArn,
    putRuleResponse_httpStatus,
  )
where

import Amazonka.CloudWatchEvents.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:/ 'newPutRule' smart constructor.
data PutRule = PutRule'
  { -- | A description of the rule.
    PutRule -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The name or ARN of the event bus to associate with this rule. If you
    -- omit this, the default event bus is used.
    PutRule -> Maybe Text
eventBusName :: Prelude.Maybe Prelude.Text,
    -- | The event pattern. For more information, see
    -- <https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html.html EventBridge event patterns>
    -- in the /Amazon EventBridge User Guide/.
    PutRule -> Maybe Text
eventPattern :: Prelude.Maybe Prelude.Text,
    -- | The Amazon Resource Name (ARN) of the IAM role associated with the rule.
    --
    -- If you\'re setting an event bus in another account as the target and
    -- that account granted permission to your account through an organization
    -- instead of directly by the account ID, you must specify a @RoleArn@ with
    -- proper permissions in the @Target@ structure, instead of here in this
    -- parameter.
    PutRule -> Maybe Text
roleArn :: Prelude.Maybe Prelude.Text,
    -- | The scheduling expression. For example, \"cron(0 20 * * ? *)\" or
    -- \"rate(5 minutes)\".
    PutRule -> Maybe Text
scheduleExpression :: Prelude.Maybe Prelude.Text,
    -- | Indicates whether the rule is enabled or disabled.
    PutRule -> Maybe RuleState
state :: Prelude.Maybe RuleState,
    -- | The list of key-value pairs to associate with the rule.
    PutRule -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The name of the rule that you are creating or updating.
    PutRule -> Text
name :: Prelude.Text
  }
  deriving (PutRule -> PutRule -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutRule -> PutRule -> Bool
$c/= :: PutRule -> PutRule -> Bool
== :: PutRule -> PutRule -> Bool
$c== :: PutRule -> PutRule -> Bool
Prelude.Eq, ReadPrec [PutRule]
ReadPrec PutRule
Int -> ReadS PutRule
ReadS [PutRule]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutRule]
$creadListPrec :: ReadPrec [PutRule]
readPrec :: ReadPrec PutRule
$creadPrec :: ReadPrec PutRule
readList :: ReadS [PutRule]
$creadList :: ReadS [PutRule]
readsPrec :: Int -> ReadS PutRule
$creadsPrec :: Int -> ReadS PutRule
Prelude.Read, Int -> PutRule -> ShowS
[PutRule] -> ShowS
PutRule -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutRule] -> ShowS
$cshowList :: [PutRule] -> ShowS
show :: PutRule -> String
$cshow :: PutRule -> String
showsPrec :: Int -> PutRule -> ShowS
$cshowsPrec :: Int -> PutRule -> ShowS
Prelude.Show, forall x. Rep PutRule x -> PutRule
forall x. PutRule -> Rep PutRule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PutRule x -> PutRule
$cfrom :: forall x. PutRule -> Rep PutRule x
Prelude.Generic)

-- |
-- Create a value of 'PutRule' 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:
--
-- 'description', 'putRule_description' - A description of the rule.
--
-- 'eventBusName', 'putRule_eventBusName' - The name or ARN of the event bus to associate with this rule. If you
-- omit this, the default event bus is used.
--
-- 'eventPattern', 'putRule_eventPattern' - The event pattern. For more information, see
-- <https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html.html EventBridge event patterns>
-- in the /Amazon EventBridge User Guide/.
--
-- 'roleArn', 'putRule_roleArn' - The Amazon Resource Name (ARN) of the IAM role associated with the rule.
--
-- If you\'re setting an event bus in another account as the target and
-- that account granted permission to your account through an organization
-- instead of directly by the account ID, you must specify a @RoleArn@ with
-- proper permissions in the @Target@ structure, instead of here in this
-- parameter.
--
-- 'scheduleExpression', 'putRule_scheduleExpression' - The scheduling expression. For example, \"cron(0 20 * * ? *)\" or
-- \"rate(5 minutes)\".
--
-- 'state', 'putRule_state' - Indicates whether the rule is enabled or disabled.
--
-- 'tags', 'putRule_tags' - The list of key-value pairs to associate with the rule.
--
-- 'name', 'putRule_name' - The name of the rule that you are creating or updating.
newPutRule ::
  -- | 'name'
  Prelude.Text ->
  PutRule
newPutRule :: Text -> PutRule
newPutRule Text
pName_ =
  PutRule'
    { $sel:description:PutRule' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:eventBusName:PutRule' :: Maybe Text
eventBusName = forall a. Maybe a
Prelude.Nothing,
      $sel:eventPattern:PutRule' :: Maybe Text
eventPattern = forall a. Maybe a
Prelude.Nothing,
      $sel:roleArn:PutRule' :: Maybe Text
roleArn = forall a. Maybe a
Prelude.Nothing,
      $sel:scheduleExpression:PutRule' :: Maybe Text
scheduleExpression = forall a. Maybe a
Prelude.Nothing,
      $sel:state:PutRule' :: Maybe RuleState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:PutRule' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:name:PutRule' :: Text
name = Text
pName_
    }

-- | A description of the rule.
putRule_description :: Lens.Lens' PutRule (Prelude.Maybe Prelude.Text)
putRule_description :: Lens' PutRule (Maybe Text)
putRule_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRule' {Maybe Text
description :: Maybe Text
$sel:description:PutRule' :: PutRule -> Maybe Text
description} -> Maybe Text
description) (\s :: PutRule
s@PutRule' {} Maybe Text
a -> PutRule
s {$sel:description:PutRule' :: Maybe Text
description = Maybe Text
a} :: PutRule)

-- | The name or ARN of the event bus to associate with this rule. If you
-- omit this, the default event bus is used.
putRule_eventBusName :: Lens.Lens' PutRule (Prelude.Maybe Prelude.Text)
putRule_eventBusName :: Lens' PutRule (Maybe Text)
putRule_eventBusName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRule' {Maybe Text
eventBusName :: Maybe Text
$sel:eventBusName:PutRule' :: PutRule -> Maybe Text
eventBusName} -> Maybe Text
eventBusName) (\s :: PutRule
s@PutRule' {} Maybe Text
a -> PutRule
s {$sel:eventBusName:PutRule' :: Maybe Text
eventBusName = Maybe Text
a} :: PutRule)

-- | The event pattern. For more information, see
-- <https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-event-patterns.html.html EventBridge event patterns>
-- in the /Amazon EventBridge User Guide/.
putRule_eventPattern :: Lens.Lens' PutRule (Prelude.Maybe Prelude.Text)
putRule_eventPattern :: Lens' PutRule (Maybe Text)
putRule_eventPattern = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRule' {Maybe Text
eventPattern :: Maybe Text
$sel:eventPattern:PutRule' :: PutRule -> Maybe Text
eventPattern} -> Maybe Text
eventPattern) (\s :: PutRule
s@PutRule' {} Maybe Text
a -> PutRule
s {$sel:eventPattern:PutRule' :: Maybe Text
eventPattern = Maybe Text
a} :: PutRule)

-- | The Amazon Resource Name (ARN) of the IAM role associated with the rule.
--
-- If you\'re setting an event bus in another account as the target and
-- that account granted permission to your account through an organization
-- instead of directly by the account ID, you must specify a @RoleArn@ with
-- proper permissions in the @Target@ structure, instead of here in this
-- parameter.
putRule_roleArn :: Lens.Lens' PutRule (Prelude.Maybe Prelude.Text)
putRule_roleArn :: Lens' PutRule (Maybe Text)
putRule_roleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRule' {Maybe Text
roleArn :: Maybe Text
$sel:roleArn:PutRule' :: PutRule -> Maybe Text
roleArn} -> Maybe Text
roleArn) (\s :: PutRule
s@PutRule' {} Maybe Text
a -> PutRule
s {$sel:roleArn:PutRule' :: Maybe Text
roleArn = Maybe Text
a} :: PutRule)

-- | The scheduling expression. For example, \"cron(0 20 * * ? *)\" or
-- \"rate(5 minutes)\".
putRule_scheduleExpression :: Lens.Lens' PutRule (Prelude.Maybe Prelude.Text)
putRule_scheduleExpression :: Lens' PutRule (Maybe Text)
putRule_scheduleExpression = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRule' {Maybe Text
scheduleExpression :: Maybe Text
$sel:scheduleExpression:PutRule' :: PutRule -> Maybe Text
scheduleExpression} -> Maybe Text
scheduleExpression) (\s :: PutRule
s@PutRule' {} Maybe Text
a -> PutRule
s {$sel:scheduleExpression:PutRule' :: Maybe Text
scheduleExpression = Maybe Text
a} :: PutRule)

-- | Indicates whether the rule is enabled or disabled.
putRule_state :: Lens.Lens' PutRule (Prelude.Maybe RuleState)
putRule_state :: Lens' PutRule (Maybe RuleState)
putRule_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRule' {Maybe RuleState
state :: Maybe RuleState
$sel:state:PutRule' :: PutRule -> Maybe RuleState
state} -> Maybe RuleState
state) (\s :: PutRule
s@PutRule' {} Maybe RuleState
a -> PutRule
s {$sel:state:PutRule' :: Maybe RuleState
state = Maybe RuleState
a} :: PutRule)

-- | The list of key-value pairs to associate with the rule.
putRule_tags :: Lens.Lens' PutRule (Prelude.Maybe [Tag])
putRule_tags :: Lens' PutRule (Maybe [Tag])
putRule_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRule' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:PutRule' :: PutRule -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: PutRule
s@PutRule' {} Maybe [Tag]
a -> PutRule
s {$sel:tags:PutRule' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: PutRule) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Core.AWSRequest PutRule where
  type AWSResponse PutRule = PutRuleResponse
  request :: (Service -> Service) -> PutRule -> Request PutRule
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 PutRule
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse PutRule)))
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 -> PutRuleResponse
PutRuleResponse'
            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
"RuleArn")
            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 PutRule where
  hashWithSalt :: Int -> PutRule -> Int
hashWithSalt Int
_salt PutRule' {Maybe [Tag]
Maybe Text
Maybe RuleState
Text
name :: Text
tags :: Maybe [Tag]
state :: Maybe RuleState
scheduleExpression :: Maybe Text
roleArn :: Maybe Text
eventPattern :: Maybe Text
eventBusName :: Maybe Text
description :: Maybe Text
$sel:name:PutRule' :: PutRule -> Text
$sel:tags:PutRule' :: PutRule -> Maybe [Tag]
$sel:state:PutRule' :: PutRule -> Maybe RuleState
$sel:scheduleExpression:PutRule' :: PutRule -> Maybe Text
$sel:roleArn:PutRule' :: PutRule -> Maybe Text
$sel:eventPattern:PutRule' :: PutRule -> Maybe Text
$sel:eventBusName:PutRule' :: PutRule -> Maybe Text
$sel:description:PutRule' :: PutRule -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
eventBusName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
eventPattern
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
roleArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
scheduleExpression
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RuleState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData PutRule where
  rnf :: PutRule -> ()
rnf PutRule' {Maybe [Tag]
Maybe Text
Maybe RuleState
Text
name :: Text
tags :: Maybe [Tag]
state :: Maybe RuleState
scheduleExpression :: Maybe Text
roleArn :: Maybe Text
eventPattern :: Maybe Text
eventBusName :: Maybe Text
description :: Maybe Text
$sel:name:PutRule' :: PutRule -> Text
$sel:tags:PutRule' :: PutRule -> Maybe [Tag]
$sel:state:PutRule' :: PutRule -> Maybe RuleState
$sel:scheduleExpression:PutRule' :: PutRule -> Maybe Text
$sel:roleArn:PutRule' :: PutRule -> Maybe Text
$sel:eventPattern:PutRule' :: PutRule -> Maybe Text
$sel:eventBusName:PutRule' :: PutRule -> Maybe Text
$sel:description:PutRule' :: PutRule -> Maybe Text
..} =
    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
eventBusName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eventPattern
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
roleArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
scheduleExpression
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RuleState
state
      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 Text
name

instance Data.ToHeaders PutRule where
  toHeaders :: PutRule -> 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
"AWSEvents.PutRule" :: 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 PutRule where
  toJSON :: PutRule -> Value
toJSON PutRule' {Maybe [Tag]
Maybe Text
Maybe RuleState
Text
name :: Text
tags :: Maybe [Tag]
state :: Maybe RuleState
scheduleExpression :: Maybe Text
roleArn :: Maybe Text
eventPattern :: Maybe Text
eventBusName :: Maybe Text
description :: Maybe Text
$sel:name:PutRule' :: PutRule -> Text
$sel:tags:PutRule' :: PutRule -> Maybe [Tag]
$sel:state:PutRule' :: PutRule -> Maybe RuleState
$sel:scheduleExpression:PutRule' :: PutRule -> Maybe Text
$sel:roleArn:PutRule' :: PutRule -> Maybe Text
$sel:eventPattern:PutRule' :: PutRule -> Maybe Text
$sel:eventBusName:PutRule' :: PutRule -> Maybe Text
$sel:description:PutRule' :: PutRule -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (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
"EventBusName" 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
eventBusName,
            (Key
"EventPattern" 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
eventPattern,
            (Key
"RoleArn" 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
roleArn,
            (Key
"ScheduleExpression" 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
scheduleExpression,
            (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 RuleState
state,
            (Key
"Tags" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

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

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

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

-- |
-- Create a value of 'PutRuleResponse' 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:
--
-- 'ruleArn', 'putRuleResponse_ruleArn' - The Amazon Resource Name (ARN) of the rule.
--
-- 'httpStatus', 'putRuleResponse_httpStatus' - The response's http status code.
newPutRuleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  PutRuleResponse
newPutRuleResponse :: Int -> PutRuleResponse
newPutRuleResponse Int
pHttpStatus_ =
  PutRuleResponse'
    { $sel:ruleArn:PutRuleResponse' :: Maybe Text
ruleArn = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:PutRuleResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Amazon Resource Name (ARN) of the rule.
putRuleResponse_ruleArn :: Lens.Lens' PutRuleResponse (Prelude.Maybe Prelude.Text)
putRuleResponse_ruleArn :: Lens' PutRuleResponse (Maybe Text)
putRuleResponse_ruleArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutRuleResponse' {Maybe Text
ruleArn :: Maybe Text
$sel:ruleArn:PutRuleResponse' :: PutRuleResponse -> Maybe Text
ruleArn} -> Maybe Text
ruleArn) (\s :: PutRuleResponse
s@PutRuleResponse' {} Maybe Text
a -> PutRuleResponse
s {$sel:ruleArn:PutRuleResponse' :: Maybe Text
ruleArn = Maybe Text
a} :: PutRuleResponse)

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

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