{-# 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.CodeStar.AssociateTeamMember
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Adds an IAM user to the team for an AWS CodeStar project.
module Amazonka.CodeStar.AssociateTeamMember
  ( -- * Creating a Request
    AssociateTeamMember (..),
    newAssociateTeamMember,

    -- * Request Lenses
    associateTeamMember_clientRequestToken,
    associateTeamMember_remoteAccessAllowed,
    associateTeamMember_projectId,
    associateTeamMember_userArn,
    associateTeamMember_projectRole,

    -- * Destructuring the Response
    AssociateTeamMemberResponse (..),
    newAssociateTeamMemberResponse,

    -- * Response Lenses
    associateTeamMemberResponse_clientRequestToken,
    associateTeamMemberResponse_httpStatus,
  )
where

import Amazonka.CodeStar.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:/ 'newAssociateTeamMember' smart constructor.
data AssociateTeamMember = AssociateTeamMember'
  { -- | A user- or system-generated token that identifies the entity that
    -- requested the team member association to the project. This token can be
    -- used to repeat the request.
    AssociateTeamMember -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | Whether the team member is allowed to use an SSH public\/private key
    -- pair to remotely access project resources, for example Amazon EC2
    -- instances.
    AssociateTeamMember -> Maybe Bool
remoteAccessAllowed :: Prelude.Maybe Prelude.Bool,
    -- | The ID of the project to which you will add the IAM user.
    AssociateTeamMember -> Text
projectId :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) for the IAM user you want to add to the
    -- AWS CodeStar project.
    AssociateTeamMember -> Text
userArn :: Prelude.Text,
    -- | The AWS CodeStar project role that will apply to this user. This role
    -- determines what actions a user can take in an AWS CodeStar project.
    AssociateTeamMember -> Text
projectRole :: Prelude.Text
  }
  deriving (AssociateTeamMember -> AssociateTeamMember -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssociateTeamMember -> AssociateTeamMember -> Bool
$c/= :: AssociateTeamMember -> AssociateTeamMember -> Bool
== :: AssociateTeamMember -> AssociateTeamMember -> Bool
$c== :: AssociateTeamMember -> AssociateTeamMember -> Bool
Prelude.Eq, ReadPrec [AssociateTeamMember]
ReadPrec AssociateTeamMember
Int -> ReadS AssociateTeamMember
ReadS [AssociateTeamMember]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssociateTeamMember]
$creadListPrec :: ReadPrec [AssociateTeamMember]
readPrec :: ReadPrec AssociateTeamMember
$creadPrec :: ReadPrec AssociateTeamMember
readList :: ReadS [AssociateTeamMember]
$creadList :: ReadS [AssociateTeamMember]
readsPrec :: Int -> ReadS AssociateTeamMember
$creadsPrec :: Int -> ReadS AssociateTeamMember
Prelude.Read, Int -> AssociateTeamMember -> ShowS
[AssociateTeamMember] -> ShowS
AssociateTeamMember -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssociateTeamMember] -> ShowS
$cshowList :: [AssociateTeamMember] -> ShowS
show :: AssociateTeamMember -> String
$cshow :: AssociateTeamMember -> String
showsPrec :: Int -> AssociateTeamMember -> ShowS
$cshowsPrec :: Int -> AssociateTeamMember -> ShowS
Prelude.Show, forall x. Rep AssociateTeamMember x -> AssociateTeamMember
forall x. AssociateTeamMember -> Rep AssociateTeamMember x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AssociateTeamMember x -> AssociateTeamMember
$cfrom :: forall x. AssociateTeamMember -> Rep AssociateTeamMember x
Prelude.Generic)

-- |
-- Create a value of 'AssociateTeamMember' 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:
--
-- 'clientRequestToken', 'associateTeamMember_clientRequestToken' - A user- or system-generated token that identifies the entity that
-- requested the team member association to the project. This token can be
-- used to repeat the request.
--
-- 'remoteAccessAllowed', 'associateTeamMember_remoteAccessAllowed' - Whether the team member is allowed to use an SSH public\/private key
-- pair to remotely access project resources, for example Amazon EC2
-- instances.
--
-- 'projectId', 'associateTeamMember_projectId' - The ID of the project to which you will add the IAM user.
--
-- 'userArn', 'associateTeamMember_userArn' - The Amazon Resource Name (ARN) for the IAM user you want to add to the
-- AWS CodeStar project.
--
-- 'projectRole', 'associateTeamMember_projectRole' - The AWS CodeStar project role that will apply to this user. This role
-- determines what actions a user can take in an AWS CodeStar project.
newAssociateTeamMember ::
  -- | 'projectId'
  Prelude.Text ->
  -- | 'userArn'
  Prelude.Text ->
  -- | 'projectRole'
  Prelude.Text ->
  AssociateTeamMember
newAssociateTeamMember :: Text -> Text -> Text -> AssociateTeamMember
newAssociateTeamMember
  Text
pProjectId_
  Text
pUserArn_
  Text
pProjectRole_ =
    AssociateTeamMember'
      { $sel:clientRequestToken:AssociateTeamMember' :: Maybe Text
clientRequestToken =
          forall a. Maybe a
Prelude.Nothing,
        $sel:remoteAccessAllowed:AssociateTeamMember' :: Maybe Bool
remoteAccessAllowed = forall a. Maybe a
Prelude.Nothing,
        $sel:projectId:AssociateTeamMember' :: Text
projectId = Text
pProjectId_,
        $sel:userArn:AssociateTeamMember' :: Text
userArn = Text
pUserArn_,
        $sel:projectRole:AssociateTeamMember' :: Text
projectRole = Text
pProjectRole_
      }

-- | A user- or system-generated token that identifies the entity that
-- requested the team member association to the project. This token can be
-- used to repeat the request.
associateTeamMember_clientRequestToken :: Lens.Lens' AssociateTeamMember (Prelude.Maybe Prelude.Text)
associateTeamMember_clientRequestToken :: Lens' AssociateTeamMember (Maybe Text)
associateTeamMember_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateTeamMember' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:AssociateTeamMember' :: AssociateTeamMember -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: AssociateTeamMember
s@AssociateTeamMember' {} Maybe Text
a -> AssociateTeamMember
s {$sel:clientRequestToken:AssociateTeamMember' :: Maybe Text
clientRequestToken = Maybe Text
a} :: AssociateTeamMember)

-- | Whether the team member is allowed to use an SSH public\/private key
-- pair to remotely access project resources, for example Amazon EC2
-- instances.
associateTeamMember_remoteAccessAllowed :: Lens.Lens' AssociateTeamMember (Prelude.Maybe Prelude.Bool)
associateTeamMember_remoteAccessAllowed :: Lens' AssociateTeamMember (Maybe Bool)
associateTeamMember_remoteAccessAllowed = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateTeamMember' {Maybe Bool
remoteAccessAllowed :: Maybe Bool
$sel:remoteAccessAllowed:AssociateTeamMember' :: AssociateTeamMember -> Maybe Bool
remoteAccessAllowed} -> Maybe Bool
remoteAccessAllowed) (\s :: AssociateTeamMember
s@AssociateTeamMember' {} Maybe Bool
a -> AssociateTeamMember
s {$sel:remoteAccessAllowed:AssociateTeamMember' :: Maybe Bool
remoteAccessAllowed = Maybe Bool
a} :: AssociateTeamMember)

-- | The ID of the project to which you will add the IAM user.
associateTeamMember_projectId :: Lens.Lens' AssociateTeamMember Prelude.Text
associateTeamMember_projectId :: Lens' AssociateTeamMember Text
associateTeamMember_projectId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateTeamMember' {Text
projectId :: Text
$sel:projectId:AssociateTeamMember' :: AssociateTeamMember -> Text
projectId} -> Text
projectId) (\s :: AssociateTeamMember
s@AssociateTeamMember' {} Text
a -> AssociateTeamMember
s {$sel:projectId:AssociateTeamMember' :: Text
projectId = Text
a} :: AssociateTeamMember)

-- | The Amazon Resource Name (ARN) for the IAM user you want to add to the
-- AWS CodeStar project.
associateTeamMember_userArn :: Lens.Lens' AssociateTeamMember Prelude.Text
associateTeamMember_userArn :: Lens' AssociateTeamMember Text
associateTeamMember_userArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateTeamMember' {Text
userArn :: Text
$sel:userArn:AssociateTeamMember' :: AssociateTeamMember -> Text
userArn} -> Text
userArn) (\s :: AssociateTeamMember
s@AssociateTeamMember' {} Text
a -> AssociateTeamMember
s {$sel:userArn:AssociateTeamMember' :: Text
userArn = Text
a} :: AssociateTeamMember)

-- | The AWS CodeStar project role that will apply to this user. This role
-- determines what actions a user can take in an AWS CodeStar project.
associateTeamMember_projectRole :: Lens.Lens' AssociateTeamMember Prelude.Text
associateTeamMember_projectRole :: Lens' AssociateTeamMember Text
associateTeamMember_projectRole = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateTeamMember' {Text
projectRole :: Text
$sel:projectRole:AssociateTeamMember' :: AssociateTeamMember -> Text
projectRole} -> Text
projectRole) (\s :: AssociateTeamMember
s@AssociateTeamMember' {} Text
a -> AssociateTeamMember
s {$sel:projectRole:AssociateTeamMember' :: Text
projectRole = Text
a} :: AssociateTeamMember)

instance Core.AWSRequest AssociateTeamMember where
  type
    AWSResponse AssociateTeamMember =
      AssociateTeamMemberResponse
  request :: (Service -> Service)
-> AssociateTeamMember -> Request AssociateTeamMember
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 AssociateTeamMember
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse AssociateTeamMember)))
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 -> AssociateTeamMemberResponse
AssociateTeamMemberResponse'
            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
"clientRequestToken")
            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 AssociateTeamMember where
  hashWithSalt :: Int -> AssociateTeamMember -> Int
hashWithSalt Int
_salt AssociateTeamMember' {Maybe Bool
Maybe Text
Text
projectRole :: Text
userArn :: Text
projectId :: Text
remoteAccessAllowed :: Maybe Bool
clientRequestToken :: Maybe Text
$sel:projectRole:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:userArn:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:projectId:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:remoteAccessAllowed:AssociateTeamMember' :: AssociateTeamMember -> Maybe Bool
$sel:clientRequestToken:AssociateTeamMember' :: AssociateTeamMember -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
remoteAccessAllowed
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
projectId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
userArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
projectRole

instance Prelude.NFData AssociateTeamMember where
  rnf :: AssociateTeamMember -> ()
rnf AssociateTeamMember' {Maybe Bool
Maybe Text
Text
projectRole :: Text
userArn :: Text
projectId :: Text
remoteAccessAllowed :: Maybe Bool
clientRequestToken :: Maybe Text
$sel:projectRole:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:userArn:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:projectId:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:remoteAccessAllowed:AssociateTeamMember' :: AssociateTeamMember -> Maybe Bool
$sel:clientRequestToken:AssociateTeamMember' :: AssociateTeamMember -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
remoteAccessAllowed
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
projectId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
userArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
projectRole

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

instance Data.ToJSON AssociateTeamMember where
  toJSON :: AssociateTeamMember -> Value
toJSON AssociateTeamMember' {Maybe Bool
Maybe Text
Text
projectRole :: Text
userArn :: Text
projectId :: Text
remoteAccessAllowed :: Maybe Bool
clientRequestToken :: Maybe Text
$sel:projectRole:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:userArn:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:projectId:AssociateTeamMember' :: AssociateTeamMember -> Text
$sel:remoteAccessAllowed:AssociateTeamMember' :: AssociateTeamMember -> Maybe Bool
$sel:clientRequestToken:AssociateTeamMember' :: AssociateTeamMember -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"clientRequestToken" 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
clientRequestToken,
            (Key
"remoteAccessAllowed" 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 Bool
remoteAccessAllowed,
            forall a. a -> Maybe a
Prelude.Just (Key
"projectId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
projectId),
            forall a. a -> Maybe a
Prelude.Just (Key
"userArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
userArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"projectRole" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
projectRole)
          ]
      )

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

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

-- | /See:/ 'newAssociateTeamMemberResponse' smart constructor.
data AssociateTeamMemberResponse = AssociateTeamMemberResponse'
  { -- | The user- or system-generated token from the initial request that can be
    -- used to repeat the request.
    AssociateTeamMemberResponse -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    AssociateTeamMemberResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (AssociateTeamMemberResponse -> AssociateTeamMemberResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AssociateTeamMemberResponse -> AssociateTeamMemberResponse -> Bool
$c/= :: AssociateTeamMemberResponse -> AssociateTeamMemberResponse -> Bool
== :: AssociateTeamMemberResponse -> AssociateTeamMemberResponse -> Bool
$c== :: AssociateTeamMemberResponse -> AssociateTeamMemberResponse -> Bool
Prelude.Eq, ReadPrec [AssociateTeamMemberResponse]
ReadPrec AssociateTeamMemberResponse
Int -> ReadS AssociateTeamMemberResponse
ReadS [AssociateTeamMemberResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AssociateTeamMemberResponse]
$creadListPrec :: ReadPrec [AssociateTeamMemberResponse]
readPrec :: ReadPrec AssociateTeamMemberResponse
$creadPrec :: ReadPrec AssociateTeamMemberResponse
readList :: ReadS [AssociateTeamMemberResponse]
$creadList :: ReadS [AssociateTeamMemberResponse]
readsPrec :: Int -> ReadS AssociateTeamMemberResponse
$creadsPrec :: Int -> ReadS AssociateTeamMemberResponse
Prelude.Read, Int -> AssociateTeamMemberResponse -> ShowS
[AssociateTeamMemberResponse] -> ShowS
AssociateTeamMemberResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AssociateTeamMemberResponse] -> ShowS
$cshowList :: [AssociateTeamMemberResponse] -> ShowS
show :: AssociateTeamMemberResponse -> String
$cshow :: AssociateTeamMemberResponse -> String
showsPrec :: Int -> AssociateTeamMemberResponse -> ShowS
$cshowsPrec :: Int -> AssociateTeamMemberResponse -> ShowS
Prelude.Show, forall x.
Rep AssociateTeamMemberResponse x -> AssociateTeamMemberResponse
forall x.
AssociateTeamMemberResponse -> Rep AssociateTeamMemberResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AssociateTeamMemberResponse x -> AssociateTeamMemberResponse
$cfrom :: forall x.
AssociateTeamMemberResponse -> Rep AssociateTeamMemberResponse x
Prelude.Generic)

-- |
-- Create a value of 'AssociateTeamMemberResponse' 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:
--
-- 'clientRequestToken', 'associateTeamMemberResponse_clientRequestToken' - The user- or system-generated token from the initial request that can be
-- used to repeat the request.
--
-- 'httpStatus', 'associateTeamMemberResponse_httpStatus' - The response's http status code.
newAssociateTeamMemberResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  AssociateTeamMemberResponse
newAssociateTeamMemberResponse :: Int -> AssociateTeamMemberResponse
newAssociateTeamMemberResponse Int
pHttpStatus_ =
  AssociateTeamMemberResponse'
    { $sel:clientRequestToken:AssociateTeamMemberResponse' :: Maybe Text
clientRequestToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:AssociateTeamMemberResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The user- or system-generated token from the initial request that can be
-- used to repeat the request.
associateTeamMemberResponse_clientRequestToken :: Lens.Lens' AssociateTeamMemberResponse (Prelude.Maybe Prelude.Text)
associateTeamMemberResponse_clientRequestToken :: Lens' AssociateTeamMemberResponse (Maybe Text)
associateTeamMemberResponse_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AssociateTeamMemberResponse' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:AssociateTeamMemberResponse' :: AssociateTeamMemberResponse -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: AssociateTeamMemberResponse
s@AssociateTeamMemberResponse' {} Maybe Text
a -> AssociateTeamMemberResponse
s {$sel:clientRequestToken:AssociateTeamMemberResponse' :: Maybe Text
clientRequestToken = Maybe Text
a} :: AssociateTeamMemberResponse)

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

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