{-# 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.RBin.CreateRule
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a Recycle Bin retention rule. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin-working-with-rules.html#recycle-bin-create-rule Create Recycle Bin retention rules>
-- in the /Amazon Elastic Compute Cloud User Guide/.
module Amazonka.RBin.CreateRule
  ( -- * Creating a Request
    CreateRule (..),
    newCreateRule,

    -- * Request Lenses
    createRule_description,
    createRule_lockConfiguration,
    createRule_resourceTags,
    createRule_tags,
    createRule_retentionPeriod,
    createRule_resourceType,

    -- * Destructuring the Response
    CreateRuleResponse (..),
    newCreateRuleResponse,

    -- * Response Lenses
    createRuleResponse_description,
    createRuleResponse_identifier,
    createRuleResponse_lockConfiguration,
    createRuleResponse_lockState,
    createRuleResponse_resourceTags,
    createRuleResponse_resourceType,
    createRuleResponse_retentionPeriod,
    createRuleResponse_status,
    createRuleResponse_tags,
    createRuleResponse_httpStatus,
  )
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 Amazonka.RBin.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newCreateRule' smart constructor.
data CreateRule = CreateRule'
  { -- | The retention rule description.
    CreateRule -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Information about the retention rule lock configuration.
    CreateRule -> Maybe LockConfiguration
lockConfiguration :: Prelude.Maybe LockConfiguration,
    -- | Specifies the resource tags to use to identify resources that are to be
    -- retained by a tag-level retention rule. For tag-level retention rules,
    -- only deleted resources, of the specified resource type, that have one or
    -- more of the specified tag key and value pairs are retained. If a
    -- resource is deleted, but it does not have any of the specified tag key
    -- and value pairs, it is immediately deleted without being retained by the
    -- retention rule.
    --
    -- You can add the same tag key and value pair to a maximum or five
    -- retention rules.
    --
    -- To create a Region-level retention rule, omit this parameter. A
    -- Region-level retention rule does not have any resource tags specified.
    -- It retains all deleted resources of the specified resource type in the
    -- Region in which the rule is created, even if the resources are not
    -- tagged.
    CreateRule -> Maybe [ResourceTag]
resourceTags :: Prelude.Maybe [ResourceTag],
    -- | Information about the tags to assign to the retention rule.
    CreateRule -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | Information about the retention period for which the retention rule is
    -- to retain resources.
    CreateRule -> RetentionPeriod
retentionPeriod :: RetentionPeriod,
    -- | The resource type to be retained by the retention rule. Currently, only
    -- Amazon EBS snapshots and EBS-backed AMIs are supported. To retain
    -- snapshots, specify @EBS_SNAPSHOT@. To retain EBS-backed AMIs, specify
    -- @EC2_IMAGE@.
    CreateRule -> ResourceType
resourceType :: ResourceType
  }
  deriving (CreateRule -> CreateRule -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRule -> CreateRule -> Bool
$c/= :: CreateRule -> CreateRule -> Bool
== :: CreateRule -> CreateRule -> Bool
$c== :: CreateRule -> CreateRule -> Bool
Prelude.Eq, ReadPrec [CreateRule]
ReadPrec CreateRule
Int -> ReadS CreateRule
ReadS [CreateRule]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRule]
$creadListPrec :: ReadPrec [CreateRule]
readPrec :: ReadPrec CreateRule
$creadPrec :: ReadPrec CreateRule
readList :: ReadS [CreateRule]
$creadList :: ReadS [CreateRule]
readsPrec :: Int -> ReadS CreateRule
$creadsPrec :: Int -> ReadS CreateRule
Prelude.Read, Int -> CreateRule -> ShowS
[CreateRule] -> ShowS
CreateRule -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRule] -> ShowS
$cshowList :: [CreateRule] -> ShowS
show :: CreateRule -> String
$cshow :: CreateRule -> String
showsPrec :: Int -> CreateRule -> ShowS
$cshowsPrec :: Int -> CreateRule -> ShowS
Prelude.Show, forall x. Rep CreateRule x -> CreateRule
forall x. CreateRule -> Rep CreateRule x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateRule x -> CreateRule
$cfrom :: forall x. CreateRule -> Rep CreateRule x
Prelude.Generic)

