{-# 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.AppRunner.CreateVpcConnector
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Create an App Runner VPC connector resource. App Runner requires this
-- resource when you want to associate your App Runner service to a custom
-- Amazon Virtual Private Cloud (Amazon VPC).
module Amazonka.AppRunner.CreateVpcConnector
  ( -- * Creating a Request
    CreateVpcConnector (..),
    newCreateVpcConnector,

    -- * Request Lenses
    createVpcConnector_securityGroups,
    createVpcConnector_tags,
    createVpcConnector_vpcConnectorName,
    createVpcConnector_subnets,

    -- * Destructuring the Response
    CreateVpcConnectorResponse (..),
    newCreateVpcConnectorResponse,

    -- * Response Lenses
    createVpcConnectorResponse_httpStatus,
    createVpcConnectorResponse_vpcConnector,
  )
where

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

-- | /See:/ 'newCreateVpcConnector' smart constructor.
data CreateVpcConnector = CreateVpcConnector'
  { -- | A list of IDs of security groups that App Runner should use for access
    -- to Amazon Web Services resources under the specified subnets. If not
    -- specified, App Runner uses the default security group of the Amazon VPC.
    -- The default security group allows all outbound traffic.
    CreateVpcConnector -> Maybe [Text]
securityGroups :: Prelude.Maybe [Prelude.Text],
    -- | A list of metadata items that you can associate with your VPC connector
    -- resource. A tag is a key-value pair.
    CreateVpcConnector -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | A name for the VPC connector.
    CreateVpcConnector -> Text
vpcConnectorName :: Prelude.Text,
    -- | A list of IDs of subnets that App Runner should use when it associates
    -- your service with a custom Amazon VPC. Specify IDs of subnets of a
    -- single Amazon VPC. App Runner determines the Amazon VPC from the subnets
    -- you specify.
    --
    -- App Runner currently only provides support for IPv4.
    CreateVpcConnector -> [Text]
subnets :: [Prelude.Text]
  }
  deriving (CreateVpcConnector -> CreateVpcConnector -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateVpcConnector -> CreateVpcConnector -> Bool
$c/= :: CreateVpcConnector -> CreateVpcConnector -> Bool
== :: CreateVpcConnector -> CreateVpcConnector -> Bool
$c== :: CreateVpcConnector -> CreateVpcConnector -> Bool
Prelude.Eq, ReadPrec [CreateVpcConnector]
ReadPrec CreateVpcConnector
Int -> ReadS CreateVpcConnector
ReadS [CreateVpcConnector]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateVpcConnector]
$creadListPrec :: ReadPrec [CreateVpcConnector]
readPrec :: ReadPrec CreateVpcConnector
$creadPrec :: ReadPrec CreateVpcConnector
readList :: ReadS [CreateVpcConnector]
$creadList :: ReadS [CreateVpcConnector]
readsPrec :: Int -> ReadS CreateVpcConnector
$creadsPrec :: Int -> ReadS CreateVpcConnector
Prelude.Read, Int -> CreateVpcConnector -> ShowS
[CreateVpcConnector] -> ShowS
CreateVpcConnector -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateVpcConnector] -> ShowS
$cshowList :: [CreateVpcConnector] -> ShowS
show :: CreateVpcConnector -> String
$cshow :: CreateVpcConnector -> String
showsPrec :: Int -> CreateVpcConnector -> ShowS
$cshowsPrec :: Int -> CreateVpcConnector -> ShowS
Prelude.Show, forall x. Rep CreateVpcConnector x -> CreateVpcConnector
forall x. CreateVpcConnector -> Rep CreateVpcConnector x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateVpcConnector x -> CreateVpcConnector
$cfrom :: forall x. CreateVpcConnector -> Rep CreateVpcConnector x
Prelude.Generic)

-- |
-- Create a value of 'CreateVpcConnector' 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:
--
-- 'securityGroups', 'createVpcConnector_securityGroups' - A list of IDs of security groups that App Runner should use for access
-- to Amazon Web Services resources under the specified subnets. If not
-- specified, App Runner uses the default security group of the Amazon VPC.
-- The default security group allows all outbound traffic.
--
-- 'tags', 'createVpcConnector_tags' - A list of metadata items that you can associate with your VPC connector
-- resource. A tag is a key-value pair.
--
-- 'vpcConnectorName', 'createVpcConnector_vpcConnectorName' - A name for the VPC connector.
--
-- 'subnets', 'createVpcConnector_subnets' - A list of IDs of subnets that App Runner should use when it associates
-- your service with a custom Amazon VPC. Specify IDs of subnets of a
-- single Amazon VPC. App Runner determines the Amazon VPC from the subnets
-- you specify.
--
-- App Runner currently only provides support for IPv4.
newCreateVpcConnector ::
  -- | 'vpcConnectorName'
  Prelude.Text ->
  CreateVpcConnector
newCreateVpcConnector :: Text -> CreateVpcConnector
newCreateVpcConnector Text
pVpcConnectorName_ =
  CreateVpcConnector'
    { $sel:securityGroups:CreateVpcConnector' :: Maybe [Text]
securityGroups =
        forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateVpcConnector' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:vpcConnectorName:CreateVpcConnector' :: Text
vpcConnectorName = Text
pVpcConnectorName_,
      $sel:subnets:CreateVpcConnector' :: [Text]
subnets = forall a. Monoid a => a
Prelude.mempty
    }

-- | A list of IDs of security groups that App Runner should use for access
-- to Amazon Web Services resources under the specified subnets. If not
-- specified, App Runner uses the default security group of the Amazon VPC.
-- The default security group allows all outbound traffic.
createVpcConnector_securityGroups :: Lens.Lens' CreateVpcConnector (Prelude.Maybe [Prelude.Text])
createVpcConnector_securityGroups :: Lens' CreateVpcConnector (Maybe [Text])
createVpcConnector_securityGroups = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVpcConnector' {Maybe [Text]
securityGroups :: Maybe [Text]
$sel:securityGroups:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Text]
securityGroups} -> Maybe [Text]
securityGroups) (\s :: CreateVpcConnector
s@CreateVpcConnector' {} Maybe [Text]
a -> CreateVpcConnector
s {$sel:securityGroups:CreateVpcConnector' :: Maybe [Text]
securityGroups = Maybe [Text]
a} :: CreateVpcConnector) 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

-- | A list of metadata items that you can associate with your VPC connector
-- resource. A tag is a key-value pair.
createVpcConnector_tags :: Lens.Lens' CreateVpcConnector (Prelude.Maybe [Tag])
createVpcConnector_tags :: Lens' CreateVpcConnector (Maybe [Tag])
createVpcConnector_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVpcConnector' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: CreateVpcConnector
s@CreateVpcConnector' {} Maybe [Tag]
a -> CreateVpcConnector
s {$sel:tags:CreateVpcConnector' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: CreateVpcConnector) 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

-- | A name for the VPC connector.
createVpcConnector_vpcConnectorName :: Lens.Lens' CreateVpcConnector Prelude.Text
createVpcConnector_vpcConnectorName :: Lens' CreateVpcConnector Text
createVpcConnector_vpcConnectorName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVpcConnector' {Text
vpcConnectorName :: Text
$sel:vpcConnectorName:CreateVpcConnector' :: CreateVpcConnector -> Text
vpcConnectorName} -> Text
vpcConnectorName) (\s :: CreateVpcConnector
s@CreateVpcConnector' {} Text
a -> CreateVpcConnector
s {$sel:vpcConnectorName:CreateVpcConnector' :: Text
vpcConnectorName = Text
a} :: CreateVpcConnector)

-- | A list of IDs of subnets that App Runner should use when it associates
-- your service with a custom Amazon VPC. Specify IDs of subnets of a
-- single Amazon VPC. App Runner determines the Amazon VPC from the subnets
-- you specify.
--
-- App Runner currently only provides support for IPv4.
createVpcConnector_subnets :: Lens.Lens' CreateVpcConnector [Prelude.Text]
createVpcConnector_subnets :: Lens' CreateVpcConnector [Text]
createVpcConnector_subnets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVpcConnector' {[Text]
subnets :: [Text]
$sel:subnets:CreateVpcConnector' :: CreateVpcConnector -> [Text]
subnets} -> [Text]
subnets) (\s :: CreateVpcConnector
s@CreateVpcConnector' {} [Text]
a -> CreateVpcConnector
s {$sel:subnets:CreateVpcConnector' :: [Text]
subnets = [Text]
a} :: CreateVpcConnector) 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 CreateVpcConnector where
  type
    AWSResponse CreateVpcConnector =
      CreateVpcConnectorResponse
  request :: (Service -> Service)
