{-# 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.Detective.CreateMembers
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- @CreateMembers@ is used to send invitations to accounts. For the
-- organization behavior graph, the Detective administrator account uses
-- @CreateMembers@ to enable organization accounts as member accounts.
--
-- For invited accounts, @CreateMembers@ sends a request to invite the
-- specified Amazon Web Services accounts to be member accounts in the
-- behavior graph. This operation can only be called by the administrator
-- account for a behavior graph.
--
-- @CreateMembers@ verifies the accounts and then invites the verified
-- accounts. The administrator can optionally specify to not send
-- invitation emails to the member accounts. This would be used when the
-- administrator manages their member accounts centrally.
--
-- For organization accounts in the organization behavior graph,
-- @CreateMembers@ attempts to enable the accounts. The organization
-- accounts do not receive invitations.
--
-- The request provides the behavior graph ARN and the list of accounts to
-- invite or to enable.
--
-- The response separates the requested accounts into two lists:
--
-- -   The accounts that @CreateMembers@ was able to process. For invited
--     accounts, includes member accounts that are being verified, that
--     have passed verification and are to be invited, and that have failed
--     verification. For organization accounts in the organization behavior
--     graph, includes accounts that can be enabled and that cannot be
--     enabled.
--
-- -   The accounts that @CreateMembers@ was unable to process. This list
--     includes accounts that were already invited to be member accounts in
--     the behavior graph.
module Amazonka.Detective.CreateMembers
  ( -- * Creating a Request
    CreateMembers (..),
    newCreateMembers,

    -- * Request Lenses
    createMembers_disableEmailNotification,
    createMembers_message,
    createMembers_graphArn,
    createMembers_accounts,

    -- * Destructuring the Response
    CreateMembersResponse (..),
    newCreateMembersResponse,

    -- * Response Lenses
    createMembersResponse_members,
    createMembersResponse_unprocessedAccounts,
    createMembersResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateMembers' smart constructor.
data CreateMembers = CreateMembers'
  { -- | if set to @true@, then the invited accounts do not receive email
    -- notifications. By default, this is set to @false@, and the invited
    -- accounts receive email notifications.
    --
    -- Organization accounts in the organization behavior graph do not receive
    -- email notifications.
    CreateMembers -> Maybe Bool
disableEmailNotification :: Prelude.Maybe Prelude.Bool,
    -- | Customized message text to include in the invitation email message to
    -- the invited member accounts.
    CreateMembers -> Maybe Text
message :: Prelude.Maybe Prelude.Text,
    -- | The ARN of the behavior graph.
    CreateMembers -> Text
graphArn :: Prelude.Text,
    -- | The list of Amazon Web Services accounts to invite or to enable. You can
    -- invite or enable up to 50 accounts at a time. For each invited account,
    -- the account list contains the account identifier and the Amazon Web
    -- Services account root user email address. For organization accounts in
    -- the organization behavior graph, the email address is not required.
    CreateMembers -> NonEmpty Account
accounts :: Prelude.NonEmpty Account
  }
  deriving (CreateMembers -> CreateMembers -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateMembers -> CreateMembers -> Bool
$c/= :: CreateMembers -> CreateMembers -> Bool
== :: CreateMembers -> CreateMembers -> Bool
$c== :: CreateMembers -> CreateMembers -> Bool
Prelude.Eq, ReadPrec [CreateMembers]
ReadPrec CreateMembers
Int -> ReadS CreateMembers
ReadS [CreateMembers]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateMembers]
$creadListPrec :: ReadPrec [CreateMembers]
readPrec :: ReadPrec CreateMembers
$creadPrec :: ReadPrec CreateMembers
readList :: ReadS [CreateMembers]
$creadList :: ReadS [CreateMembers]
readsPrec :: Int -> ReadS CreateMembers
$creadsPrec :: Int -> ReadS CreateMembers
Prelude.Read, Int -> CreateMembers -> ShowS
[CreateMembers] -> ShowS
CreateMembers -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateMembers] -> ShowS
$cshowList :: [CreateMembers] -> ShowS
show :: CreateMembers -> String
$cshow :: CreateMembers -> String
showsPrec :: Int -> CreateMembers -> ShowS
$cshowsPrec :: Int -> CreateMembers -> ShowS
Prelude.Show, forall x. Rep CreateMembers x -> CreateMembers
forall x. CreateMembers -> Rep CreateMembers x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateMembers x -> CreateMembers
$cfrom :: forall x. CreateMembers -> Rep CreateMembers x
Prelude.Generic)

