{-# 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 #-}
module Amazonka.EC2.AcceptVpcEndpointConnections
(
AcceptVpcEndpointConnections (..),
newAcceptVpcEndpointConnections,
acceptVpcEndpointConnections_dryRun,
acceptVpcEndpointConnections_serviceId,
acceptVpcEndpointConnections_vpcEndpointIds,
AcceptVpcEndpointConnectionsResponse (..),
newAcceptVpcEndpointConnectionsResponse,
acceptVpcEndpointConnectionsResponse_unsuccessful,
acceptVpcEndpointConnectionsResponse_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
data AcceptVpcEndpointConnections = AcceptVpcEndpointConnections'
{
AcceptVpcEndpointConnections -> Maybe Bool
dryRun :: Prelude.Maybe Prelude.Bool,
AcceptVpcEndpointConnections -> Text
serviceId :: Prelude.Text,
AcceptVpcEndpointConnections -> [Text]
vpcEndpointIds :: [Prelude.Text]
}
deriving (AcceptVpcEndpointConnections
-> AcceptVpcEndpointConnections -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AcceptVpcEndpointConnections
-> AcceptVpcEndpointConnections -> Bool
$c/= :: AcceptVpcEndpointConnections
-> AcceptVpcEndpointConnections -> Bool
== :: AcceptVpcEndpointConnections
-> AcceptVpcEndpointConnections -> Bool
$c== :: AcceptVpcEndpointConnections
-> AcceptVpcEndpointConnections -> Bool
Prelude.Eq, ReadPrec [AcceptVpcEndpointConnections]
ReadPrec AcceptVpcEndpointConnections
Int -> ReadS AcceptVpcEndpointConnections
ReadS [AcceptVpcEndpointConnections]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AcceptVpcEndpointConnections]
$creadListPrec :: ReadPrec [AcceptVpcEndpointConnections]
readPrec :: ReadPrec AcceptVpcEndpointConnections
$creadPrec :: ReadPrec AcceptVpcEndpointConnections
readList :: ReadS [AcceptVpcEndpointConnections]
$creadList :: ReadS [AcceptVpcEndpointConnections]
readsPrec :: Int -> ReadS AcceptVpcEndpointConnections
$creadsPrec :: Int -> ReadS AcceptVpcEndpointConnections
Prelude.Read, Int -> AcceptVpcEndpointConnections -> ShowS
[AcceptVpcEndpointConnections] -> ShowS
AcceptVpcEndpointConnections -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AcceptVpcEndpointConnections] -> ShowS
$cshowList :: [AcceptVpcEndpointConnections] -> ShowS
show :: AcceptVpcEndpointConnections -> String
$cshow :: AcceptVpcEndpointConnections -> String
showsPrec :: Int -> AcceptVpcEndpointConnections -> ShowS
$cshowsPrec :: Int -> AcceptVpcEndpointConnections -> ShowS
Prelude.Show, forall x.
Rep AcceptVpcEndpointConnections x -> AcceptVpcEndpointConnections
forall x.
AcceptVpcEndpointConnections -> Rep AcceptVpcEndpointConnections x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AcceptVpcEndpointConnections x -> AcceptVpcEndpointConnections
$cfrom :: forall x.
AcceptVpcEndpointConnections -> Rep AcceptVpcEndpointConnections x
Prelude.Generic)
newAcceptVpcEndpointConnections ::
Prelude.Text ->
AcceptVpcEndpointConnections
newAcceptVpcEndpointConnections :: Text -> AcceptVpcEndpointConnections
newAcceptVpcEndpointConnections Text
pServiceId_ =
AcceptVpcEndpointConnections'
{ $sel:dryRun:AcceptVpcEndpointConnections' :: Maybe Bool
dryRun =
forall a. Maybe a
Prelude.Nothing,
$sel:serviceId:AcceptVpcEndpointConnections' :: Text
serviceId = Text
pServiceId_,
$sel:vpcEndpointIds:AcceptVpcEndpointConnections' :: [Text]
vpcEndpointIds = forall a. Monoid a => a
Prelude.mempty
}
acceptVpcEndpointConnections_dryRun :: Lens.Lens' AcceptVpcEndpointConnections (Prelude.Maybe Prelude.Bool)
acceptVpcEndpointConnections_dryRun :: Lens' AcceptVpcEndpointConnections (Maybe Bool)
acceptVpcEndpointConnections_dryRun = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AcceptVpcEndpointConnections' {Maybe Bool
dryRun :: Maybe Bool
$sel:dryRun:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> Maybe Bool
dryRun} -> Maybe Bool
dryRun) (\s :: AcceptVpcEndpointConnections
s@AcceptVpcEndpointConnections' {} Maybe Bool
a -> AcceptVpcEndpointConnections
s {$sel:dryRun:AcceptVpcEndpointConnections' :: Maybe Bool
dryRun = Maybe Bool
a} :: AcceptVpcEndpointConnections)
acceptVpcEndpointConnections_serviceId :: Lens.Lens' AcceptVpcEndpointConnections Prelude.Text
acceptVpcEndpointConnections_serviceId :: Lens' AcceptVpcEndpointConnections Text
acceptVpcEndpointConnections_serviceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AcceptVpcEndpointConnections' {Text
serviceId :: Text
$sel:serviceId:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> Text
serviceId} -> Text
serviceId) (\s :: AcceptVpcEndpointConnections
s@AcceptVpcEndpointConnections' {} Text
a -> AcceptVpcEndpointConnections
s {$sel:serviceId:AcceptVpcEndpointConnections' :: Text
serviceId = Text
a} :: AcceptVpcEndpointConnections)
acceptVpcEndpointConnections_vpcEndpointIds :: Lens.Lens' AcceptVpcEndpointConnections [Prelude.Text]
acceptVpcEndpointConnections_vpcEndpointIds :: Lens' AcceptVpcEndpointConnections [Text]
acceptVpcEndpointConnections_vpcEndpointIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AcceptVpcEndpointConnections' {[Text]
vpcEndpointIds :: [Text]
$sel:vpcEndpointIds:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> [Text]
vpcEndpointIds} -> [Text]
vpcEndpointIds) (\s :: AcceptVpcEndpointConnections
s@AcceptVpcEndpointConnections' {} [Text]
a -> AcceptVpcEndpointConnections
s {$sel:vpcEndpointIds:AcceptVpcEndpointConnections' :: [Text]
vpcEndpointIds = [Text]
a} :: AcceptVpcEndpointConnections) 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 AcceptVpcEndpointConnections where
type
AWSResponse AcceptVpcEndpointConnections =
AcceptVpcEndpointConnectionsResponse
request :: (Service -> Service)
-> AcceptVpcEndpointConnections
-> Request AcceptVpcEndpointConnections
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 AcceptVpcEndpointConnections
-> ClientResponse ClientBody
-> m (Either
Error (ClientResponse (AWSResponse AcceptVpcEndpointConnections)))
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 [UnsuccessfulItem]
-> Int -> AcceptVpcEndpointConnectionsResponse
AcceptVpcEndpointConnectionsResponse'
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
"unsuccessful"
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
)
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
AcceptVpcEndpointConnections
where
hashWithSalt :: Int -> AcceptVpcEndpointConnections -> Int
hashWithSalt Int
_salt AcceptVpcEndpointConnections' {[Text]
Maybe Bool
Text
vpcEndpointIds :: [Text]
serviceId :: Text
dryRun :: Maybe Bool
$sel:vpcEndpointIds:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> [Text]
$sel:serviceId:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> Text
$sel:dryRun:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> 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
serviceId
forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` [Text]
vpcEndpointIds
instance Prelude.NFData AcceptVpcEndpointConnections where
rnf :: AcceptVpcEndpointConnections -> ()
rnf AcceptVpcEndpointConnections' {[Text]
Maybe Bool
Text
vpcEndpointIds :: [Text]
serviceId :: Text
dryRun :: Maybe Bool
$sel:vpcEndpointIds:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> [Text]
$sel:serviceId:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> Text
$sel:dryRun:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> 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
serviceId
seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf [Text]
vpcEndpointIds
instance Data.ToHeaders AcceptVpcEndpointConnections where
toHeaders :: AcceptVpcEndpointConnections -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty
instance Data.ToPath AcceptVpcEndpointConnections where
toPath :: AcceptVpcEndpointConnections -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"
instance Data.ToQuery AcceptVpcEndpointConnections where
toQuery :: AcceptVpcEndpointConnections -> QueryString
toQuery AcceptVpcEndpointConnections' {[Text]
Maybe Bool
Text
vpcEndpointIds :: [Text]
serviceId :: Text
dryRun :: Maybe Bool
$sel:vpcEndpointIds:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> [Text]
$sel:serviceId:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> Text
$sel:dryRun:AcceptVpcEndpointConnections' :: AcceptVpcEndpointConnections -> Maybe Bool
..} =
forall a. Monoid a => [a] -> a
Prelude.mconcat
[ ByteString
"Action"
forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: ( ByteString
"AcceptVpcEndpointConnections" ::
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
"ServiceId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
serviceId,
forall a.
(IsList a, ToQuery (Item a)) =>
ByteString -> a -> QueryString
Data.toQueryList ByteString
"VpcEndpointId" [Text]
vpcEndpointIds
]
data AcceptVpcEndpointConnectionsResponse = AcceptVpcEndpointConnectionsResponse'
{
AcceptVpcEndpointConnectionsResponse -> Maybe [UnsuccessfulItem]
unsuccessful :: Prelude.Maybe [UnsuccessfulItem],
AcceptVpcEndpointConnectionsResponse -> Int
httpStatus :: Prelude.Int
}
deriving (AcceptVpcEndpointConnectionsResponse
-> AcceptVpcEndpointConnectionsResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AcceptVpcEndpointConnectionsResponse
-> AcceptVpcEndpointConnectionsResponse -> Bool
$c/= :: AcceptVpcEndpointConnectionsResponse
-> AcceptVpcEndpointConnectionsResponse -> Bool
== :: AcceptVpcEndpointConnectionsResponse
-> AcceptVpcEndpointConnectionsResponse -> Bool
$c== :: AcceptVpcEndpointConnectionsResponse
-> AcceptVpcEndpointConnectionsResponse -> Bool
Prelude.Eq, ReadPrec [AcceptVpcEndpointConnectionsResponse]
ReadPrec AcceptVpcEndpointConnectionsResponse
Int -> ReadS AcceptVpcEndpointConnectionsResponse
ReadS [AcceptVpcEndpointConnectionsResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AcceptVpcEndpointConnectionsResponse]
$creadListPrec :: ReadPrec [AcceptVpcEndpointConnectionsResponse]
readPrec :: ReadPrec AcceptVpcEndpointConnectionsResponse
$creadPrec :: ReadPrec AcceptVpcEndpointConnectionsResponse
readList :: ReadS [AcceptVpcEndpointConnectionsResponse]
$creadList :: ReadS [AcceptVpcEndpointConnectionsResponse]
readsPrec :: Int -> ReadS AcceptVpcEndpointConnectionsResponse
$creadsPrec :: Int -> ReadS AcceptVpcEndpointConnectionsResponse
Prelude.Read, Int -> AcceptVpcEndpointConnectionsResponse -> ShowS
[AcceptVpcEndpointConnectionsResponse] -> ShowS
AcceptVpcEndpointConnectionsResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AcceptVpcEndpointConnectionsResponse] -> ShowS
$cshowList :: [AcceptVpcEndpointConnectionsResponse] -> ShowS
show :: AcceptVpcEndpointConnectionsResponse -> String
$cshow :: AcceptVpcEndpointConnectionsResponse -> String
showsPrec :: Int -> AcceptVpcEndpointConnectionsResponse -> ShowS
$cshowsPrec :: Int -> AcceptVpcEndpointConnectionsResponse -> ShowS
Prelude.Show, forall x.
Rep AcceptVpcEndpointConnectionsResponse x
-> AcceptVpcEndpointConnectionsResponse
forall x.
AcceptVpcEndpointConnectionsResponse
-> Rep AcceptVpcEndpointConnectionsResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AcceptVpcEndpointConnectionsResponse x
-> AcceptVpcEndpointConnectionsResponse
$cfrom :: forall x.
AcceptVpcEndpointConnectionsResponse
-> Rep AcceptVpcEndpointConnectionsResponse x
Prelude.Generic)
newAcceptVpcEndpointConnectionsResponse ::
Prelude.Int ->
AcceptVpcEndpointConnectionsResponse
newAcceptVpcEndpointConnectionsResponse :: Int -> AcceptVpcEndpointConnectionsResponse
newAcceptVpcEndpointConnectionsResponse Int
pHttpStatus_ =
AcceptVpcEndpointConnectionsResponse'
{ $sel:unsuccessful:AcceptVpcEndpointConnectionsResponse' :: Maybe [UnsuccessfulItem]
unsuccessful =
forall a. Maybe a
Prelude.Nothing,
$sel:httpStatus:AcceptVpcEndpointConnectionsResponse' :: Int
httpStatus = Int
pHttpStatus_
}
acceptVpcEndpointConnectionsResponse_unsuccessful :: Lens.Lens' AcceptVpcEndpointConnectionsResponse (Prelude.Maybe [UnsuccessfulItem])
acceptVpcEndpointConnectionsResponse_unsuccessful :: Lens'
AcceptVpcEndpointConnectionsResponse (Maybe [UnsuccessfulItem])
acceptVpcEndpointConnectionsResponse_unsuccessful = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AcceptVpcEndpointConnectionsResponse' {Maybe [UnsuccessfulItem]
unsuccessful :: Maybe [UnsuccessfulItem]
$sel:unsuccessful:AcceptVpcEndpointConnectionsResponse' :: AcceptVpcEndpointConnectionsResponse -> Maybe [UnsuccessfulItem]
unsuccessful} -> Maybe [UnsuccessfulItem]
unsuccessful) (\s :: AcceptVpcEndpointConnectionsResponse
s@AcceptVpcEndpointConnectionsResponse' {} Maybe [UnsuccessfulItem]
a -> AcceptVpcEndpointConnectionsResponse
s {$sel:unsuccessful:AcceptVpcEndpointConnectionsResponse' :: Maybe [UnsuccessfulItem]
unsuccessful = Maybe [UnsuccessfulItem]
a} :: AcceptVpcEndpointConnectionsResponse) 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
acceptVpcEndpointConnectionsResponse_httpStatus :: Lens.Lens' AcceptVpcEndpointConnectionsResponse Prelude.Int
acceptVpcEndpointConnectionsResponse_httpStatus :: Lens' AcceptVpcEndpointConnectionsResponse Int
acceptVpcEndpointConnectionsResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AcceptVpcEndpointConnectionsResponse' {Int
httpStatus :: Int
$sel:httpStatus:AcceptVpcEndpointConnectionsResponse' :: AcceptVpcEndpointConnectionsResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: AcceptVpcEndpointConnectionsResponse
s@AcceptVpcEndpointConnectionsResponse' {} Int
a -> AcceptVpcEndpointConnectionsResponse
s {$sel:httpStatus:AcceptVpcEndpointConnectionsResponse' :: Int
httpStatus = Int
a} :: AcceptVpcEndpointConnectionsResponse)
instance
Prelude.NFData
AcceptVpcEndpointConnectionsResponse
where
rnf :: AcceptVpcEndpointConnectionsResponse -> ()
rnf AcceptVpcEndpointConnectionsResponse' {Int
Maybe [UnsuccessfulItem]
httpStatus :: Int
unsuccessful :: Maybe [UnsuccessfulItem]
$sel:httpStatus:AcceptVpcEndpointConnectionsResponse' :: AcceptVpcEndpointConnectionsResponse -> Int
$sel:unsuccessful:AcceptVpcEndpointConnectionsResponse' :: AcceptVpcEndpointConnectionsResponse -> Maybe [UnsuccessfulItem]
..} =
forall a. NFData a => a -> ()
Prelude.rnf Maybe [UnsuccessfulItem]
unsuccessful
seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus