{-# 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.CognitoIdentityProvider.AdminLinkProviderForUser
-- 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)
--
-- Links an existing user account in a user pool (@DestinationUser@) to an
-- identity from an external identity provider (@SourceUser@) based on a
-- specified attribute name and value from the external identity provider.
-- This allows you to create a link from the existing user account to an
-- external federated user identity that has not yet been used to sign in,
-- so that the federated user identity can be used to sign in as the
-- existing user account.
--
-- For example, if there is an existing user with a username and password,
-- this API links that user to a federated user identity, so that when the
-- federated user identity is used, the user signs in as the existing user
-- account.
--
-- The maximum number of federated identities linked to a user is 5.
--
-- Because this API allows a user with an external federated identity to
-- sign in as an existing user in the user pool, it is critical that it
-- only be used with external identity providers and provider attributes
-- that have been trusted by the application owner.
--
-- This action is enabled only for admin access and requires developer
-- credentials.
module Amazonka.CognitoIdentityProvider.AdminLinkProviderForUser
  ( -- * Creating a Request
    AdminLinkProviderForUser (..),
    newAdminLinkProviderForUser,

    -- * Request Lenses
    adminLinkProviderForUser_userPoolId,
    adminLinkProviderForUser_destinationUser,
    adminLinkProviderForUser_sourceUser,

    -- * Destructuring the Response
    AdminLinkProviderForUserResponse (..),
    newAdminLinkProviderForUserResponse,

    -- * Response Lenses
    adminLinkProviderForUserResponse_httpStatus,
  )
where

import Amazonka.CognitoIdentityProvider.Types
import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newAdminLinkProviderForUser' smart constructor.
data AdminLinkProviderForUser = AdminLinkProviderForUser'
  { -- | The user pool ID for the user pool.
    AdminLinkProviderForUser -> Text
userPoolId :: Prelude.Text,
    -- | The existing user in the user pool to be linked to the external identity
    -- provider user account. Can be a native (Username + Password) Cognito
    -- User Pools user or a federated user (for example, a SAML or Facebook
    -- user). If the user doesn\'t exist, an exception is thrown. This is the
    -- user that is returned when the new user (with the linked identity
    -- provider attribute) signs in.
    --
    -- For a native username + password user, the @ProviderAttributeValue@ for
    -- the @DestinationUser@ should be the username in the user pool. For a
    -- federated user, it should be the provider-specific @user_id@.
    --
    -- The @ProviderAttributeName@ of the @DestinationUser@ is ignored.
    --
    -- The @ProviderName@ should be set to @Cognito@ for users in Cognito user
    -- pools.
    AdminLinkProviderForUser -> ProviderUserIdentifierType
destinationUser :: ProviderUserIdentifierType,
    -- | An external identity provider account for a user who does not currently
    -- exist yet in the user pool. This user must be a federated user (for
    -- example, a SAML or Facebook user), not another native user.
    --
    -- If the @SourceUser@ is a federated social identity provider user
    -- (Facebook, Google, or Login with Amazon), you must set the
    -- @ProviderAttributeName@ to @Cognito_Subject@. For social identity
    -- providers, the @ProviderName@ will be @Facebook@, @Google@, or
    -- @LoginWithAmazon@, and Cognito will automatically parse the Facebook,
    -- Google, and Login with Amazon tokens for @id@, @sub@, and @user_id@,
    -- respectively. The @ProviderAttributeValue@ for the user must be the same
    -- value as the @id@, @sub@, or @user_id@ value found in the social
    -- identity provider token.
    --
    -- For SAML, the @ProviderAttributeName@ can be any value that matches a
    -- claim in the SAML assertion. If you wish to link SAML users based on the
    -- subject of the SAML assertion, you should map the subject to a claim
    -- through the SAML identity provider and submit that claim name as the
    -- @ProviderAttributeName@. If you set @ProviderAttributeName@ to
    -- @Cognito_Subject@, Cognito will automatically parse the default unique
    -- identifier found in the subject from the SAML token.
    AdminLinkProviderForUser -> ProviderUserIdentifierType
sourceUser :: ProviderUserIdentifierType
  }
  deriving (AdminLinkProviderForUser -> AdminLinkProviderForUser -> Bool
(AdminLinkProviderForUser -> AdminLinkProviderForUser -> Bool)
-> (AdminLinkProviderForUser -> AdminLinkProviderForUser -> Bool)
-> Eq AdminLinkProviderForUser
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AdminLinkProviderForUser -> AdminLinkProviderForUser -> Bool
$c/= :: AdminLinkProviderForUser -> AdminLinkProviderForUser -> Bool
== :: AdminLinkProviderForUser -> AdminLinkProviderForUser -> Bool
$c== :: AdminLinkProviderForUser -> AdminLinkProviderForUser -> Bool
Prelude.Eq, ReadPrec [AdminLinkProviderForUser]
ReadPrec AdminLinkProviderForUser
Int -> ReadS AdminLinkProviderForUser
ReadS [AdminLinkProviderForUser]
(Int -> ReadS AdminLinkProviderForUser)
-> ReadS [AdminLinkProviderForUser]
-> ReadPrec AdminLinkProviderForUser
-> ReadPrec [AdminLinkProviderForUser]
-> Read AdminLinkProviderForUser
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AdminLinkProviderForUser]
$creadListPrec :: ReadPrec [AdminLinkProviderForUser]
readPrec :: ReadPrec AdminLinkProviderForUser
$creadPrec :: ReadPrec AdminLinkProviderForUser
readList :: ReadS [AdminLinkProviderForUser]
$creadList :: ReadS [AdminLinkProviderForUser]
readsPrec :: Int -> ReadS AdminLinkProviderForUser
$creadsPrec :: Int -> ReadS AdminLinkProviderForUser
Prelude.Read, Int -> AdminLinkProviderForUser -> ShowS
[AdminLinkProviderForUser] -> ShowS
AdminLinkProviderForUser -> String
(Int -> AdminLinkProviderForUser -> ShowS)
-> (AdminLinkProviderForUser -> String)
-> ([AdminLinkProviderForUser] -> ShowS)
-> Show AdminLinkProviderForUser
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AdminLinkProviderForUser] -> ShowS
$cshowList :: [AdminLinkProviderForUser] -> ShowS
show :: AdminLinkProviderForUser -> String
$cshow :: AdminLinkProviderForUser -> String
showsPrec :: Int -> AdminLinkProviderForUser -> ShowS
$cshowsPrec :: Int -> AdminLinkProviderForUser -> ShowS
Prelude.Show, (forall x.
 AdminLinkProviderForUser -> Rep AdminLinkProviderForUser x)
-> (forall x.
    Rep AdminLinkProviderForUser x -> AdminLinkProviderForUser)
-> Generic AdminLinkProviderForUser
forall x.
Rep AdminLinkProviderForUser x -> AdminLinkProviderForUser
forall x.
AdminLinkProviderForUser -> Rep AdminLinkProviderForUser x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AdminLinkProviderForUser x -> AdminLinkProviderForUser
$cfrom :: forall x.
AdminLinkProviderForUser -> Rep AdminLinkProviderForUser x
Prelude.Generic)

-- |
-- Create a value of 'AdminLinkProviderForUser' 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:
--
-- 'userPoolId', 'adminLinkProviderForUser_userPoolId' - The user pool ID for the user pool.
--
-- 'destinationUser', 'adminLinkProviderForUser_destinationUser' - The existing user in the user pool to be linked to the external identity
-- provider user account. Can be a native (Username + Password) Cognito
-- User Pools user or a federated user (for example, a SAML or Facebook
-- user). If the user doesn\'t exist, an exception is thrown. This is the
-- user that is returned when the new user (with the linked identity
-- provider attribute) signs in.
--
-- For a native username + password user, the @ProviderAttributeValue@ for
-- the @DestinationUser@ should be the username in the user pool. For a
-- federated user, it should be the provider-specific @user_id@.
--
-- The @ProviderAttributeName@ of the @DestinationUser@ is ignored.
--
-- The @ProviderName@ should be set to @Cognito@ for users in Cognito user
-- pools.
--
-- 'sourceUser', 'adminLinkProviderForUser_sourceUser' - An external identity provider account for a user who does not currently
-- exist yet in the user pool. This user must be a federated user (for
-- example, a SAML or Facebook user), not another native user.
--
-- If the @SourceUser@ is a federated social identity provider user
-- (Facebook, Google, or Login with Amazon), you must set the
-- @ProviderAttributeName@ to @Cognito_Subject@. For social identity
-- providers, the @ProviderName@ will be @Facebook@, @Google@, or
-- @LoginWithAmazon@, and Cognito will automatically parse the Facebook,
-- Google, and Login with Amazon tokens for @id@, @sub@, and @user_id@,
-- respectively. The @ProviderAttributeValue@ for the user must be the same
-- value as the @id@, @sub@, or @user_id@ value found in the social
-- identity provider token.
--
-- For SAML, the @ProviderAttributeName@ can be any value that matches a
-- claim in the SAML assertion. If you wish to link SAML users based on the
-- subject of the SAML assertion, you should map the subject to a claim
-- through the SAML identity provider and submit that claim name as the
-- @ProviderAttributeName@. If you set @ProviderAttributeName@ to
-- @Cognito_Subject@, Cognito will automatically parse the default unique
-- identifier found in the subject from the SAML token.
newAdminLinkProviderForUser ::
  -- | 'userPoolId'
  Prelude.Text ->
  -- | 'destinationUser'
  ProviderUserIdentifierType ->
  -- | 'sourceUser'
  ProviderUserIdentifierType ->
  AdminLinkProviderForUser
newAdminLinkProviderForUser :: Text
-> ProviderUserIdentifierType
-> ProviderUserIdentifierType
-> AdminLinkProviderForUser
newAdminLinkProviderForUser
  Text
pUserPoolId_
  ProviderUserIdentifierType
pDestinationUser_
  ProviderUserIdentifierType
pSourceUser_ =
    AdminLinkProviderForUser' :: Text
-> ProviderUserIdentifierType
-> ProviderUserIdentifierType
-> AdminLinkProviderForUser
AdminLinkProviderForUser'
      { $sel:userPoolId:AdminLinkProviderForUser' :: Text
userPoolId =
          Text
pUserPoolId_,
        $sel:destinationUser:AdminLinkProviderForUser' :: ProviderUserIdentifierType
destinationUser = ProviderUserIdentifierType
pDestinationUser_,
        $sel:sourceUser:AdminLinkProviderForUser' :: ProviderUserIdentifierType
sourceUser = ProviderUserIdentifierType
pSourceUser_
      }

-- | The user pool ID for the user pool.
adminLinkProviderForUser_userPoolId :: Lens.Lens' AdminLinkProviderForUser Prelude.Text
adminLinkProviderForUser_userPoolId :: (Text -> f Text)
-> AdminLinkProviderForUser -> f AdminLinkProviderForUser
adminLinkProviderForUser_userPoolId = (AdminLinkProviderForUser -> Text)
-> (AdminLinkProviderForUser -> Text -> AdminLinkProviderForUser)
-> Lens AdminLinkProviderForUser AdminLinkProviderForUser Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AdminLinkProviderForUser' {Text
userPoolId :: Text
$sel:userPoolId:AdminLinkProviderForUser' :: AdminLinkProviderForUser -> Text
userPoolId} -> Text
userPoolId) (\s :: AdminLinkProviderForUser
s@AdminLinkProviderForUser' {} Text
a -> AdminLinkProviderForUser
s {$sel:userPoolId:AdminLinkProviderForUser' :: Text
userPoolId = Text
a} :: AdminLinkProviderForUser)

-- | The existing user in the user pool to be linked to the external identity
-- provider user account. Can be a native (Username + Password) Cognito
-- User Pools user or a federated user (for example, a SAML or Facebook
-- user). If the user doesn\'t exist, an exception is thrown. This is the
-- user that is returned when the new user (with the linked identity
-- provider attribute) signs in.
--
-- For a native username + password user, the @ProviderAttributeValue@ for
-- the @DestinationUser@ should be the username in the user pool. For a
-- federated user, it should be the provider-specific @user_id@.
--
-- The @ProviderAttributeName@ of the @DestinationUser@ is ignored.
--
-- The @ProviderName@ should be set to @Cognito@ for users in Cognito user
-- pools.
adminLinkProviderForUser_destinationUser :: Lens.Lens' AdminLinkProviderForUser ProviderUserIdentifierType
adminLinkProviderForUser_destinationUser :: (ProviderUserIdentifierType -> f ProviderUserIdentifierType)
-> AdminLinkProviderForUser -> f AdminLinkProviderForUser
adminLinkProviderForUser_destinationUser = (AdminLinkProviderForUser -> ProviderUserIdentifierType)
-> (AdminLinkProviderForUser
    -> ProviderUserIdentifierType -> AdminLinkProviderForUser)
-> Lens
     AdminLinkProviderForUser
     AdminLinkProviderForUser
     ProviderUserIdentifierType
     ProviderUserIdentifierType
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AdminLinkProviderForUser' {ProviderUserIdentifierType
destinationUser :: ProviderUserIdentifierType
$sel:destinationUser:AdminLinkProviderForUser' :: AdminLinkProviderForUser -> ProviderUserIdentifierType
destinationUser} -> ProviderUserIdentifierType
destinationUser) (\s :: AdminLinkProviderForUser
s@AdminLinkProviderForUser' {} ProviderUserIdentifierType
a -> AdminLinkProviderForUser
s {$sel:destinationUser:AdminLinkProviderForUser' :: ProviderUserIdentifierType
destinationUser = ProviderUserIdentifierType
a} :: AdminLinkProviderForUser)

-- | An external identity provider account for a user who does not currently
-- exist yet in the user pool. This user must be a federated user (for
-- example, a SAML or Facebook user), not another native user.
--
-- If the @SourceUser@ is a federated social identity provider user
-- (Facebook, Google, or Login with Amazon), you must set the
-- @ProviderAttributeName@ to @Cognito_Subject@. For social identity
-- providers, the @ProviderName@ will be @Facebook@, @Google@, or
-- @LoginWithAmazon@, and Cognito will automatically parse the Facebook,
-- Google, and Login with Amazon tokens for @id@, @sub@, and @user_id@,
-- respectively. The @ProviderAttributeValue@ for the user must be the same
-- value as the @id@, @sub@, or @user_id@ value found in the social
-- identity provider token.
--
-- For SAML, the @ProviderAttributeName@ can be any value that matches a
-- claim in the SAML assertion. If you wish to link SAML users based on the
-- subject of the SAML assertion, you should map the subject to a claim
-- through the SAML identity provider and submit that claim name as the
-- @ProviderAttributeName@. If you set @ProviderAttributeName@ to
-- @Cognito_Subject@, Cognito will automatically parse the default unique
-- identifier found in the subject from the SAML token.
adminLinkProviderForUser_sourceUser :: Lens.Lens' AdminLinkProviderForUser ProviderUserIdentifierType
adminLinkProviderForUser_sourceUser :: (ProviderUserIdentifierType -> f ProviderUserIdentifierType)
-> AdminLinkProviderForUser -> f AdminLinkProviderForUser
adminLinkProviderForUser_sourceUser = (AdminLinkProviderForUser -> ProviderUserIdentifierType)
-> (AdminLinkProviderForUser
    -> ProviderUserIdentifierType -> AdminLinkProviderForUser)
-> Lens
     AdminLinkProviderForUser
     AdminLinkProviderForUser
     ProviderUserIdentifierType
     ProviderUserIdentifierType
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AdminLinkProviderForUser' {ProviderUserIdentifierType
sourceUser :: ProviderUserIdentifierType
$sel:sourceUser:AdminLinkProviderForUser' :: AdminLinkProviderForUser -> ProviderUserIdentifierType
sourceUser} -> ProviderUserIdentifierType
sourceUser) (\s :: AdminLinkProviderForUser
s@AdminLinkProviderForUser' {} ProviderUserIdentifierType
a -> AdminLinkProviderForUser
s {$sel:sourceUser:AdminLinkProviderForUser' :: ProviderUserIdentifierType
sourceUser = ProviderUserIdentifierType
a} :: AdminLinkProviderForUser)

instance Core.AWSRequest AdminLinkProviderForUser where
  type
    AWSResponse AdminLinkProviderForUser =
      AdminLinkProviderForUserResponse
  request :: AdminLinkProviderForUser -> Request AdminLinkProviderForUser
request = Service
-> AdminLinkProviderForUser -> Request AdminLinkProviderForUser
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy AdminLinkProviderForUser
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse AdminLinkProviderForUser)))
response =
    (Int
 -> ResponseHeaders
 -> ()
 -> Either String (AWSResponse AdminLinkProviderForUser))
-> Logger
-> Service
-> Proxy AdminLinkProviderForUser
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse AdminLinkProviderForUser)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> AdminLinkProviderForUserResponse
AdminLinkProviderForUserResponse'
            (Int -> AdminLinkProviderForUserResponse)
-> Either String Int
-> Either String AdminLinkProviderForUserResponse
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable AdminLinkProviderForUser

instance Prelude.NFData AdminLinkProviderForUser

instance Core.ToHeaders AdminLinkProviderForUser where
  toHeaders :: AdminLinkProviderForUser -> ResponseHeaders
toHeaders =
    ResponseHeaders -> AdminLinkProviderForUser -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"AWSCognitoIdentityProviderService.AdminLinkProviderForUser" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON AdminLinkProviderForUser where
  toJSON :: AdminLinkProviderForUser -> Value
toJSON AdminLinkProviderForUser' {Text
ProviderUserIdentifierType
sourceUser :: ProviderUserIdentifierType
destinationUser :: ProviderUserIdentifierType
userPoolId :: Text
$sel:sourceUser:AdminLinkProviderForUser' :: AdminLinkProviderForUser -> ProviderUserIdentifierType
$sel:destinationUser:AdminLinkProviderForUser' :: AdminLinkProviderForUser -> ProviderUserIdentifierType
$sel:userPoolId:AdminLinkProviderForUser' :: AdminLinkProviderForUser -> Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"UserPoolId" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
userPoolId),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"DestinationUser" Text -> ProviderUserIdentifierType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= ProviderUserIdentifierType
destinationUser),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"SourceUser" Text -> ProviderUserIdentifierType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= ProviderUserIdentifierType
sourceUser)
          ]
      )

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

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

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

-- |
-- Create a value of 'AdminLinkProviderForUserResponse' 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:
--
-- 'httpStatus', 'adminLinkProviderForUserResponse_httpStatus' - The response's http status code.
newAdminLinkProviderForUserResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  AdminLinkProviderForUserResponse
newAdminLinkProviderForUserResponse :: Int -> AdminLinkProviderForUserResponse
newAdminLinkProviderForUserResponse Int
pHttpStatus_ =
  AdminLinkProviderForUserResponse' :: Int -> AdminLinkProviderForUserResponse
AdminLinkProviderForUserResponse'
    { $sel:httpStatus:AdminLinkProviderForUserResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance
  Prelude.NFData
    AdminLinkProviderForUserResponse