{-# 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.AppFlow.RegisterConnector
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Registers a new custom connector with your Amazon Web Services account.
-- Before you can register the connector, you must deploy the associated
-- AWS lambda function in your account.
module Amazonka.AppFlow.RegisterConnector
  ( -- * Creating a Request
    RegisterConnector (..),
    newRegisterConnector,

    -- * Request Lenses
    registerConnector_connectorLabel,
    registerConnector_connectorProvisioningConfig,
    registerConnector_connectorProvisioningType,
    registerConnector_description,

    -- * Destructuring the Response
    RegisterConnectorResponse (..),
    newRegisterConnectorResponse,

    -- * Response Lenses
    registerConnectorResponse_connectorArn,
    registerConnectorResponse_httpStatus,
  )
where

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

-- | /See:/ 'newRegisterConnector' smart constructor.
data RegisterConnector = RegisterConnector'
  { -- | The name of the connector. The name is unique for each
    -- @ConnectorRegistration@ in your Amazon Web Services account.
    RegisterConnector -> Maybe Text
connectorLabel :: Prelude.Maybe Prelude.Text,
    -- | The provisioning type of the connector. Currently the only supported
    -- value is LAMBDA.
    RegisterConnector -> Maybe ConnectorProvisioningConfig
connectorProvisioningConfig :: Prelude.Maybe ConnectorProvisioningConfig,
    -- | The provisioning type of the connector. Currently the only supported
    -- value is LAMBDA.
    RegisterConnector -> Maybe ConnectorProvisioningType
connectorProvisioningType :: Prelude.Maybe ConnectorProvisioningType,
    -- | A description about the connector that\'s being registered.
    RegisterConnector -> Maybe Text
description :: Prelude.Maybe Prelude.Text
  }
  deriving (RegisterConnector -> RegisterConnector -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterConnector -> RegisterConnector -> Bool
$c/= :: RegisterConnector -> RegisterConnector -> Bool
== :: RegisterConnector -> RegisterConnector -> Bool
$c== :: RegisterConnector -> RegisterConnector -> Bool
Prelude.Eq, ReadPrec [RegisterConnector]
ReadPrec RegisterConnector
Int -> ReadS RegisterConnector
ReadS [RegisterConnector]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterConnector]
$creadListPrec :: ReadPrec [RegisterConnector]
readPrec :: ReadPrec RegisterConnector
$creadPrec :: ReadPrec RegisterConnector
readList :: ReadS [RegisterConnector]
$creadList :: ReadS [RegisterConnector]
readsPrec :: Int -> ReadS RegisterConnector
$creadsPrec :: Int -> ReadS RegisterConnector
Prelude.Read, Int -> RegisterConnector -> ShowS
[RegisterConnector] -> ShowS
RegisterConnector -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterConnector] -> ShowS
$cshowList :: [RegisterConnector] -> ShowS
show :: RegisterConnector -> String
$cshow :: RegisterConnector -> String
showsPrec :: Int -> RegisterConnector -> ShowS
$cshowsPrec :: Int -> RegisterConnector -> ShowS
Prelude.Show, forall x. Rep RegisterConnector x -> RegisterConnector
forall x. RegisterConnector -> Rep RegisterConnector x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RegisterConnector x -> RegisterConnector
$cfrom :: forall x. RegisterConnector -> Rep RegisterConnector x
Prelude.Generic)

-- |
-- Create a value of 'RegisterConnector' 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:
--
-- 'connectorLabel', 'registerConnector_connectorLabel' - The name of the connector. The name is unique for each
-- @ConnectorRegistration@ in your Amazon Web Services account.
--
-- 'connectorProvisioningConfig', 'registerConnector_connectorProvisioningConfig' - The provisioning type of the connector. Currently the only supported
-- value is LAMBDA.
--
-- 'connectorProvisioningType', 'registerConnector_connectorProvisioningType' - The provisioning type of the connector. Currently the only supported
-- value is LAMBDA.
--
-- 'description', 'registerConnector_description' - A description about the connector that\'s being registered.
newRegisterConnector ::
  RegisterConnector
newRegisterConnector :: RegisterConnector
newRegisterConnector =
  RegisterConnector'
    { $sel:connectorLabel:RegisterConnector' :: Maybe Text
connectorLabel =
        forall a. Maybe a
Prelude.Nothing,
      $sel:connectorProvisioningConfig:RegisterConnector' :: Maybe ConnectorProvisioningConfig
connectorProvisioningConfig = forall a. Maybe a
Prelude.Nothing,
      $sel:connectorProvisioningType:RegisterConnector' :: Maybe ConnectorProvisioningType
connectorProvisioningType = forall a. Maybe a
Prelude.Nothing,
      $sel:description:RegisterConnector' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing
    }

-- | The name of the connector. The name is unique for each
-- @ConnectorRegistration@ in your Amazon Web Services account.
registerConnector_connectorLabel :: Lens.Lens' RegisterConnector (Prelude.Maybe Prelude.Text)
registerConnector_connectorLabel :: Lens' RegisterConnector (Maybe Text)
registerConnector_connectorLabel = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterConnector' {Maybe Text
connectorLabel :: Maybe Text
$sel:connectorLabel:RegisterConnector' :: RegisterConnector -> Maybe Text
connectorLabel} -> Maybe Text
connectorLabel) (\s :: RegisterConnector
s@RegisterConnector' {} Maybe Text
a -> RegisterConnector
s {$sel:connectorLabel:RegisterConnector' :: Maybe Text
connectorLabel = Maybe Text
a} :: RegisterConnector)

-- | The provisioning type of the connector. Currently the only supported
-- value is LAMBDA.
registerConnector_connectorProvisioningConfig :: Lens.Lens' RegisterConnector (Prelude.Maybe ConnectorProvisioningConfig)
registerConnector_connectorProvisioningConfig :: Lens' RegisterConnector (Maybe ConnectorProvisioningConfig)
registerConnector_connectorProvisioningConfig = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterConnector' {Maybe ConnectorProvisioningConfig
connectorProvisioningConfig :: Maybe ConnectorProvisioningConfig
$sel:connectorProvisioningConfig:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningConfig
connectorProvisioningConfig} -> Maybe ConnectorProvisioningConfig
connectorProvisioningConfig) (\s :: RegisterConnector
s@RegisterConnector' {} Maybe ConnectorProvisioningConfig
a -> RegisterConnector
s {$sel:connectorProvisioningConfig:RegisterConnector' :: Maybe ConnectorProvisioningConfig
connectorProvisioningConfig = Maybe ConnectorProvisioningConfig
a} :: RegisterConnector)

-- | The provisioning type of the connector. Currently the only supported
-- value is LAMBDA.
registerConnector_connectorProvisioningType :: Lens.Lens' RegisterConnector (Prelude.Maybe ConnectorProvisioningType)
registerConnector_connectorProvisioningType :: Lens' RegisterConnector (Maybe ConnectorProvisioningType)
registerConnector_connectorProvisioningType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterConnector' {Maybe ConnectorProvisioningType
connectorProvisioningType :: Maybe ConnectorProvisioningType
$sel:connectorProvisioningType:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningType
connectorProvisioningType} -> Maybe ConnectorProvisioningType
connectorProvisioningType) (\s :: RegisterConnector
s@RegisterConnector' {} Maybe ConnectorProvisioningType
a -> RegisterConnector
s {$sel:connectorProvisioningType:RegisterConnector' :: Maybe ConnectorProvisioningType
connectorProvisioningType = Maybe ConnectorProvisioningType
a} :: RegisterConnector)

-- | A description about the connector that\'s being registered.
registerConnector_description :: Lens.Lens' RegisterConnector (Prelude.Maybe Prelude.Text)
registerConnector_description :: Lens' RegisterConnector (Maybe Text)
registerConnector_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterConnector' {Maybe Text
description :: Maybe Text
$sel:description:RegisterConnector' :: RegisterConnector -> Maybe Text
description} -> Maybe Text
description) (\s :: RegisterConnector
s@RegisterConnector' {} Maybe Text
a -> RegisterConnector
s {$sel:description:RegisterConnector' :: Maybe Text
description = Maybe Text
a} :: RegisterConnector)

instance Core.AWSRequest RegisterConnector where
  type
    AWSResponse RegisterConnector =
      RegisterConnectorResponse
  request :: (Service -> Service)
-> RegisterConnector -> Request RegisterConnector
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 RegisterConnector
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RegisterConnector)))
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 Text -> Int -> RegisterConnectorResponse
RegisterConnectorResponse'
            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
"connectorArn")
            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 RegisterConnector where
  hashWithSalt :: Int -> RegisterConnector -> Int
hashWithSalt Int
_salt RegisterConnector' {Maybe Text
Maybe ConnectorProvisioningType
Maybe ConnectorProvisioningConfig
description :: Maybe Text
connectorProvisioningType :: Maybe ConnectorProvisioningType
connectorProvisioningConfig :: Maybe ConnectorProvisioningConfig
connectorLabel :: Maybe Text
$sel:description:RegisterConnector' :: RegisterConnector -> Maybe Text
$sel:connectorProvisioningType:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningType
$sel:connectorProvisioningConfig:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningConfig
$sel:connectorLabel:RegisterConnector' :: RegisterConnector -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
connectorLabel
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ConnectorProvisioningConfig
connectorProvisioningConfig
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ConnectorProvisioningType
connectorProvisioningType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description

instance Prelude.NFData RegisterConnector where
  rnf :: RegisterConnector -> ()
rnf RegisterConnector' {Maybe Text
Maybe ConnectorProvisioningType
Maybe ConnectorProvisioningConfig
description :: Maybe Text
connectorProvisioningType :: Maybe ConnectorProvisioningType
connectorProvisioningConfig :: Maybe ConnectorProvisioningConfig
connectorLabel :: Maybe Text
$sel:description:RegisterConnector' :: RegisterConnector -> Maybe Text
$sel:connectorProvisioningType:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningType
$sel:connectorProvisioningConfig:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningConfig
$sel:connectorLabel:RegisterConnector' :: RegisterConnector -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
connectorLabel
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ConnectorProvisioningConfig
connectorProvisioningConfig
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ConnectorProvisioningType
connectorProvisioningType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description

instance Data.ToHeaders RegisterConnector where
  toHeaders :: RegisterConnector -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON RegisterConnector where
  toJSON :: RegisterConnector -> Value
toJSON RegisterConnector' {Maybe Text
Maybe ConnectorProvisioningType
Maybe ConnectorProvisioningConfig
description :: Maybe Text
connectorProvisioningType :: Maybe ConnectorProvisioningType
connectorProvisioningConfig :: Maybe ConnectorProvisioningConfig
connectorLabel :: Maybe Text
$sel:description:RegisterConnector' :: RegisterConnector -> Maybe Text
$sel:connectorProvisioningType:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningType
$sel:connectorProvisioningConfig:RegisterConnector' :: RegisterConnector -> Maybe ConnectorProvisioningConfig
$sel:connectorLabel:RegisterConnector' :: RegisterConnector -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"connectorLabel" 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
connectorLabel,
            (Key
"connectorProvisioningConfig" 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 ConnectorProvisioningConfig
connectorProvisioningConfig,
            (Key
"connectorProvisioningType" 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 ConnectorProvisioningType
connectorProvisioningType,
            (Key
"description" 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
description
          ]
      )

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

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

-- | /See:/ 'newRegisterConnectorResponse' smart constructor.
data RegisterConnectorResponse = RegisterConnectorResponse'
  { -- | The ARN of the connector being registered.
    RegisterConnectorResponse -> Maybe Text
connectorArn :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    RegisterConnectorResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RegisterConnectorResponse -> RegisterConnectorResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RegisterConnectorResponse -> RegisterConnectorResponse -> Bool
$c/= :: RegisterConnectorResponse -> RegisterConnectorResponse -> Bool
== :: RegisterConnectorResponse -> RegisterConnectorResponse -> Bool
$c== :: RegisterConnectorResponse -> RegisterConnectorResponse -> Bool
Prelude.Eq, ReadPrec [RegisterConnectorResponse]
ReadPrec RegisterConnectorResponse
Int -> ReadS RegisterConnectorResponse
ReadS [RegisterConnectorResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RegisterConnectorResponse]
$creadListPrec :: ReadPrec [RegisterConnectorResponse]
readPrec :: ReadPrec RegisterConnectorResponse
$creadPrec :: ReadPrec RegisterConnectorResponse
readList :: ReadS [RegisterConnectorResponse]
$creadList :: ReadS [RegisterConnectorResponse]
readsPrec :: Int -> ReadS RegisterConnectorResponse
$creadsPrec :: Int -> ReadS RegisterConnectorResponse
Prelude.Read, Int -> RegisterConnectorResponse -> ShowS
[RegisterConnectorResponse] -> ShowS
RegisterConnectorResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RegisterConnectorResponse] -> ShowS
$cshowList :: [RegisterConnectorResponse] -> ShowS
show :: RegisterConnectorResponse -> String
$cshow :: RegisterConnectorResponse -> String
showsPrec :: Int -> RegisterConnectorResponse -> ShowS
$cshowsPrec :: Int -> RegisterConnectorResponse -> ShowS
Prelude.Show, forall x.
Rep RegisterConnectorResponse x -> RegisterConnectorResponse
forall x.
RegisterConnectorResponse -> Rep RegisterConnectorResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RegisterConnectorResponse x -> RegisterConnectorResponse
$cfrom :: forall x.
RegisterConnectorResponse -> Rep RegisterConnectorResponse x
Prelude.Generic)

-- |
-- Create a value of 'RegisterConnectorResponse' 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:
--
-- 'connectorArn', 'registerConnectorResponse_connectorArn' - The ARN of the connector being registered.
--
-- 'httpStatus', 'registerConnectorResponse_httpStatus' - The response's http status code.
newRegisterConnectorResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RegisterConnectorResponse
newRegisterConnectorResponse :: Int -> RegisterConnectorResponse
newRegisterConnectorResponse Int
pHttpStatus_ =
  RegisterConnectorResponse'
    { $sel:connectorArn:RegisterConnectorResponse' :: Maybe Text
connectorArn =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RegisterConnectorResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The ARN of the connector being registered.
registerConnectorResponse_connectorArn :: Lens.Lens' RegisterConnectorResponse (Prelude.Maybe Prelude.Text)
registerConnectorResponse_connectorArn :: Lens' RegisterConnectorResponse (Maybe Text)
registerConnectorResponse_connectorArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RegisterConnectorResponse' {Maybe Text
connectorArn :: Maybe Text
$sel:connectorArn:RegisterConnectorResponse' :: RegisterConnectorResponse -> Maybe Text
connectorArn} -> Maybe Text
connectorArn) (\s :: RegisterConnectorResponse
s@RegisterConnectorResponse' {} Maybe Text
a -> RegisterConnectorResponse
s {$sel:connectorArn:RegisterConnectorResponse' :: Maybe Text
connectorArn = Maybe Text
a} :: RegisterConnectorResponse)

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

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