-- |
-- Create a value of 'CreateMembers' 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:
--
-- 'disableEmailNotification', 'createMembers_disableEmailNotification' - if set to @true@, then the invited accounts do not receive email
-- notifications. By default, this is set to @false@, and the invited
-- accounts receive email notifications.
--
-- Organization accounts in the organization behavior graph do not receive
-- email notifications.
--
-- 'message', 'createMembers_message' - Customized message text to include in the invitation email message to
-- the invited member accounts.
--
-- 'graphArn', 'createMembers_graphArn' - The ARN of the behavior graph.
--
-- 'accounts', 'createMembers_accounts' - The list of Amazon Web Services accounts to invite or to enable. You can
-- invite or enable up to 50 accounts at a time. For each invited account,
-- the account list contains the account identifier and the Amazon Web
-- Services account root user email address. For organization accounts in
-- the organization behavior graph, the email address is not required.
newCreateMembers ::
  -- | 'graphArn'
  Prelude.Text ->
  -- | 'accounts'
  Prelude.NonEmpty Account ->
  CreateMembers
newCreateMembers :: Text -> NonEmpty Account -> CreateMembers
newCreateMembers Text
pGraphArn_ NonEmpty Account
pAccounts_ =
  CreateMembers'
    { $sel:disableEmailNotification:CreateMembers' :: Maybe Bool
disableEmailNotification =
        forall a. Maybe a
Prelude.Nothing,
      $sel:message:CreateMembers' :: Maybe Text
message = forall a. Maybe a
Prelude.Nothing,
      $sel:graphArn:CreateMembers' :: Text
graphArn = Text
pGraphArn_,
      $sel:accounts:CreateMembers' :: NonEmpty Account
accounts = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Account
pAccounts_
    }

-- | if set to @true@, then the invited accounts do not receive email
-- notifications. By default, this is set to @false@, and the invited
-- accounts receive email notifications.
--
-- Organization accounts in the organization behavior graph do not receive
-- email notifications.
createMembers_disableEmailNotification :: Lens.Lens' CreateMembers (Prelude.Maybe Prelude.Bool)
createMembers_disableEmailNotification :: Lens' CreateMembers (Maybe Bool)
createMembers_disableEmailNotification = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMembers' {Maybe Bool
disableEmailNotification :: Maybe Bool
$sel:disableEmailNotification:CreateMembers' :: CreateMembers -> Maybe Bool
disableEmailNotification} -> Maybe Bool
disableEmailNotification) (\s :: CreateMembers
s@CreateMembers' {} Maybe Bool
a -> CreateMembers
s {$sel:disableEmailNotification:CreateMembers' :: Maybe Bool
disableEmailNotification = Maybe Bool
a} :: CreateMembers)

-- | Customized message text to include in the invitation email message to
-- the invited member accounts.
createMembers_message :: Lens.Lens' CreateMembers (Prelude.Maybe Prelude.Text)
createMembers_message :: Lens' CreateMembers (Maybe Text)
createMembers_message = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMembers' {Maybe Text
message :: Maybe Text
$sel:message:CreateMembers' :: CreateMembers -> Maybe Text
message} -> Maybe Text
message) (\s :: CreateMembers
s@CreateMembers' {} Maybe Text
a -> CreateMembers
s {$sel:message:CreateMembers' :: Maybe Text
message = Maybe Text
a} :: CreateMembers)

-- | The ARN of the behavior graph.
createMembers_graphArn :: Lens.Lens' CreateMembers Prelude.Text
createMembers_graphArn :: Lens' CreateMembers Text
createMembers_graphArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMembers' {Text
graphArn :: Text
$sel:graphArn:CreateMembers' :: CreateMembers -> Text
graphArn} -> Text
graphArn) (\s :: CreateMembers
s@CreateMembers' {} Text
a -> CreateMembers
s {$sel:graphArn:CreateMembers' :: Text
graphArn = Text
a} :: CreateMembers)

-- | The list of Amazon Web Services accounts to invite or to enable. You can
-- invite or enable up to 50 accounts at a time. For each invited account,
-- the account list contains the account identifier and the Amazon Web
-- Services account root user email address. For organization accounts in
-- the organization behavior graph, the email address is not required.
createMembers_accounts :: Lens.Lens' CreateMembers (Prelude.NonEmpty Account)
createMembers_accounts :: Lens' CreateMembers (NonEmpty Account)
createMembers_accounts = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMembers' {NonEmpty Account
accounts :: NonEmpty Account
$sel:accounts:CreateMembers' :: CreateMembers -> NonEmpty Account
accounts} -> NonEmpty Account
accounts) (\s :: CreateMembers
s@CreateMembers' {} NonEmpty Account
a -> CreateMembers
s {$sel:accounts:CreateMembers' :: NonEmpty Account
accounts = NonEmpty Account
a} :: CreateMembers) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest CreateMembers where
  type
    AWSResponse CreateMembers =
      CreateMembersResponse
  request :: (Service -> Service) -> CreateMembers -> Request CreateMembers
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 CreateMembers
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CreateMembers)))
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 [MemberDetail]
-> Maybe [UnprocessedAccount] -> Int -> CreateMembersResponse
CreateMembersResponse'
            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
"Members" forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty)
            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
"UnprocessedAccounts"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            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 CreateMembers where
  hashWithSalt :: Int -> CreateMembers -> Int
hashWithSalt Int
_salt CreateMembers' {Maybe Bool
Maybe Text
NonEmpty Account
Text
accounts :: NonEmpty Account
graphArn :: Text
message :: Maybe Text
disableEmailNotification :: Maybe Bool
$sel:accounts:CreateMembers' :: CreateMembers -> NonEmpty Account
$sel:graphArn:CreateMembers' :: CreateMembers -> Text
$sel:message:CreateMembers' :: CreateMembers -> Maybe Text
$sel:disableEmailNotification:CreateMembers' :: CreateMembers -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
disableEmailNotification
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
message
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
graphArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Account
accounts

instance Prelude.NFData CreateMembers where
  rnf :: CreateMembers -> ()
rnf CreateMembers' {Maybe Bool
Maybe Text
NonEmpty Account
Text
accounts :: NonEmpty Account
graphArn :: Text
message :: Maybe Text
disableEmailNotification :: Maybe Bool
$sel:accounts:CreateMembers' :: CreateMembers -> NonEmpty Account
$sel:graphArn:CreateMembers' :: CreateMembers -> Text
$sel:message:CreateMembers' :: CreateMembers -> Maybe Text
$sel:disableEmailNotification:CreateMembers' :: CreateMembers -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
disableEmailNotification
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
message
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
graphArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Account
accounts

instance Data.ToHeaders CreateMembers where
  toHeaders :: CreateMembers -> 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 CreateMembers where
  toJSON :: CreateMembers -> Value
toJSON CreateMembers' {Maybe Bool
Maybe Text
NonEmpty Account
Text
accounts :: NonEmpty Account
graphArn :: Text
message :: Maybe Text
disableEmailNotification :: Maybe Bool
$sel:accounts:CreateMembers' :: CreateMembers -> NonEmpty Account
$sel:graphArn:CreateMembers' :: CreateMembers -> Text
$sel:message:CreateMembers' :: CreateMembers -> Maybe Text
$sel:disableEmailNotification:CreateMembers' :: CreateMembers -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DisableEmailNotification" 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
disableEmailNotification,
            (Key
"Message" 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
message,
            forall a. a -> Maybe a
Prelude.Just (Key
"GraphArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
graphArn),
            forall a. a -> Maybe a
Prelude.Just (Key
"Accounts" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Account
accounts)
          ]
      )

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

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

