{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# 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.Types.ServiceDetail
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.EC2.Types.ServiceDetail where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.DnsNameState
import Amazonka.EC2.Types.PayerResponsibility
import Amazonka.EC2.Types.PrivateDnsDetails
import Amazonka.EC2.Types.ServiceConnectivityType
import Amazonka.EC2.Types.ServiceTypeDetail
import Amazonka.EC2.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Describes a VPC endpoint service.
--
-- /See:/ 'newServiceDetail' smart constructor.
data ServiceDetail = ServiceDetail'
  { -- | Indicates whether VPC endpoint connection requests to the service must
    -- be accepted by the service owner.
    ServiceDetail -> Maybe Bool
acceptanceRequired :: Prelude.Maybe Prelude.Bool,
    -- | The Availability Zones in which the service is available.
    ServiceDetail -> Maybe [Text]
availabilityZones :: Prelude.Maybe [Prelude.Text],
    -- | The DNS names for the service.
    ServiceDetail -> Maybe [Text]
baseEndpointDnsNames :: Prelude.Maybe [Prelude.Text],
    -- | Indicates whether the service manages its VPC endpoints. Management of
    -- the service VPC endpoints using the VPC endpoint API is restricted.
    ServiceDetail -> Maybe Bool
managesVpcEndpoints :: Prelude.Maybe Prelude.Bool,
    -- | The Amazon Web Services account ID of the service owner.
    ServiceDetail -> Maybe Text
owner :: Prelude.Maybe Prelude.Text,
    -- | The payer responsibility.
    ServiceDetail -> Maybe PayerResponsibility
payerResponsibility :: Prelude.Maybe PayerResponsibility,
    -- | The private DNS name for the service.
    ServiceDetail -> Maybe Text
privateDnsName :: Prelude.Maybe Prelude.Text,
    -- | The verification state of the VPC endpoint service.
    --
    -- Consumers of the endpoint service cannot use the private name when the
    -- state is not @verified@.
    ServiceDetail -> Maybe DnsNameState
privateDnsNameVerificationState :: Prelude.Maybe DnsNameState,
    -- | The private DNS names assigned to the VPC endpoint service.
    ServiceDetail -> Maybe [PrivateDnsDetails]
privateDnsNames :: Prelude.Maybe [PrivateDnsDetails],
    -- | The ID of the endpoint service.
    ServiceDetail -> Maybe Text
serviceId :: Prelude.Maybe Prelude.Text,
    -- | The name of the service.
    ServiceDetail -> Maybe Text
serviceName :: Prelude.Maybe Prelude.Text,
    -- | The type of service.
    ServiceDetail -> Maybe [ServiceTypeDetail]
serviceType :: Prelude.Maybe [ServiceTypeDetail],
    -- | The supported IP address types.
    ServiceDetail -> Maybe [ServiceConnectivityType]
supportedIpAddressTypes :: Prelude.Maybe [ServiceConnectivityType],
    -- | Any tags assigned to the service.
    ServiceDetail -> Maybe [Tag]
tags :: Prelude.Maybe [Tag],
    -- | Indicates whether the service supports endpoint policies.
    ServiceDetail -> Maybe Bool
vpcEndpointPolicySupported :: Prelude.Maybe Prelude.Bool
  }
  deriving (ServiceDetail -> ServiceDetail -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ServiceDetail -> ServiceDetail -> Bool
$c/= :: ServiceDetail -> ServiceDetail -> Bool
== :: ServiceDetail -> ServiceDetail -> Bool
$c== :: ServiceDetail -> ServiceDetail -> Bool
Prelude.Eq, ReadPrec [ServiceDetail]
ReadPrec ServiceDetail
Int -> ReadS ServiceDetail
ReadS [ServiceDetail]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ServiceDetail]
$creadListPrec :: ReadPrec [ServiceDetail]
readPrec :: ReadPrec ServiceDetail
$creadPrec :: ReadPrec ServiceDetail
readList :: ReadS [ServiceDetail]
$creadList :: ReadS [ServiceDetail]
readsPrec :: Int -> ReadS ServiceDetail
$creadsPrec :: Int -> ReadS ServiceDetail
Prelude.Read, Int -> ServiceDetail -> ShowS
[ServiceDetail] -> ShowS
ServiceDetail -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ServiceDetail] -> ShowS
$cshowList :: [ServiceDetail] -> ShowS
show :: ServiceDetail -> String
$cshow :: ServiceDetail -> String
showsPrec :: Int -> ServiceDetail -> ShowS
$cshowsPrec :: Int -> ServiceDetail -> ShowS
Prelude.Show, forall x. Rep ServiceDetail x -> ServiceDetail
forall x. ServiceDetail -> Rep ServiceDetail x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ServiceDetail x -> ServiceDetail
$cfrom :: forall x. ServiceDetail -> Rep ServiceDetail x
Prelude.Generic)

-- |
-- Create a value of 'ServiceDetail' 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:
--
-- 'acceptanceRequired', 'serviceDetail_acceptanceRequired' - Indicates whether VPC endpoint connection requests to the service must
-- be accepted by the service owner.
--
-- 'availabilityZones', 'serviceDetail_availabilityZones' - The Availability Zones in which the service is available.
--
-- 'baseEndpointDnsNames', 'serviceDetail_baseEndpointDnsNames' - The DNS names for the service.
--
-- 'managesVpcEndpoints', 'serviceDetail_managesVpcEndpoints' - Indicates whether the service manages its VPC endpoints. Management of
-- the service VPC endpoints using the VPC endpoint API is restricted.
--
-- 'owner', 'serviceDetail_owner' - The Amazon Web Services account ID of the service owner.
--
-- 'payerResponsibility', 'serviceDetail_payerResponsibility' - The payer responsibility.
--
-- 'privateDnsName', 'serviceDetail_privateDnsName' - The private DNS name for the service.
--
-- 'privateDnsNameVerificationState', 'serviceDetail_privateDnsNameVerificationState' - The verification state of the VPC endpoint service.
--
-- Consumers of the endpoint service cannot use the private name when the
-- state is not @verified@.
--
-- 'privateDnsNames', 'serviceDetail_privateDnsNames' - The private DNS names assigned to the VPC endpoint service.
--
-- 'serviceId', 'serviceDetail_serviceId' - The ID of the endpoint service.
--
-- 'serviceName', 'serviceDetail_serviceName' - The name of the service.
--
-- 'serviceType', 'serviceDetail_serviceType' - The type of service.
--
-- 'supportedIpAddressTypes', 'serviceDetail_supportedIpAddressTypes' - The supported IP address types.
--
-- 'tags', 'serviceDetail_tags' - Any tags assigned to the service.
--
-- 'vpcEndpointPolicySupported', 'serviceDetail_vpcEndpointPolicySupported' - Indicates whether the service supports endpoint policies.
newServiceDetail ::
  ServiceDetail
newServiceDetail :: ServiceDetail
newServiceDetail =
  ServiceDetail'
    { $sel:acceptanceRequired:ServiceDetail' :: Maybe Bool
acceptanceRequired =
        forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZones:ServiceDetail' :: Maybe [Text]
availabilityZones = forall a. Maybe a
Prelude.Nothing,
      $sel:baseEndpointDnsNames:ServiceDetail' :: Maybe [Text]
baseEndpointDnsNames = forall a. Maybe a
Prelude.Nothing,
      $sel:managesVpcEndpoints:ServiceDetail' :: Maybe Bool
managesVpcEndpoints = forall a. Maybe a
Prelude.Nothing,
      $sel:owner:ServiceDetail' :: Maybe Text
owner = forall a. Maybe a
Prelude.Nothing,
      $sel:payerResponsibility:ServiceDetail' :: Maybe PayerResponsibility
payerResponsibility = forall a. Maybe a
Prelude.Nothing,
      $sel:privateDnsName:ServiceDetail' :: Maybe Text
privateDnsName = forall a. Maybe a
Prelude.Nothing,
      $sel:privateDnsNameVerificationState:ServiceDetail' :: Maybe DnsNameState
privateDnsNameVerificationState = forall a. Maybe a
Prelude.Nothing,
      $sel:privateDnsNames:ServiceDetail' :: Maybe [PrivateDnsDetails]
privateDnsNames = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceId:ServiceDetail' :: Maybe Text
serviceId = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceName:ServiceDetail' :: Maybe Text
serviceName = forall a. Maybe a
Prelude.Nothing,
      $sel:serviceType:ServiceDetail' :: Maybe [ServiceTypeDetail]
serviceType = forall a. Maybe a
Prelude.Nothing,
      $sel:supportedIpAddressTypes:ServiceDetail' :: Maybe [ServiceConnectivityType]
supportedIpAddressTypes = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:ServiceDetail' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:vpcEndpointPolicySupported:ServiceDetail' :: Maybe Bool
vpcEndpointPolicySupported = forall a. Maybe a
Prelude.Nothing
    }

-- | Indicates whether VPC endpoint connection requests to the service must
-- be accepted by the service owner.
serviceDetail_acceptanceRequired :: Lens.Lens' ServiceDetail (Prelude.Maybe Prelude.Bool)
serviceDetail_acceptanceRequired :: Lens' ServiceDetail (Maybe Bool)
serviceDetail_acceptanceRequired = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe Bool
acceptanceRequired :: Maybe Bool
$sel:acceptanceRequired:ServiceDetail' :: ServiceDetail -> Maybe Bool
acceptanceRequired} -> Maybe Bool
acceptanceRequired) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe Bool
a -> ServiceDetail
s {$sel:acceptanceRequired:ServiceDetail' :: Maybe Bool
acceptanceRequired = Maybe Bool
a} :: ServiceDetail)

-- | The Availability Zones in which the service is available.
serviceDetail_availabilityZones :: Lens.Lens' ServiceDetail (Prelude.Maybe [Prelude.Text])
serviceDetail_availabilityZones :: Lens' ServiceDetail (Maybe [Text])
serviceDetail_availabilityZones = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe [Text]
availabilityZones :: Maybe [Text]
$sel:availabilityZones:ServiceDetail' :: ServiceDetail -> Maybe [Text]
availabilityZones} -> Maybe [Text]
availabilityZones) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe [Text]
a -> ServiceDetail
s {$sel:availabilityZones:ServiceDetail' :: Maybe [Text]
availabilityZones = Maybe [Text]
a} :: ServiceDetail) 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 DNS names for the service.
serviceDetail_baseEndpointDnsNames :: Lens.Lens' ServiceDetail (Prelude.Maybe [Prelude.Text])
serviceDetail_baseEndpointDnsNames :: Lens' ServiceDetail (Maybe [Text])
serviceDetail_baseEndpointDnsNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe [Text]
baseEndpointDnsNames :: Maybe [Text]
$sel:baseEndpointDnsNames:ServiceDetail' :: ServiceDetail -> Maybe [Text]
baseEndpointDnsNames} -> Maybe [Text]
baseEndpointDnsNames) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe [Text]
a -> ServiceDetail
s {$sel:baseEndpointDnsNames:ServiceDetail' :: Maybe [Text]
baseEndpointDnsNames = Maybe [Text]
a} :: ServiceDetail) 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

-- | Indicates whether the service manages its VPC endpoints. Management of
-- the service VPC endpoints using the VPC endpoint API is restricted.
serviceDetail_managesVpcEndpoints :: Lens.Lens' ServiceDetail (Prelude.Maybe Prelude.Bool)
serviceDetail_managesVpcEndpoints :: Lens' ServiceDetail (Maybe Bool)
serviceDetail_managesVpcEndpoints = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe Bool
managesVpcEndpoints :: Maybe Bool
$sel:managesVpcEndpoints:ServiceDetail' :: ServiceDetail -> Maybe Bool
managesVpcEndpoints} -> Maybe Bool
managesVpcEndpoints) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe Bool
a -> ServiceDetail
s {$sel:managesVpcEndpoints:ServiceDetail' :: Maybe Bool
managesVpcEndpoints = Maybe Bool
a} :: ServiceDetail)

-- | The Amazon Web Services account ID of the service owner.
serviceDetail_owner :: Lens.Lens' ServiceDetail (Prelude.Maybe Prelude.Text)
serviceDetail_owner :: Lens' ServiceDetail (Maybe Text)
serviceDetail_owner = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe Text
owner :: Maybe Text
$sel:owner:ServiceDetail' :: ServiceDetail -> Maybe Text
owner} -> Maybe Text
owner) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe Text
a -> ServiceDetail
s {$sel:owner:ServiceDetail' :: Maybe Text
owner = Maybe Text
a} :: ServiceDetail)

-- | The payer responsibility.
serviceDetail_payerResponsibility :: Lens.Lens' ServiceDetail (Prelude.Maybe PayerResponsibility)
serviceDetail_payerResponsibility :: Lens' ServiceDetail (Maybe PayerResponsibility)
serviceDetail_payerResponsibility = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe PayerResponsibility
payerResponsibility :: Maybe PayerResponsibility
$sel:payerResponsibility:ServiceDetail' :: ServiceDetail -> Maybe PayerResponsibility
payerResponsibility} -> Maybe PayerResponsibility
payerResponsibility) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe PayerResponsibility
a -> ServiceDetail
s {$sel:payerResponsibility:ServiceDetail' :: Maybe PayerResponsibility
payerResponsibility = Maybe PayerResponsibility
a} :: ServiceDetail)

-- | The private DNS name for the service.
serviceDetail_privateDnsName :: Lens.Lens' ServiceDetail (Prelude.Maybe Prelude.Text)
serviceDetail_privateDnsName :: Lens' ServiceDetail (Maybe Text)
serviceDetail_privateDnsName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe Text
privateDnsName :: Maybe Text
$sel:privateDnsName:ServiceDetail' :: ServiceDetail -> Maybe Text
privateDnsName} -> Maybe Text
privateDnsName) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe Text
a -> ServiceDetail
s {$sel:privateDnsName:ServiceDetail' :: Maybe Text
privateDnsName = Maybe Text
a} :: ServiceDetail)

-- | The verification state of the VPC endpoint service.
--
-- Consumers of the endpoint service cannot use the private name when the
-- state is not @verified@.
serviceDetail_privateDnsNameVerificationState :: Lens.Lens' ServiceDetail (Prelude.Maybe DnsNameState)
serviceDetail_privateDnsNameVerificationState :: Lens' ServiceDetail (Maybe DnsNameState)
serviceDetail_privateDnsNameVerificationState = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe DnsNameState
privateDnsNameVerificationState :: Maybe DnsNameState
$sel:privateDnsNameVerificationState:ServiceDetail' :: ServiceDetail -> Maybe DnsNameState
privateDnsNameVerificationState} -> Maybe DnsNameState
privateDnsNameVerificationState) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe DnsNameState
a -> ServiceDetail
s {$sel:privateDnsNameVerificationState:ServiceDetail' :: Maybe DnsNameState
privateDnsNameVerificationState = Maybe DnsNameState
a} :: ServiceDetail)

-- | The private DNS names assigned to the VPC endpoint service.
serviceDetail_privateDnsNames :: Lens.Lens' ServiceDetail (Prelude.Maybe [PrivateDnsDetails])
serviceDetail_privateDnsNames :: Lens' ServiceDetail (Maybe [PrivateDnsDetails])
serviceDetail_privateDnsNames = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe [PrivateDnsDetails]
privateDnsNames :: Maybe [PrivateDnsDetails]
$sel:privateDnsNames:ServiceDetail' :: ServiceDetail -> Maybe [PrivateDnsDetails]
privateDnsNames} -> Maybe [PrivateDnsDetails]
privateDnsNames) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe [PrivateDnsDetails]
a -> ServiceDetail
s {$sel:privateDnsNames:ServiceDetail' :: Maybe [PrivateDnsDetails]
privateDnsNames = Maybe [PrivateDnsDetails]
a} :: ServiceDetail) 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 the endpoint service.
serviceDetail_serviceId :: Lens.Lens' ServiceDetail (Prelude.Maybe Prelude.Text)
serviceDetail_serviceId :: Lens' ServiceDetail (Maybe Text)
serviceDetail_serviceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe Text
serviceId :: Maybe Text
$sel:serviceId:ServiceDetail' :: ServiceDetail -> Maybe Text
serviceId} -> Maybe Text
serviceId) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe Text
a -> ServiceDetail
s {$sel:serviceId:ServiceDetail' :: Maybe Text
serviceId = Maybe Text
a} :: ServiceDetail)

-- | The name of the service.
serviceDetail_serviceName :: Lens.Lens' ServiceDetail (Prelude.Maybe Prelude.Text)
serviceDetail_serviceName :: Lens' ServiceDetail (Maybe Text)
serviceDetail_serviceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe Text
serviceName :: Maybe Text
$sel:serviceName:ServiceDetail' :: ServiceDetail -> Maybe Text
serviceName} -> Maybe Text
serviceName) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe Text
a -> ServiceDetail
s {$sel:serviceName:ServiceDetail' :: Maybe Text
serviceName = Maybe Text
a} :: ServiceDetail)

-- | The type of service.
serviceDetail_serviceType :: Lens.Lens' ServiceDetail (Prelude.Maybe [ServiceTypeDetail])
serviceDetail_serviceType :: Lens' ServiceDetail (Maybe [ServiceTypeDetail])
serviceDetail_serviceType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe [ServiceTypeDetail]
serviceType :: Maybe [ServiceTypeDetail]
$sel:serviceType:ServiceDetail' :: ServiceDetail -> Maybe [ServiceTypeDetail]
serviceType} -> Maybe [ServiceTypeDetail]
serviceType) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe [ServiceTypeDetail]
a -> ServiceDetail
s {$sel:serviceType:ServiceDetail' :: Maybe [ServiceTypeDetail]
serviceType = Maybe [ServiceTypeDetail]
a} :: ServiceDetail) 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 supported IP address types.
serviceDetail_supportedIpAddressTypes :: Lens.Lens' ServiceDetail (Prelude.Maybe [ServiceConnectivityType])
serviceDetail_supportedIpAddressTypes :: Lens' ServiceDetail (Maybe [ServiceConnectivityType])
serviceDetail_supportedIpAddressTypes = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe [ServiceConnectivityType]
supportedIpAddressTypes :: Maybe [ServiceConnectivityType]
$sel:supportedIpAddressTypes:ServiceDetail' :: ServiceDetail -> Maybe [ServiceConnectivityType]
supportedIpAddressTypes} -> Maybe [ServiceConnectivityType]
supportedIpAddressTypes) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe [ServiceConnectivityType]
a -> ServiceDetail
s {$sel:supportedIpAddressTypes:ServiceDetail' :: Maybe [ServiceConnectivityType]
supportedIpAddressTypes = Maybe [ServiceConnectivityType]
a} :: ServiceDetail) 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

