{-# 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.EC2.DeleteTags
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes the specified set of tags from the specified set of resources.
--
-- To list the current tags, use DescribeTags. For more information about
-- tags, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html Tag your Amazon EC2 resources>
-- in the /Amazon Elastic Compute Cloud User Guide/.
module Amazonka.EC2.DeleteTags
  ( -- * Creating a Request
    DeleteTags (..),
    newDeleteTags,

    -- * Request Lenses
    deleteTags_dryRun,
    deleteTags_tags,
    deleteTags_resources,

    -- * Destructuring the Response
    DeleteTagsResponse (..),
    newDeleteTagsResponse,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newDeleteTags' smart constructor.
data DeleteTags = DeleteTags'
  { -- | Checks whether you have the required permissions for the action, without
    -- actually making the request, and provides an error response. If you have
    -- the required permissions, the error response is @DryRunOperation@.
    -- Otherwise, it is @UnauthorizedOperation@.
    DeleteTags -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The tags to delete. Specify a tag key and an optional tag value to
    -- delete specific tags. If you specify a tag key without a tag value, we
    -- delete any tag with this key regardless of its value. If you specify a
    -- tag key with an empty string as the tag value, we delete the tag only if
    -- its value is an empty string.
    --
    -- If you omit this parameter, we delete all user-defined tags for the
    -- specified resources. We do not delete Amazon Web Services-generated tags
    -- (tags that have the @aws:@ prefix).
    --
    -- Constraints: Up to 1000 tags.
    DeleteTags -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | The IDs of the resources, separated by spaces.
    --
    -- Constraints: Up to 1000 resource IDs. We recommend breaking up this
    -- request into smaller batches.
    DeleteTags -> [Text]
resources :: [Prelude.Text]
  }
  deriving (DeleteTags -> DeleteTags -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTags -> DeleteTags -> Bool
$c/= :: DeleteTags -> DeleteTags -> Bool
== :: DeleteTags -> DeleteTags -> Bool
$c== :: DeleteTags -> DeleteTags -> Bool
Prelude.Eq, ReadPrec [DeleteTags]
ReadPrec DeleteTags
Int -> ReadS DeleteTags
ReadS [DeleteTags]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTags]
$creadListPrec :: ReadPrec [DeleteTags]
readPrec :: ReadPrec DeleteTags
$creadPrec :: ReadPrec DeleteTags
readList :: ReadS [DeleteTags]
$creadList :: ReadS [DeleteTags]
readsPrec :: Int -> ReadS DeleteTags
$creadsPrec :: Int -> ReadS DeleteTags
Prelude.Read, Int -> DeleteTags -> ShowS
[DeleteTags] -> ShowS
DeleteTags -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTags] -> ShowS
$cshowList :: [DeleteTags] -> ShowS
show :: DeleteTags -> String
$cshow :: DeleteTags -> String
showsPrec :: Int -> DeleteTags -> ShowS
$cshowsPrec :: Int -> DeleteTags -> ShowS
Prelude.Show, forall x. Rep DeleteTags x -> DeleteTags
forall x. DeleteTags -> Rep DeleteTags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteTags x -> DeleteTags
$cfrom :: forall x. DeleteTags -> Rep DeleteTags x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTags' 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:
--
-- 'dryRun', 'deleteTags_dryRun' - Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
--
-- 'tags', 'deleteTags_tags' - The tags to delete. Specify a tag key and an optional tag value to
-- delete specific tags. If you specify a tag key without a tag value, we
-- delete any tag with this key regardless of its value. If you specify a
-- tag key with an empty string as the tag value, we delete the tag only if
-- its value is an empty string.
--
-- If you omit this parameter, we delete all user-defined tags for the
-- specified resources. We do not delete Amazon Web Services-generated tags
-- (tags that have the @aws:@ prefix).
--
-- Constraints: Up to 1000 tags.
--
-- 'resources', 'deleteTags_resources' - The IDs of the resources, separated by spaces.
--
-- Constraints: Up to 1000 resource IDs. We recommend breaking up this
-- request into smaller batches.
newDeleteTags ::
  DeleteTags
newDeleteTags :: DeleteTags
newDeleteTags =
  DeleteTags'
    { $sel:dryRun:DeleteTags' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:DeleteTags' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:resources:DeleteTags' :: [Text]
resources = forall a. Monoid a => a
Prelude.mempty
    }

-- | Checks whether you have the required permissions for the action, without
-- actually making the request, and provides an error response. If you have
-- the required permissions, the error response is @DryRunOperation@.
-- Otherwise, it is @UnauthorizedOperation@.
deleteTags_dryRun :: Lens.Lens' DeleteTags (Prelude.Maybe Prelude.Bool)
deleteTags_dryRun :: Lens' DeleteTags (Maybe Bool)
deleteTags_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTags' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:DeleteTags' :: DeleteTags -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: DeleteTags
s@DeleteTags' {} Maybe Bool
a -> DeleteTags
s {$sel:dryRun:DeleteTags' :: Maybe Bool
dryRun = Maybe Bool
a} :: DeleteTags)

-- | The tags to delete. Specify a tag key and an optional tag value to
-- delete specific tags. If you specify a tag key without a tag value, we
-- delete any tag with this key regardless of its value. If you specify a
-- tag key with an empty string as the tag value, we delete the tag only if
-- its value is an empty string.
--
-- If you omit this parameter, we delete all user-defined tags for the
-- specified resources. We do not delete Amazon Web Services-generated tags
-- (tags that have the @aws:@ prefix).
--
-- Constraints: Up to 1000 tags.
deleteTags_tags :: Lens.Lens' DeleteTags (Prelude.Maybe [Tag])
deleteTags_tags :: Lens' DeleteTags (Maybe [Tag])
deleteTags_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTags' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:DeleteTags' :: DeleteTags -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: DeleteTags
s@DeleteTags' {} Maybe [Tag]
a -> DeleteTags
s {$sel:tags:DeleteTags' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: DeleteTags) 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 IDs of the resources, separated by spaces.
--
-- Constraints: Up to 1000 resource IDs. We recommend breaking up this
-- request into smaller batches.
deleteTags_resources :: Lens.Lens' DeleteTags [Prelude.Text]
deleteTags_resources :: Lens' DeleteTags [Text]
deleteTags_resources = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTags' {[Text]
resources :: [Text]
$sel:resources:DeleteTags' :: DeleteTags -> [Text]
resources} -> [Text]
resources) (\s :: DeleteTags
s@DeleteTags' {} [Text]
a -> DeleteTags
s {$sel:resources:DeleteTags' :: [Text]
resources = [Text]
a} :: DeleteTags) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest DeleteTags where
  type AWSResponse DeleteTags = DeleteTagsResponse
  request :: (Service -> Service) -> DeleteTags -> Request DeleteTags
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.postQuery (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy DeleteTags
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse DeleteTags)))
response = forall (m :: * -> *) a.
MonadResource m =>
AWSResponse a
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveNull DeleteTagsResponse
DeleteTagsResponse'

instance Prelude.Hashable DeleteTags where
  hashWithSalt :: Int -> DeleteTags -> Int
hashWithSalt Int
_salt DeleteTags' {[Text]
Maybe Bool
Maybe [Tag]
resources :: [Text]
tags :: Maybe [Tag]
dryRun :: Maybe Bool
$sel:resources:DeleteTags' :: DeleteTags -> [Text]
$sel:tags:DeleteTags' :: DeleteTags -> Maybe [Tag]
$sel:dryRun:DeleteTags' :: DeleteTags -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
dryRun
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
resources

instance Prelude.NFData DeleteTags where
  rnf :: DeleteTags -> ()
rnf DeleteTags' {[Text]
Maybe Bool
Maybe [Tag]
resources :: [Text]
tags :: Maybe [Tag]
dryRun :: Maybe Bool
$sel:resources:DeleteTags' :: DeleteTags -> [Text]
$sel:tags:DeleteTags' :: DeleteTags -> Maybe [Tag]
$sel:dryRun:DeleteTags' :: DeleteTags -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
dryRun
      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]
resources

instance Data.ToHeaders DeleteTags where
  toHeaders :: DeleteTags -> [Header]
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery DeleteTags where
  toQuery :: DeleteTags -> QueryString
toQuery DeleteTags' {[Text]
Maybe Bool
Maybe [Tag]
resources :: [Text]
tags :: Maybe [Tag]
dryRun :: Maybe Bool
$sel:resources:DeleteTags' :: DeleteTags -> [Text]
$sel:tags:DeleteTags' :: DeleteTags -> Maybe [Tag]
$sel:dryRun:DeleteTags' :: DeleteTags -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"DeleteTags" :: Prelude.ByteString),
        ByteString
"Version"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"2016-11-15" :: Prelude.ByteString),
        ByteString
"DryRun" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
dryRun,
        forall a. ToQuery a => a -> QueryString
Data.toQuery
          (forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"Tag" forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [Tag]
tags),
        forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"ResourceId" [Text]
resources
      ]

-- | /See:/ 'newDeleteTagsResponse' smart constructor.
data DeleteTagsResponse = DeleteTagsResponse'
  {
  }
  deriving (DeleteTagsResponse -> DeleteTagsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTagsResponse -> DeleteTagsResponse -> Bool
$c/= :: DeleteTagsResponse -> DeleteTagsResponse -> Bool
== :: DeleteTagsResponse -> DeleteTagsResponse -> Bool
$c== :: DeleteTagsResponse -> DeleteTagsResponse -> Bool
Prelude.Eq, ReadPrec [DeleteTagsResponse]
ReadPrec DeleteTagsResponse
Int -> ReadS DeleteTagsResponse
ReadS [DeleteTagsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTagsResponse]
$creadListPrec :: ReadPrec [DeleteTagsResponse]
readPrec :: ReadPrec DeleteTagsResponse
$creadPrec :: ReadPrec DeleteTagsResponse
readList :: ReadS [DeleteTagsResponse]
$creadList :: ReadS [DeleteTagsResponse]
readsPrec :: Int -> ReadS DeleteTagsResponse
$creadsPrec :: Int -> ReadS DeleteTagsResponse
Prelude.Read, Int -> DeleteTagsResponse -> ShowS
[DeleteTagsResponse] -> ShowS
DeleteTagsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTagsResponse] -> ShowS
$cshowList :: [DeleteTagsResponse] -> ShowS
show :: DeleteTagsResponse -> String
$cshow :: DeleteTagsResponse -> String
showsPrec :: Int -> DeleteTagsResponse -> ShowS
$cshowsPrec :: Int -> DeleteTagsResponse -> ShowS
Prelude.Show, forall x. Rep DeleteTagsResponse x -> DeleteTagsResponse
forall x. DeleteTagsResponse -> Rep DeleteTagsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteTagsResponse x -> DeleteTagsResponse
$cfrom :: forall x. DeleteTagsResponse -> Rep DeleteTagsResponse x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTagsResponse' 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.
newDeleteTagsResponse ::
  DeleteTagsResponse
newDeleteTagsResponse :: DeleteTagsResponse
newDeleteTagsResponse = DeleteTagsResponse
DeleteTagsResponse'

instance Prelude.NFData DeleteTagsResponse where
  rnf :: DeleteTagsResponse -> ()
rnf DeleteTagsResponse
_ = ()