{-# 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.AmplifyBackend.ImportBackendAuth
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Imports an existing backend authentication resource.
module Amazonka.AmplifyBackend.ImportBackendAuth
  ( -- * Creating a Request
    ImportBackendAuth (..),
    newImportBackendAuth,

    -- * Request Lenses
    importBackendAuth_identityPoolId,
    importBackendAuth_appId,
    importBackendAuth_backendEnvironmentName,
    importBackendAuth_userPoolId,
    importBackendAuth_nativeClientId,
    importBackendAuth_webClientId,

    -- * Destructuring the Response
    ImportBackendAuthResponse (..),
    newImportBackendAuthResponse,

    -- * Response Lenses
    importBackendAuthResponse_appId,
    importBackendAuthResponse_backendEnvironmentName,
    importBackendAuthResponse_error,
    importBackendAuthResponse_jobId,
    importBackendAuthResponse_operation,
    importBackendAuthResponse_status,
    importBackendAuthResponse_httpStatus,
  )
where

import Amazonka.AmplifyBackend.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

-- | The request body for ImportBackendAuth.
--
-- /See:/ 'newImportBackendAuth' smart constructor.
data ImportBackendAuth = ImportBackendAuth'
  { -- | The ID of the Amazon Cognito identity pool.
    ImportBackendAuth -> Maybe Text
identityPoolId :: Prelude.Maybe Prelude.Text,
    -- | The app ID.
    ImportBackendAuth -> Text
appId :: Prelude.Text,
    -- | The name of the backend environment.
    ImportBackendAuth -> Text
backendEnvironmentName :: Prelude.Text,
    -- | The ID of the Amazon Cognito user pool.
    ImportBackendAuth -> Text
userPoolId :: Prelude.Text,
    -- | The ID of the Amazon Cognito native client.
    ImportBackendAuth -> Text
nativeClientId :: Prelude.Text,
    -- | The ID of the Amazon Cognito web client.
    ImportBackendAuth -> Text
webClientId :: Prelude.Text
  }
  deriving (ImportBackendAuth -> ImportBackendAuth -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportBackendAuth -> ImportBackendAuth -> Bool
$c/= :: ImportBackendAuth -> ImportBackendAuth -> Bool
== :: ImportBackendAuth -> ImportBackendAuth -> Bool
$c== :: ImportBackendAuth -> ImportBackendAuth -> Bool
Prelude.Eq, ReadPrec [ImportBackendAuth]
ReadPrec ImportBackendAuth
Int -> ReadS ImportBackendAuth
ReadS [ImportBackendAuth]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ImportBackendAuth]
$creadListPrec :: ReadPrec [ImportBackendAuth]
readPrec :: ReadPrec ImportBackendAuth
$creadPrec :: ReadPrec ImportBackendAuth
readList :: ReadS [ImportBackendAuth]
$creadList :: ReadS [ImportBackendAuth]
readsPrec :: Int -> ReadS ImportBackendAuth
$creadsPrec :: Int -> ReadS ImportBackendAuth
Prelude.Read, Int -> ImportBackendAuth -> ShowS
[ImportBackendAuth] -> ShowS
ImportBackendAuth -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportBackendAuth] -> ShowS
$cshowList :: [ImportBackendAuth] -> ShowS
show :: ImportBackendAuth -> String
$cshow :: ImportBackendAuth -> String
showsPrec :: Int -> ImportBackendAuth -> ShowS
$cshowsPrec :: Int -> ImportBackendAuth -> ShowS
Prelude.Show, forall x. Rep ImportBackendAuth x -> ImportBackendAuth
forall x. ImportBackendAuth -> Rep ImportBackendAuth x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ImportBackendAuth x -> ImportBackendAuth
$cfrom :: forall x. ImportBackendAuth -> Rep ImportBackendAuth x
Prelude.Generic)

-- |
-- Create a value of 'ImportBackendAuth' 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:
--
-- 'identityPoolId', 'importBackendAuth_identityPoolId' - The ID of the Amazon Cognito identity pool.
--
-- 'appId', 'importBackendAuth_appId' - The app ID.
--
-- 'backendEnvironmentName', 'importBackendAuth_backendEnvironmentName' - The name of the backend environment.
--
-- 'userPoolId', 'importBackendAuth_userPoolId' - The ID of the Amazon Cognito user pool.
--
-- 'nativeClientId', 'importBackendAuth_nativeClientId' - The ID of the Amazon Cognito native client.
--
-- 'webClientId', 'importBackendAuth_webClientId' - The ID of the Amazon Cognito web client.
newImportBackendAuth ::
  -- | 'appId'
  Prelude.Text ->
  -- | 'backendEnvironmentName'
  Prelude.Text ->
  -- | 'userPoolId'
  Prelude.Text ->
  -- | 'nativeClientId'
  Prelude.Text ->
  -- | 'webClientId'
  Prelude.Text ->
  ImportBackendAuth
newImportBackendAuth :: Text -> Text -> Text -> Text -> Text -> ImportBackendAuth
newImportBackendAuth
  Text
pAppId_
  Text
pBackendEnvironmentName_
  Text
pUserPoolId_
  Text
pNativeClientId_
  Text
pWebClientId_ =
    ImportBackendAuth'
      { $sel:identityPoolId:ImportBackendAuth' :: Maybe Text
identityPoolId =
          forall a. Maybe a
Prelude.Nothing,
        $sel:appId:ImportBackendAuth' :: Text
appId = Text
pAppId_,
        $sel:backendEnvironmentName:ImportBackendAuth' :: Text
backendEnvironmentName = Text
pBackendEnvironmentName_,
        $sel:userPoolId:ImportBackendAuth' :: Text
userPoolId = Text
pUserPoolId_,
        $sel:nativeClientId:ImportBackendAuth' :: Text
nativeClientId = Text
pNativeClientId_,
        $sel:webClientId:ImportBackendAuth' :: Text
webClientId = Text
pWebClientId_
      }

-- | The ID of the Amazon Cognito identity pool.
importBackendAuth_identityPoolId :: Lens.Lens' ImportBackendAuth (Prelude.Maybe Prelude.Text)
importBackendAuth_identityPoolId :: Lens' ImportBackendAuth (Maybe Text)
importBackendAuth_identityPoolId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuth' {Maybe Text
identityPoolId :: Maybe Text
$sel:identityPoolId:ImportBackendAuth' :: ImportBackendAuth -> Maybe Text
identityPoolId} -> Maybe Text
identityPoolId) (\s :: ImportBackendAuth
s@ImportBackendAuth' {} Maybe Text
a -> ImportBackendAuth
s {$sel:identityPoolId:ImportBackendAuth' :: Maybe Text
identityPoolId = Maybe Text
a} :: ImportBackendAuth)

-- | The app ID.
importBackendAuth_appId :: Lens.Lens' ImportBackendAuth Prelude.Text
importBackendAuth_appId :: Lens' ImportBackendAuth Text
importBackendAuth_appId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuth' {Text
appId :: Text
$sel:appId:ImportBackendAuth' :: ImportBackendAuth -> Text
appId} -> Text
appId) (\s :: ImportBackendAuth
s@ImportBackendAuth' {} Text
a -> ImportBackendAuth
s {$sel:appId:ImportBackendAuth' :: Text
appId = Text
a} :: ImportBackendAuth)

-- | The name of the backend environment.
importBackendAuth_backendEnvironmentName :: Lens.Lens' ImportBackendAuth Prelude.Text
importBackendAuth_backendEnvironmentName :: Lens' ImportBackendAuth Text
importBackendAuth_backendEnvironmentName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuth' {Text
backendEnvironmentName :: Text
$sel:backendEnvironmentName:ImportBackendAuth' :: ImportBackendAuth -> Text
backendEnvironmentName} -> Text
backendEnvironmentName) (\s :: ImportBackendAuth
s@ImportBackendAuth' {} Text
a -> ImportBackendAuth
s {$sel:backendEnvironmentName:ImportBackendAuth' :: Text
backendEnvironmentName = Text
a} :: ImportBackendAuth)

-- | The ID of the Amazon Cognito user pool.
importBackendAuth_userPoolId :: Lens.Lens' ImportBackendAuth Prelude.Text
importBackendAuth_userPoolId :: Lens' ImportBackendAuth Text
importBackendAuth_userPoolId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuth' {Text
userPoolId :: Text
$sel:userPoolId:ImportBackendAuth' :: ImportBackendAuth -> Text
userPoolId} -> Text
userPoolId) (\s :: ImportBackendAuth
s@ImportBackendAuth' {} Text
a -> ImportBackendAuth
s {$sel:userPoolId:ImportBackendAuth' :: Text
userPoolId = Text
a} :: ImportBackendAuth)

-- | The ID of the Amazon Cognito native client.
importBackendAuth_nativeClientId :: Lens.Lens' ImportBackendAuth Prelude.Text
importBackendAuth_nativeClientId :: Lens' ImportBackendAuth Text
importBackendAuth_nativeClientId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuth' {Text
nativeClientId :: Text
$sel:nativeClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
nativeClientId} -> Text
nativeClientId) (\s :: ImportBackendAuth
s@ImportBackendAuth' {} Text
a -> ImportBackendAuth
s {$sel:nativeClientId:ImportBackendAuth' :: Text
nativeClientId = Text
a} :: ImportBackendAuth)

-- | The ID of the Amazon Cognito web client.
importBackendAuth_webClientId :: Lens.Lens' ImportBackendAuth Prelude.Text
importBackendAuth_webClientId :: Lens' ImportBackendAuth Text
importBackendAuth_webClientId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuth' {Text
webClientId :: Text
$sel:webClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
webClientId} -> Text
webClientId) (\s :: ImportBackendAuth
s@ImportBackendAuth' {} Text
a -> ImportBackendAuth
s {$sel:webClientId:ImportBackendAuth' :: Text
webClientId = Text
a} :: ImportBackendAuth)

instance Core.AWSRequest ImportBackendAuth where
  type
    AWSResponse ImportBackendAuth =
      ImportBackendAuthResponse
  request :: (Service -> Service)
-> ImportBackendAuth -> Request ImportBackendAuth
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 ImportBackendAuth
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ImportBackendAuth)))
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
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Int
-> ImportBackendAuthResponse
ImportBackendAuthResponse'
            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
"appId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"backendEnvironmentName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"error")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"jobId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"operation")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"status")
            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 ImportBackendAuth where
  hashWithSalt :: Int -> ImportBackendAuth -> Int
hashWithSalt Int
_salt ImportBackendAuth' {Maybe Text
Text
webClientId :: Text
nativeClientId :: Text
userPoolId :: Text
backendEnvironmentName :: Text
appId :: Text
identityPoolId :: Maybe Text
$sel:webClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:nativeClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:userPoolId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:backendEnvironmentName:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:appId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:identityPoolId:ImportBackendAuth' :: ImportBackendAuth -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
identityPoolId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
appId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
backendEnvironmentName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
userPoolId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
nativeClientId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
webClientId

instance Prelude.NFData ImportBackendAuth where
  rnf :: ImportBackendAuth -> ()
rnf ImportBackendAuth' {Maybe Text
Text
webClientId :: Text
nativeClientId :: Text
userPoolId :: Text
backendEnvironmentName :: Text
appId :: Text
identityPoolId :: Maybe Text
$sel:webClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:nativeClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:userPoolId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:backendEnvironmentName:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:appId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:identityPoolId:ImportBackendAuth' :: ImportBackendAuth -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
identityPoolId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
appId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
backendEnvironmentName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
userPoolId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
nativeClientId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
webClientId

instance Data.ToHeaders ImportBackendAuth where
  toHeaders :: ImportBackendAuth -> 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 ImportBackendAuth where
  toJSON :: ImportBackendAuth -> Value
toJSON ImportBackendAuth' {Maybe Text
Text
webClientId :: Text
nativeClientId :: Text
userPoolId :: Text
backendEnvironmentName :: Text
appId :: Text
identityPoolId :: Maybe Text
$sel:webClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:nativeClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:userPoolId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:backendEnvironmentName:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:appId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:identityPoolId:ImportBackendAuth' :: ImportBackendAuth -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"identityPoolId" 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
identityPoolId,
            forall a. a -> Maybe a
Prelude.Just (Key
"userPoolId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
userPoolId),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"nativeClientId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
nativeClientId),
            forall a. a -> Maybe a
Prelude.Just (Key
"webClientId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
webClientId)
          ]
      )

instance Data.ToPath ImportBackendAuth where
  toPath :: ImportBackendAuth -> ByteString
toPath ImportBackendAuth' {Maybe Text
Text
webClientId :: Text
nativeClientId :: Text
userPoolId :: Text
backendEnvironmentName :: Text
appId :: Text
identityPoolId :: Maybe Text
$sel:webClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:nativeClientId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:userPoolId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:backendEnvironmentName:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:appId:ImportBackendAuth' :: ImportBackendAuth -> Text
$sel:identityPoolId:ImportBackendAuth' :: ImportBackendAuth -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/backend/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
appId,
        ByteString
"/auth/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
backendEnvironmentName,
        ByteString
"/import"
      ]

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

-- | /See:/ 'newImportBackendAuthResponse' smart constructor.
data ImportBackendAuthResponse = ImportBackendAuthResponse'
  { -- | The app ID.
    ImportBackendAuthResponse -> Maybe Text
appId :: Prelude.Maybe Prelude.Text,
    -- | The name of the backend environment.
    ImportBackendAuthResponse -> Maybe Text
backendEnvironmentName :: Prelude.Maybe Prelude.Text,
    -- | If the request fails, this error is returned.
    ImportBackendAuthResponse -> Maybe Text
error :: Prelude.Maybe Prelude.Text,
    -- | The ID for the job.
    ImportBackendAuthResponse -> Maybe Text
jobId :: Prelude.Maybe Prelude.Text,
    -- | The name of the operation.
    ImportBackendAuthResponse -> Maybe Text
operation :: Prelude.Maybe Prelude.Text,
    -- | The current status of the request.
    ImportBackendAuthResponse -> Maybe Text
status :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ImportBackendAuthResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ImportBackendAuthResponse -> ImportBackendAuthResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ImportBackendAuthResponse -> ImportBackendAuthResponse -> Bool
$c/= :: ImportBackendAuthResponse -> ImportBackendAuthResponse -> Bool
== :: ImportBackendAuthResponse -> ImportBackendAuthResponse -> Bool
$c== :: ImportBackendAuthResponse -> ImportBackendAuthResponse -> Bool
Prelude.Eq, ReadPrec [ImportBackendAuthResponse]
ReadPrec ImportBackendAuthResponse
Int -> ReadS ImportBackendAuthResponse
ReadS [ImportBackendAuthResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ImportBackendAuthResponse]
$creadListPrec :: ReadPrec [ImportBackendAuthResponse]
readPrec :: ReadPrec ImportBackendAuthResponse
$creadPrec :: ReadPrec ImportBackendAuthResponse
readList :: ReadS [ImportBackendAuthResponse]
$creadList :: ReadS [ImportBackendAuthResponse]
readsPrec :: Int -> ReadS ImportBackendAuthResponse
$creadsPrec :: Int -> ReadS ImportBackendAuthResponse
Prelude.Read, Int -> ImportBackendAuthResponse -> ShowS
[ImportBackendAuthResponse] -> ShowS
ImportBackendAuthResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ImportBackendAuthResponse] -> ShowS
$cshowList :: [ImportBackendAuthResponse] -> ShowS
show :: ImportBackendAuthResponse -> String
$cshow :: ImportBackendAuthResponse -> String
showsPrec :: Int -> ImportBackendAuthResponse -> ShowS
$cshowsPrec :: Int -> ImportBackendAuthResponse -> ShowS
Prelude.Show, forall x.
Rep ImportBackendAuthResponse x -> ImportBackendAuthResponse
forall x.
ImportBackendAuthResponse -> Rep ImportBackendAuthResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ImportBackendAuthResponse x -> ImportBackendAuthResponse
$cfrom :: forall x.
ImportBackendAuthResponse -> Rep ImportBackendAuthResponse x
Prelude.Generic)

-- |
-- Create a value of 'ImportBackendAuthResponse' 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:
--
-- 'appId', 'importBackendAuthResponse_appId' - The app ID.
--
-- 'backendEnvironmentName', 'importBackendAuthResponse_backendEnvironmentName' - The name of the backend environment.
--
-- 'error', 'importBackendAuthResponse_error' - If the request fails, this error is returned.
--
-- 'jobId', 'importBackendAuthResponse_jobId' - The ID for the job.
--
-- 'operation', 'importBackendAuthResponse_operation' - The name of the operation.
--
-- 'status', 'importBackendAuthResponse_status' - The current status of the request.
--
-- 'httpStatus', 'importBackendAuthResponse_httpStatus' - The response's http status code.
newImportBackendAuthResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ImportBackendAuthResponse
newImportBackendAuthResponse :: Int -> ImportBackendAuthResponse
newImportBackendAuthResponse Int
pHttpStatus_ =
  ImportBackendAuthResponse'
    { $sel:appId:ImportBackendAuthResponse' :: Maybe Text
appId = forall a. Maybe a
Prelude.Nothing,
      $sel:backendEnvironmentName:ImportBackendAuthResponse' :: Maybe Text
backendEnvironmentName = forall a. Maybe a
Prelude.Nothing,
      $sel:error:ImportBackendAuthResponse' :: Maybe Text
error = forall a. Maybe a
Prelude.Nothing,
      $sel:jobId:ImportBackendAuthResponse' :: Maybe Text
jobId = forall a. Maybe a
Prelude.Nothing,
      $sel:operation:ImportBackendAuthResponse' :: Maybe Text
operation = forall a. Maybe a
Prelude.Nothing,
      $sel:status:ImportBackendAuthResponse' :: Maybe Text
status = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ImportBackendAuthResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The app ID.
importBackendAuthResponse_appId :: Lens.Lens' ImportBackendAuthResponse (Prelude.Maybe Prelude.Text)
importBackendAuthResponse_appId :: Lens' ImportBackendAuthResponse (Maybe Text)
importBackendAuthResponse_appId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuthResponse' {Maybe Text
appId :: Maybe Text
$sel:appId:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
appId} -> Maybe Text
appId) (\s :: ImportBackendAuthResponse
s@ImportBackendAuthResponse' {} Maybe Text
a -> ImportBackendAuthResponse
s {$sel:appId:ImportBackendAuthResponse' :: Maybe Text
appId = Maybe Text
a} :: ImportBackendAuthResponse)

-- | The name of the backend environment.
importBackendAuthResponse_backendEnvironmentName :: Lens.Lens' ImportBackendAuthResponse (Prelude.Maybe Prelude.Text)
importBackendAuthResponse_backendEnvironmentName :: Lens' ImportBackendAuthResponse (Maybe Text)
importBackendAuthResponse_backendEnvironmentName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuthResponse' {Maybe Text
backendEnvironmentName :: Maybe Text
$sel:backendEnvironmentName:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
backendEnvironmentName} -> Maybe Text
backendEnvironmentName) (\s :: ImportBackendAuthResponse
s@ImportBackendAuthResponse' {} Maybe Text
a -> ImportBackendAuthResponse
s {$sel:backendEnvironmentName:ImportBackendAuthResponse' :: Maybe Text
backendEnvironmentName = Maybe Text
a} :: ImportBackendAuthResponse)

-- | If the request fails, this error is returned.
importBackendAuthResponse_error :: Lens.Lens' ImportBackendAuthResponse (Prelude.Maybe Prelude.Text)
importBackendAuthResponse_error :: Lens' ImportBackendAuthResponse (Maybe Text)
importBackendAuthResponse_error = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuthResponse' {Maybe Text
error :: Maybe Text
$sel:error:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
error} -> Maybe Text
error) (\s :: ImportBackendAuthResponse
s@ImportBackendAuthResponse' {} Maybe Text
a -> ImportBackendAuthResponse
s {$sel:error:ImportBackendAuthResponse' :: Maybe Text
error = Maybe Text
a} :: ImportBackendAuthResponse)

-- | The ID for the job.
importBackendAuthResponse_jobId :: Lens.Lens' ImportBackendAuthResponse (Prelude.Maybe Prelude.Text)
importBackendAuthResponse_jobId :: Lens' ImportBackendAuthResponse (Maybe Text)
importBackendAuthResponse_jobId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuthResponse' {Maybe Text
jobId :: Maybe Text
$sel:jobId:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
jobId} -> Maybe Text
jobId) (\s :: ImportBackendAuthResponse
s@ImportBackendAuthResponse' {} Maybe Text
a -> ImportBackendAuthResponse
s {$sel:jobId:ImportBackendAuthResponse' :: Maybe Text
jobId = Maybe Text
a} :: ImportBackendAuthResponse)

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

-- | The current status of the request.
importBackendAuthResponse_status :: Lens.Lens' ImportBackendAuthResponse (Prelude.Maybe Prelude.Text)
importBackendAuthResponse_status :: Lens' ImportBackendAuthResponse (Maybe Text)
importBackendAuthResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ImportBackendAuthResponse' {Maybe Text
status :: Maybe Text
$sel:status:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
status} -> Maybe Text
status) (\s :: ImportBackendAuthResponse
s@ImportBackendAuthResponse' {} Maybe Text
a -> ImportBackendAuthResponse
s {$sel:status:ImportBackendAuthResponse' :: Maybe Text
status = Maybe Text
a} :: ImportBackendAuthResponse)

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

instance Prelude.NFData ImportBackendAuthResponse where
  rnf :: ImportBackendAuthResponse -> ()
rnf ImportBackendAuthResponse' {Int
Maybe Text
httpStatus :: Int
status :: Maybe Text
operation :: Maybe Text
jobId :: Maybe Text
error :: Maybe Text
backendEnvironmentName :: Maybe Text
appId :: Maybe Text
$sel:httpStatus:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Int
$sel:status:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
$sel:operation:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
$sel:jobId:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
$sel:error:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
$sel:backendEnvironmentName:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
$sel:appId:ImportBackendAuthResponse' :: ImportBackendAuthResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
appId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
backendEnvironmentName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
error
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
jobId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
operation
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
status
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus