{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.MacieV2.Types.UserIdentity
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.MacieV2.Types.UserIdentity where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.MacieV2.Types.AssumedRole
import Amazonka.MacieV2.Types.AwsAccount
import Amazonka.MacieV2.Types.AwsService
import Amazonka.MacieV2.Types.FederatedUser
import Amazonka.MacieV2.Types.IamUser
import Amazonka.MacieV2.Types.UserIdentityRoot
import Amazonka.MacieV2.Types.UserIdentityType
import qualified Amazonka.Prelude as Prelude

-- | Provides information about the type and other characteristics of an
-- entity that performed an action on an affected resource.
--
-- /See:/ 'newUserIdentity' smart constructor.
data UserIdentity = UserIdentity'
  { -- | If the action was performed with temporary security credentials that
    -- were obtained using the AssumeRole operation of the Security Token
    -- Service (STS) API, the identifiers, session context, and other details
    -- about the identity.
    UserIdentity -> Maybe AssumedRole
assumedRole :: Prelude.Maybe AssumedRole,
    -- | If the action was performed using the credentials for another Amazon Web
    -- Services account, the details of that account.
    UserIdentity -> Maybe AwsAccount
awsAccount :: Prelude.Maybe AwsAccount,
    -- | If the action was performed by an Amazon Web Services account that
    -- belongs to an Amazon Web Service, the name of the service.
    UserIdentity -> Maybe AwsService
awsService :: Prelude.Maybe AwsService,
    -- | If the action was performed with temporary security credentials that
    -- were obtained using the GetFederationToken operation of the Security
    -- Token Service (STS) API, the identifiers, session context, and other
    -- details about the identity.
    UserIdentity -> Maybe FederatedUser
federatedUser :: Prelude.Maybe FederatedUser,
    -- | If the action was performed using the credentials for an Identity and
    -- Access Management (IAM) user, the name and other details about the user.
    UserIdentity -> Maybe IamUser
iamUser :: Prelude.Maybe IamUser,
    -- | If the action was performed using the credentials for your Amazon Web
    -- Services account, the details of your account.
    UserIdentity -> Maybe UserIdentityRoot
root :: Prelude.Maybe UserIdentityRoot,
    -- | The type of entity that performed the action.
    UserIdentity -> Maybe UserIdentityType
type' :: Prelude.Maybe UserIdentityType
  }
  deriving (UserIdentity -> UserIdentity -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserIdentity -> UserIdentity -> Bool
$c/= :: UserIdentity -> UserIdentity -> Bool
== :: UserIdentity -> UserIdentity -> Bool
$c== :: UserIdentity -> UserIdentity -> Bool
Prelude.Eq, ReadPrec [UserIdentity]
ReadPrec UserIdentity
Int -> ReadS UserIdentity
ReadS [UserIdentity]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [UserIdentity]
$creadListPrec :: ReadPrec [UserIdentity]
readPrec :: ReadPrec UserIdentity
$creadPrec :: ReadPrec UserIdentity
readList :: ReadS [UserIdentity]
$creadList :: ReadS [UserIdentity]
readsPrec :: Int -> ReadS UserIdentity
$creadsPrec :: Int -> ReadS UserIdentity
Prelude.Read, Int -> UserIdentity -> ShowS
[UserIdentity] -> ShowS
UserIdentity -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserIdentity] -> ShowS
$cshowList :: [UserIdentity] -> ShowS
show :: UserIdentity -> String
$cshow :: UserIdentity -> String
showsPrec :: Int -> UserIdentity -> ShowS
$cshowsPrec :: Int -> UserIdentity -> ShowS
Prelude.Show, forall x. Rep UserIdentity x -> UserIdentity
forall x. UserIdentity -> Rep UserIdentity x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep UserIdentity x -> UserIdentity
$cfrom :: forall x. UserIdentity -> Rep UserIdentity x
Prelude.Generic)

