{-# 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.AppFlow.Types.ConnectorConfiguration
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.AppFlow.Types.ConnectorConfiguration where

import Amazonka.AppFlow.Types.ConnectorMetadata
import Amazonka.AppFlow.Types.ConnectorType
import Amazonka.AppFlow.Types.ScheduleFrequencyType
import Amazonka.AppFlow.Types.TriggerType
import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | The configuration settings related to a given connector.
--
-- /See:/ 'newConnectorConfiguration' smart constructor.
data ConnectorConfiguration = ConnectorConfiguration'
  { -- | Specifies if PrivateLink is enabled for that connector.
    ConnectorConfiguration -> Maybe Bool
isPrivateLinkEnabled :: Prelude.Maybe Prelude.Bool,
    -- | Specifies the supported trigger types for the flow.
    ConnectorConfiguration -> Maybe [TriggerType]
supportedTriggerTypes :: Prelude.Maybe [TriggerType],
    -- | Specifies whether the connector can be used as a source.
    ConnectorConfiguration -> Maybe Bool
canUseAsSource :: Prelude.Maybe Prelude.Bool,
    -- | Specifies connector-specific metadata such as @oAuthScopes@,
    -- @supportedRegions@, @privateLinkServiceUrl@, and so on.
    ConnectorConfiguration -> Maybe ConnectorMetadata
connectorMetadata :: Prelude.Maybe ConnectorMetadata,
    -- | Specifies whether the connector can be used as a destination.
    ConnectorConfiguration -> Maybe Bool
canUseAsDestination :: Prelude.Maybe Prelude.Bool,
    -- | Specifies the supported flow frequency for that connector.
    ConnectorConfiguration -> Maybe [ScheduleFrequencyType]
supportedSchedulingFrequencies :: Prelude.Maybe [ScheduleFrequencyType],
    -- | Lists the connectors that are available for use as destinations.
    ConnectorConfiguration -> Maybe [ConnectorType]
supportedDestinationConnectors :: Prelude.Maybe [ConnectorType],
    -- | Specifies if a PrivateLink endpoint URL is required.
    ConnectorConfiguration -> Maybe Bool
isPrivateLinkEndpointUrlRequired :: Prelude.Maybe Prelude.Bool
  }
  deriving (ConnectorConfiguration -> ConnectorConfiguration -> Bool
(ConnectorConfiguration -> ConnectorConfiguration -> Bool)
-> (ConnectorConfiguration -> ConnectorConfiguration -> Bool)
-> Eq ConnectorConfiguration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ConnectorConfiguration -> ConnectorConfiguration -> Bool
$c/= :: ConnectorConfiguration -> ConnectorConfiguration -> Bool
== :: ConnectorConfiguration -> ConnectorConfiguration -> Bool
$c== :: ConnectorConfiguration -> ConnectorConfiguration -> Bool
Prelude.Eq, ReadPrec [ConnectorConfiguration]
ReadPrec ConnectorConfiguration
Int -> ReadS ConnectorConfiguration
ReadS [ConnectorConfiguration]
(Int -> ReadS ConnectorConfiguration)
-> ReadS [ConnectorConfiguration]
-> ReadPrec ConnectorConfiguration
-> ReadPrec [ConnectorConfiguration]
-> Read ConnectorConfiguration
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ConnectorConfiguration]
$creadListPrec :: ReadPrec [ConnectorConfiguration]
readPrec :: ReadPrec ConnectorConfiguration
$creadPrec :: ReadPrec ConnectorConfiguration
readList :: ReadS [ConnectorConfiguration]
$creadList :: ReadS [ConnectorConfiguration]
readsPrec :: Int -> ReadS ConnectorConfiguration
$creadsPrec :: Int -> ReadS ConnectorConfiguration
Prelude.Read, Int -> ConnectorConfiguration -> ShowS
[ConnectorConfiguration] -> ShowS
ConnectorConfiguration -> String
(Int -> ConnectorConfiguration -> ShowS)
-> (ConnectorConfiguration -> String)
-> ([ConnectorConfiguration] -> ShowS)
-> Show ConnectorConfiguration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ConnectorConfiguration] -> ShowS
$cshowList :: [ConnectorConfiguration] -> ShowS
show :: ConnectorConfiguration -> String
$cshow :: ConnectorConfiguration -> String
showsPrec :: Int -> ConnectorConfiguration -> ShowS
$cshowsPrec :: Int -> ConnectorConfiguration -> ShowS
Prelude.Show, (forall x. ConnectorConfiguration -> Rep ConnectorConfiguration x)
-> (forall x.
    Rep ConnectorConfiguration x -> ConnectorConfiguration)
-> Generic ConnectorConfiguration
forall x. Rep ConnectorConfiguration x -> ConnectorConfiguration
forall x. ConnectorConfiguration -> Rep ConnectorConfiguration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ConnectorConfiguration x -> ConnectorConfiguration
$cfrom :: forall x. ConnectorConfiguration -> Rep ConnectorConfiguration x
Prelude.Generic)

-- |
-- Create a value of 'ConnectorConfiguration' 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:
--
-- 'isPrivateLinkEnabled', 'connectorConfiguration_isPrivateLinkEnabled' - Specifies if PrivateLink is enabled for that connector.
--
-- 'supportedTriggerTypes', 'connectorConfiguration_supportedTriggerTypes' - Specifies the supported trigger types for the flow.
--
-- 'canUseAsSource', 'connectorConfiguration_canUseAsSource' - Specifies whether the connector can be used as a source.
--
-- 'connectorMetadata', 'connectorConfiguration_connectorMetadata' - Specifies connector-specific metadata such as @oAuthScopes@,
-- @supportedRegions@, @privateLinkServiceUrl@, and so on.
--
-- 'canUseAsDestination', 'connectorConfiguration_canUseAsDestination' - Specifies whether the connector can be used as a destination.
--
-- 'supportedSchedulingFrequencies', 'connectorConfiguration_supportedSchedulingFrequencies' - Specifies the supported flow frequency for that connector.
--
-- 'supportedDestinationConnectors', 'connectorConfiguration_supportedDestinationConnectors' - Lists the connectors that are available for use as destinations.
--
-- 'isPrivateLinkEndpointUrlRequired', 'connectorConfiguration_isPrivateLinkEndpointUrlRequired' - Specifies if a PrivateLink endpoint URL is required.
newConnectorConfiguration ::
  ConnectorConfiguration
newConnectorConfiguration :: ConnectorConfiguration
newConnectorConfiguration =
  ConnectorConfiguration' :: Maybe Bool
-> Maybe [TriggerType]
-> Maybe Bool
-> Maybe ConnectorMetadata
-> Maybe Bool
-> Maybe [ScheduleFrequencyType]
-> Maybe [ConnectorType]
-> Maybe Bool
-> ConnectorConfiguration
ConnectorConfiguration'
    { $sel:isPrivateLinkEnabled:ConnectorConfiguration' :: Maybe Bool
isPrivateLinkEnabled =
        Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:supportedTriggerTypes:ConnectorConfiguration' :: Maybe [TriggerType]
supportedTriggerTypes = Maybe [TriggerType]
forall a. Maybe a
Prelude.Nothing,
      $sel:canUseAsSource:ConnectorConfiguration' :: Maybe Bool
canUseAsSource = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:connectorMetadata:ConnectorConfiguration' :: Maybe ConnectorMetadata
connectorMetadata = Maybe ConnectorMetadata
forall a. Maybe a
Prelude.Nothing,
      $sel:canUseAsDestination:ConnectorConfiguration' :: Maybe Bool
canUseAsDestination = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:supportedSchedulingFrequencies:ConnectorConfiguration' :: Maybe [ScheduleFrequencyType]
supportedSchedulingFrequencies = Maybe [ScheduleFrequencyType]
forall a. Maybe a
Prelude.Nothing,
      $sel:supportedDestinationConnectors:ConnectorConfiguration' :: Maybe [ConnectorType]
supportedDestinationConnectors = Maybe [ConnectorType]
forall a. Maybe a
Prelude.Nothing,
      $sel:isPrivateLinkEndpointUrlRequired:ConnectorConfiguration' :: Maybe Bool
isPrivateLinkEndpointUrlRequired = Maybe Bool
forall a. Maybe a
Prelude.Nothing
    }

-- | Specifies if PrivateLink is enabled for that connector.
connectorConfiguration_isPrivateLinkEnabled :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe Prelude.Bool)
connectorConfiguration_isPrivateLinkEnabled :: (Maybe Bool -> f (Maybe Bool))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_isPrivateLinkEnabled = (ConnectorConfiguration -> Maybe Bool)
-> (ConnectorConfiguration -> Maybe Bool -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe Bool)
     (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe Bool
isPrivateLinkEnabled :: Maybe Bool
$sel:isPrivateLinkEnabled:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe Bool
isPrivateLinkEnabled} -> Maybe Bool
isPrivateLinkEnabled) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe Bool
a -> ConnectorConfiguration
s {$sel:isPrivateLinkEnabled:ConnectorConfiguration' :: Maybe Bool
isPrivateLinkEnabled = Maybe Bool
a} :: ConnectorConfiguration)

-- | Specifies the supported trigger types for the flow.
connectorConfiguration_supportedTriggerTypes :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe [TriggerType])
connectorConfiguration_supportedTriggerTypes :: (Maybe [TriggerType] -> f (Maybe [TriggerType]))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_supportedTriggerTypes = (ConnectorConfiguration -> Maybe [TriggerType])
-> (ConnectorConfiguration
    -> Maybe [TriggerType] -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe [TriggerType])
     (Maybe [TriggerType])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe [TriggerType]
supportedTriggerTypes :: Maybe [TriggerType]
$sel:supportedTriggerTypes:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe [TriggerType]
supportedTriggerTypes} -> Maybe [TriggerType]
supportedTriggerTypes) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe [TriggerType]
a -> ConnectorConfiguration
s {$sel:supportedTriggerTypes:ConnectorConfiguration' :: Maybe [TriggerType]
supportedTriggerTypes = Maybe [TriggerType]
a} :: ConnectorConfiguration) ((Maybe [TriggerType] -> f (Maybe [TriggerType]))
 -> ConnectorConfiguration -> f ConnectorConfiguration)
-> ((Maybe [TriggerType] -> f (Maybe [TriggerType]))
    -> Maybe [TriggerType] -> f (Maybe [TriggerType]))
-> (Maybe [TriggerType] -> f (Maybe [TriggerType]))
-> ConnectorConfiguration
-> f ConnectorConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [TriggerType] [TriggerType] [TriggerType] [TriggerType]
-> Iso
     (Maybe [TriggerType])
     (Maybe [TriggerType])
     (Maybe [TriggerType])
     (Maybe [TriggerType])
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 AnIso [TriggerType] [TriggerType] [TriggerType] [TriggerType]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies whether the connector can be used as a source.
connectorConfiguration_canUseAsSource :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe Prelude.Bool)
connectorConfiguration_canUseAsSource :: (Maybe Bool -> f (Maybe Bool))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_canUseAsSource = (ConnectorConfiguration -> Maybe Bool)
-> (ConnectorConfiguration -> Maybe Bool -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe Bool)
     (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe Bool
canUseAsSource :: Maybe Bool
$sel:canUseAsSource:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe Bool
canUseAsSource} -> Maybe Bool
canUseAsSource) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe Bool
a -> ConnectorConfiguration
s {$sel:canUseAsSource:ConnectorConfiguration' :: Maybe Bool
canUseAsSource = Maybe Bool
a} :: ConnectorConfiguration)

-- | Specifies connector-specific metadata such as @oAuthScopes@,
-- @supportedRegions@, @privateLinkServiceUrl@, and so on.
connectorConfiguration_connectorMetadata :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe ConnectorMetadata)
connectorConfiguration_connectorMetadata :: (Maybe ConnectorMetadata -> f (Maybe ConnectorMetadata))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_connectorMetadata = (ConnectorConfiguration -> Maybe ConnectorMetadata)
-> (ConnectorConfiguration
    -> Maybe ConnectorMetadata -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe ConnectorMetadata)
     (Maybe ConnectorMetadata)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe ConnectorMetadata
connectorMetadata :: Maybe ConnectorMetadata
$sel:connectorMetadata:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe ConnectorMetadata
connectorMetadata} -> Maybe ConnectorMetadata
connectorMetadata) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe ConnectorMetadata
a -> ConnectorConfiguration
s {$sel:connectorMetadata:ConnectorConfiguration' :: Maybe ConnectorMetadata
connectorMetadata = Maybe ConnectorMetadata
a} :: ConnectorConfiguration)

-- | Specifies whether the connector can be used as a destination.
connectorConfiguration_canUseAsDestination :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe Prelude.Bool)
connectorConfiguration_canUseAsDestination :: (Maybe Bool -> f (Maybe Bool))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_canUseAsDestination = (ConnectorConfiguration -> Maybe Bool)
-> (ConnectorConfiguration -> Maybe Bool -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe Bool)
     (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe Bool
canUseAsDestination :: Maybe Bool
$sel:canUseAsDestination:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe Bool
canUseAsDestination} -> Maybe Bool
canUseAsDestination) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe Bool
a -> ConnectorConfiguration
s {$sel:canUseAsDestination:ConnectorConfiguration' :: Maybe Bool
canUseAsDestination = Maybe Bool
a} :: ConnectorConfiguration)

-- | Specifies the supported flow frequency for that connector.
connectorConfiguration_supportedSchedulingFrequencies :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe [ScheduleFrequencyType])
connectorConfiguration_supportedSchedulingFrequencies :: (Maybe [ScheduleFrequencyType]
 -> f (Maybe [ScheduleFrequencyType]))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_supportedSchedulingFrequencies = (ConnectorConfiguration -> Maybe [ScheduleFrequencyType])
-> (ConnectorConfiguration
    -> Maybe [ScheduleFrequencyType] -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe [ScheduleFrequencyType])
     (Maybe [ScheduleFrequencyType])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe [ScheduleFrequencyType]
supportedSchedulingFrequencies :: Maybe [ScheduleFrequencyType]
$sel:supportedSchedulingFrequencies:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe [ScheduleFrequencyType]
supportedSchedulingFrequencies} -> Maybe [ScheduleFrequencyType]
supportedSchedulingFrequencies) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe [ScheduleFrequencyType]
a -> ConnectorConfiguration
s {$sel:supportedSchedulingFrequencies:ConnectorConfiguration' :: Maybe [ScheduleFrequencyType]
supportedSchedulingFrequencies = Maybe [ScheduleFrequencyType]
a} :: ConnectorConfiguration) ((Maybe [ScheduleFrequencyType]
  -> f (Maybe [ScheduleFrequencyType]))
 -> ConnectorConfiguration -> f ConnectorConfiguration)
-> ((Maybe [ScheduleFrequencyType]
     -> f (Maybe [ScheduleFrequencyType]))
    -> Maybe [ScheduleFrequencyType]
    -> f (Maybe [ScheduleFrequencyType]))
-> (Maybe [ScheduleFrequencyType]
    -> f (Maybe [ScheduleFrequencyType]))
-> ConnectorConfiguration
-> f ConnectorConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ScheduleFrequencyType]
  [ScheduleFrequencyType]
  [ScheduleFrequencyType]
  [ScheduleFrequencyType]
-> Iso
     (Maybe [ScheduleFrequencyType])
     (Maybe [ScheduleFrequencyType])
     (Maybe [ScheduleFrequencyType])
     (Maybe [ScheduleFrequencyType])
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 AnIso
  [ScheduleFrequencyType]
  [ScheduleFrequencyType]
  [ScheduleFrequencyType]
  [ScheduleFrequencyType]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Lists the connectors that are available for use as destinations.
connectorConfiguration_supportedDestinationConnectors :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe [ConnectorType])
connectorConfiguration_supportedDestinationConnectors :: (Maybe [ConnectorType] -> f (Maybe [ConnectorType]))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_supportedDestinationConnectors = (ConnectorConfiguration -> Maybe [ConnectorType])
-> (ConnectorConfiguration
    -> Maybe [ConnectorType] -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe [ConnectorType])
     (Maybe [ConnectorType])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe [ConnectorType]
supportedDestinationConnectors :: Maybe [ConnectorType]
$sel:supportedDestinationConnectors:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe [ConnectorType]
supportedDestinationConnectors} -> Maybe [ConnectorType]
supportedDestinationConnectors) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe [ConnectorType]
a -> ConnectorConfiguration
s {$sel:supportedDestinationConnectors:ConnectorConfiguration' :: Maybe [ConnectorType]
supportedDestinationConnectors = Maybe [ConnectorType]
a} :: ConnectorConfiguration) ((Maybe [ConnectorType] -> f (Maybe [ConnectorType]))
 -> ConnectorConfiguration -> f ConnectorConfiguration)
-> ((Maybe [ConnectorType] -> f (Maybe [ConnectorType]))
    -> Maybe [ConnectorType] -> f (Maybe [ConnectorType]))
-> (Maybe [ConnectorType] -> f (Maybe [ConnectorType]))
-> ConnectorConfiguration
-> f ConnectorConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ConnectorType] [ConnectorType] [ConnectorType] [ConnectorType]
-> Iso
     (Maybe [ConnectorType])
     (Maybe [ConnectorType])
     (Maybe [ConnectorType])
     (Maybe [ConnectorType])
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 AnIso
  [ConnectorType] [ConnectorType] [ConnectorType] [ConnectorType]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Specifies if a PrivateLink endpoint URL is required.
connectorConfiguration_isPrivateLinkEndpointUrlRequired :: Lens.Lens' ConnectorConfiguration (Prelude.Maybe Prelude.Bool)
connectorConfiguration_isPrivateLinkEndpointUrlRequired :: (Maybe Bool -> f (Maybe Bool))
-> ConnectorConfiguration -> f ConnectorConfiguration
connectorConfiguration_isPrivateLinkEndpointUrlRequired = (ConnectorConfiguration -> Maybe Bool)
-> (ConnectorConfiguration -> Maybe Bool -> ConnectorConfiguration)
-> Lens
     ConnectorConfiguration
     ConnectorConfiguration
     (Maybe Bool)
     (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ConnectorConfiguration' {Maybe Bool
isPrivateLinkEndpointUrlRequired :: Maybe Bool
$sel:isPrivateLinkEndpointUrlRequired:ConnectorConfiguration' :: ConnectorConfiguration -> Maybe Bool
isPrivateLinkEndpointUrlRequired} -> Maybe Bool
isPrivateLinkEndpointUrlRequired) (\s :: ConnectorConfiguration
s@ConnectorConfiguration' {} Maybe Bool
a -> ConnectorConfiguration
s {$sel:isPrivateLinkEndpointUrlRequired:ConnectorConfiguration' :: Maybe Bool
isPrivateLinkEndpointUrlRequired = Maybe Bool
a} :: ConnectorConfiguration)

instance Core.FromJSON ConnectorConfiguration where
  parseJSON :: Value -> Parser ConnectorConfiguration
parseJSON =
    String
-> (Object -> Parser ConnectorConfiguration)
-> Value
-> Parser ConnectorConfiguration
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"ConnectorConfiguration"
      ( \Object
x ->
          Maybe Bool
-> Maybe [TriggerType]
-> Maybe Bool
-> Maybe ConnectorMetadata
-> Maybe Bool
-> Maybe [ScheduleFrequencyType]
-> Maybe [ConnectorType]
-> Maybe Bool
-> ConnectorConfiguration
ConnectorConfiguration'
            (Maybe Bool
 -> Maybe [TriggerType]
 -> Maybe Bool
 -> Maybe ConnectorMetadata
 -> Maybe Bool
 -> Maybe [ScheduleFrequencyType]
 -> Maybe [ConnectorType]
 -> Maybe Bool
 -> ConnectorConfiguration)
-> Parser (Maybe Bool)
-> Parser
     (Maybe [TriggerType]
      -> Maybe Bool
      -> Maybe ConnectorMetadata
      -> Maybe Bool
      -> Maybe [ScheduleFrequencyType]
      -> Maybe [ConnectorType]
      -> Maybe Bool
      -> ConnectorConfiguration)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"isPrivateLinkEnabled")
            Parser
  (Maybe [TriggerType]
   -> Maybe Bool
   -> Maybe ConnectorMetadata
   -> Maybe Bool
   -> Maybe [ScheduleFrequencyType]
   -> Maybe [ConnectorType]
   -> Maybe Bool
   -> ConnectorConfiguration)
-> Parser (Maybe [TriggerType])
-> Parser
     (Maybe Bool
      -> Maybe ConnectorMetadata
      -> Maybe Bool
      -> Maybe [ScheduleFrequencyType]
      -> Maybe [ConnectorType]
      -> Maybe Bool
      -> ConnectorConfiguration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [TriggerType]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"supportedTriggerTypes"
                            Parser (Maybe (Maybe [TriggerType]))
-> Maybe [TriggerType] -> Parser (Maybe [TriggerType])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [TriggerType]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe Bool
   -> Maybe ConnectorMetadata
   -> Maybe Bool
   -> Maybe [ScheduleFrequencyType]
   -> Maybe [ConnectorType]
   -> Maybe Bool
   -> ConnectorConfiguration)
-> Parser (Maybe Bool)
-> Parser
     (Maybe ConnectorMetadata
      -> Maybe Bool
      -> Maybe [ScheduleFrequencyType]
      -> Maybe [ConnectorType]
      -> Maybe Bool
      -> ConnectorConfiguration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"canUseAsSource")
            Parser
  (Maybe ConnectorMetadata
   -> Maybe Bool
   -> Maybe [ScheduleFrequencyType]
   -> Maybe [ConnectorType]
   -> Maybe Bool
   -> ConnectorConfiguration)
-> Parser (Maybe ConnectorMetadata)
-> Parser
     (Maybe Bool
      -> Maybe [ScheduleFrequencyType]
      -> Maybe [ConnectorType]
      -> Maybe Bool
      -> ConnectorConfiguration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe ConnectorMetadata)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"connectorMetadata")
            Parser
  (Maybe Bool
   -> Maybe [ScheduleFrequencyType]
   -> Maybe [ConnectorType]
   -> Maybe Bool
   -> ConnectorConfiguration)
-> Parser (Maybe Bool)
-> Parser
     (Maybe [ScheduleFrequencyType]
      -> Maybe [ConnectorType] -> Maybe Bool -> ConnectorConfiguration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"canUseAsDestination")
            Parser
  (Maybe [ScheduleFrequencyType]
   -> Maybe [ConnectorType] -> Maybe Bool -> ConnectorConfiguration)
-> Parser (Maybe [ScheduleFrequencyType])
-> Parser
     (Maybe [ConnectorType] -> Maybe Bool -> ConnectorConfiguration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [ScheduleFrequencyType]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"supportedSchedulingFrequencies"
                            Parser (Maybe (Maybe [ScheduleFrequencyType]))
-> Maybe [ScheduleFrequencyType]
-> Parser (Maybe [ScheduleFrequencyType])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [ScheduleFrequencyType]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe [ConnectorType] -> Maybe Bool -> ConnectorConfiguration)
-> Parser (Maybe [ConnectorType])
-> Parser (Maybe Bool -> ConnectorConfiguration)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [ConnectorType]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"supportedDestinationConnectors"
                            Parser (Maybe (Maybe [ConnectorType]))
-> Maybe [ConnectorType] -> Parser (Maybe [ConnectorType])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [ConnectorType]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser (Maybe Bool -> ConnectorConfiguration)
-> Parser (Maybe Bool) -> Parser ConnectorConfiguration
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Bool)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"isPrivateLinkEndpointUrlRequired")
      )

instance Prelude.Hashable ConnectorConfiguration

instance Prelude.NFData ConnectorConfiguration