-> CreateVpcConnector -> Request CreateVpcConnector
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 CreateVpcConnector
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateVpcConnector)))
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 ->
          Int -> VpcConnector -> CreateVpcConnectorResponse
CreateVpcConnectorResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"VpcConnector")
      )

instance Prelude.Hashable CreateVpcConnector where
  hashWithSalt :: Int -> CreateVpcConnector -> Int
hashWithSalt Int
_salt CreateVpcConnector' {[Text]
Maybe [Text]
Maybe [Tag]
Text
subnets :: [Text]
vpcConnectorName :: Text
tags :: Maybe [Tag]
securityGroups :: Maybe [Text]
$sel:subnets:CreateVpcConnector' :: CreateVpcConnector -> [Text]
$sel:vpcConnectorName:CreateVpcConnector' :: CreateVpcConnector -> Text
$sel:tags:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Tag]
$sel:securityGroups:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
securityGroups
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
vpcConnectorName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
subnets

instance Prelude.NFData CreateVpcConnector where
  rnf :: CreateVpcConnector -> ()
rnf CreateVpcConnector' {[Text]
Maybe [Text]
Maybe [Tag]
Text
subnets :: [Text]
vpcConnectorName :: Text
tags :: Maybe [Tag]
securityGroups :: Maybe [Text]
$sel:subnets:CreateVpcConnector' :: CreateVpcConnector -> [Text]
$sel:vpcConnectorName:CreateVpcConnector' :: CreateVpcConnector -> Text
$sel:tags:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Tag]
$sel:securityGroups:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
securityGroups
      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
vpcConnectorName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
subnets

instance Data.ToHeaders CreateVpcConnector where
  toHeaders :: CreateVpcConnector -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"AppRunner.CreateVpcConnector" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateVpcConnector where
  toJSON :: CreateVpcConnector -> Value
toJSON CreateVpcConnector' {[Text]
Maybe [Text]
Maybe [Tag]
Text
subnets :: [Text]
vpcConnectorName :: Text
tags :: Maybe [Tag]
securityGroups :: Maybe [Text]
$sel:subnets:CreateVpcConnector' :: CreateVpcConnector -> [Text]
$sel:vpcConnectorName:CreateVpcConnector' :: CreateVpcConnector -> Text
$sel:tags:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Tag]
$sel:securityGroups:CreateVpcConnector' :: CreateVpcConnector -> Maybe [Text]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"SecurityGroups" 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]
securityGroups,
            (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
"VpcConnectorName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
vpcConnectorName),
            forall a. a -> Maybe a
Prelude.Just (Key
"Subnets" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= [Text]
subnets)
          ]
      )

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

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

-- | /See:/ 'newCreateVpcConnectorResponse' smart constructor.
data CreateVpcConnectorResponse = CreateVpcConnectorResponse'
  { -- | The response's http status code.
    CreateVpcConnectorResponse -> Int
httpStatus :: Prelude.Int,
    -- | A description of the App Runner VPC connector that\'s created by this
    -- request.
    CreateVpcConnectorResponse -> VpcConnector
vpcConnector :: VpcConnector
  }
  deriving (CreateVpcConnectorResponse -> CreateVpcConnectorResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateVpcConnectorResponse -> CreateVpcConnectorResponse -> Bool
$c/= :: CreateVpcConnectorResponse -> CreateVpcConnectorResponse -> Bool
== :: CreateVpcConnectorResponse -> CreateVpcConnectorResponse -> Bool
$c== :: CreateVpcConnectorResponse -> CreateVpcConnectorResponse -> Bool
Prelude.Eq, ReadPrec [CreateVpcConnectorResponse]
ReadPrec CreateVpcConnectorResponse
Int -> ReadS CreateVpcConnectorResponse
ReadS [CreateVpcConnectorResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateVpcConnectorResponse]
$creadListPrec :: ReadPrec [CreateVpcConnectorResponse]
readPrec :: ReadPrec CreateVpcConnectorResponse
$creadPrec :: ReadPrec CreateVpcConnectorResponse
readList :: ReadS [CreateVpcConnectorResponse]
$creadList :: ReadS [CreateVpcConnectorResponse]
readsPrec :: Int -> ReadS CreateVpcConnectorResponse
$creadsPrec :: Int -> ReadS CreateVpcConnectorResponse
Prelude.Read, Int -> CreateVpcConnectorResponse -> ShowS
[CreateVpcConnectorResponse] -> ShowS
CreateVpcConnectorResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateVpcConnectorResponse] -> ShowS
$cshowList :: [CreateVpcConnectorResponse] -> ShowS
show :: CreateVpcConnectorResponse -> String
$cshow :: CreateVpcConnectorResponse -> String
showsPrec :: Int -> CreateVpcConnectorResponse -> ShowS
$cshowsPrec :: Int -> CreateVpcConnectorResponse -> ShowS
Prelude.Show, forall x.
Rep CreateVpcConnectorResponse x -> CreateVpcConnectorResponse
forall x.
CreateVpcConnectorResponse -> Rep CreateVpcConnectorResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateVpcConnectorResponse x -> CreateVpcConnectorResponse
$cfrom :: forall x.
CreateVpcConnectorResponse -> Rep CreateVpcConnectorResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateVpcConnectorResponse' 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:
--
-- 'httpStatus', 'createVpcConnectorResponse_httpStatus' - The response's http status code.
--
-- 'vpcConnector', 'createVpcConnectorResponse_vpcConnector' - A description of the App Runner VPC connector that\'s created by this
-- request.
newCreateVpcConnectorResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'vpcConnector'
  VpcConnector ->
  CreateVpcConnectorResponse
newCreateVpcConnectorResponse :: Int -> VpcConnector -> CreateVpcConnectorResponse
newCreateVpcConnectorResponse
  Int
pHttpStatus_
  VpcConnector
pVpcConnector_ =
    CreateVpcConnectorResponse'
      { $sel:httpStatus:CreateVpcConnectorResponse' :: Int
httpStatus =
          Int
pHttpStatus_,
        $sel:vpcConnector:CreateVpcConnectorResponse' :: VpcConnector
vpcConnector = VpcConnector
pVpcConnector_
      }

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

-- | A description of the App Runner VPC connector that\'s created by this
-- request.
createVpcConnectorResponse_vpcConnector :: Lens.Lens' CreateVpcConnectorResponse VpcConnector
createVpcConnectorResponse_vpcConnector :: Lens' CreateVpcConnectorResponse VpcConnector
createVpcConnectorResponse_vpcConnector = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVpcConnectorResponse' {VpcConnector
vpcConnector :: VpcConnector
$sel:vpcConnector:CreateVpcConnectorResponse' :: CreateVpcConnectorResponse -> VpcConnector
vpcConnector} -> VpcConnector
vpcConnector) (\s :: CreateVpcConnectorResponse
s@CreateVpcConnectorResponse' {} VpcConnector
a -> CreateVpcConnectorResponse
s {$sel:vpcConnector:CreateVpcConnectorResponse' :: VpcConnector
vpcConnector = VpcConnector
a} :: CreateVpcConnectorResponse)

instance Prelude.NFData CreateVpcConnectorResponse where
  rnf :: CreateVpcConnectorResponse -> ()
rnf CreateVpcConnectorResponse' {Int
VpcConnector
vpcConnector :: VpcConnector
httpStatus :: Int
$sel:vpcConnector:CreateVpcConnectorResponse' :: CreateVpcConnectorResponse -> VpcConnector
$sel:httpStatus:CreateVpcConnectorResponse' :: CreateVpcConnectorResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf VpcConnector
vpcConnector