-- |
-- Create a value of 'UserIdentity' 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:
--
-- 'assumedRole', 'userIdentity_assumedRole' - If the action was performed with temporary security credentials that
-- were obtained using the AssumeRole operation of the Security Token
-- Service (STS) API, the identifiers, session context, and other details
-- about the identity.
--
-- 'awsAccount', 'userIdentity_awsAccount' - If the action was performed using the credentials for another Amazon Web
-- Services account, the details of that account.
--
-- 'awsService', 'userIdentity_awsService' - If the action was performed by an Amazon Web Services account that
-- belongs to an Amazon Web Service, the name of the service.
--
-- 'federatedUser', 'userIdentity_federatedUser' - If the action was performed with temporary security credentials that
-- were obtained using the GetFederationToken operation of the Security
-- Token Service (STS) API, the identifiers, session context, and other
-- details about the identity.
--
-- 'iamUser', 'userIdentity_iamUser' - If the action was performed using the credentials for an Identity and
-- Access Management (IAM) user, the name and other details about the user.
--
-- 'root', 'userIdentity_root' - If the action was performed using the credentials for your Amazon Web
-- Services account, the details of your account.
--
-- 'type'', 'userIdentity_type' - The type of entity that performed the action.
newUserIdentity ::
  UserIdentity
newUserIdentity :: UserIdentity
newUserIdentity =
  UserIdentity'
    { $sel:assumedRole:UserIdentity' :: Maybe AssumedRole
assumedRole = forall a. Maybe a
Prelude.Nothing,
      $sel:awsAccount:UserIdentity' :: Maybe AwsAccount
awsAccount = forall a. Maybe a
Prelude.Nothing,
      $sel:awsService:UserIdentity' :: Maybe AwsService
awsService = forall a. Maybe a
Prelude.Nothing,
      $sel:federatedUser:UserIdentity' :: Maybe FederatedUser
federatedUser = forall a. Maybe a
Prelude.Nothing,
      $sel:iamUser:UserIdentity' :: Maybe IamUser
iamUser = forall a. Maybe a
Prelude.Nothing,
      $sel:root:UserIdentity' :: Maybe UserIdentityRoot
root = forall a. Maybe a
Prelude.Nothing,
      $sel:type':UserIdentity' :: Maybe UserIdentityType
type' = forall a. Maybe a
Prelude.Nothing
    }

-- | If the action was performed with temporary security credentials that
-- were obtained using the AssumeRole operation of the Security Token
-- Service (STS) API, the identifiers, session context, and other details
-- about the identity.
userIdentity_assumedRole :: Lens.Lens' UserIdentity (Prelude.Maybe AssumedRole)
userIdentity_assumedRole :: Lens' UserIdentity (Maybe AssumedRole)
userIdentity_assumedRole = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UserIdentity' {Maybe AssumedRole
assumedRole :: Maybe AssumedRole
$sel:assumedRole:UserIdentity' :: UserIdentity -> Maybe AssumedRole
assumedRole} -> Maybe AssumedRole
assumedRole) (\s :: UserIdentity
s@UserIdentity' {} Maybe AssumedRole
a -> UserIdentity
s {$sel:assumedRole:UserIdentity' :: Maybe AssumedRole
assumedRole = Maybe AssumedRole
a} :: UserIdentity)

-- | If the action was performed using the credentials for another Amazon Web
-- Services account, the details of that account.
userIdentity_awsAccount :: Lens.Lens' UserIdentity (Prelude.Maybe AwsAccount)
userIdentity_awsAccount :: Lens' UserIdentity (Maybe AwsAccount)
userIdentity_awsAccount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UserIdentity' {Maybe AwsAccount
awsAccount :: Maybe AwsAccount
$sel:awsAccount:UserIdentity' :: UserIdentity -> Maybe AwsAccount
awsAccount} -> Maybe AwsAccount
awsAccount) (\s :: UserIdentity
s@UserIdentity' {} Maybe AwsAccount
a -> UserIdentity
s {$sel:awsAccount:UserIdentity' :: Maybe AwsAccount
awsAccount = Maybe AwsAccount
a} :: UserIdentity)

-- | If the action was performed by an Amazon Web Services account that
-- belongs to an Amazon Web Service, the name of the service.
userIdentity_awsService :: Lens.Lens' UserIdentity (Prelude.Maybe AwsService)
userIdentity_awsService :: Lens' UserIdentity (Maybe AwsService)
userIdentity_awsService = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UserIdentity' {Maybe AwsService
awsService :: Maybe AwsService
$sel:awsService:UserIdentity' :: UserIdentity -> Maybe AwsService
awsService} -> Maybe AwsService
awsService) (\s :: UserIdentity
s@UserIdentity' {} Maybe AwsService
a -> UserIdentity
s {$sel:awsService:UserIdentity' :: Maybe AwsService
awsService = Maybe AwsService
a} :: UserIdentity)

-- | If the action was performed with temporary security credentials that
-- were obtained using the GetFederationToken operation of the Security
-- Token Service (STS) API, the identifiers, session context, and other
-- details about the identity.
userIdentity_federatedUser :: Lens.Lens' UserIdentity (Prelude.Maybe FederatedUser)
userIdentity_federatedUser :: Lens' UserIdentity (Maybe FederatedUser)
userIdentity_federatedUser = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UserIdentity' {Maybe FederatedUser
federatedUser :: Maybe FederatedUser
$sel:federatedUser:UserIdentity' :: UserIdentity -> Maybe FederatedUser
federatedUser} -> Maybe FederatedUser
federatedUser) (\s :: UserIdentity
s@UserIdentity' {} Maybe FederatedUser
a -> UserIdentity
s {$sel:federatedUser:UserIdentity' :: Maybe FederatedUser
federatedUser = Maybe FederatedUser
a} :: UserIdentity)

-- | If the action was performed using the credentials for an Identity and
-- Access Management (IAM) user, the name and other details about the user.
userIdentity_iamUser :: Lens.Lens' UserIdentity (Prelude.Maybe IamUser)
userIdentity_iamUser :: Lens' UserIdentity (Maybe IamUser)
userIdentity_iamUser = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UserIdentity' {Maybe IamUser
iamUser :: Maybe IamUser
$sel:iamUser:UserIdentity' :: UserIdentity -> Maybe IamUser
iamUser} -> Maybe IamUser
iamUser) (\s :: UserIdentity
s@UserIdentity' {} Maybe IamUser
a -> UserIdentity
s {$sel:iamUser:UserIdentity' :: Maybe IamUser
iamUser = Maybe IamUser
a} :: UserIdentity)

-- | If the action was performed using the credentials for your Amazon Web
-- Services account, the details of your account.
userIdentity_root :: Lens.Lens' UserIdentity (Prelude.Maybe UserIdentityRoot)
userIdentity_root :: Lens' UserIdentity (Maybe UserIdentityRoot)
userIdentity_root = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UserIdentity' {Maybe UserIdentityRoot
root :: Maybe UserIdentityRoot
$sel:root:UserIdentity' :: UserIdentity -> Maybe UserIdentityRoot
root} -> Maybe UserIdentityRoot
root) (\s :: UserIdentity
s@UserIdentity' {} Maybe UserIdentityRoot
a -> UserIdentity
s {$sel:root:UserIdentity' :: Maybe UserIdentityRoot
root = Maybe UserIdentityRoot
a} :: UserIdentity)

-- | The type of entity that performed the action.
userIdentity_type :: Lens.Lens' UserIdentity (Prelude.Maybe UserIdentityType)
userIdentity_type :: Lens' UserIdentity (Maybe UserIdentityType)
userIdentity_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\UserIdentity' {Maybe UserIdentityType
type' :: Maybe UserIdentityType
$sel:type':UserIdentity' :: UserIdentity -> Maybe UserIdentityType
type'} -> Maybe UserIdentityType
type') (\s :: UserIdentity
s@UserIdentity' {} Maybe UserIdentityType
a -> UserIdentity
s {$sel:type':UserIdentity' :: Maybe UserIdentityType
type' = Maybe UserIdentityType
a} :: UserIdentity)

instance Data.FromJSON UserIdentity where
  parseJSON :: Value -> Parser UserIdentity
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"UserIdentity"
      ( \Object
x ->
          Maybe AssumedRole
-> Maybe AwsAccount
-> Maybe AwsService
-> Maybe FederatedUser
-> Maybe IamUser
-> Maybe UserIdentityRoot
-> Maybe UserIdentityType
-> UserIdentity
UserIdentity'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"assumedRole")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"awsAccount")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"awsService")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"federatedUser")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"iamUser")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"root")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"type")
      )

instance Prelude.Hashable UserIdentity where
  hashWithSalt :: Int -> UserIdentity -> Int
hashWithSalt Int
_salt UserIdentity' {Maybe AwsAccount
Maybe AwsService
Maybe IamUser
Maybe FederatedUser
Maybe AssumedRole
Maybe UserIdentityRoot
Maybe UserIdentityType
type' :: Maybe UserIdentityType
root :: Maybe UserIdentityRoot
iamUser :: Maybe IamUser
federatedUser :: Maybe FederatedUser
awsService :: Maybe AwsService
awsAccount :: Maybe AwsAccount
assumedRole :: Maybe AssumedRole
$sel:type':UserIdentity' :: UserIdentity -> Maybe UserIdentityType
$sel:root:UserIdentity' :: UserIdentity -> Maybe UserIdentityRoot
$sel:iamUser:UserIdentity' :: UserIdentity -> Maybe IamUser
$sel:federatedUser:UserIdentity' :: UserIdentity -> Maybe FederatedUser
$sel:awsService:UserIdentity' :: UserIdentity -> Maybe AwsService
$sel:awsAccount:UserIdentity' :: UserIdentity -> Maybe AwsAccount
$sel:assumedRole:UserIdentity' :: UserIdentity -> Maybe AssumedRole
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AssumedRole
assumedRole
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AwsAccount
awsAccount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AwsService
awsService
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FederatedUser
federatedUser
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe IamUser
iamUser
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UserIdentityRoot
root
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe UserIdentityType
type'

instance Prelude.NFData UserIdentity where
  rnf :: UserIdentity -> ()
rnf UserIdentity' {Maybe AwsAccount
Maybe AwsService
Maybe IamUser
Maybe FederatedUser
Maybe AssumedRole
Maybe UserIdentityRoot
Maybe UserIdentityType
type' :: Maybe UserIdentityType
root :: Maybe UserIdentityRoot
iamUser :: Maybe IamUser
federatedUser :: Maybe FederatedUser
awsService :: Maybe AwsService
awsAccount :: Maybe AwsAccount
assumedRole :: Maybe AssumedRole
$sel:type':UserIdentity' :: UserIdentity -> Maybe UserIdentityType
$sel:root:UserIdentity' :: UserIdentity -> Maybe UserIdentityRoot
$sel:iamUser:UserIdentity' :: UserIdentity -> Maybe IamUser
$sel:federatedUser:UserIdentity' :: UserIdentity -> Maybe FederatedUser
$sel:awsService:UserIdentity' :: UserIdentity -> Maybe AwsService
$sel:awsAccount:UserIdentity' :: UserIdentity -> Maybe AwsAccount
$sel:assumedRole:UserIdentity' :: UserIdentity -> Maybe AssumedRole
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe AssumedRole
assumedRole
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AwsAccount
awsAccount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AwsService
awsService
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FederatedUser
federatedUser
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe IamUser
iamUser
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UserIdentityRoot
root
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe UserIdentityType
type'