{-# 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.CreateDefaultSubnet
-- 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 default subnet with a size @\/20@ IPv4 CIDR block in the
-- specified Availability Zone in your default VPC. You can have only one
-- default subnet per Availability Zone. For more information, see
-- <https://docs.aws.amazon.com/vpc/latest/userguide/default-vpc.html#create-default-subnet Creating a default subnet>
-- in the /Amazon Virtual Private Cloud User Guide/.
module Amazonka.EC2.CreateDefaultSubnet
  ( -- * Creating a Request
    CreateDefaultSubnet (..),
    newCreateDefaultSubnet,

    -- * Request Lenses
    createDefaultSubnet_dryRun,
    createDefaultSubnet_ipv6Native,
    createDefaultSubnet_availabilityZone,

    -- * Destructuring the Response
    CreateDefaultSubnetResponse (..),
    newCreateDefaultSubnetResponse,

    -- * Response Lenses
    createDefaultSubnetResponse_subnet,
    createDefaultSubnetResponse_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:/ 'newCreateDefaultSubnet' smart constructor.
data CreateDefaultSubnet = CreateDefaultSubnet'
  { -- | 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@.
    CreateDefaultSubnet -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
    -- | Indicates whether to create an IPv6 only subnet. If you already have a
    -- default subnet for this Availability Zone, you must delete it before you
    -- can create an IPv6 only subnet.
    CreateDefaultSubnet -> Maybe Bool
ipv6Native :: Prelude.Maybe Prelude.Bool,
    -- | The Availability Zone in which to create the default subnet.
    CreateDefaultSubnet -> Text
availabilityZone :: Prelude.Text
  }
  deriving (CreateDefaultSubnet -> CreateDefaultSubnet -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDefaultSubnet -> CreateDefaultSubnet -> Bool
$c/= :: CreateDefaultSubnet -> CreateDefaultSubnet -> Bool
== :: CreateDefaultSubnet -> CreateDefaultSubnet -> Bool
$c== :: CreateDefaultSubnet -> CreateDefaultSubnet -> Bool
Prelude.Eq, ReadPrec [CreateDefaultSubnet]
ReadPrec CreateDefaultSubnet
Int -> ReadS CreateDefaultSubnet
ReadS [CreateDefaultSubnet]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDefaultSubnet]
$creadListPrec :: ReadPrec [CreateDefaultSubnet]
readPrec :: ReadPrec CreateDefaultSubnet
$creadPrec :: ReadPrec CreateDefaultSubnet
readList :: ReadS [CreateDefaultSubnet]
$creadList :: ReadS [CreateDefaultSubnet]
readsPrec :: Int -> ReadS CreateDefaultSubnet
$creadsPrec :: Int -> ReadS CreateDefaultSubnet
Prelude.Read, Int -> CreateDefaultSubnet -> ShowS
[CreateDefaultSubnet] -> ShowS
CreateDefaultSubnet -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDefaultSubnet] -> ShowS
$cshowList :: [CreateDefaultSubnet] -> ShowS
show :: CreateDefaultSubnet -> String
$cshow :: CreateDefaultSubnet -> String
showsPrec :: Int -> CreateDefaultSubnet -> ShowS
$cshowsPrec :: Int -> CreateDefaultSubnet -> ShowS
Prelude.Show, forall x. Rep CreateDefaultSubnet x -> CreateDefaultSubnet
forall x. CreateDefaultSubnet -> Rep CreateDefaultSubnet x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateDefaultSubnet x -> CreateDefaultSubnet
$cfrom :: forall x. CreateDefaultSubnet -> Rep CreateDefaultSubnet x
Prelude.Generic)

-- |
-- Create a value of 'CreateDefaultSubnet' 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', 'createDefaultSubnet_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@.
--
-- 'ipv6Native', 'createDefaultSubnet_ipv6Native' - Indicates whether to create an IPv6 only subnet. If you already have a
-- default subnet for this Availability Zone, you must delete it before you
-- can create an IPv6 only subnet.
--
-- 'availabilityZone', 'createDefaultSubnet_availabilityZone' - The Availability Zone in which to create the default subnet.
newCreateDefaultSubnet ::
  -- | 'availabilityZone'
  Prelude.Text ->
  CreateDefaultSubnet
newCreateDefaultSubnet :: Text -> CreateDefaultSubnet
newCreateDefaultSubnet Text
pAvailabilityZone_ =
  CreateDefaultSubnet'
    { $sel:dryRun:CreateDefaultSubnet' :: Maybe Bool
dryRun = forall a. Maybe a
Prelude.Nothing,
      $sel:ipv6Native:CreateDefaultSubnet' :: Maybe Bool
ipv6Native = forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZone:CreateDefaultSubnet' :: Text
availabilityZone = Text
pAvailabilityZone_
    }

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

-- | Indicates whether to create an IPv6 only subnet. If you already have a
-- default subnet for this Availability Zone, you must delete it before you
-- can create an IPv6 only subnet.
createDefaultSubnet_ipv6Native :: Lens.Lens' CreateDefaultSubnet (Prelude.Maybe Prelude.Bool)
createDefaultSubnet_ipv6Native :: Lens' CreateDefaultSubnet (Maybe Bool)
createDefaultSubnet_ipv6Native = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDefaultSubnet' {Maybe Bool
ipv6Native :: Maybe Bool
$sel:ipv6Native:CreateDefaultSubnet' :: CreateDefaultSubnet -> Maybe Bool
ipv6Native} -> Maybe Bool
ipv6Native) (\s :: CreateDefaultSubnet
s@CreateDefaultSubnet' {} Maybe Bool
a -> CreateDefaultSubnet
s {$sel:ipv6Native:CreateDefaultSubnet' :: Maybe Bool
ipv6Native = Maybe Bool
a} :: CreateDefaultSubnet)

-- | The Availability Zone in which to create the default subnet.
createDefaultSubnet_availabilityZone :: Lens.Lens' CreateDefaultSubnet Prelude.Text
createDefaultSubnet_availabilityZone :: Lens' CreateDefaultSubnet Text
createDefaultSubnet_availabilityZone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDefaultSubnet' {Text
availabilityZone :: Text
$sel:availabilityZone:CreateDefaultSubnet' :: CreateDefaultSubnet -> Text
availabilityZone} -> Text
availabilityZone) (\s :: CreateDefaultSubnet
s@CreateDefaultSubnet' {} Text
a -> CreateDefaultSubnet
s {$sel:availabilityZone:CreateDefaultSubnet' :: Text
availabilityZone = Text
a} :: CreateDefaultSubnet)

instance Core.AWSRequest CreateDefaultSubnet where
  type
    AWSResponse CreateDefaultSubnet =
      CreateDefaultSubnetResponse
  request :: (Service -> Service)
-> CreateDefaultSubnet -> Request CreateDefaultSubnet
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 CreateDefaultSubnet
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateDefaultSubnet)))
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 Subnet -> Int -> CreateDefaultSubnetResponse
CreateDefaultSubnetResponse'
            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
"subnet")
            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 CreateDefaultSubnet where
  hashWithSalt :: Int -> CreateDefaultSubnet -> Int
hashWithSalt Int
_salt CreateDefaultSubnet' {Maybe Bool
Text
availabilityZone :: Text
ipv6Native :: Maybe Bool
dryRun :: Maybe Bool
$sel:availabilityZone:CreateDefaultSubnet' :: CreateDefaultSubnet -> Text
$sel:ipv6Native:CreateDefaultSubnet' :: CreateDefaultSubnet -> Maybe Bool
$sel:dryRun:CreateDefaultSubnet' :: CreateDefaultSubnet -> 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 Bool
ipv6Native
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
availabilityZone

instance Prelude.NFData CreateDefaultSubnet where
  rnf :: CreateDefaultSubnet -> ()
rnf CreateDefaultSubnet' {Maybe Bool
Text
availabilityZone :: Text
ipv6Native :: Maybe Bool
dryRun :: Maybe Bool
$sel:availabilityZone:CreateDefaultSubnet' :: CreateDefaultSubnet -> Text
$sel:ipv6Native:CreateDefaultSubnet' :: CreateDefaultSubnet -> Maybe Bool
$sel:dryRun:CreateDefaultSubnet' :: CreateDefaultSubnet -> 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 Bool
ipv6Native
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
availabilityZone

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

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

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

-- | /See:/ 'newCreateDefaultSubnetResponse' smart constructor.
data CreateDefaultSubnetResponse = CreateDefaultSubnetResponse'
  { -- | Information about the subnet.
    CreateDefaultSubnetResponse -> Maybe Subnet
subnet :: Prelude.Maybe Subnet,
    -- | The response's http status code.
    CreateDefaultSubnetResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateDefaultSubnetResponse -> CreateDefaultSubnetResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateDefaultSubnetResponse -> CreateDefaultSubnetResponse -> Bool
$c/= :: CreateDefaultSubnetResponse -> CreateDefaultSubnetResponse -> Bool
== :: CreateDefaultSubnetResponse -> CreateDefaultSubnetResponse -> Bool
$c== :: CreateDefaultSubnetResponse -> CreateDefaultSubnetResponse -> Bool
Prelude.Eq, ReadPrec [CreateDefaultSubnetResponse]
ReadPrec CreateDefaultSubnetResponse
Int -> ReadS CreateDefaultSubnetResponse
ReadS [CreateDefaultSubnetResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateDefaultSubnetResponse]
$creadListPrec :: ReadPrec [CreateDefaultSubnetResponse]
readPrec :: ReadPrec CreateDefaultSubnetResponse
$creadPrec :: ReadPrec CreateDefaultSubnetResponse
readList :: ReadS [CreateDefaultSubnetResponse]
$creadList :: ReadS [CreateDefaultSubnetResponse]
readsPrec :: Int -> ReadS CreateDefaultSubnetResponse
$creadsPrec :: Int -> ReadS CreateDefaultSubnetResponse
Prelude.Read, Int -> CreateDefaultSubnetResponse -> ShowS
[CreateDefaultSubnetResponse] -> ShowS
CreateDefaultSubnetResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateDefaultSubnetResponse] -> ShowS
$cshowList :: [CreateDefaultSubnetResponse] -> ShowS
show :: CreateDefaultSubnetResponse -> String
$cshow :: CreateDefaultSubnetResponse -> String
showsPrec :: Int -> CreateDefaultSubnetResponse -> ShowS
$cshowsPrec :: Int -> CreateDefaultSubnetResponse -> ShowS
Prelude.Show, forall x.
Rep CreateDefaultSubnetResponse x -> CreateDefaultSubnetResponse
forall x.
CreateDefaultSubnetResponse -> Rep CreateDefaultSubnetResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateDefaultSubnetResponse x -> CreateDefaultSubnetResponse
$cfrom :: forall x.
CreateDefaultSubnetResponse -> Rep CreateDefaultSubnetResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateDefaultSubnetResponse' 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:
--
-- 'subnet', 'createDefaultSubnetResponse_subnet' - Information about the subnet.
--
-- 'httpStatus', 'createDefaultSubnetResponse_httpStatus' - The response's http status code.
newCreateDefaultSubnetResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateDefaultSubnetResponse
newCreateDefaultSubnetResponse :: Int -> CreateDefaultSubnetResponse
newCreateDefaultSubnetResponse Int
pHttpStatus_ =
  CreateDefaultSubnetResponse'
    { $sel:subnet:CreateDefaultSubnetResponse' :: Maybe Subnet
subnet =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateDefaultSubnetResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Information about the subnet.
createDefaultSubnetResponse_subnet :: Lens.Lens' CreateDefaultSubnetResponse (Prelude.Maybe Subnet)
createDefaultSubnetResponse_subnet :: Lens' CreateDefaultSubnetResponse (Maybe Subnet)
createDefaultSubnetResponse_subnet = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateDefaultSubnetResponse' {Maybe Subnet
subnet :: Maybe Subnet
$sel:subnet:CreateDefaultSubnetResponse' :: CreateDefaultSubnetResponse -> Maybe Subnet
subnet} -> Maybe Subnet
subnet) (\s :: CreateDefaultSubnetResponse
s@CreateDefaultSubnetResponse' {} Maybe Subnet
a -> CreateDefaultSubnetResponse
s {$sel:subnet:CreateDefaultSubnetResponse' :: Maybe Subnet
subnet = Maybe Subnet
a} :: CreateDefaultSubnetResponse)

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

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