{-# 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.RestoreAddressToClassic
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Restores an Elastic IP address that was previously moved to the EC2-VPC
-- platform back to the EC2-Classic platform. You cannot move an Elastic IP
-- address that was originally allocated for use in EC2-VPC. The Elastic IP
-- address must not be associated with an instance or network interface.
--
-- We are retiring EC2-Classic. We recommend that you migrate from
-- EC2-Classic to a VPC. For more information, see
-- <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/vpc-migrate.html Migrate from EC2-Classic to a VPC>
-- in the /Amazon Elastic Compute Cloud User Guide/.
module Amazonka.EC2.RestoreAddressToClassic
  ( -- * Creating a Request
    RestoreAddressToClassic (..),
    newRestoreAddressToClassic,

    -- * Request Lenses
    restoreAddressToClassic_dryRun,
    restoreAddressToClassic_publicIp,

    -- * Destructuring the Response
    RestoreAddressToClassicResponse (..),
    newRestoreAddressToClassicResponse,

    -- * Response Lenses
    restoreAddressToClassicResponse_publicIp,
    restoreAddressToClassicResponse_status,
    restoreAddressToClassicResponse_httpStatus,
  )
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:/ 'newRestoreAddressToClassic' smart constructor.
data RestoreAddressToClassic = RestoreAddressToClassic'
  { -- | 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@.
    RestoreAddressToClassic -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | The Elastic IP address.
    RestoreAddressToClassic -> Text
publicIp :: Prelude.Text
  }
  deriving (RestoreAddressToClassic -> RestoreAddressToClassic -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreAddressToClassic -> RestoreAddressToClassic -> Bool
$c/= :: RestoreAddressToClassic -> RestoreAddressToClassic -> Bool
== :: RestoreAddressToClassic -> RestoreAddressToClassic -> Bool
$c== :: RestoreAddressToClassic -> RestoreAddressToClassic -> Bool
Prelude.Eq, ReadPrec [RestoreAddressToClassic]
ReadPrec RestoreAddressToClassic
Int -> ReadS RestoreAddressToClassic
ReadS [RestoreAddressToClassic]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreAddressToClassic]
$creadListPrec :: ReadPrec [RestoreAddressToClassic]
readPrec :: ReadPrec RestoreAddressToClassic
$creadPrec :: ReadPrec RestoreAddressToClassic
readList :: ReadS [RestoreAddressToClassic]
$creadList :: ReadS [RestoreAddressToClassic]
readsPrec :: Int -> ReadS RestoreAddressToClassic
$creadsPrec :: Int -> ReadS RestoreAddressToClassic
Prelude.Read, Int -> RestoreAddressToClassic -> ShowS
[RestoreAddressToClassic] -> ShowS
RestoreAddressToClassic -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreAddressToClassic] -> ShowS
$cshowList :: [RestoreAddressToClassic] -> ShowS
show :: RestoreAddressToClassic -> String
$cshow :: RestoreAddressToClassic -> String
showsPrec :: Int -> RestoreAddressToClassic -> ShowS
$cshowsPrec :: Int -> RestoreAddressToClassic -> ShowS
Prelude.Show, forall x. Rep RestoreAddressToClassic x -> RestoreAddressToClassic
forall x. RestoreAddressToClassic -> Rep RestoreAddressToClassic x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RestoreAddressToClassic x -> RestoreAddressToClassic
$cfrom :: forall x. RestoreAddressToClassic -> Rep RestoreAddressToClassic x
Prelude.Generic)

-- |
-- Create a value of 'RestoreAddressToClassic' 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', 'restoreAddressToClassic_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@.
--
-- 'publicIp', 'restoreAddressToClassic_publicIp' - The Elastic IP address.
newRestoreAddressToClassic ::
  -- | 'publicIp'
  Prelude.Text ->
  RestoreAddressToClassic
newRestoreAddressToClassic :: Text -> RestoreAddressToClassic
newRestoreAddressToClassic Text
pPublicIp_ =
  RestoreAddressToClassic'
    { $sel:dryRun:RestoreAddressToClassic' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:publicIp:RestoreAddressToClassic' :: Text
publicIp = Text
pPublicIp_
    }

-- | 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@.
restoreAddressToClassic_dryRun :: Lens.Lens' RestoreAddressToClassic (Prelude.Maybe Prelude.Bool)
restoreAddressToClassic_dryRun :: Lens' RestoreAddressToClassic (Maybe Bool)
restoreAddressToClassic_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreAddressToClassic' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:RestoreAddressToClassic' :: RestoreAddressToClassic -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: RestoreAddressToClassic
s@RestoreAddressToClassic' {} Maybe Bool
a -> RestoreAddressToClassic
s {$sel:dryRun:RestoreAddressToClassic' :: Maybe Bool
dryRun = Maybe Bool
a} :: RestoreAddressToClassic)

-- | The Elastic IP address.
restoreAddressToClassic_publicIp :: Lens.Lens' RestoreAddressToClassic Prelude.Text
restoreAddressToClassic_publicIp :: Lens' RestoreAddressToClassic Text
restoreAddressToClassic_publicIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreAddressToClassic' {Text
publicIp :: Text
$sel:publicIp:RestoreAddressToClassic' :: RestoreAddressToClassic -> Text
publicIp} -> Text
publicIp) (\s :: RestoreAddressToClassic
s@RestoreAddressToClassic' {} Text
a -> RestoreAddressToClassic
s {$sel:publicIp:RestoreAddressToClassic' :: Text
publicIp = Text
a} :: RestoreAddressToClassic)

instance Core.AWSRequest RestoreAddressToClassic where
  type
    AWSResponse RestoreAddressToClassic =
      RestoreAddressToClassicResponse
  request :: (Service -> Service)
-> RestoreAddressToClassic -> Request RestoreAddressToClassic
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 RestoreAddressToClassic
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RestoreAddressToClassic)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe Text
-> Maybe AddressStatus -> Int -> RestoreAddressToClassicResponse
RestoreAddressToClassicResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"publicIp")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"status")
            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 RestoreAddressToClassic where
  hashWithSalt :: Int -> RestoreAddressToClassic -> Int
hashWithSalt Int
_salt RestoreAddressToClassic' {Maybe Bool
Text
publicIp :: Text
dryRun :: Maybe Bool
$sel:publicIp:RestoreAddressToClassic' :: RestoreAddressToClassic -> Text
$sel:dryRun:RestoreAddressToClassic' :: RestoreAddressToClassic -> 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` Text
publicIp

instance Prelude.NFData RestoreAddressToClassic where
  rnf :: RestoreAddressToClassic -> ()
rnf RestoreAddressToClassic' {Maybe Bool
Text
publicIp :: Text
dryRun :: Maybe Bool
$sel:publicIp:RestoreAddressToClassic' :: RestoreAddressToClassic -> Text
$sel:dryRun:RestoreAddressToClassic' :: RestoreAddressToClassic -> 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 Text
publicIp

instance Data.ToHeaders RestoreAddressToClassic where
  toHeaders :: RestoreAddressToClassic -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

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

instance Data.ToQuery RestoreAddressToClassic where
  toQuery :: RestoreAddressToClassic -> QueryString
toQuery RestoreAddressToClassic' {Maybe Bool
Text
publicIp :: Text
dryRun :: Maybe Bool
$sel:publicIp:RestoreAddressToClassic' :: RestoreAddressToClassic -> Text
$sel:dryRun:RestoreAddressToClassic' :: RestoreAddressToClassic -> Maybe Bool
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Action"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: (ByteString
"RestoreAddressToClassic" :: 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,
        ByteString
"PublicIp" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
publicIp
      ]

-- | /See:/ 'newRestoreAddressToClassicResponse' smart constructor.
data RestoreAddressToClassicResponse = RestoreAddressToClassicResponse'
  { -- | The Elastic IP address.
    RestoreAddressToClassicResponse -> Maybe Text
publicIp :: Prelude.Maybe Prelude.Text,
    -- | The move status for the IP address.
    RestoreAddressToClassicResponse -> Maybe AddressStatus
status :: Prelude.Maybe AddressStatus,
    -- | The response's http status code.
    RestoreAddressToClassicResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RestoreAddressToClassicResponse
-> RestoreAddressToClassicResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreAddressToClassicResponse
-> RestoreAddressToClassicResponse -> Bool
$c/= :: RestoreAddressToClassicResponse
-> RestoreAddressToClassicResponse -> Bool
== :: RestoreAddressToClassicResponse
-> RestoreAddressToClassicResponse -> Bool
$c== :: RestoreAddressToClassicResponse
-> RestoreAddressToClassicResponse -> Bool
Prelude.Eq, ReadPrec [RestoreAddressToClassicResponse]
ReadPrec RestoreAddressToClassicResponse
Int -> ReadS RestoreAddressToClassicResponse
ReadS [RestoreAddressToClassicResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreAddressToClassicResponse]
$creadListPrec :: ReadPrec [RestoreAddressToClassicResponse]
readPrec :: ReadPrec RestoreAddressToClassicResponse
$creadPrec :: ReadPrec RestoreAddressToClassicResponse
readList :: ReadS [RestoreAddressToClassicResponse]
$creadList :: ReadS [RestoreAddressToClassicResponse]
readsPrec :: Int -> ReadS RestoreAddressToClassicResponse
$creadsPrec :: Int -> ReadS RestoreAddressToClassicResponse
Prelude.Read, Int -> RestoreAddressToClassicResponse -> ShowS
[RestoreAddressToClassicResponse] -> ShowS
RestoreAddressToClassicResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreAddressToClassicResponse] -> ShowS
$cshowList :: [RestoreAddressToClassicResponse] -> ShowS
show :: RestoreAddressToClassicResponse -> String
$cshow :: RestoreAddressToClassicResponse -> String
showsPrec :: Int -> RestoreAddressToClassicResponse -> ShowS
$cshowsPrec :: Int -> RestoreAddressToClassicResponse -> ShowS
Prelude.Show, forall x.
Rep RestoreAddressToClassicResponse x
-> RestoreAddressToClassicResponse
forall x.
RestoreAddressToClassicResponse
-> Rep RestoreAddressToClassicResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RestoreAddressToClassicResponse x
-> RestoreAddressToClassicResponse
$cfrom :: forall x.
RestoreAddressToClassicResponse
-> Rep RestoreAddressToClassicResponse x
Prelude.Generic)

-- |
-- Create a value of 'RestoreAddressToClassicResponse' 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:
--
-- 'publicIp', 'restoreAddressToClassicResponse_publicIp' - The Elastic IP address.
--
-- 'status', 'restoreAddressToClassicResponse_status' - The move status for the IP address.
--
-- 'httpStatus', 'restoreAddressToClassicResponse_httpStatus' - The response's http status code.
newRestoreAddressToClassicResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RestoreAddressToClassicResponse
newRestoreAddressToClassicResponse :: Int -> RestoreAddressToClassicResponse
newRestoreAddressToClassicResponse Int
pHttpStatus_ =
  RestoreAddressToClassicResponse'
    { $sel:publicIp:RestoreAddressToClassicResponse' :: Maybe Text
publicIp =
        forall a. Maybe a
Prelude.Nothing,
      $sel:status:RestoreAddressToClassicResponse' :: Maybe AddressStatus
status = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RestoreAddressToClassicResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The Elastic IP address.
restoreAddressToClassicResponse_publicIp :: Lens.Lens' RestoreAddressToClassicResponse (Prelude.Maybe Prelude.Text)
restoreAddressToClassicResponse_publicIp :: Lens' RestoreAddressToClassicResponse (Maybe Text)
restoreAddressToClassicResponse_publicIp = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreAddressToClassicResponse' {Maybe Text
publicIp :: Maybe Text
$sel:publicIp:RestoreAddressToClassicResponse' :: RestoreAddressToClassicResponse -> Maybe Text
publicIp} -> Maybe Text
publicIp) (\s :: RestoreAddressToClassicResponse
s@RestoreAddressToClassicResponse' {} Maybe Text
a -> RestoreAddressToClassicResponse
s {$sel:publicIp:RestoreAddressToClassicResponse' :: Maybe Text
publicIp = Maybe Text
a} :: RestoreAddressToClassicResponse)

-- | The move status for the IP address.
restoreAddressToClassicResponse_status :: Lens.Lens' RestoreAddressToClassicResponse (Prelude.Maybe AddressStatus)
restoreAddressToClassicResponse_status :: Lens' RestoreAddressToClassicResponse (Maybe AddressStatus)
restoreAddressToClassicResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreAddressToClassicResponse' {Maybe AddressStatus
status :: Maybe AddressStatus
$sel:status:RestoreAddressToClassicResponse' :: RestoreAddressToClassicResponse -> Maybe AddressStatus
status} -> Maybe AddressStatus
status) (\s :: RestoreAddressToClassicResponse
s@RestoreAddressToClassicResponse' {} Maybe AddressStatus
a -> RestoreAddressToClassicResponse
s {$sel:status:RestoreAddressToClassicResponse' :: Maybe AddressStatus
status = Maybe AddressStatus
a} :: RestoreAddressToClassicResponse)

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

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