-- | /See:/ 'newCreateMembersResponse' smart constructor.
data CreateMembersResponse = CreateMembersResponse'
  { -- | The set of member account invitation or enablement requests that
    -- Detective was able to process. This includes accounts that are being
    -- verified, that failed verification, and that passed verification and are
    -- being sent an invitation or are being enabled.
    CreateMembersResponse -> Maybe [MemberDetail]
members :: Prelude.Maybe [MemberDetail],
    -- | The list of accounts for which Detective was unable to process the
    -- invitation or enablement request. For each account, the list provides
    -- the reason why the request could not be processed. The list includes
    -- accounts that are already member accounts in the behavior graph.
    CreateMembersResponse -> Maybe [UnprocessedAccount]
unprocessedAccounts :: Prelude.Maybe [UnprocessedAccount],
    -- | The response's http status code.
    CreateMembersResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateMembersResponse -> CreateMembersResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateMembersResponse -> CreateMembersResponse -> Bool
$c/= :: CreateMembersResponse -> CreateMembersResponse -> Bool
== :: CreateMembersResponse -> CreateMembersResponse -> Bool
$c== :: CreateMembersResponse -> CreateMembersResponse -> Bool
Prelude.Eq, ReadPrec [CreateMembersResponse]
ReadPrec CreateMembersResponse
Int -> ReadS CreateMembersResponse
ReadS [CreateMembersResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateMembersResponse]
$creadListPrec :: ReadPrec [CreateMembersResponse]
readPrec :: ReadPrec CreateMembersResponse
$creadPrec :: ReadPrec CreateMembersResponse
readList :: ReadS [CreateMembersResponse]
$creadList :: ReadS [CreateMembersResponse]
readsPrec :: Int -> ReadS CreateMembersResponse
$creadsPrec :: Int -> ReadS CreateMembersResponse
Prelude.Read, Int -> CreateMembersResponse -> ShowS
[CreateMembersResponse] -> ShowS
CreateMembersResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateMembersResponse] -> ShowS
$cshowList :: [CreateMembersResponse] -> ShowS
show :: CreateMembersResponse -> String
$cshow :: CreateMembersResponse -> String
showsPrec :: Int -> CreateMembersResponse -> ShowS
$cshowsPrec :: Int -> CreateMembersResponse -> ShowS
Prelude.Show, forall x. Rep CreateMembersResponse x -> CreateMembersResponse
forall x. CreateMembersResponse -> Rep CreateMembersResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateMembersResponse x -> CreateMembersResponse
$cfrom :: forall x. CreateMembersResponse -> Rep CreateMembersResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateMembersResponse' 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:
--
-- 'members', 'createMembersResponse_members' - The set of member account invitation or enablement requests that
-- Detective was able to process. This includes accounts that are being
-- verified, that failed verification, and that passed verification and are
-- being sent an invitation or are being enabled.
--
-- 'unprocessedAccounts', 'createMembersResponse_unprocessedAccounts' - The list of accounts for which Detective was unable to process the
-- invitation or enablement request. For each account, the list provides
-- the reason why the request could not be processed. The list includes
-- accounts that are already member accounts in the behavior graph.
--
-- 'httpStatus', 'createMembersResponse_httpStatus' - The response's http status code.
newCreateMembersResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateMembersResponse
newCreateMembersResponse :: Int -> CreateMembersResponse
newCreateMembersResponse Int
pHttpStatus_ =
  CreateMembersResponse'
    { $sel:members:CreateMembersResponse' :: Maybe [MemberDetail]
members = forall a. Maybe a
Prelude.Nothing,
      $sel:unprocessedAccounts:CreateMembersResponse' :: Maybe [UnprocessedAccount]
unprocessedAccounts = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateMembersResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The set of member account invitation or enablement requests that
-- Detective was able to process. This includes accounts that are being
-- verified, that failed verification, and that passed verification and are
-- being sent an invitation or are being enabled.
createMembersResponse_members :: Lens.Lens' CreateMembersResponse (Prelude.Maybe [MemberDetail])
createMembersResponse_members :: Lens' CreateMembersResponse (Maybe [MemberDetail])
createMembersResponse_members = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMembersResponse' {Maybe [MemberDetail]
members :: Maybe [MemberDetail]
$sel:members:CreateMembersResponse' :: CreateMembersResponse -> Maybe [MemberDetail]
members} -> Maybe [MemberDetail]
members) (\s :: CreateMembersResponse
s@CreateMembersResponse' {} Maybe [MemberDetail]
a -> CreateMembersResponse
s {$sel:members:CreateMembersResponse' :: Maybe [MemberDetail]
members = Maybe [MemberDetail]
a} :: CreateMembersResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The list of accounts for which Detective was unable to process the
-- invitation or enablement request. For each account, the list provides
-- the reason why the request could not be processed. The list includes
-- accounts that are already member accounts in the behavior graph.
createMembersResponse_unprocessedAccounts :: Lens.Lens' CreateMembersResponse (Prelude.Maybe [UnprocessedAccount])
createMembersResponse_unprocessedAccounts :: Lens' CreateMembersResponse (Maybe [UnprocessedAccount])
createMembersResponse_unprocessedAccounts = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateMembersResponse' {Maybe [UnprocessedAccount]
unprocessedAccounts :: Maybe [UnprocessedAccount]
$sel:unprocessedAccounts:CreateMembersResponse' :: CreateMembersResponse -> Maybe [UnprocessedAccount]
unprocessedAccounts} -> Maybe [UnprocessedAccount]
unprocessedAccounts) (\s :: CreateMembersResponse
s@CreateMembersResponse' {} Maybe [UnprocessedAccount]
a -> CreateMembersResponse
s {$sel:unprocessedAccounts:CreateMembersResponse' :: Maybe [UnprocessedAccount]
unprocessedAccounts = Maybe [UnprocessedAccount]
a} :: CreateMembersResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance Prelude.NFData CreateMembersResponse where
  rnf :: CreateMembersResponse -> ()
rnf CreateMembersResponse' {Int
Maybe [MemberDetail]
Maybe [UnprocessedAccount]
httpStatus :: Int
unprocessedAccounts :: Maybe [UnprocessedAccount]
members :: Maybe [MemberDetail]
$sel:httpStatus:CreateMembersResponse' :: CreateMembersResponse -> Int
$sel:unprocessedAccounts:CreateMembersResponse' :: CreateMembersResponse -> Maybe [UnprocessedAccount]
$sel:members:CreateMembersResponse' :: CreateMembersResponse -> Maybe [MemberDetail]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [MemberDetail]
members
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [UnprocessedAccount]
unprocessedAccounts
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus