{-# 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.OpenSearchServerless.UpdateVpcEndpoint
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Updates an OpenSearch Serverless-managed interface endpoint. For more
-- information, see
-- <https://docs.aws.amazon.com/opensearch-service/latest/developerguide/serverless-vpc.html Access Amazon OpenSearch Serverless using an interface endpoint>.
module Amazonka.OpenSearchServerless.UpdateVpcEndpoint
  ( -- * Creating a Request
    UpdateVpcEndpoint (..),
    newUpdateVpcEndpoint,

    -- * Request Lenses
    updateVpcEndpoint_addSecurityGroupIds,
    updateVpcEndpoint_addSubnetIds,
    updateVpcEndpoint_clientToken,
    updateVpcEndpoint_removeSecurityGroupIds,
    updateVpcEndpoint_removeSubnetIds,
    updateVpcEndpoint_id,

    -- * Destructuring the Response
    UpdateVpcEndpointResponse (..),
    newUpdateVpcEndpointResponse,

    -- * Response Lenses
    updateVpcEndpointResponse_updateVpcEndpointDetail,
    updateVpcEndpointResponse_httpStatus,
  )
where

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

-- | /See:/ 'newUpdateVpcEndpoint' smart constructor.
data UpdateVpcEndpoint = UpdateVpcEndpoint'
  { -- | The unique identifiers of the security groups to add to the endpoint.
    -- Security groups define the ports, protocols, and sources for inbound
    -- traffic that you are authorizing into your endpoint.
    UpdateVpcEndpoint -> Maybe (NonEmpty Text)
addSecurityGroupIds :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | The ID of one or more subnets to add to the endpoint.
    UpdateVpcEndpoint -> Maybe (NonEmpty Text)
addSubnetIds :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | Unique, case-sensitive identifier to ensure idempotency of the request.
    UpdateVpcEndpoint -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The unique identifiers of the security groups to remove from the
    -- endpoint.
    UpdateVpcEndpoint -> Maybe (NonEmpty Text)
removeSecurityGroupIds :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | The unique identifiers of the subnets to remove from the endpoint.
    UpdateVpcEndpoint -> Maybe (NonEmpty Text)
removeSubnetIds :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | The unique identifier of the interface endpoint to update.
    UpdateVpcEndpoint -> Text
id :: Prelude.Text
  }
  deriving (UpdateVpcEndpoint -> UpdateVpcEndpoint -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UpdateVpcEndpoint -> UpdateVpcEndpoint -> Bool
$c/= :: UpdateVpcEndpoint -> UpdateVpcEndpoint -> Bool
== :: UpdateVpcEndpoint -> UpdateVpcEndpoint -> Bool
$c== :: UpdateVpcEndpoint -> UpdateVpcEndpoint -> Bool
Prelude.Eq, ReadPrec [UpdateVpcEndpoint]
ReadPrec UpdateVpcEndpoint
Int -> ReadS UpdateVpcEndpoint
ReadS [UpdateVpcEndpoint]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UpdateVpcEndpoint]
$creadListPrec :: ReadPrec [UpdateVpcEndpoint]
readPrec :: ReadPrec UpdateVpcEndpoint
$creadPrec :: ReadPrec UpdateVpcEndpoint
readList :: ReadS [UpdateVpcEndpoint]
$creadList :: ReadS [UpdateVpcEndpoint]
readsPrec :: Int -> ReadS UpdateVpcEndpoint
$creadsPrec :: Int -> ReadS UpdateVpcEndpoint
Prelude.Read, Int -> UpdateVpcEndpoint -> ShowS
[UpdateVpcEndpoint] -> ShowS
UpdateVpcEndpoint -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UpdateVpcEndpoint] -> ShowS
$cshowList :: [UpdateVpcEndpoint] -> ShowS
show :: UpdateVpcEndpoint -> String
$cshow :: UpdateVpcEndpoint -> String
showsPrec :: Int -> UpdateVpcEndpoint -> ShowS
$cshowsPrec :: Int -> UpdateVpcEndpoint -> ShowS
Prelude.Show, forall x. Rep UpdateVpcEndpoint x -> UpdateVpcEndpoint
forall x. UpdateVpcEndpoint -> Rep UpdateVpcEndpoint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UpdateVpcEndpoint x -> UpdateVpcEndpoint
$cfrom :: forall x. UpdateVpcEndpoint -> Rep UpdateVpcEndpoint x
Prelude.Generic)

-- |
-- Create a value of 'UpdateVpcEndpoint' 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:
--
-- 'addSecurityGroupIds', 'updateVpcEndpoint_addSecurityGroupIds' - The unique identifiers of the security groups to add to the endpoint.
-- Security groups define the ports, protocols, and sources for inbound
-- traffic that you are authorizing into your endpoint.
--
-- 'addSubnetIds', 'updateVpcEndpoint_addSubnetIds' - The ID of one or more subnets to add to the endpoint.
--
-- 'clientToken', 'updateVpcEndpoint_clientToken' - Unique, case-sensitive identifier to ensure idempotency of the request.
--
-- 'removeSecurityGroupIds', 'updateVpcEndpoint_removeSecurityGroupIds' - The unique identifiers of the security groups to remove from the
-- endpoint.
--
-- 'removeSubnetIds', 'updateVpcEndpoint_removeSubnetIds' - The unique identifiers of the subnets to remove from the endpoint.
--
-- 'id', 'updateVpcEndpoint_id' - The unique identifier of the interface endpoint to update.
newUpdateVpcEndpoint ::
  -- | 'id'
  Prelude.Text ->
  UpdateVpcEndpoint
newUpdateVpcEndpoint :: Text -> UpdateVpcEndpoint
newUpdateVpcEndpoint Text
pId_ =
  UpdateVpcEndpoint'
    { $sel:addSecurityGroupIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
addSecurityGroupIds =
        forall a. Maybe a
Prelude.Nothing,
      $sel:addSubnetIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
addSubnetIds = forall a. Maybe a
Prelude.Nothing,
      $sel:clientToken:UpdateVpcEndpoint' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:removeSecurityGroupIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
removeSecurityGroupIds = forall a. Maybe a
Prelude.Nothing,
      $sel:removeSubnetIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
removeSubnetIds = forall a. Maybe a
Prelude.Nothing,
      $sel:id:UpdateVpcEndpoint' :: Text
id = Text
pId_
    }

-- | The unique identifiers of the security groups to add to the endpoint.
-- Security groups define the ports, protocols, and sources for inbound
-- traffic that you are authorizing into your endpoint.
updateVpcEndpoint_addSecurityGroupIds :: Lens.Lens' UpdateVpcEndpoint (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
updateVpcEndpoint_addSecurityGroupIds :: Lens' UpdateVpcEndpoint (Maybe (NonEmpty Text))
updateVpcEndpoint_addSecurityGroupIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVpcEndpoint' {Maybe (NonEmpty Text)
addSecurityGroupIds :: Maybe (NonEmpty Text)
$sel:addSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
addSecurityGroupIds} -> Maybe (NonEmpty Text)
addSecurityGroupIds) (\s :: UpdateVpcEndpoint
s@UpdateVpcEndpoint' {} Maybe (NonEmpty Text)
a -> UpdateVpcEndpoint
s {$sel:addSecurityGroupIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
addSecurityGroupIds = Maybe (NonEmpty Text)
a} :: UpdateVpcEndpoint) 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 ID of one or more subnets to add to the endpoint.
updateVpcEndpoint_addSubnetIds :: Lens.Lens' UpdateVpcEndpoint (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
updateVpcEndpoint_addSubnetIds :: Lens' UpdateVpcEndpoint (Maybe (NonEmpty Text))
updateVpcEndpoint_addSubnetIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVpcEndpoint' {Maybe (NonEmpty Text)
addSubnetIds :: Maybe (NonEmpty Text)
$sel:addSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
addSubnetIds} -> Maybe (NonEmpty Text)
addSubnetIds) (\s :: UpdateVpcEndpoint
s@UpdateVpcEndpoint' {} Maybe (NonEmpty Text)
a -> UpdateVpcEndpoint
s {$sel:addSubnetIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
addSubnetIds = Maybe (NonEmpty Text)
a} :: UpdateVpcEndpoint) 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

-- | Unique, case-sensitive identifier to ensure idempotency of the request.
updateVpcEndpoint_clientToken :: Lens.Lens' UpdateVpcEndpoint (Prelude.Maybe Prelude.Text)
updateVpcEndpoint_clientToken :: Lens' UpdateVpcEndpoint (Maybe Text)
updateVpcEndpoint_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVpcEndpoint' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: UpdateVpcEndpoint
s@UpdateVpcEndpoint' {} Maybe Text
a -> UpdateVpcEndpoint
s {$sel:clientToken:UpdateVpcEndpoint' :: Maybe Text
clientToken = Maybe Text
a} :: UpdateVpcEndpoint)

-- | The unique identifiers of the security groups to remove from the
-- endpoint.
updateVpcEndpoint_removeSecurityGroupIds :: Lens.Lens' UpdateVpcEndpoint (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
updateVpcEndpoint_removeSecurityGroupIds :: Lens' UpdateVpcEndpoint (Maybe (NonEmpty Text))
updateVpcEndpoint_removeSecurityGroupIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVpcEndpoint' {Maybe (NonEmpty Text)
removeSecurityGroupIds :: Maybe (NonEmpty Text)
$sel:removeSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
removeSecurityGroupIds} -> Maybe (NonEmpty Text)
removeSecurityGroupIds) (\s :: UpdateVpcEndpoint
s@UpdateVpcEndpoint' {} Maybe (NonEmpty Text)
a -> UpdateVpcEndpoint
s {$sel:removeSecurityGroupIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
removeSecurityGroupIds = Maybe (NonEmpty Text)
a} :: UpdateVpcEndpoint) 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 unique identifiers of the subnets to remove from the endpoint.
updateVpcEndpoint_removeSubnetIds :: Lens.Lens' UpdateVpcEndpoint (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
updateVpcEndpoint_removeSubnetIds :: Lens' UpdateVpcEndpoint (Maybe (NonEmpty Text))
updateVpcEndpoint_removeSubnetIds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVpcEndpoint' {Maybe (NonEmpty Text)
removeSubnetIds :: Maybe (NonEmpty Text)
$sel:removeSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
removeSubnetIds} -> Maybe (NonEmpty Text)
removeSubnetIds) (\s :: UpdateVpcEndpoint
s@UpdateVpcEndpoint' {} Maybe (NonEmpty Text)
a -> UpdateVpcEndpoint
s {$sel:removeSubnetIds:UpdateVpcEndpoint' :: Maybe (NonEmpty Text)
removeSubnetIds = Maybe (NonEmpty Text)
a} :: UpdateVpcEndpoint) 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 unique identifier of the interface endpoint to update.
updateVpcEndpoint_id :: Lens.Lens' UpdateVpcEndpoint Prelude.Text
updateVpcEndpoint_id :: Lens' UpdateVpcEndpoint Text
updateVpcEndpoint_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVpcEndpoint' {Text
id :: Text
$sel:id:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Text
id} -> Text
id) (\s :: UpdateVpcEndpoint
s@UpdateVpcEndpoint' {} Text
a -> UpdateVpcEndpoint
s {$sel:id:UpdateVpcEndpoint' :: Text
id = Text
a} :: UpdateVpcEndpoint)

instance Core.AWSRequest UpdateVpcEndpoint where
  type
    AWSResponse UpdateVpcEndpoint =
      UpdateVpcEndpointResponse
  request :: (Service -> Service)
-> UpdateVpcEndpoint -> Request UpdateVpcEndpoint
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 UpdateVpcEndpoint
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse UpdateVpcEndpoint)))
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 ->
          Maybe UpdateVpcEndpointDetail -> Int -> UpdateVpcEndpointResponse
UpdateVpcEndpointResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"UpdateVpcEndpointDetail")
            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 UpdateVpcEndpoint where
  hashWithSalt :: Int -> UpdateVpcEndpoint -> Int
hashWithSalt Int
_salt UpdateVpcEndpoint' {Maybe (NonEmpty Text)
Maybe Text
Text
id :: Text
removeSubnetIds :: Maybe (NonEmpty Text)
removeSecurityGroupIds :: Maybe (NonEmpty Text)
clientToken :: Maybe Text
addSubnetIds :: Maybe (NonEmpty Text)
addSecurityGroupIds :: Maybe (NonEmpty Text)
$sel:id:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Text
$sel:removeSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:removeSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:clientToken:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe Text
$sel:addSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:addSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
addSecurityGroupIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
addSubnetIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
removeSecurityGroupIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Text)
removeSubnetIds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
id

instance Prelude.NFData UpdateVpcEndpoint where
  rnf :: UpdateVpcEndpoint -> ()
rnf UpdateVpcEndpoint' {Maybe (NonEmpty Text)
Maybe Text
Text
id :: Text
removeSubnetIds :: Maybe (NonEmpty Text)
removeSecurityGroupIds :: Maybe (NonEmpty Text)
clientToken :: Maybe Text
addSubnetIds :: Maybe (NonEmpty Text)
addSecurityGroupIds :: Maybe (NonEmpty Text)
$sel:id:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Text
$sel:removeSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:removeSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:clientToken:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe Text
$sel:addSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:addSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
addSecurityGroupIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
addSubnetIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
removeSecurityGroupIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Text)
removeSubnetIds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
id

instance Data.ToHeaders UpdateVpcEndpoint where
  toHeaders :: UpdateVpcEndpoint -> 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
"OpenSearchServerless.UpdateVpcEndpoint" ::
                          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 UpdateVpcEndpoint where
  toJSON :: UpdateVpcEndpoint -> Value
toJSON UpdateVpcEndpoint' {Maybe (NonEmpty Text)
Maybe Text
Text
id :: Text
removeSubnetIds :: Maybe (NonEmpty Text)
removeSecurityGroupIds :: Maybe (NonEmpty Text)
clientToken :: Maybe Text
addSubnetIds :: Maybe (NonEmpty Text)
addSecurityGroupIds :: Maybe (NonEmpty Text)
$sel:id:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Text
$sel:removeSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:removeSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:clientToken:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe Text
$sel:addSubnetIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
$sel:addSecurityGroupIds:UpdateVpcEndpoint' :: UpdateVpcEndpoint -> Maybe (NonEmpty Text)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"addSecurityGroupIds" 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 (NonEmpty Text)
addSecurityGroupIds,
            (Key
"addSubnetIds" 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 (NonEmpty Text)
addSubnetIds,
            (Key
"clientToken" 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
clientToken,
            (Key
"removeSecurityGroupIds" 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 (NonEmpty Text)
removeSecurityGroupIds,
            (Key
"removeSubnetIds" 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 (NonEmpty Text)
removeSubnetIds,
            forall a. a -> Maybe a
Prelude.Just (Key
"id" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
id)
          ]
      )

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

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

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

-- |
-- Create a value of 'UpdateVpcEndpointResponse' 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:
--
-- 'updateVpcEndpointDetail', 'updateVpcEndpointResponse_updateVpcEndpointDetail' - Details about the updated VPC endpoint.
--
-- 'httpStatus', 'updateVpcEndpointResponse_httpStatus' - The response's http status code.
newUpdateVpcEndpointResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  UpdateVpcEndpointResponse
newUpdateVpcEndpointResponse :: Int -> UpdateVpcEndpointResponse
newUpdateVpcEndpointResponse Int
pHttpStatus_ =
  UpdateVpcEndpointResponse'
    { $sel:updateVpcEndpointDetail:UpdateVpcEndpointResponse' :: Maybe UpdateVpcEndpointDetail
updateVpcEndpointDetail =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:UpdateVpcEndpointResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Details about the updated VPC endpoint.
updateVpcEndpointResponse_updateVpcEndpointDetail :: Lens.Lens' UpdateVpcEndpointResponse (Prelude.Maybe UpdateVpcEndpointDetail)
updateVpcEndpointResponse_updateVpcEndpointDetail :: Lens' UpdateVpcEndpointResponse (Maybe UpdateVpcEndpointDetail)
updateVpcEndpointResponse_updateVpcEndpointDetail = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UpdateVpcEndpointResponse' {Maybe UpdateVpcEndpointDetail
updateVpcEndpointDetail :: Maybe UpdateVpcEndpointDetail
$sel:updateVpcEndpointDetail:UpdateVpcEndpointResponse' :: UpdateVpcEndpointResponse -> Maybe UpdateVpcEndpointDetail
updateVpcEndpointDetail} -> Maybe UpdateVpcEndpointDetail
updateVpcEndpointDetail) (\s :: UpdateVpcEndpointResponse
s@UpdateVpcEndpointResponse' {} Maybe UpdateVpcEndpointDetail
a -> UpdateVpcEndpointResponse
s {$sel:updateVpcEndpointDetail:UpdateVpcEndpointResponse' :: Maybe UpdateVpcEndpointDetail
updateVpcEndpointDetail = Maybe UpdateVpcEndpointDetail
a} :: UpdateVpcEndpointResponse)

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

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