-- |
-- Create a value of 'CreateRule' 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', 'createRule_description' - The retention rule description.
--
-- 'lockConfiguration', 'createRule_lockConfiguration' - Information about the retention rule lock configuration.
--
-- 'resourceTags', 'createRule_resourceTags' - Specifies the resource tags to use to identify resources that are to be
-- retained by a tag-level retention rule. For tag-level retention rules,
-- only deleted resources, of the specified resource type, that have one or
-- more of the specified tag key and value pairs are retained. If a
-- resource is deleted, but it does not have any of the specified tag key
-- and value pairs, it is immediately deleted without being retained by the
-- retention rule.
--
-- You can add the same tag key and value pair to a maximum or five
-- retention rules.
--
-- To create a Region-level retention rule, omit this parameter. A
-- Region-level retention rule does not have any resource tags specified.
-- It retains all deleted resources of the specified resource type in the
-- Region in which the rule is created, even if the resources are not
-- tagged.
--
-- 'tags', 'createRule_tags' - Information about the tags to assign to the retention rule.
--
-- 'retentionPeriod', 'createRule_retentionPeriod' - Information about the retention period for which the retention rule is
-- to retain resources.
--
-- 'resourceType', 'createRule_resourceType' - The resource type to be retained by the retention rule. Currently, only
-- Amazon EBS snapshots and EBS-backed AMIs are supported. To retain
-- snapshots, specify @EBS_SNAPSHOT@. To retain EBS-backed AMIs, specify
-- @EC2_IMAGE@.
newCreateRule ::
  -- | 'retentionPeriod'
  RetentionPeriod ->
  -- | 'resourceType'
  ResourceType ->
  CreateRule
newCreateRule :: RetentionPeriod -> ResourceType -> CreateRule
newCreateRule RetentionPeriod
pRetentionPeriod_ ResourceType
pResourceType_ =
  CreateRule'
    { $sel:description:CreateRule' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:lockConfiguration:CreateRule' :: Maybe LockConfiguration
lockConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceTags:CreateRule' :: Maybe [ResourceTag]
resourceTags = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateRule' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:retentionPeriod:CreateRule' :: RetentionPeriod
retentionPeriod = RetentionPeriod
pRetentionPeriod_,
      $sel:resourceType:CreateRule' :: ResourceType
resourceType = ResourceType
pResourceType_
    }

-- | The retention rule description.
createRule_description :: Lens.Lens' CreateRule (Prelude.Maybe Prelude.Text)
createRule_description :: Lens' CreateRule (Maybe Text)
createRule_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRule' {Maybe Text
description :: Maybe Text
$sel:description:CreateRule' :: CreateRule -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateRule
s@CreateRule' {} Maybe Text
a -> CreateRule
s {$sel:description:CreateRule' :: Maybe Text
description = Maybe Text
a} :: CreateRule)

-- | Information about the retention rule lock configuration.
createRule_lockConfiguration :: Lens.Lens' CreateRule (Prelude.Maybe LockConfiguration)
createRule_lockConfiguration :: Lens' CreateRule (Maybe LockConfiguration)
createRule_lockConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRule' {Maybe LockConfiguration
lockConfiguration :: Maybe LockConfiguration
$sel:lockConfiguration:CreateRule' :: CreateRule -> Maybe LockConfiguration
lockConfiguration} -> Maybe LockConfiguration
lockConfiguration) (\s :: CreateRule
s@CreateRule' {} Maybe LockConfiguration
a -> CreateRule
s {$sel:lockConfiguration:CreateRule' :: Maybe LockConfiguration
lockConfiguration = Maybe LockConfiguration
a} :: CreateRule)

-- | Specifies the resource tags to use to identify resources that are to be
-- retained by a tag-level retention rule. For tag-level retention rules,
-- only deleted resources, of the specified resource type, that have one or
-- more of the specified tag key and value pairs are retained. If a
-- resource is deleted, but it does not have any of the specified tag key
-- and value pairs, it is immediately deleted without being retained by the
-- retention rule.
--
-- You can add the same tag key and value pair to a maximum or five
-- retention rules.
--
-- To create a Region-level retention rule, omit this parameter. A
-- Region-level retention rule does not have any resource tags specified.
-- It retains all deleted resources of the specified resource type in the
-- Region in which the rule is created, even if the resources are not
-- tagged.
createRule_resourceTags :: Lens.Lens' CreateRule (Prelude.Maybe [ResourceTag])
createRule_resourceTags :: Lens' CreateRule (Maybe [ResourceTag])
createRule_resourceTags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRule' {Maybe [ResourceTag]
resourceTags :: Maybe [ResourceTag]
$sel:resourceTags:CreateRule' :: CreateRule -> Maybe [ResourceTag]
resourceTags} -> Maybe [ResourceTag]
resourceTags) (\s :: CreateRule
s@CreateRule' {} Maybe [ResourceTag]
a -> CreateRule
s {$sel:resourceTags:CreateRule' :: Maybe [ResourceTag]
resourceTags = Maybe [ResourceTag]
a} :: CreateRule) 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

-- | Information about the tags to assign to the retention rule.
createRule_tags :: Lens.Lens' CreateRule (Prelude.Maybe [Tag])
createRule_tags :: Lens' CreateRule (Maybe [Tag])
createRule_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRule' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateRule' :: CreateRule -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateRule
s@CreateRule' {} Maybe [Tag]
a -> CreateRule
s {$sel:tags:CreateRule' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateRule) 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

-- | Information about the retention period for which the retention rule is
-- to retain resources.
createRule_retentionPeriod :: Lens.Lens' CreateRule RetentionPeriod
createRule_retentionPeriod :: Lens' CreateRule RetentionPeriod
createRule_retentionPeriod = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRule' {RetentionPeriod
retentionPeriod :: RetentionPeriod
$sel:retentionPeriod:CreateRule' :: CreateRule -> RetentionPeriod
retentionPeriod} -> RetentionPeriod
retentionPeriod) (\s :: CreateRule
s@CreateRule' {} RetentionPeriod
a -> CreateRule
s {$sel:retentionPeriod:CreateRule' :: RetentionPeriod
retentionPeriod = RetentionPeriod
a} :: CreateRule)

-- | The resource type to be retained by the retention rule. Currently, only
-- Amazon EBS snapshots and EBS-backed AMIs are supported. To retain
-- snapshots, specify @EBS_SNAPSHOT@. To retain EBS-backed AMIs, specify
-- @EC2_IMAGE@.
createRule_resourceType :: Lens.Lens' CreateRule ResourceType
createRule_resourceType :: Lens' CreateRule ResourceType
createRule_resourceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRule' {ResourceType
resourceType :: ResourceType
$sel:resourceType:CreateRule' :: CreateRule -> ResourceType
resourceType} -> ResourceType
resourceType) (\s :: CreateRule
s@CreateRule' {} ResourceType
a -> CreateRule
s {$sel:resourceType:CreateRule' :: ResourceType
resourceType = ResourceType
a} :: CreateRule)

instance Core.AWSRequest CreateRule where
  type AWSResponse CreateRule = CreateRuleResponse
  request :: (Service -> Service) -> CreateRule -> Request CreateRule
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 CreateRule
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateRule)))
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
-> Maybe Text
-> Maybe LockConfiguration
-> Maybe LockState
-> Maybe [ResourceTag]
-> Maybe ResourceType
-> Maybe RetentionPeriod
-> Maybe RuleStatus
-> Maybe [Tag]
-> Int
-> CreateRuleResponse
CreateRuleResponse'
            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
"Description")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Identifier")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"LockConfiguration")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"LockState")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ResourceTags" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ResourceType")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"RetentionPeriod")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Status")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Tags" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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 CreateRule where
  hashWithSalt :: Int -> CreateRule -> Int
hashWithSalt Int
_salt CreateRule' {Maybe [ResourceTag]
Maybe [Tag]
Maybe Text
Maybe LockConfiguration
ResourceType
RetentionPeriod
resourceType :: ResourceType
retentionPeriod :: RetentionPeriod
tags :: Maybe [Tag]
resourceTags :: Maybe [ResourceTag]
lockConfiguration :: Maybe LockConfiguration
description :: Maybe Text
$sel:resourceType:CreateRule' :: CreateRule -> ResourceType
$sel:retentionPeriod:CreateRule' :: CreateRule -> RetentionPeriod
$sel:tags:CreateRule' :: CreateRule -> Maybe [Tag]
$sel:resourceTags:CreateRule' :: CreateRule -> Maybe [ResourceTag]
$sel:lockConfiguration:CreateRule' :: CreateRule -> Maybe LockConfiguration
$sel:description:CreateRule' :: CreateRule -> 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 LockConfiguration
lockConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ResourceTag]
resourceTags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` RetentionPeriod
retentionPeriod
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ResourceType
resourceType

instance Prelude.NFData CreateRule where
  rnf :: CreateRule -> ()
rnf CreateRule' {Maybe [ResourceTag]
Maybe [Tag]
Maybe Text
Maybe LockConfiguration
ResourceType
RetentionPeriod
resourceType :: ResourceType
retentionPeriod :: RetentionPeriod
tags :: Maybe [Tag]
resourceTags :: Maybe [ResourceTag]
lockConfiguration :: Maybe LockConfiguration
description :: Maybe Text
$sel:resourceType:CreateRule' :: CreateRule -> ResourceType
$sel:retentionPeriod:CreateRule' :: CreateRule -> RetentionPeriod
$sel:tags:CreateRule' :: CreateRule -> Maybe [Tag]
$sel:resourceTags:CreateRule' :: CreateRule -> Maybe [ResourceTag]
$sel:lockConfiguration:CreateRule' :: CreateRule -> Maybe LockConfiguration
$sel:description:CreateRule' :: CreateRule -> 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 LockConfiguration
lockConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ResourceTag]
resourceTags
      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 RetentionPeriod
retentionPeriod
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ResourceType
resourceType

instance Data.ToHeaders CreateRule where
  toHeaders :: CreateRule -> 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 CreateRule where
  toJSON :: CreateRule -> Value
toJSON CreateRule' {Maybe [ResourceTag]
Maybe [Tag]
Maybe Text
Maybe LockConfiguration
ResourceType
RetentionPeriod
resourceType :: ResourceType
retentionPeriod :: RetentionPeriod
tags :: Maybe [Tag]
resourceTags :: Maybe [ResourceTag]
lockConfiguration :: Maybe LockConfiguration
description :: Maybe Text
$sel:resourceType:CreateRule' :: CreateRule -> ResourceType
$sel:retentionPeriod:CreateRule' :: CreateRule -> RetentionPeriod
$sel:tags:CreateRule' :: CreateRule -> Maybe [Tag]
$sel:resourceTags:CreateRule' :: CreateRule -> Maybe [ResourceTag]
$sel:lockConfiguration:CreateRule' :: CreateRule -> Maybe LockConfiguration
$sel:description:CreateRule' :: CreateRule -> 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
"LockConfiguration" 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 LockConfiguration
lockConfiguration,
            (Key
"ResourceTags" 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 [ResourceTag]
resourceTags,
            (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
"RetentionPeriod" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= RetentionPeriod
retentionPeriod),
            forall a. a -> Maybe a
Prelude.Just (Key
"ResourceType" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ResourceType
resourceType)
          ]
      )

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

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

-- | /See:/ 'newCreateRuleResponse' smart constructor.
data CreateRuleResponse = CreateRuleResponse'
  { -- | The retention rule description.
    CreateRuleResponse -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | The unique ID of the retention rule.
    CreateRuleResponse -> Maybe Text
identifier :: Prelude.Maybe Prelude.Text,
    -- | Information about the retention rule lock configuration.
    CreateRuleResponse -> Maybe LockConfiguration
lockConfiguration :: Prelude.Maybe LockConfiguration,
    -- | The lock state for the retention rule.
    --
    -- -   @locked@ - The retention rule is locked and can\'t be modified or
    --     deleted.
    --
    -- -   @pending_unlock@ - The retention rule has been unlocked but it is
    --     still within the unlock delay period. The retention rule can be
    --     modified or deleted only after the unlock delay period has expired.
    --
    -- -   @unlocked@ - The retention rule is unlocked and it can be modified
    --     or deleted by any user with the required permissions.
    --
    -- -   @null@ - The retention rule has never been locked. Once a retention
    --     rule has been locked, it can transition between the @locked@ and
    --     @unlocked@ states only; it can never transition back to @null@.
    CreateRuleResponse -> Maybe LockState
lockState :: Prelude.Maybe LockState,
    -- | Information about the resource tags used to identify resources that are
    -- retained by the retention rule.
    CreateRuleResponse -> Maybe [ResourceTag]
resourceTags :: Prelude.Maybe [ResourceTag],
    -- | The resource type retained by the retention rule.
    CreateRuleResponse -> Maybe ResourceType
resourceType :: Prelude.Maybe ResourceType,
    CreateRuleResponse -> Maybe RetentionPeriod
retentionPeriod :: Prelude.Maybe RetentionPeriod,
    -- | The state of the retention rule. Only retention rules that are in the
    -- @available@ state retain resources.
    CreateRuleResponse -> Maybe RuleStatus
status :: Prelude.Maybe RuleStatus,
    -- | Information about the tags assigned to the retention rule.
    CreateRuleResponse -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The response's http status code.
    CreateRuleResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateRuleResponse -> CreateRuleResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateRuleResponse -> CreateRuleResponse -> Bool
$c/= :: CreateRuleResponse -> CreateRuleResponse -> Bool
== :: CreateRuleResponse -> CreateRuleResponse -> Bool
$c== :: CreateRuleResponse -> CreateRuleResponse -> Bool
Prelude.Eq, ReadPrec [CreateRuleResponse]
ReadPrec CreateRuleResponse
Int -> ReadS CreateRuleResponse
ReadS [CreateRuleResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateRuleResponse]
$creadListPrec :: ReadPrec [CreateRuleResponse]
readPrec :: ReadPrec CreateRuleResponse
$creadPrec :: ReadPrec CreateRuleResponse
readList :: ReadS [CreateRuleResponse]
$creadList :: ReadS [CreateRuleResponse]
readsPrec :: Int -> ReadS CreateRuleResponse
$creadsPrec :: Int -> ReadS CreateRuleResponse
Prelude.Read, Int -> CreateRuleResponse -> ShowS
[CreateRuleResponse] -> ShowS
CreateRuleResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateRuleResponse] -> ShowS
$cshowList :: [CreateRuleResponse] -> ShowS
show :: CreateRuleResponse -> String
$cshow :: CreateRuleResponse -> String
showsPrec :: Int -> CreateRuleResponse -> ShowS
$cshowsPrec :: Int -> CreateRuleResponse -> ShowS
Prelude.Show, forall x. Rep CreateRuleResponse x -> CreateRuleResponse
forall x. CreateRuleResponse -> Rep CreateRuleResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateRuleResponse x -> CreateRuleResponse
$cfrom :: forall x. CreateRuleResponse -> Rep CreateRuleResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateRuleResponse' 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', 'createRuleResponse_description' - The retention rule description.
--
-- 'identifier', 'createRuleResponse_identifier' - The unique ID of the retention rule.
--
-- 'lockConfiguration', 'createRuleResponse_lockConfiguration' - Information about the retention rule lock configuration.
--
-- 'lockState', 'createRuleResponse_lockState' - The lock state for the retention rule.
--
-- -   @locked@ - The retention rule is locked and can\'t be modified or
--     deleted.
--
-- -   @pending_unlock@ - The retention rule has been unlocked but it is
--     still within the unlock delay period. The retention rule can be
--     modified or deleted only after the unlock delay period has expired.
--
-- -   @unlocked@ - The retention rule is unlocked and it can be modified
--     or deleted by any user with the required permissions.
--
-- -   @null@ - The retention rule has never been locked. Once a retention
--     rule has been locked, it can transition between the @locked@ and
--     @unlocked@ states only; it can never transition back to @null@.
--
-- 'resourceTags', 'createRuleResponse_resourceTags' - Information about the resource tags used to identify resources that are
-- retained by the retention rule.
--
-- 'resourceType', 'createRuleResponse_resourceType' - The resource type retained by the retention rule.
--
-- 'retentionPeriod', 'createRuleResponse_retentionPeriod' - Undocumented member.
--
-- 'status', 'createRuleResponse_status' - The state of the retention rule. Only retention rules that are in the
-- @available@ state retain resources.
--
-- 'tags', 'createRuleResponse_tags' - Information about the tags assigned to the retention rule.
--
-- 'httpStatus', 'createRuleResponse_httpStatus' - The response's http status code.
newCreateRuleResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateRuleResponse
newCreateRuleResponse :: Int -> CreateRuleResponse
newCreateRuleResponse Int
pHttpStatus_ =
  CreateRuleResponse'
    { $sel:description:CreateRuleResponse' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:identifier:CreateRuleResponse' :: Maybe Text
identifier = forall a. Maybe a
Prelude.Nothing,
      $sel:lockConfiguration:CreateRuleResponse' :: Maybe LockConfiguration
lockConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:lockState:CreateRuleResponse' :: Maybe LockState
lockState = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceTags:CreateRuleResponse' :: Maybe [ResourceTag]
resourceTags = forall a. Maybe a
Prelude.Nothing,
      $sel:resourceType:CreateRuleResponse' :: Maybe ResourceType
resourceType = forall a. Maybe a
Prelude.Nothing,
      $sel:retentionPeriod:CreateRuleResponse' :: Maybe RetentionPeriod
retentionPeriod = forall a. Maybe a
Prelude.Nothing,
      $sel:status:CreateRuleResponse' :: Maybe RuleStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateRuleResponse' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateRuleResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The retention rule description.
createRuleResponse_description :: Lens.Lens' CreateRuleResponse (Prelude.Maybe Prelude.Text)
createRuleResponse_description :: Lens' CreateRuleResponse (Maybe Text)
createRuleResponse_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe Text
description :: Maybe Text
$sel:description:CreateRuleResponse' :: CreateRuleResponse -> Maybe Text
description} -> Maybe Text
description) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe Text
a -> CreateRuleResponse
s {$sel:description:CreateRuleResponse' :: Maybe Text
description = Maybe Text
a} :: CreateRuleResponse)

-- | The unique ID of the retention rule.
createRuleResponse_identifier :: Lens.Lens' CreateRuleResponse (Prelude.Maybe Prelude.Text)
createRuleResponse_identifier :: Lens' CreateRuleResponse (Maybe Text)
createRuleResponse_identifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe Text
identifier :: Maybe Text
$sel:identifier:CreateRuleResponse' :: CreateRuleResponse -> Maybe Text
identifier} -> Maybe Text
identifier) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe Text
a -> CreateRuleResponse
s {$sel:identifier:CreateRuleResponse' :: Maybe Text
identifier = Maybe Text
a} :: CreateRuleResponse)

-- | Information about the retention rule lock configuration.
createRuleResponse_lockConfiguration :: Lens.Lens' CreateRuleResponse (Prelude.Maybe LockConfiguration)
createRuleResponse_lockConfiguration :: Lens' CreateRuleResponse (Maybe LockConfiguration)
createRuleResponse_lockConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe LockConfiguration
lockConfiguration :: Maybe LockConfiguration
$sel:lockConfiguration:CreateRuleResponse' :: CreateRuleResponse -> Maybe LockConfiguration
lockConfiguration} -> Maybe LockConfiguration
lockConfiguration) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe LockConfiguration
a -> CreateRuleResponse
s {$sel:lockConfiguration:CreateRuleResponse' :: Maybe LockConfiguration
lockConfiguration = Maybe LockConfiguration
a} :: CreateRuleResponse)

-- | The lock state for the retention rule.
--
-- -   @locked@ - The retention rule is locked and can\'t be modified or
--     deleted.
--
-- -   @pending_unlock@ - The retention rule has been unlocked but it is
--     still within the unlock delay period. The retention rule can be
--     modified or deleted only after the unlock delay period has expired.
--
-- -   @unlocked@ - The retention rule is unlocked and it can be modified
--     or deleted by any user with the required permissions.
--
-- -   @null@ - The retention rule has never been locked. Once a retention
--     rule has been locked, it can transition between the @locked@ and
--     @unlocked@ states only; it can never transition back to @null@.
createRuleResponse_lockState :: Lens.Lens' CreateRuleResponse (Prelude.Maybe LockState)
createRuleResponse_lockState :: Lens' CreateRuleResponse (Maybe LockState)
createRuleResponse_lockState = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe LockState
lockState :: Maybe LockState
$sel:lockState:CreateRuleResponse' :: CreateRuleResponse -> Maybe LockState
lockState} -> Maybe LockState
lockState) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe LockState
a -> CreateRuleResponse
s {$sel:lockState:CreateRuleResponse' :: Maybe LockState
lockState = Maybe LockState
a} :: CreateRuleResponse)

-- | Information about the resource tags used to identify resources that are
-- retained by the retention rule.
createRuleResponse_resourceTags :: Lens.Lens' CreateRuleResponse (Prelude.Maybe [ResourceTag])
createRuleResponse_resourceTags :: Lens' CreateRuleResponse (Maybe [ResourceTag])
createRuleResponse_resourceTags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe [ResourceTag]
resourceTags :: Maybe [ResourceTag]
$sel:resourceTags:CreateRuleResponse' :: CreateRuleResponse -> Maybe [ResourceTag]
resourceTags} -> Maybe [ResourceTag]
resourceTags) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe [ResourceTag]
a -> CreateRuleResponse
s {$sel:resourceTags:CreateRuleResponse' :: Maybe [ResourceTag]
resourceTags = Maybe [ResourceTag]
a} :: CreateRuleResponse) 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 resource type retained by the retention rule.
createRuleResponse_resourceType :: Lens.Lens' CreateRuleResponse (Prelude.Maybe ResourceType)
createRuleResponse_resourceType :: Lens' CreateRuleResponse (Maybe ResourceType)
createRuleResponse_resourceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe ResourceType
resourceType :: Maybe ResourceType
$sel:resourceType:CreateRuleResponse' :: CreateRuleResponse -> Maybe ResourceType
resourceType} -> Maybe ResourceType
resourceType) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe ResourceType
a -> CreateRuleResponse
s {$sel:resourceType:CreateRuleResponse' :: Maybe ResourceType
resourceType = Maybe ResourceType
a} :: CreateRuleResponse)

-- | Undocumented member.
createRuleResponse_retentionPeriod :: Lens.Lens' CreateRuleResponse (Prelude.Maybe RetentionPeriod)
createRuleResponse_retentionPeriod :: Lens' CreateRuleResponse (Maybe RetentionPeriod)
createRuleResponse_retentionPeriod = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe RetentionPeriod
retentionPeriod :: Maybe RetentionPeriod
$sel:retentionPeriod:CreateRuleResponse' :: CreateRuleResponse -> Maybe RetentionPeriod
retentionPeriod} -> Maybe RetentionPeriod
retentionPeriod) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe RetentionPeriod
a -> CreateRuleResponse
s {$sel:retentionPeriod:CreateRuleResponse' :: Maybe RetentionPeriod
retentionPeriod = Maybe RetentionPeriod
a} :: CreateRuleResponse)

-- | The state of the retention rule. Only retention rules that are in the
-- @available@ state retain resources.
createRuleResponse_status :: Lens.Lens' CreateRuleResponse (Prelude.Maybe RuleStatus)
createRuleResponse_status :: Lens' CreateRuleResponse (Maybe RuleStatus)
createRuleResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe RuleStatus
status :: Maybe RuleStatus
$sel:status:CreateRuleResponse' :: CreateRuleResponse -> Maybe RuleStatus
status} -> Maybe RuleStatus
status) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe RuleStatus
a -> CreateRuleResponse
s {$sel:status:CreateRuleResponse' :: Maybe RuleStatus
status = Maybe RuleStatus
a} :: CreateRuleResponse)

-- | Information about the tags assigned to the retention rule.
createRuleResponse_tags :: Lens.Lens' CreateRuleResponse (Prelude.Maybe [Tag])
createRuleResponse_tags :: Lens' CreateRuleResponse (Maybe [Tag])
createRuleResponse_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateRuleResponse' :: CreateRuleResponse -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Maybe [Tag]
a -> CreateRuleResponse
s {$sel:tags:CreateRuleResponse' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateRuleResponse) 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 response's http status code.
createRuleResponse_httpStatus :: Lens.Lens' CreateRuleResponse Prelude.Int
createRuleResponse_httpStatus :: Lens' CreateRuleResponse Int
createRuleResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateRuleResponse' {Int
httpStatus :: Int
$sel:httpStatus:CreateRuleResponse' :: CreateRuleResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: CreateRuleResponse
s@CreateRuleResponse' {} Int
a -> CreateRuleResponse
s {$sel:httpStatus:CreateRuleResponse' :: Int
httpStatus = Int
a} :: CreateRuleResponse)

instance Prelude.NFData CreateRuleResponse where
  rnf :: CreateRuleResponse -> ()
rnf CreateRuleResponse' {Int
Maybe [ResourceTag]
Maybe [Tag]
Maybe Text
Maybe LockState
Maybe ResourceType
Maybe RetentionPeriod
Maybe RuleStatus
Maybe LockConfiguration
httpStatus :: Int
tags :: Maybe [Tag]
status :: Maybe RuleStatus
retentionPeriod :: Maybe RetentionPeriod
resourceType :: Maybe ResourceType
resourceTags :: Maybe [ResourceTag]
lockState :: Maybe LockState
lockConfiguration :: Maybe LockConfiguration
identifier :: Maybe Text
description :: Maybe Text
$sel:httpStatus:CreateRuleResponse' :: CreateRuleResponse -> Int
$sel:tags:CreateRuleResponse' :: CreateRuleResponse -> Maybe [Tag]
$sel:status:CreateRuleResponse' :: CreateRuleResponse -> Maybe RuleStatus
$sel:retentionPeriod:CreateRuleResponse' :: CreateRuleResponse -> Maybe RetentionPeriod
$sel:resourceType:CreateRuleResponse' :: CreateRuleResponse -> Maybe ResourceType
$sel:resourceTags:CreateRuleResponse' :: CreateRuleResponse -> Maybe [ResourceTag]
$sel:lockState:CreateRuleResponse' :: CreateRuleResponse -> Maybe LockState
$sel:lockConfiguration:CreateRuleResponse' :: CreateRuleResponse -> Maybe LockConfiguration
$sel:identifier:CreateRuleResponse' :: CreateRuleResponse -> Maybe Text
$sel:description:CreateRuleResponse' :: CreateRuleResponse -> 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
identifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LockConfiguration
lockConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe LockState
lockState
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ResourceTag]
resourceTags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ResourceType
resourceType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RetentionPeriod
retentionPeriod
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RuleStatus
status
      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 Int
httpStatus