-- | Any tags assigned to the service.
serviceDetail_tags :: Lens.Lens' ServiceDetail (Prelude.Maybe [Tag])
serviceDetail_tags :: Lens' ServiceDetail (Maybe [Tag])
serviceDetail_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:ServiceDetail' :: ServiceDetail -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe [Tag]
a -> ServiceDetail
s {$sel:tags:ServiceDetail' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: ServiceDetail) 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

-- | Indicates whether the service supports endpoint policies.
serviceDetail_vpcEndpointPolicySupported :: Lens.Lens' ServiceDetail (Prelude.Maybe Prelude.Bool)
serviceDetail_vpcEndpointPolicySupported :: Lens' ServiceDetail (Maybe Bool)
serviceDetail_vpcEndpointPolicySupported = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ServiceDetail' {Maybe Bool
vpcEndpointPolicySupported :: Maybe Bool
$sel:vpcEndpointPolicySupported:ServiceDetail' :: ServiceDetail -> Maybe Bool
vpcEndpointPolicySupported} -> Maybe Bool
vpcEndpointPolicySupported) (\s :: ServiceDetail
s@ServiceDetail' {} Maybe Bool
a -> ServiceDetail
s {$sel:vpcEndpointPolicySupported:ServiceDetail' :: Maybe Bool
vpcEndpointPolicySupported = Maybe Bool
a} :: ServiceDetail)

instance Data.FromXML ServiceDetail where
  parseXML :: [Node] -> Either String ServiceDetail
parseXML [Node]
x =
    Maybe Bool
-> Maybe [Text]
-> Maybe [Text]
-> Maybe Bool
-> Maybe Text
-> Maybe PayerResponsibility
-> Maybe Text
-> Maybe DnsNameState
-> Maybe [PrivateDnsDetails]
-> Maybe Text
-> Maybe Text
-> Maybe [ServiceTypeDetail]
-> Maybe [ServiceConnectivityType]
-> Maybe [Tag]
-> Maybe Bool
-> ServiceDetail
ServiceDetail'
      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
"acceptanceRequired")
      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
"availabilityZoneSet"
                      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.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"baseEndpointDnsNameSet"
                      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.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"managesVpcEndpoints")
      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
"owner")
      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
"payerResponsibility")
      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
"privateDnsName")
      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
"privateDnsNameVerificationState")
      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
"privateDnsNameSet"
                      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.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"serviceId")
      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
"serviceName")
      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
"serviceType"
                      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.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"supportedIpAddressTypeSet"
                      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.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"tagSet"
                      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.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"vpcEndpointPolicySupported")

instance Prelude.Hashable ServiceDetail where
  hashWithSalt :: Int -> ServiceDetail -> Int
hashWithSalt Int
_salt ServiceDetail' {Maybe Bool
Maybe [Text]
Maybe [PrivateDnsDetails]
Maybe [ServiceConnectivityType]
Maybe [ServiceTypeDetail]
Maybe [Tag]
Maybe Text
Maybe DnsNameState
Maybe PayerResponsibility
vpcEndpointPolicySupported :: Maybe Bool
tags :: Maybe [Tag]
supportedIpAddressTypes :: Maybe [ServiceConnectivityType]
serviceType :: Maybe [ServiceTypeDetail]
serviceName :: Maybe Text
serviceId :: Maybe Text
privateDnsNames :: Maybe [PrivateDnsDetails]
privateDnsNameVerificationState :: Maybe DnsNameState
privateDnsName :: Maybe Text
payerResponsibility :: Maybe PayerResponsibility
owner :: Maybe Text
managesVpcEndpoints :: Maybe Bool
baseEndpointDnsNames :: Maybe [Text]
availabilityZones :: Maybe [Text]
acceptanceRequired :: Maybe Bool
$sel:vpcEndpointPolicySupported:ServiceDetail' :: ServiceDetail -> Maybe Bool
$sel:tags:ServiceDetail' :: ServiceDetail -> Maybe [Tag]
$sel:supportedIpAddressTypes:ServiceDetail' :: ServiceDetail -> Maybe [ServiceConnectivityType]
$sel:serviceType:ServiceDetail' :: ServiceDetail -> Maybe [ServiceTypeDetail]
$sel:serviceName:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:serviceId:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:privateDnsNames:ServiceDetail' :: ServiceDetail -> Maybe [PrivateDnsDetails]
$sel:privateDnsNameVerificationState:ServiceDetail' :: ServiceDetail -> Maybe DnsNameState
$sel:privateDnsName:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:payerResponsibility:ServiceDetail' :: ServiceDetail -> Maybe PayerResponsibility
$sel:owner:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:managesVpcEndpoints:ServiceDetail' :: ServiceDetail -> Maybe Bool
$sel:baseEndpointDnsNames:ServiceDetail' :: ServiceDetail -> Maybe [Text]
$sel:availabilityZones:ServiceDetail' :: ServiceDetail -> Maybe [Text]
$sel:acceptanceRequired:ServiceDetail' :: ServiceDetail -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
acceptanceRequired
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
availabilityZones
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
baseEndpointDnsNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
managesVpcEndpoints
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
owner
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PayerResponsibility
payerResponsibility
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
privateDnsName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DnsNameState
privateDnsNameVerificationState
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [PrivateDnsDetails]
privateDnsNames
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
serviceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
serviceName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ServiceTypeDetail]
serviceType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [ServiceConnectivityType]
supportedIpAddressTypes
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
vpcEndpointPolicySupported

instance Prelude.NFData ServiceDetail where
  rnf :: ServiceDetail -> ()
rnf ServiceDetail' {Maybe Bool
Maybe [Text]
Maybe [PrivateDnsDetails]
Maybe [ServiceConnectivityType]
Maybe [ServiceTypeDetail]
Maybe [Tag]
Maybe Text
Maybe DnsNameState
Maybe PayerResponsibility
vpcEndpointPolicySupported :: Maybe Bool
tags :: Maybe [Tag]
supportedIpAddressTypes :: Maybe [ServiceConnectivityType]
serviceType :: Maybe [ServiceTypeDetail]
serviceName :: Maybe Text
serviceId :: Maybe Text
privateDnsNames :: Maybe [PrivateDnsDetails]
privateDnsNameVerificationState :: Maybe DnsNameState
privateDnsName :: Maybe Text
payerResponsibility :: Maybe PayerResponsibility
owner :: Maybe Text
managesVpcEndpoints :: Maybe Bool
baseEndpointDnsNames :: Maybe [Text]
availabilityZones :: Maybe [Text]
acceptanceRequired :: Maybe Bool
$sel:vpcEndpointPolicySupported:ServiceDetail' :: ServiceDetail -> Maybe Bool
$sel:tags:ServiceDetail' :: ServiceDetail -> Maybe [Tag]
$sel:supportedIpAddressTypes:ServiceDetail' :: ServiceDetail -> Maybe [ServiceConnectivityType]
$sel:serviceType:ServiceDetail' :: ServiceDetail -> Maybe [ServiceTypeDetail]
$sel:serviceName:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:serviceId:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:privateDnsNames:ServiceDetail' :: ServiceDetail -> Maybe [PrivateDnsDetails]
$sel:privateDnsNameVerificationState:ServiceDetail' :: ServiceDetail -> Maybe DnsNameState
$sel:privateDnsName:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:payerResponsibility:ServiceDetail' :: ServiceDetail -> Maybe PayerResponsibility
$sel:owner:ServiceDetail' :: ServiceDetail -> Maybe Text
$sel:managesVpcEndpoints:ServiceDetail' :: ServiceDetail -> Maybe Bool
$sel:baseEndpointDnsNames:ServiceDetail' :: ServiceDetail -> Maybe [Text]
$sel:availabilityZones:ServiceDetail' :: ServiceDetail -> Maybe [Text]
$sel:acceptanceRequired:ServiceDetail' :: ServiceDetail -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
acceptanceRequired
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
availabilityZones
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
baseEndpointDnsNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
managesVpcEndpoints
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
owner
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PayerResponsibility
payerResponsibility
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
privateDnsName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DnsNameState
privateDnsNameVerificationState
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [PrivateDnsDetails]
privateDnsNames
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
serviceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
serviceName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ServiceTypeDetail]
serviceType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [ServiceConnectivityType]
supportedIpAddressTypes
      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 Maybe Bool
vpcEndpointPolicySupported