{-# 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.VerifySoftwareToken
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Use this API to register a user\'s entered time-based one-time password
-- (TOTP) code and mark the user\'s software token MFA status as
-- \"verified\" if successful. The request takes an access token or a
-- session string, but not both.
module Amazonka.CognitoIdentityProvider.VerifySoftwareToken
  ( -- * Creating a Request
    VerifySoftwareToken (..),
    newVerifySoftwareToken,

    -- * Request Lenses
    verifySoftwareToken_accessToken,
    verifySoftwareToken_friendlyDeviceName,
    verifySoftwareToken_session,
    verifySoftwareToken_userCode,

    -- * Destructuring the Response
    VerifySoftwareTokenResponse (..),
    newVerifySoftwareTokenResponse,

    -- * Response Lenses
    verifySoftwareTokenResponse_session,
    verifySoftwareTokenResponse_status,
    verifySoftwareTokenResponse_httpStatus,
  )
where

import Amazonka.CognitoIdentityProvider.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:/ 'newVerifySoftwareToken' smart constructor.
data VerifySoftwareToken = VerifySoftwareToken'
  { -- | A valid access token that Amazon Cognito issued to the user whose
    -- software token you want to verify.
    VerifySoftwareToken -> Maybe (Sensitive Text)
accessToken :: Prelude.Maybe (Data.Sensitive Prelude.Text),
    -- | The friendly device name.
    VerifySoftwareToken -> Maybe Text
friendlyDeviceName :: Prelude.Maybe Prelude.Text,
    -- | The session that should be passed both ways in challenge-response calls
    -- to the service.
    VerifySoftwareToken -> Maybe Text
session :: Prelude.Maybe Prelude.Text,
    -- | The one- time password computed using the secret code returned by
    -- <https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AssociateSoftwareToken.html AssociateSoftwareToken>.
    VerifySoftwareToken -> Text
userCode :: Prelude.Text
  }
  deriving (VerifySoftwareToken -> VerifySoftwareToken -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VerifySoftwareToken -> VerifySoftwareToken -> Bool
$c/= :: VerifySoftwareToken -> VerifySoftwareToken -> Bool
== :: VerifySoftwareToken -> VerifySoftwareToken -> Bool
$c== :: VerifySoftwareToken -> VerifySoftwareToken -> Bool
Prelude.Eq, Int -> VerifySoftwareToken -> ShowS
[VerifySoftwareToken] -> ShowS
VerifySoftwareToken -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VerifySoftwareToken] -> ShowS
$cshowList :: [VerifySoftwareToken] -> ShowS
show :: VerifySoftwareToken -> String
$cshow :: VerifySoftwareToken -> String
showsPrec :: Int -> VerifySoftwareToken -> ShowS
$cshowsPrec :: Int -> VerifySoftwareToken -> ShowS
Prelude.Show, forall x. Rep VerifySoftwareToken x -> VerifySoftwareToken
forall x. VerifySoftwareToken -> Rep VerifySoftwareToken x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VerifySoftwareToken x -> VerifySoftwareToken
$cfrom :: forall x. VerifySoftwareToken -> Rep VerifySoftwareToken x
Prelude.Generic)

-- |
-- Create a value of 'VerifySoftwareToken' 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:
--
-- 'accessToken', 'verifySoftwareToken_accessToken' - A valid access token that Amazon Cognito issued to the user whose
-- software token you want to verify.
--
-- 'friendlyDeviceName', 'verifySoftwareToken_friendlyDeviceName' - The friendly device name.
--
-- 'session', 'verifySoftwareToken_session' - The session that should be passed both ways in challenge-response calls
-- to the service.
--
-- 'userCode', 'verifySoftwareToken_userCode' - The one- time password computed using the secret code returned by
-- <https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AssociateSoftwareToken.html AssociateSoftwareToken>.
newVerifySoftwareToken ::
  -- | 'userCode'
  Prelude.Text ->
  VerifySoftwareToken
newVerifySoftwareToken :: Text -> VerifySoftwareToken
newVerifySoftwareToken Text
pUserCode_ =
  VerifySoftwareToken'
    { $sel:accessToken:VerifySoftwareToken' :: Maybe (Sensitive Text)
accessToken = forall a. Maybe a
Prelude.Nothing,
      $sel:friendlyDeviceName:VerifySoftwareToken' :: Maybe Text
friendlyDeviceName = forall a. Maybe a
Prelude.Nothing,
      $sel:session:VerifySoftwareToken' :: Maybe Text
session = forall a. Maybe a
Prelude.Nothing,
      $sel:userCode:VerifySoftwareToken' :: Text
userCode = Text
pUserCode_
    }

-- | A valid access token that Amazon Cognito issued to the user whose
-- software token you want to verify.
verifySoftwareToken_accessToken :: Lens.Lens' VerifySoftwareToken (Prelude.Maybe Prelude.Text)
verifySoftwareToken_accessToken :: Lens' VerifySoftwareToken (Maybe Text)
verifySoftwareToken_accessToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VerifySoftwareToken' {Maybe (Sensitive Text)
accessToken :: Maybe (Sensitive Text)
$sel:accessToken:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe (Sensitive Text)
accessToken} -> Maybe (Sensitive Text)
accessToken) (\s :: VerifySoftwareToken
s@VerifySoftwareToken' {} Maybe (Sensitive Text)
a -> VerifySoftwareToken
s {$sel:accessToken:VerifySoftwareToken' :: Maybe (Sensitive Text)
accessToken = Maybe (Sensitive Text)
a} :: VerifySoftwareToken) 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 a. Iso' (Sensitive a) a
Data._Sensitive

-- | The friendly device name.
verifySoftwareToken_friendlyDeviceName :: Lens.Lens' VerifySoftwareToken (Prelude.Maybe Prelude.Text)
verifySoftwareToken_friendlyDeviceName :: Lens' VerifySoftwareToken (Maybe Text)
verifySoftwareToken_friendlyDeviceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VerifySoftwareToken' {Maybe Text
friendlyDeviceName :: Maybe Text
$sel:friendlyDeviceName:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
friendlyDeviceName} -> Maybe Text
friendlyDeviceName) (\s :: VerifySoftwareToken
s@VerifySoftwareToken' {} Maybe Text
a -> VerifySoftwareToken
s {$sel:friendlyDeviceName:VerifySoftwareToken' :: Maybe Text
friendlyDeviceName = Maybe Text
a} :: VerifySoftwareToken)

-- | The session that should be passed both ways in challenge-response calls
-- to the service.
verifySoftwareToken_session :: Lens.Lens' VerifySoftwareToken (Prelude.Maybe Prelude.Text)
verifySoftwareToken_session :: Lens' VerifySoftwareToken (Maybe Text)
verifySoftwareToken_session = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VerifySoftwareToken' {Maybe Text
session :: Maybe Text
$sel:session:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
session} -> Maybe Text
session) (\s :: VerifySoftwareToken
s@VerifySoftwareToken' {} Maybe Text
a -> VerifySoftwareToken
s {$sel:session:VerifySoftwareToken' :: Maybe Text
session = Maybe Text
a} :: VerifySoftwareToken)

-- | The one- time password computed using the secret code returned by
-- <https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AssociateSoftwareToken.html AssociateSoftwareToken>.
verifySoftwareToken_userCode :: Lens.Lens' VerifySoftwareToken Prelude.Text
verifySoftwareToken_userCode :: Lens' VerifySoftwareToken Text
verifySoftwareToken_userCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VerifySoftwareToken' {Text
userCode :: Text
$sel:userCode:VerifySoftwareToken' :: VerifySoftwareToken -> Text
userCode} -> Text
userCode) (\s :: VerifySoftwareToken
s@VerifySoftwareToken' {} Text
a -> VerifySoftwareToken
s {$sel:userCode:VerifySoftwareToken' :: Text
userCode = Text
a} :: VerifySoftwareToken)

instance Core.AWSRequest VerifySoftwareToken where
  type
    AWSResponse VerifySoftwareToken =
      VerifySoftwareTokenResponse
  request :: (Service -> Service)
-> VerifySoftwareToken -> Request VerifySoftwareToken
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 VerifySoftwareToken
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse VerifySoftwareToken)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe VerifySoftwareTokenResponseType
-> Int
-> VerifySoftwareTokenResponse
VerifySoftwareTokenResponse'
            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
"Session")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Status")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable VerifySoftwareToken where
  hashWithSalt :: Int -> VerifySoftwareToken -> Int
hashWithSalt Int
_salt VerifySoftwareToken' {Maybe Text
Maybe (Sensitive Text)
Text
userCode :: Text
session :: Maybe Text
friendlyDeviceName :: Maybe Text
accessToken :: Maybe (Sensitive Text)
$sel:userCode:VerifySoftwareToken' :: VerifySoftwareToken -> Text
$sel:session:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
$sel:friendlyDeviceName:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
$sel:accessToken:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe (Sensitive Text)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (Sensitive Text)
accessToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
friendlyDeviceName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
session
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
userCode

instance Prelude.NFData VerifySoftwareToken where
  rnf :: VerifySoftwareToken -> ()
rnf VerifySoftwareToken' {Maybe Text
Maybe (Sensitive Text)
Text
userCode :: Text
session :: Maybe Text
friendlyDeviceName :: Maybe Text
accessToken :: Maybe (Sensitive Text)
$sel:userCode:VerifySoftwareToken' :: VerifySoftwareToken -> Text
$sel:session:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
$sel:friendlyDeviceName:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
$sel:accessToken:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe (Sensitive Text)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (Sensitive Text)
accessToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
friendlyDeviceName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
session
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
userCode

instance Data.ToHeaders VerifySoftwareToken where
  toHeaders :: VerifySoftwareToken -> 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
"AWSCognitoIdentityProviderService.VerifySoftwareToken" ::
                          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 VerifySoftwareToken where
  toJSON :: VerifySoftwareToken -> Value
toJSON VerifySoftwareToken' {Maybe Text
Maybe (Sensitive Text)
Text
userCode :: Text
session :: Maybe Text
friendlyDeviceName :: Maybe Text
accessToken :: Maybe (Sensitive Text)
$sel:userCode:VerifySoftwareToken' :: VerifySoftwareToken -> Text
$sel:session:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
$sel:friendlyDeviceName:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe Text
$sel:accessToken:VerifySoftwareToken' :: VerifySoftwareToken -> Maybe (Sensitive Text)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"AccessToken" 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 (Sensitive Text)
accessToken,
            (Key
"FriendlyDeviceName" 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
friendlyDeviceName,
            (Key
"Session" 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
session,
            forall a. a -> Maybe a
Prelude.Just (Key
"UserCode" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
userCode)
          ]
      )

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

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

-- | /See:/ 'newVerifySoftwareTokenResponse' smart constructor.
data VerifySoftwareTokenResponse = VerifySoftwareTokenResponse'
  { -- | The session that should be passed both ways in challenge-response calls
    -- to the service.
    VerifySoftwareTokenResponse -> Maybe Text
session :: Prelude.Maybe Prelude.Text,
    -- | The status of the verify software token.
    VerifySoftwareTokenResponse
-> Maybe VerifySoftwareTokenResponseType
status :: Prelude.Maybe VerifySoftwareTokenResponseType,
    -- | The response's http status code.
    VerifySoftwareTokenResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (VerifySoftwareTokenResponse -> VerifySoftwareTokenResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VerifySoftwareTokenResponse -> VerifySoftwareTokenResponse -> Bool
$c/= :: VerifySoftwareTokenResponse -> VerifySoftwareTokenResponse -> Bool
== :: VerifySoftwareTokenResponse -> VerifySoftwareTokenResponse -> Bool
$c== :: VerifySoftwareTokenResponse -> VerifySoftwareTokenResponse -> Bool
Prelude.Eq, ReadPrec [VerifySoftwareTokenResponse]
ReadPrec VerifySoftwareTokenResponse
Int -> ReadS VerifySoftwareTokenResponse
ReadS [VerifySoftwareTokenResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VerifySoftwareTokenResponse]
$creadListPrec :: ReadPrec [VerifySoftwareTokenResponse]
readPrec :: ReadPrec VerifySoftwareTokenResponse
$creadPrec :: ReadPrec VerifySoftwareTokenResponse
readList :: ReadS [VerifySoftwareTokenResponse]
$creadList :: ReadS [VerifySoftwareTokenResponse]
readsPrec :: Int -> ReadS VerifySoftwareTokenResponse
$creadsPrec :: Int -> ReadS VerifySoftwareTokenResponse
Prelude.Read, Int -> VerifySoftwareTokenResponse -> ShowS
[VerifySoftwareTokenResponse] -> ShowS
VerifySoftwareTokenResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VerifySoftwareTokenResponse] -> ShowS
$cshowList :: [VerifySoftwareTokenResponse] -> ShowS
show :: VerifySoftwareTokenResponse -> String
$cshow :: VerifySoftwareTokenResponse -> String
showsPrec :: Int -> VerifySoftwareTokenResponse -> ShowS
$cshowsPrec :: Int -> VerifySoftwareTokenResponse -> ShowS
Prelude.Show, forall x.
Rep VerifySoftwareTokenResponse x -> VerifySoftwareTokenResponse
forall x.
VerifySoftwareTokenResponse -> Rep VerifySoftwareTokenResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep VerifySoftwareTokenResponse x -> VerifySoftwareTokenResponse
$cfrom :: forall x.
VerifySoftwareTokenResponse -> Rep VerifySoftwareTokenResponse x
Prelude.Generic)

-- |
-- Create a value of 'VerifySoftwareTokenResponse' 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:
--
-- 'session', 'verifySoftwareTokenResponse_session' - The session that should be passed both ways in challenge-response calls
-- to the service.
--
-- 'status', 'verifySoftwareTokenResponse_status' - The status of the verify software token.
--
-- 'httpStatus', 'verifySoftwareTokenResponse_httpStatus' - The response's http status code.
newVerifySoftwareTokenResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  VerifySoftwareTokenResponse
newVerifySoftwareTokenResponse :: Int -> VerifySoftwareTokenResponse
newVerifySoftwareTokenResponse Int
pHttpStatus_ =
  VerifySoftwareTokenResponse'
    { $sel:session:VerifySoftwareTokenResponse' :: Maybe Text
session =
        forall a. Maybe a
Prelude.Nothing,
      $sel:status:VerifySoftwareTokenResponse' :: Maybe VerifySoftwareTokenResponseType
status = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:VerifySoftwareTokenResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The session that should be passed both ways in challenge-response calls
-- to the service.
verifySoftwareTokenResponse_session :: Lens.Lens' VerifySoftwareTokenResponse (Prelude.Maybe Prelude.Text)
verifySoftwareTokenResponse_session :: Lens' VerifySoftwareTokenResponse (Maybe Text)
verifySoftwareTokenResponse_session = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VerifySoftwareTokenResponse' {Maybe Text
session :: Maybe Text
$sel:session:VerifySoftwareTokenResponse' :: VerifySoftwareTokenResponse -> Maybe Text
session} -> Maybe Text
session) (\s :: VerifySoftwareTokenResponse
s@VerifySoftwareTokenResponse' {} Maybe Text
a -> VerifySoftwareTokenResponse
s {$sel:session:VerifySoftwareTokenResponse' :: Maybe Text
session = Maybe Text
a} :: VerifySoftwareTokenResponse)

-- | The status of the verify software token.
verifySoftwareTokenResponse_status :: Lens.Lens' VerifySoftwareTokenResponse (Prelude.Maybe VerifySoftwareTokenResponseType)
verifySoftwareTokenResponse_status :: Lens'
  VerifySoftwareTokenResponse (Maybe VerifySoftwareTokenResponseType)
verifySoftwareTokenResponse_status = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VerifySoftwareTokenResponse' {Maybe VerifySoftwareTokenResponseType
status :: Maybe VerifySoftwareTokenResponseType
$sel:status:VerifySoftwareTokenResponse' :: VerifySoftwareTokenResponse
-> Maybe VerifySoftwareTokenResponseType
status} -> Maybe VerifySoftwareTokenResponseType
status) (\s :: VerifySoftwareTokenResponse
s@VerifySoftwareTokenResponse' {} Maybe VerifySoftwareTokenResponseType
a -> VerifySoftwareTokenResponse
s {$sel:status:VerifySoftwareTokenResponse' :: Maybe VerifySoftwareTokenResponseType
status = Maybe VerifySoftwareTokenResponseType
a} :: VerifySoftwareTokenResponse)

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

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