{-# 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.AuditManager.GetEvidenceByEvidenceFolder
-- 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)
--
-- Returns all evidence from a specified evidence folder in Audit Manager.
module Amazonka.AuditManager.GetEvidenceByEvidenceFolder
  ( -- * Creating a Request
    GetEvidenceByEvidenceFolder (..),
    newGetEvidenceByEvidenceFolder,

    -- * Request Lenses
    getEvidenceByEvidenceFolder_nextToken,
    getEvidenceByEvidenceFolder_maxResults,
    getEvidenceByEvidenceFolder_assessmentId,
    getEvidenceByEvidenceFolder_controlSetId,
    getEvidenceByEvidenceFolder_evidenceFolderId,

    -- * Destructuring the Response
    GetEvidenceByEvidenceFolderResponse (..),
    newGetEvidenceByEvidenceFolderResponse,

    -- * Response Lenses
    getEvidenceByEvidenceFolderResponse_nextToken,
    getEvidenceByEvidenceFolderResponse_evidence,
    getEvidenceByEvidenceFolderResponse_httpStatus,
  )
where

import Amazonka.AuditManager.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:/ 'newGetEvidenceByEvidenceFolder' smart constructor.
data GetEvidenceByEvidenceFolder = GetEvidenceByEvidenceFolder'
  { -- | The pagination token used to fetch the next set of results.
    GetEvidenceByEvidenceFolder -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | Represents the maximum number of results per page, or per API request
    -- call.
    GetEvidenceByEvidenceFolder -> Maybe Natural
maxResults :: Prelude.Maybe Prelude.Natural,
    -- | The identifier for the specified assessment.
    GetEvidenceByEvidenceFolder -> Text
assessmentId :: Prelude.Text,
    -- | The identifier for the control set.
    GetEvidenceByEvidenceFolder -> Text
controlSetId :: Prelude.Text,
    -- | The unique identifier for the folder in which the evidence is stored.
    GetEvidenceByEvidenceFolder -> Text
evidenceFolderId :: Prelude.Text
  }
  deriving (GetEvidenceByEvidenceFolder -> GetEvidenceByEvidenceFolder -> Bool
(GetEvidenceByEvidenceFolder
 -> GetEvidenceByEvidenceFolder -> Bool)
-> (GetEvidenceByEvidenceFolder
    -> GetEvidenceByEvidenceFolder -> Bool)
-> Eq GetEvidenceByEvidenceFolder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetEvidenceByEvidenceFolder -> GetEvidenceByEvidenceFolder -> Bool
$c/= :: GetEvidenceByEvidenceFolder -> GetEvidenceByEvidenceFolder -> Bool
== :: GetEvidenceByEvidenceFolder -> GetEvidenceByEvidenceFolder -> Bool
$c== :: GetEvidenceByEvidenceFolder -> GetEvidenceByEvidenceFolder -> Bool
Prelude.Eq, ReadPrec [GetEvidenceByEvidenceFolder]
ReadPrec GetEvidenceByEvidenceFolder
Int -> ReadS GetEvidenceByEvidenceFolder
ReadS [GetEvidenceByEvidenceFolder]
(Int -> ReadS GetEvidenceByEvidenceFolder)
-> ReadS [GetEvidenceByEvidenceFolder]
-> ReadPrec GetEvidenceByEvidenceFolder
-> ReadPrec [GetEvidenceByEvidenceFolder]
-> Read GetEvidenceByEvidenceFolder
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetEvidenceByEvidenceFolder]
$creadListPrec :: ReadPrec [GetEvidenceByEvidenceFolder]
readPrec :: ReadPrec GetEvidenceByEvidenceFolder
$creadPrec :: ReadPrec GetEvidenceByEvidenceFolder
readList :: ReadS [GetEvidenceByEvidenceFolder]
$creadList :: ReadS [GetEvidenceByEvidenceFolder]
readsPrec :: Int -> ReadS GetEvidenceByEvidenceFolder
$creadsPrec :: Int -> ReadS GetEvidenceByEvidenceFolder
Prelude.Read, Int -> GetEvidenceByEvidenceFolder -> ShowS
[GetEvidenceByEvidenceFolder] -> ShowS
GetEvidenceByEvidenceFolder -> String
(Int -> GetEvidenceByEvidenceFolder -> ShowS)
-> (GetEvidenceByEvidenceFolder -> String)
-> ([GetEvidenceByEvidenceFolder] -> ShowS)
-> Show GetEvidenceByEvidenceFolder
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetEvidenceByEvidenceFolder] -> ShowS
$cshowList :: [GetEvidenceByEvidenceFolder] -> ShowS
show :: GetEvidenceByEvidenceFolder -> String
$cshow :: GetEvidenceByEvidenceFolder -> String
showsPrec :: Int -> GetEvidenceByEvidenceFolder -> ShowS
$cshowsPrec :: Int -> GetEvidenceByEvidenceFolder -> ShowS
Prelude.Show, (forall x.
 GetEvidenceByEvidenceFolder -> Rep GetEvidenceByEvidenceFolder x)
-> (forall x.
    Rep GetEvidenceByEvidenceFolder x -> GetEvidenceByEvidenceFolder)
-> Generic GetEvidenceByEvidenceFolder
forall x.
Rep GetEvidenceByEvidenceFolder x -> GetEvidenceByEvidenceFolder
forall x.
GetEvidenceByEvidenceFolder -> Rep GetEvidenceByEvidenceFolder x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetEvidenceByEvidenceFolder x -> GetEvidenceByEvidenceFolder
$cfrom :: forall x.
GetEvidenceByEvidenceFolder -> Rep GetEvidenceByEvidenceFolder x
Prelude.Generic)

-- |
-- Create a value of 'GetEvidenceByEvidenceFolder' 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:
--
-- 'nextToken', 'getEvidenceByEvidenceFolder_nextToken' - The pagination token used to fetch the next set of results.
--
-- 'maxResults', 'getEvidenceByEvidenceFolder_maxResults' - Represents the maximum number of results per page, or per API request
-- call.
--
-- 'assessmentId', 'getEvidenceByEvidenceFolder_assessmentId' - The identifier for the specified assessment.
--
-- 'controlSetId', 'getEvidenceByEvidenceFolder_controlSetId' - The identifier for the control set.
--
-- 'evidenceFolderId', 'getEvidenceByEvidenceFolder_evidenceFolderId' - The unique identifier for the folder in which the evidence is stored.
newGetEvidenceByEvidenceFolder ::
  -- | 'assessmentId'
  Prelude.Text ->
  -- | 'controlSetId'
  Prelude.Text ->
  -- | 'evidenceFolderId'
  Prelude.Text ->
  GetEvidenceByEvidenceFolder
newGetEvidenceByEvidenceFolder :: Text -> Text -> Text -> GetEvidenceByEvidenceFolder
newGetEvidenceByEvidenceFolder
  Text
pAssessmentId_
  Text
pControlSetId_
  Text
pEvidenceFolderId_ =
    GetEvidenceByEvidenceFolder' :: Maybe Text
-> Maybe Natural
-> Text
-> Text
-> Text
-> GetEvidenceByEvidenceFolder
GetEvidenceByEvidenceFolder'
      { $sel:nextToken:GetEvidenceByEvidenceFolder' :: Maybe Text
nextToken =
          Maybe Text
forall a. Maybe a
Prelude.Nothing,
        $sel:maxResults:GetEvidenceByEvidenceFolder' :: Maybe Natural
maxResults = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:assessmentId:GetEvidenceByEvidenceFolder' :: Text
assessmentId = Text
pAssessmentId_,
        $sel:controlSetId:GetEvidenceByEvidenceFolder' :: Text
controlSetId = Text
pControlSetId_,
        $sel:evidenceFolderId:GetEvidenceByEvidenceFolder' :: Text
evidenceFolderId = Text
pEvidenceFolderId_
      }

-- | The pagination token used to fetch the next set of results.
getEvidenceByEvidenceFolder_nextToken :: Lens.Lens' GetEvidenceByEvidenceFolder (Prelude.Maybe Prelude.Text)
getEvidenceByEvidenceFolder_nextToken :: (Maybe Text -> f (Maybe Text))
-> GetEvidenceByEvidenceFolder -> f GetEvidenceByEvidenceFolder
getEvidenceByEvidenceFolder_nextToken = (GetEvidenceByEvidenceFolder -> Maybe Text)
-> (GetEvidenceByEvidenceFolder
    -> Maybe Text -> GetEvidenceByEvidenceFolder)
-> Lens
     GetEvidenceByEvidenceFolder
     GetEvidenceByEvidenceFolder
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvidenceByEvidenceFolder' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetEvidenceByEvidenceFolder
s@GetEvidenceByEvidenceFolder' {} Maybe Text
a -> GetEvidenceByEvidenceFolder
s {$sel:nextToken:GetEvidenceByEvidenceFolder' :: Maybe Text
nextToken = Maybe Text
a} :: GetEvidenceByEvidenceFolder)

-- | Represents the maximum number of results per page, or per API request
-- call.
getEvidenceByEvidenceFolder_maxResults :: Lens.Lens' GetEvidenceByEvidenceFolder (Prelude.Maybe Prelude.Natural)
getEvidenceByEvidenceFolder_maxResults :: (Maybe Natural -> f (Maybe Natural))
-> GetEvidenceByEvidenceFolder -> f GetEvidenceByEvidenceFolder
getEvidenceByEvidenceFolder_maxResults = (GetEvidenceByEvidenceFolder -> Maybe Natural)
-> (GetEvidenceByEvidenceFolder
    -> Maybe Natural -> GetEvidenceByEvidenceFolder)
-> Lens
     GetEvidenceByEvidenceFolder
     GetEvidenceByEvidenceFolder
     (Maybe Natural)
     (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvidenceByEvidenceFolder' {Maybe Natural
maxResults :: Maybe Natural
$sel:maxResults:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Maybe Natural
maxResults} -> Maybe Natural
maxResults) (\s :: GetEvidenceByEvidenceFolder
s@GetEvidenceByEvidenceFolder' {} Maybe Natural
a -> GetEvidenceByEvidenceFolder
s {$sel:maxResults:GetEvidenceByEvidenceFolder' :: Maybe Natural
maxResults = Maybe Natural
a} :: GetEvidenceByEvidenceFolder)

-- | The identifier for the specified assessment.
getEvidenceByEvidenceFolder_assessmentId :: Lens.Lens' GetEvidenceByEvidenceFolder Prelude.Text
getEvidenceByEvidenceFolder_assessmentId :: (Text -> f Text)
-> GetEvidenceByEvidenceFolder -> f GetEvidenceByEvidenceFolder
getEvidenceByEvidenceFolder_assessmentId = (GetEvidenceByEvidenceFolder -> Text)
-> (GetEvidenceByEvidenceFolder
    -> Text -> GetEvidenceByEvidenceFolder)
-> Lens
     GetEvidenceByEvidenceFolder GetEvidenceByEvidenceFolder Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvidenceByEvidenceFolder' {Text
assessmentId :: Text
$sel:assessmentId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
assessmentId} -> Text
assessmentId) (\s :: GetEvidenceByEvidenceFolder
s@GetEvidenceByEvidenceFolder' {} Text
a -> GetEvidenceByEvidenceFolder
s {$sel:assessmentId:GetEvidenceByEvidenceFolder' :: Text
assessmentId = Text
a} :: GetEvidenceByEvidenceFolder)

-- | The identifier for the control set.
getEvidenceByEvidenceFolder_controlSetId :: Lens.Lens' GetEvidenceByEvidenceFolder Prelude.Text
getEvidenceByEvidenceFolder_controlSetId :: (Text -> f Text)
-> GetEvidenceByEvidenceFolder -> f GetEvidenceByEvidenceFolder
getEvidenceByEvidenceFolder_controlSetId = (GetEvidenceByEvidenceFolder -> Text)
-> (GetEvidenceByEvidenceFolder
    -> Text -> GetEvidenceByEvidenceFolder)
-> Lens
     GetEvidenceByEvidenceFolder GetEvidenceByEvidenceFolder Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvidenceByEvidenceFolder' {Text
controlSetId :: Text
$sel:controlSetId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
controlSetId} -> Text
controlSetId) (\s :: GetEvidenceByEvidenceFolder
s@GetEvidenceByEvidenceFolder' {} Text
a -> GetEvidenceByEvidenceFolder
s {$sel:controlSetId:GetEvidenceByEvidenceFolder' :: Text
controlSetId = Text
a} :: GetEvidenceByEvidenceFolder)

-- | The unique identifier for the folder in which the evidence is stored.
getEvidenceByEvidenceFolder_evidenceFolderId :: Lens.Lens' GetEvidenceByEvidenceFolder Prelude.Text
getEvidenceByEvidenceFolder_evidenceFolderId :: (Text -> f Text)
-> GetEvidenceByEvidenceFolder -> f GetEvidenceByEvidenceFolder
getEvidenceByEvidenceFolder_evidenceFolderId = (GetEvidenceByEvidenceFolder -> Text)
-> (GetEvidenceByEvidenceFolder
    -> Text -> GetEvidenceByEvidenceFolder)
-> Lens
     GetEvidenceByEvidenceFolder GetEvidenceByEvidenceFolder Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvidenceByEvidenceFolder' {Text
evidenceFolderId :: Text
$sel:evidenceFolderId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
evidenceFolderId} -> Text
evidenceFolderId) (\s :: GetEvidenceByEvidenceFolder
s@GetEvidenceByEvidenceFolder' {} Text
a -> GetEvidenceByEvidenceFolder
s {$sel:evidenceFolderId:GetEvidenceByEvidenceFolder' :: Text
evidenceFolderId = Text
a} :: GetEvidenceByEvidenceFolder)

instance Core.AWSRequest GetEvidenceByEvidenceFolder where
  type
    AWSResponse GetEvidenceByEvidenceFolder =
      GetEvidenceByEvidenceFolderResponse
  request :: GetEvidenceByEvidenceFolder -> Request GetEvidenceByEvidenceFolder
request = Service
-> GetEvidenceByEvidenceFolder
-> Request GetEvidenceByEvidenceFolder
forall a. ToRequest a => Service -> a -> Request a
Request.get Service
defaultService
  response :: Logger
-> Service
-> Proxy GetEvidenceByEvidenceFolder
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetEvidenceByEvidenceFolder)))
response =
    (Int
 -> ResponseHeaders
 -> Object
 -> Either String (AWSResponse GetEvidenceByEvidenceFolder))
-> Logger
-> Service
-> Proxy GetEvidenceByEvidenceFolder
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse GetEvidenceByEvidenceFolder)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe [Evidence] -> Int -> GetEvidenceByEvidenceFolderResponse
GetEvidenceByEvidenceFolderResponse'
            (Maybe Text
 -> Maybe [Evidence] -> Int -> GetEvidenceByEvidenceFolderResponse)
-> Either String (Maybe Text)
-> Either
     String
     (Maybe [Evidence] -> Int -> GetEvidenceByEvidenceFolderResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Either String (Maybe Text)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"nextToken")
            Either
  String
  (Maybe [Evidence] -> Int -> GetEvidenceByEvidenceFolderResponse)
-> Either String (Maybe [Evidence])
-> Either String (Int -> GetEvidenceByEvidenceFolderResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe (Maybe [Evidence]))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"evidence" Either String (Maybe (Maybe [Evidence]))
-> Maybe [Evidence] -> Either String (Maybe [Evidence])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [Evidence]
forall a. Monoid a => a
Prelude.mempty)
            Either String (Int -> GetEvidenceByEvidenceFolderResponse)
-> Either String Int
-> Either String GetEvidenceByEvidenceFolderResponse
forall (f :: * -> *) a b. Applicative f => 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 GetEvidenceByEvidenceFolder

instance Prelude.NFData GetEvidenceByEvidenceFolder

instance Core.ToHeaders GetEvidenceByEvidenceFolder where
  toHeaders :: GetEvidenceByEvidenceFolder -> ResponseHeaders
toHeaders =
    ResponseHeaders -> GetEvidenceByEvidenceFolder -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ 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.ToPath GetEvidenceByEvidenceFolder where
  toPath :: GetEvidenceByEvidenceFolder -> ByteString
toPath GetEvidenceByEvidenceFolder' {Maybe Natural
Maybe Text
Text
evidenceFolderId :: Text
controlSetId :: Text
assessmentId :: Text
maxResults :: Maybe Natural
nextToken :: Maybe Text
$sel:evidenceFolderId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
$sel:controlSetId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
$sel:assessmentId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
$sel:maxResults:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Maybe Natural
$sel:nextToken:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Maybe Text
..} =
    [ByteString] -> ByteString
forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/assessments/",
        Text -> ByteString
forall a. ToByteString a => a -> ByteString
Core.toBS Text
assessmentId,
        ByteString
"/controlSets/",
        Text -> ByteString
forall a. ToByteString a => a -> ByteString
Core.toBS Text
controlSetId,
        ByteString
"/evidenceFolders/",
        Text -> ByteString
forall a. ToByteString a => a -> ByteString
Core.toBS Text
evidenceFolderId,
        ByteString
"/evidence"
      ]

instance Core.ToQuery GetEvidenceByEvidenceFolder where
  toQuery :: GetEvidenceByEvidenceFolder -> QueryString
toQuery GetEvidenceByEvidenceFolder' {Maybe Natural
Maybe Text
Text
evidenceFolderId :: Text
controlSetId :: Text
assessmentId :: Text
maxResults :: Maybe Natural
nextToken :: Maybe Text
$sel:evidenceFolderId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
$sel:controlSetId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
$sel:assessmentId:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Text
$sel:maxResults:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Maybe Natural
$sel:nextToken:GetEvidenceByEvidenceFolder' :: GetEvidenceByEvidenceFolder -> Maybe Text
..} =
    [QueryString] -> QueryString
forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"nextToken" ByteString -> Maybe Text -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Text
nextToken,
        ByteString
"maxResults" ByteString -> Maybe Natural -> QueryString
forall a. ToQuery a => ByteString -> a -> QueryString
Core.=: Maybe Natural
maxResults
      ]

-- | /See:/ 'newGetEvidenceByEvidenceFolderResponse' smart constructor.
data GetEvidenceByEvidenceFolderResponse = GetEvidenceByEvidenceFolderResponse'
  { -- | The pagination token used to fetch the next set of results.
    GetEvidenceByEvidenceFolderResponse -> Maybe Text
nextToken :: Prelude.Maybe Prelude.Text,
    -- | The list of evidence returned by the @GetEvidenceByEvidenceFolder@ API.
    GetEvidenceByEvidenceFolderResponse -> Maybe [Evidence]
evidence :: Prelude.Maybe [Evidence],
    -- | The response's http status code.
    GetEvidenceByEvidenceFolderResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetEvidenceByEvidenceFolderResponse
-> GetEvidenceByEvidenceFolderResponse -> Bool
(GetEvidenceByEvidenceFolderResponse
 -> GetEvidenceByEvidenceFolderResponse -> Bool)
-> (GetEvidenceByEvidenceFolderResponse
    -> GetEvidenceByEvidenceFolderResponse -> Bool)
-> Eq GetEvidenceByEvidenceFolderResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetEvidenceByEvidenceFolderResponse
-> GetEvidenceByEvidenceFolderResponse -> Bool
$c/= :: GetEvidenceByEvidenceFolderResponse
-> GetEvidenceByEvidenceFolderResponse -> Bool
== :: GetEvidenceByEvidenceFolderResponse
-> GetEvidenceByEvidenceFolderResponse -> Bool
$c== :: GetEvidenceByEvidenceFolderResponse
-> GetEvidenceByEvidenceFolderResponse -> Bool
Prelude.Eq, ReadPrec [GetEvidenceByEvidenceFolderResponse]
ReadPrec GetEvidenceByEvidenceFolderResponse
Int -> ReadS GetEvidenceByEvidenceFolderResponse
ReadS [GetEvidenceByEvidenceFolderResponse]
(Int -> ReadS GetEvidenceByEvidenceFolderResponse)
-> ReadS [GetEvidenceByEvidenceFolderResponse]
-> ReadPrec GetEvidenceByEvidenceFolderResponse
-> ReadPrec [GetEvidenceByEvidenceFolderResponse]
-> Read GetEvidenceByEvidenceFolderResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetEvidenceByEvidenceFolderResponse]
$creadListPrec :: ReadPrec [GetEvidenceByEvidenceFolderResponse]
readPrec :: ReadPrec GetEvidenceByEvidenceFolderResponse
$creadPrec :: ReadPrec GetEvidenceByEvidenceFolderResponse
readList :: ReadS [GetEvidenceByEvidenceFolderResponse]
$creadList :: ReadS [GetEvidenceByEvidenceFolderResponse]
readsPrec :: Int -> ReadS GetEvidenceByEvidenceFolderResponse
$creadsPrec :: Int -> ReadS GetEvidenceByEvidenceFolderResponse
Prelude.Read, Int -> GetEvidenceByEvidenceFolderResponse -> ShowS
[GetEvidenceByEvidenceFolderResponse] -> ShowS
GetEvidenceByEvidenceFolderResponse -> String
(Int -> GetEvidenceByEvidenceFolderResponse -> ShowS)
-> (GetEvidenceByEvidenceFolderResponse -> String)
-> ([GetEvidenceByEvidenceFolderResponse] -> ShowS)
-> Show GetEvidenceByEvidenceFolderResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetEvidenceByEvidenceFolderResponse] -> ShowS
$cshowList :: [GetEvidenceByEvidenceFolderResponse] -> ShowS
show :: GetEvidenceByEvidenceFolderResponse -> String
$cshow :: GetEvidenceByEvidenceFolderResponse -> String
showsPrec :: Int -> GetEvidenceByEvidenceFolderResponse -> ShowS
$cshowsPrec :: Int -> GetEvidenceByEvidenceFolderResponse -> ShowS
Prelude.Show, (forall x.
 GetEvidenceByEvidenceFolderResponse
 -> Rep GetEvidenceByEvidenceFolderResponse x)
-> (forall x.
    Rep GetEvidenceByEvidenceFolderResponse x
    -> GetEvidenceByEvidenceFolderResponse)
-> Generic GetEvidenceByEvidenceFolderResponse
forall x.
Rep GetEvidenceByEvidenceFolderResponse x
-> GetEvidenceByEvidenceFolderResponse
forall x.
GetEvidenceByEvidenceFolderResponse
-> Rep GetEvidenceByEvidenceFolderResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep GetEvidenceByEvidenceFolderResponse x
-> GetEvidenceByEvidenceFolderResponse
$cfrom :: forall x.
GetEvidenceByEvidenceFolderResponse
-> Rep GetEvidenceByEvidenceFolderResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetEvidenceByEvidenceFolderResponse' 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:
--
-- 'nextToken', 'getEvidenceByEvidenceFolderResponse_nextToken' - The pagination token used to fetch the next set of results.
--
-- 'evidence', 'getEvidenceByEvidenceFolderResponse_evidence' - The list of evidence returned by the @GetEvidenceByEvidenceFolder@ API.
--
-- 'httpStatus', 'getEvidenceByEvidenceFolderResponse_httpStatus' - The response's http status code.
newGetEvidenceByEvidenceFolderResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetEvidenceByEvidenceFolderResponse
newGetEvidenceByEvidenceFolderResponse :: Int -> GetEvidenceByEvidenceFolderResponse
newGetEvidenceByEvidenceFolderResponse Int
pHttpStatus_ =
  GetEvidenceByEvidenceFolderResponse' :: Maybe Text
-> Maybe [Evidence] -> Int -> GetEvidenceByEvidenceFolderResponse
GetEvidenceByEvidenceFolderResponse'
    { $sel:nextToken:GetEvidenceByEvidenceFolderResponse' :: Maybe Text
nextToken =
        Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:evidence:GetEvidenceByEvidenceFolderResponse' :: Maybe [Evidence]
evidence = Maybe [Evidence]
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetEvidenceByEvidenceFolderResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The pagination token used to fetch the next set of results.
getEvidenceByEvidenceFolderResponse_nextToken :: Lens.Lens' GetEvidenceByEvidenceFolderResponse (Prelude.Maybe Prelude.Text)
getEvidenceByEvidenceFolderResponse_nextToken :: (Maybe Text -> f (Maybe Text))
-> GetEvidenceByEvidenceFolderResponse
-> f GetEvidenceByEvidenceFolderResponse
getEvidenceByEvidenceFolderResponse_nextToken = (GetEvidenceByEvidenceFolderResponse -> Maybe Text)
-> (GetEvidenceByEvidenceFolderResponse
    -> Maybe Text -> GetEvidenceByEvidenceFolderResponse)
-> Lens
     GetEvidenceByEvidenceFolderResponse
     GetEvidenceByEvidenceFolderResponse
     (Maybe Text)
     (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvidenceByEvidenceFolderResponse' {Maybe Text
nextToken :: Maybe Text
$sel:nextToken:GetEvidenceByEvidenceFolderResponse' :: GetEvidenceByEvidenceFolderResponse -> Maybe Text
nextToken} -> Maybe Text
nextToken) (\s :: GetEvidenceByEvidenceFolderResponse
s@GetEvidenceByEvidenceFolderResponse' {} Maybe Text
a -> GetEvidenceByEvidenceFolderResponse
s {$sel:nextToken:GetEvidenceByEvidenceFolderResponse' :: Maybe Text
nextToken = Maybe Text
a} :: GetEvidenceByEvidenceFolderResponse)

-- | The list of evidence returned by the @GetEvidenceByEvidenceFolder@ API.
getEvidenceByEvidenceFolderResponse_evidence :: Lens.Lens' GetEvidenceByEvidenceFolderResponse (Prelude.Maybe [Evidence])
getEvidenceByEvidenceFolderResponse_evidence :: (Maybe [Evidence] -> f (Maybe [Evidence]))
-> GetEvidenceByEvidenceFolderResponse
-> f GetEvidenceByEvidenceFolderResponse
getEvidenceByEvidenceFolderResponse_evidence = (GetEvidenceByEvidenceFolderResponse -> Maybe [Evidence])
-> (GetEvidenceByEvidenceFolderResponse
    -> Maybe [Evidence] -> GetEvidenceByEvidenceFolderResponse)
-> Lens
     GetEvidenceByEvidenceFolderResponse
     GetEvidenceByEvidenceFolderResponse
     (Maybe [Evidence])
     (Maybe [Evidence])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetEvidenceByEvidenceFolderResponse' {Maybe [Evidence]
evidence :: Maybe [Evidence]
$sel:evidence:GetEvidenceByEvidenceFolderResponse' :: GetEvidenceByEvidenceFolderResponse -> Maybe [Evidence]
evidence} -> Maybe [Evidence]
evidence) (\s :: GetEvidenceByEvidenceFolderResponse
s@GetEvidenceByEvidenceFolderResponse' {} Maybe [Evidence]
a -> GetEvidenceByEvidenceFolderResponse
s {$sel:evidence:GetEvidenceByEvidenceFolderResponse' :: Maybe [Evidence]
evidence = Maybe [Evidence]
a} :: GetEvidenceByEvidenceFolderResponse) ((Maybe [Evidence] -> f (Maybe [Evidence]))
 -> GetEvidenceByEvidenceFolderResponse
 -> f GetEvidenceByEvidenceFolderResponse)
-> ((Maybe [Evidence] -> f (Maybe [Evidence]))
    -> Maybe [Evidence] -> f (Maybe [Evidence]))
-> (Maybe [Evidence] -> f (Maybe [Evidence]))
-> GetEvidenceByEvidenceFolderResponse
-> f GetEvidenceByEvidenceFolderResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Evidence] [Evidence] [Evidence] [Evidence]
-> Iso
     (Maybe [Evidence])
     (Maybe [Evidence])
     (Maybe [Evidence])
     (Maybe [Evidence])
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 AnIso [Evidence] [Evidence] [Evidence] [Evidence]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

instance
  Prelude.NFData
    GetEvidenceByEvidenceFolderResponse