{-# 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.CertificateManager.Types.CertificateDetail
-- 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)
module Amazonka.CertificateManager.Types.CertificateDetail where

import Amazonka.CertificateManager.Types.CertificateOptions
import Amazonka.CertificateManager.Types.CertificateStatus
import Amazonka.CertificateManager.Types.CertificateType
import Amazonka.CertificateManager.Types.DomainValidation
import Amazonka.CertificateManager.Types.ExtendedKeyUsage
import Amazonka.CertificateManager.Types.FailureReason
import Amazonka.CertificateManager.Types.KeyAlgorithm
import Amazonka.CertificateManager.Types.KeyUsage
import Amazonka.CertificateManager.Types.RenewalEligibility
import Amazonka.CertificateManager.Types.RenewalSummary
import Amazonka.CertificateManager.Types.RevocationReason
import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | Contains metadata about an ACM certificate. This structure is returned
-- in the response to a DescribeCertificate request.
--
-- /See:/ 'newCertificateDetail' smart constructor.
data CertificateDetail = CertificateDetail'
  { -- | The name of the entity that is associated with the public key contained
    -- in the certificate.
    CertificateDetail -> Maybe Text
subject :: Prelude.Maybe Prelude.Text,
    -- | The status of the certificate.
    CertificateDetail -> Maybe CertificateStatus
status :: Prelude.Maybe CertificateStatus,
    -- | The reason the certificate request failed. This value exists only when
    -- the certificate status is @FAILED@. For more information, see
    -- <https://docs.aws.amazon.com/acm/latest/userguide/troubleshooting.html#troubleshooting-failed Certificate Request Failed>
    -- in the /Amazon Web Services Certificate Manager User Guide/.
    CertificateDetail -> Maybe FailureReason
failureReason :: Prelude.Maybe FailureReason,
    -- | One or more domain names (subject alternative names) included in the
    -- certificate. This list contains the domain names that are bound to the
    -- public key that is contained in the certificate. The subject alternative
    -- names include the canonical domain name (CN) of the certificate and
    -- additional domain names that can be used to connect to the website.
    CertificateDetail -> Maybe (NonEmpty Text)
subjectAlternativeNames :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | A list of ARNs for the Amazon Web Services resources that are using the
    -- certificate. A certificate can be used by multiple Amazon Web Services
    -- resources.
    CertificateDetail -> Maybe [Text]
inUseBy :: Prelude.Maybe [Prelude.Text],
    -- | The time at which the certificate was requested.
    CertificateDetail -> Maybe POSIX
createdAt :: Prelude.Maybe Core.POSIX,
    -- | The Amazon Resource Name (ARN) of the certificate. For more information
    -- about ARNs, see
    -- <https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html Amazon Resource Names (ARNs)>
    -- in the /Amazon Web Services General Reference/.
    CertificateDetail -> Maybe Text
certificateArn :: Prelude.Maybe Prelude.Text,
    -- | The serial number of the certificate.
    CertificateDetail -> Maybe Text
serial :: Prelude.Maybe Prelude.Text,
    -- | Specifies whether the certificate is eligible for renewal. At this time,
    -- only exported private certificates can be renewed with the
    -- RenewCertificate command.
    CertificateDetail -> Maybe RenewalEligibility
renewalEligibility :: Prelude.Maybe RenewalEligibility,
    -- | Contains a list of Extended Key Usage X.509 v3 extension objects. Each
    -- object specifies a purpose for which the certificate public key can be
    -- used and consists of a name and an object identifier (OID).
    CertificateDetail -> Maybe [ExtendedKeyUsage]
extendedKeyUsages :: Prelude.Maybe [ExtendedKeyUsage],
    -- | The date and time at which the certificate was imported. This value
    -- exists only when the certificate type is @IMPORTED@.
    CertificateDetail -> Maybe POSIX
importedAt :: Prelude.Maybe Core.POSIX,
    -- | A list of Key Usage X.509 v3 extension objects. Each object is a string
    -- value that identifies the purpose of the public key contained in the
    -- certificate. Possible extension values include DIGITAL_SIGNATURE,
    -- KEY_ENCHIPHERMENT, NON_REPUDIATION, and more.
    CertificateDetail -> Maybe [KeyUsage]
keyUsages :: Prelude.Maybe [KeyUsage],
    -- | The time at which the certificate was revoked. This value exists only
    -- when the certificate status is @REVOKED@.
    CertificateDetail -> Maybe POSIX
revokedAt :: Prelude.Maybe Core.POSIX,
    -- | The time before which the certificate is not valid.
    CertificateDetail -> Maybe POSIX
notBefore :: Prelude.Maybe Core.POSIX,
    -- | The reason the certificate was revoked. This value exists only when the
    -- certificate status is @REVOKED@.
    CertificateDetail -> Maybe RevocationReason
revocationReason :: Prelude.Maybe RevocationReason,
    -- | The fully qualified domain name for the certificate, such as
    -- www.example.com or example.com.
    CertificateDetail -> Maybe Text
domainName :: Prelude.Maybe Prelude.Text,
    -- | Contains information about the status of ACM\'s
    -- <https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html managed renewal>
    -- for the certificate. This field exists only when the certificate type is
    -- @AMAZON_ISSUED@.
    CertificateDetail -> Maybe RenewalSummary
renewalSummary :: Prelude.Maybe RenewalSummary,
    -- | The algorithm that was used to generate the public-private key pair.
    CertificateDetail -> Maybe KeyAlgorithm
keyAlgorithm :: Prelude.Maybe KeyAlgorithm,
    -- | The source of the certificate. For certificates provided by ACM, this
    -- value is @AMAZON_ISSUED@. For certificates that you imported with
    -- ImportCertificate, this value is @IMPORTED@. ACM does not provide
    -- <https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html managed renewal>
    -- for imported certificates. For more information about the differences
    -- between certificates that you import and those that ACM provides, see
    -- <https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html Importing Certificates>
    -- in the /Amazon Web Services Certificate Manager User Guide/.
    CertificateDetail -> Maybe CertificateType
type' :: Prelude.Maybe CertificateType,
    -- | Value that specifies whether to add the certificate to a transparency
    -- log. Certificate transparency makes it possible to detect SSL
    -- certificates that have been mistakenly or maliciously issued. A browser
    -- might respond to certificate that has not been logged by showing an
    -- error message. The logs are cryptographically secure.
    CertificateDetail -> Maybe CertificateOptions
options :: Prelude.Maybe CertificateOptions,
    -- | The time at which the certificate was issued. This value exists only
    -- when the certificate type is @AMAZON_ISSUED@.
    CertificateDetail -> Maybe POSIX
issuedAt :: Prelude.Maybe Core.POSIX,
    -- | The algorithm that was used to sign the certificate.
    CertificateDetail -> Maybe Text
signatureAlgorithm :: Prelude.Maybe Prelude.Text,
    -- | Contains information about the initial validation of each domain name
    -- that occurs as a result of the RequestCertificate request. This field
    -- exists only when the certificate type is @AMAZON_ISSUED@.
    CertificateDetail -> Maybe (NonEmpty DomainValidation)
domainValidationOptions :: Prelude.Maybe (Prelude.NonEmpty DomainValidation),
    -- | The name of the certificate authority that issued and signed the
    -- certificate.
    CertificateDetail -> Maybe Text
issuer :: Prelude.Maybe Prelude.Text,
    -- | The time after which the certificate is not valid.
    CertificateDetail -> Maybe POSIX
notAfter :: Prelude.Maybe Core.POSIX,
    -- | The Amazon Resource Name (ARN) of the ACM PCA private certificate
    -- authority (CA) that issued the certificate. This has the following
    -- format:
    --
    -- @arn:aws:acm-pca:region:account:certificate-authority\/12345678-1234-1234-1234-123456789012@
    CertificateDetail -> Maybe Text
certificateAuthorityArn :: Prelude.Maybe Prelude.Text
  }
  deriving (CertificateDetail -> CertificateDetail -> Bool
(CertificateDetail -> CertificateDetail -> Bool)
-> (CertificateDetail -> CertificateDetail -> Bool)
-> Eq CertificateDetail
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CertificateDetail -> CertificateDetail -> Bool
$c/= :: CertificateDetail -> CertificateDetail -> Bool
== :: CertificateDetail -> CertificateDetail -> Bool
$c== :: CertificateDetail -> CertificateDetail -> Bool
Prelude.Eq, ReadPrec [CertificateDetail]
ReadPrec CertificateDetail
Int -> ReadS CertificateDetail
ReadS [CertificateDetail]
(Int -> ReadS CertificateDetail)
-> ReadS [CertificateDetail]
-> ReadPrec CertificateDetail
-> ReadPrec [CertificateDetail]
-> Read CertificateDetail
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CertificateDetail]
$creadListPrec :: ReadPrec [CertificateDetail]
readPrec :: ReadPrec CertificateDetail
$creadPrec :: ReadPrec CertificateDetail
readList :: ReadS [CertificateDetail]
$creadList :: ReadS [CertificateDetail]
readsPrec :: Int -> ReadS CertificateDetail
$creadsPrec :: Int -> ReadS CertificateDetail
Prelude.Read, Int -> CertificateDetail -> ShowS
[CertificateDetail] -> ShowS
CertificateDetail -> String
(Int -> CertificateDetail -> ShowS)
-> (CertificateDetail -> String)
-> ([CertificateDetail] -> ShowS)
-> Show CertificateDetail
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CertificateDetail] -> ShowS
$cshowList :: [CertificateDetail] -> ShowS
show :: CertificateDetail -> String
$cshow :: CertificateDetail -> String
showsPrec :: Int -> CertificateDetail -> ShowS
$cshowsPrec :: Int -> CertificateDetail -> ShowS
Prelude.Show, (forall x. CertificateDetail -> Rep CertificateDetail x)
-> (forall x. Rep CertificateDetail x -> CertificateDetail)
-> Generic CertificateDetail
forall x. Rep CertificateDetail x -> CertificateDetail
forall x. CertificateDetail -> Rep CertificateDetail x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CertificateDetail x -> CertificateDetail
$cfrom :: forall x. CertificateDetail -> Rep CertificateDetail x
Prelude.Generic)

-- |
-- Create a value of 'CertificateDetail' 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:
--
-- 'subject', 'certificateDetail_subject' - The name of the entity that is associated with the public key contained
-- in the certificate.
--
-- 'status', 'certificateDetail_status' - The status of the certificate.
--
-- 'failureReason', 'certificateDetail_failureReason' - The reason the certificate request failed. This value exists only when
-- the certificate status is @FAILED@. For more information, see
-- <https://docs.aws.amazon.com/acm/latest/userguide/troubleshooting.html#troubleshooting-failed Certificate Request Failed>
-- in the /Amazon Web Services Certificate Manager User Guide/.
--
-- 'subjectAlternativeNames', 'certificateDetail_subjectAlternativeNames' - One or more domain names (subject alternative names) included in the
-- certificate. This list contains the domain names that are bound to the
-- public key that is contained in the certificate. The subject alternative
-- names include the canonical domain name (CN) of the certificate and
-- additional domain names that can be used to connect to the website.
--
-- 'inUseBy', 'certificateDetail_inUseBy' - A list of ARNs for the Amazon Web Services resources that are using the
-- certificate. A certificate can be used by multiple Amazon Web Services
-- resources.
--
-- 'createdAt', 'certificateDetail_createdAt' - The time at which the certificate was requested.
--
-- 'certificateArn', 'certificateDetail_certificateArn' - The Amazon Resource Name (ARN) of the certificate. For more information
-- about ARNs, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html Amazon Resource Names (ARNs)>
-- in the /Amazon Web Services General Reference/.
--
-- 'serial', 'certificateDetail_serial' - The serial number of the certificate.
--
-- 'renewalEligibility', 'certificateDetail_renewalEligibility' - Specifies whether the certificate is eligible for renewal. At this time,
-- only exported private certificates can be renewed with the
-- RenewCertificate command.
--
-- 'extendedKeyUsages', 'certificateDetail_extendedKeyUsages' - Contains a list of Extended Key Usage X.509 v3 extension objects. Each
-- object specifies a purpose for which the certificate public key can be
-- used and consists of a name and an object identifier (OID).
--
-- 'importedAt', 'certificateDetail_importedAt' - The date and time at which the certificate was imported. This value
-- exists only when the certificate type is @IMPORTED@.
--
-- 'keyUsages', 'certificateDetail_keyUsages' - A list of Key Usage X.509 v3 extension objects. Each object is a string
-- value that identifies the purpose of the public key contained in the
-- certificate. Possible extension values include DIGITAL_SIGNATURE,
-- KEY_ENCHIPHERMENT, NON_REPUDIATION, and more.
--
-- 'revokedAt', 'certificateDetail_revokedAt' - The time at which the certificate was revoked. This value exists only
-- when the certificate status is @REVOKED@.
--
-- 'notBefore', 'certificateDetail_notBefore' - The time before which the certificate is not valid.
--
-- 'revocationReason', 'certificateDetail_revocationReason' - The reason the certificate was revoked. This value exists only when the
-- certificate status is @REVOKED@.
--
-- 'domainName', 'certificateDetail_domainName' - The fully qualified domain name for the certificate, such as
-- www.example.com or example.com.
--
-- 'renewalSummary', 'certificateDetail_renewalSummary' - Contains information about the status of ACM\'s
-- <https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html managed renewal>
-- for the certificate. This field exists only when the certificate type is
-- @AMAZON_ISSUED@.
--
-- 'keyAlgorithm', 'certificateDetail_keyAlgorithm' - The algorithm that was used to generate the public-private key pair.
--
-- 'type'', 'certificateDetail_type' - The source of the certificate. For certificates provided by ACM, this
-- value is @AMAZON_ISSUED@. For certificates that you imported with
-- ImportCertificate, this value is @IMPORTED@. ACM does not provide
-- <https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html managed renewal>
-- for imported certificates. For more information about the differences
-- between certificates that you import and those that ACM provides, see
-- <https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html Importing Certificates>
-- in the /Amazon Web Services Certificate Manager User Guide/.
--
-- 'options', 'certificateDetail_options' - Value that specifies whether to add the certificate to a transparency
-- log. Certificate transparency makes it possible to detect SSL
-- certificates that have been mistakenly or maliciously issued. A browser
-- might respond to certificate that has not been logged by showing an
-- error message. The logs are cryptographically secure.
--
-- 'issuedAt', 'certificateDetail_issuedAt' - The time at which the certificate was issued. This value exists only
-- when the certificate type is @AMAZON_ISSUED@.
--
-- 'signatureAlgorithm', 'certificateDetail_signatureAlgorithm' - The algorithm that was used to sign the certificate.
--
-- 'domainValidationOptions', 'certificateDetail_domainValidationOptions' - Contains information about the initial validation of each domain name
-- that occurs as a result of the RequestCertificate request. This field
-- exists only when the certificate type is @AMAZON_ISSUED@.
--
-- 'issuer', 'certificateDetail_issuer' - The name of the certificate authority that issued and signed the
-- certificate.
--
-- 'notAfter', 'certificateDetail_notAfter' - The time after which the certificate is not valid.
--
-- 'certificateAuthorityArn', 'certificateDetail_certificateAuthorityArn' - The Amazon Resource Name (ARN) of the ACM PCA private certificate
-- authority (CA) that issued the certificate. This has the following
-- format:
--
-- @arn:aws:acm-pca:region:account:certificate-authority\/12345678-1234-1234-1234-123456789012@
newCertificateDetail ::
  CertificateDetail
newCertificateDetail :: CertificateDetail
newCertificateDetail =
  CertificateDetail' :: Maybe Text
-> Maybe CertificateStatus
-> Maybe FailureReason
-> Maybe (NonEmpty Text)
-> Maybe [Text]
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe RenewalEligibility
-> Maybe [ExtendedKeyUsage]
-> Maybe POSIX
-> Maybe [KeyUsage]
-> Maybe POSIX
-> Maybe POSIX
-> Maybe RevocationReason
-> Maybe Text
-> Maybe RenewalSummary
-> Maybe KeyAlgorithm
-> Maybe CertificateType
-> Maybe CertificateOptions
-> Maybe POSIX
-> Maybe Text
-> Maybe (NonEmpty DomainValidation)
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> CertificateDetail
CertificateDetail'
    { $sel:subject:CertificateDetail' :: Maybe Text
subject = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:status:CertificateDetail' :: Maybe CertificateStatus
status = Maybe CertificateStatus
forall a. Maybe a
Prelude.Nothing,
      $sel:failureReason:CertificateDetail' :: Maybe FailureReason
failureReason = Maybe FailureReason
forall a. Maybe a
Prelude.Nothing,
      $sel:subjectAlternativeNames:CertificateDetail' :: Maybe (NonEmpty Text)
subjectAlternativeNames = Maybe (NonEmpty Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:inUseBy:CertificateDetail' :: Maybe [Text]
inUseBy = Maybe [Text]
forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:CertificateDetail' :: Maybe POSIX
createdAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:certificateArn:CertificateDetail' :: Maybe Text
certificateArn = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:serial:CertificateDetail' :: Maybe Text
serial = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:renewalEligibility:CertificateDetail' :: Maybe RenewalEligibility
renewalEligibility = Maybe RenewalEligibility
forall a. Maybe a
Prelude.Nothing,
      $sel:extendedKeyUsages:CertificateDetail' :: Maybe [ExtendedKeyUsage]
extendedKeyUsages = Maybe [ExtendedKeyUsage]
forall a. Maybe a
Prelude.Nothing,
      $sel:importedAt:CertificateDetail' :: Maybe POSIX
importedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:keyUsages:CertificateDetail' :: Maybe [KeyUsage]
keyUsages = Maybe [KeyUsage]
forall a. Maybe a
Prelude.Nothing,
      $sel:revokedAt:CertificateDetail' :: Maybe POSIX
revokedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:notBefore:CertificateDetail' :: Maybe POSIX
notBefore = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:revocationReason:CertificateDetail' :: Maybe RevocationReason
revocationReason = Maybe RevocationReason
forall a. Maybe a
Prelude.Nothing,
      $sel:domainName:CertificateDetail' :: Maybe Text
domainName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:renewalSummary:CertificateDetail' :: Maybe RenewalSummary
renewalSummary = Maybe RenewalSummary
forall a. Maybe a
Prelude.Nothing,
      $sel:keyAlgorithm:CertificateDetail' :: Maybe KeyAlgorithm
keyAlgorithm = Maybe KeyAlgorithm
forall a. Maybe a
Prelude.Nothing,
      $sel:type':CertificateDetail' :: Maybe CertificateType
type' = Maybe CertificateType
forall a. Maybe a
Prelude.Nothing,
      $sel:options:CertificateDetail' :: Maybe CertificateOptions
options = Maybe CertificateOptions
forall a. Maybe a
Prelude.Nothing,
      $sel:issuedAt:CertificateDetail' :: Maybe POSIX
issuedAt = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:signatureAlgorithm:CertificateDetail' :: Maybe Text
signatureAlgorithm = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:domainValidationOptions:CertificateDetail' :: Maybe (NonEmpty DomainValidation)
domainValidationOptions = Maybe (NonEmpty DomainValidation)
forall a. Maybe a
Prelude.Nothing,
      $sel:issuer:CertificateDetail' :: Maybe Text
issuer = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:notAfter:CertificateDetail' :: Maybe POSIX
notAfter = Maybe POSIX
forall a. Maybe a
Prelude.Nothing,
      $sel:certificateAuthorityArn:CertificateDetail' :: Maybe Text
certificateAuthorityArn = Maybe Text
forall a. Maybe a
Prelude.Nothing
    }

-- | The name of the entity that is associated with the public key contained
-- in the certificate.
certificateDetail_subject :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.Text)
certificateDetail_subject :: (Maybe Text -> f (Maybe Text))
-> CertificateDetail -> f CertificateDetail
certificateDetail_subject = (CertificateDetail -> Maybe Text)
-> (CertificateDetail -> Maybe Text -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe Text
subject :: Maybe Text
$sel:subject:CertificateDetail' :: CertificateDetail -> Maybe Text
subject} -> Maybe Text
subject) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe Text
a -> CertificateDetail
s {$sel:subject:CertificateDetail' :: Maybe Text
subject = Maybe Text
a} :: CertificateDetail)

-- | The status of the certificate.
certificateDetail_status :: Lens.Lens' CertificateDetail (Prelude.Maybe CertificateStatus)
certificateDetail_status :: (Maybe CertificateStatus -> f (Maybe CertificateStatus))
-> CertificateDetail -> f CertificateDetail
certificateDetail_status = (CertificateDetail -> Maybe CertificateStatus)
-> (CertificateDetail
    -> Maybe CertificateStatus -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe CertificateStatus)
     (Maybe CertificateStatus)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe CertificateStatus
status :: Maybe CertificateStatus
$sel:status:CertificateDetail' :: CertificateDetail -> Maybe CertificateStatus
status} -> Maybe CertificateStatus
status) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe CertificateStatus
a -> CertificateDetail
s {$sel:status:CertificateDetail' :: Maybe CertificateStatus
status = Maybe CertificateStatus
a} :: CertificateDetail)

-- | The reason the certificate request failed. This value exists only when
-- the certificate status is @FAILED@. For more information, see
-- <https://docs.aws.amazon.com/acm/latest/userguide/troubleshooting.html#troubleshooting-failed Certificate Request Failed>
-- in the /Amazon Web Services Certificate Manager User Guide/.
certificateDetail_failureReason :: Lens.Lens' CertificateDetail (Prelude.Maybe FailureReason)
certificateDetail_failureReason :: (Maybe FailureReason -> f (Maybe FailureReason))
-> CertificateDetail -> f CertificateDetail
certificateDetail_failureReason = (CertificateDetail -> Maybe FailureReason)
-> (CertificateDetail -> Maybe FailureReason -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe FailureReason)
     (Maybe FailureReason)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe FailureReason
failureReason :: Maybe FailureReason
$sel:failureReason:CertificateDetail' :: CertificateDetail -> Maybe FailureReason
failureReason} -> Maybe FailureReason
failureReason) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe FailureReason
a -> CertificateDetail
s {$sel:failureReason:CertificateDetail' :: Maybe FailureReason
failureReason = Maybe FailureReason
a} :: CertificateDetail)

-- | One or more domain names (subject alternative names) included in the
-- certificate. This list contains the domain names that are bound to the
-- public key that is contained in the certificate. The subject alternative
-- names include the canonical domain name (CN) of the certificate and
-- additional domain names that can be used to connect to the website.
certificateDetail_subjectAlternativeNames :: Lens.Lens' CertificateDetail (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
certificateDetail_subjectAlternativeNames :: (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> CertificateDetail -> f CertificateDetail
certificateDetail_subjectAlternativeNames = (CertificateDetail -> Maybe (NonEmpty Text))
-> (CertificateDetail
    -> Maybe (NonEmpty Text) -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe (NonEmpty Text)
subjectAlternativeNames :: Maybe (NonEmpty Text)
$sel:subjectAlternativeNames:CertificateDetail' :: CertificateDetail -> Maybe (NonEmpty Text)
subjectAlternativeNames} -> Maybe (NonEmpty Text)
subjectAlternativeNames) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe (NonEmpty Text)
a -> CertificateDetail
s {$sel:subjectAlternativeNames:CertificateDetail' :: Maybe (NonEmpty Text)
subjectAlternativeNames = Maybe (NonEmpty Text)
a} :: CertificateDetail) ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
    -> Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (NonEmpty Text) (NonEmpty Text) (NonEmpty Text) (NonEmpty Text)
-> Iso
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
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
  (NonEmpty Text) (NonEmpty Text) (NonEmpty Text) (NonEmpty Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of ARNs for the Amazon Web Services resources that are using the
-- certificate. A certificate can be used by multiple Amazon Web Services
-- resources.
certificateDetail_inUseBy :: Lens.Lens' CertificateDetail (Prelude.Maybe [Prelude.Text])
certificateDetail_inUseBy :: (Maybe [Text] -> f (Maybe [Text]))
-> CertificateDetail -> f CertificateDetail
certificateDetail_inUseBy = (CertificateDetail -> Maybe [Text])
-> (CertificateDetail -> Maybe [Text] -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe [Text]) (Maybe [Text])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe [Text]
inUseBy :: Maybe [Text]
$sel:inUseBy:CertificateDetail' :: CertificateDetail -> Maybe [Text]
inUseBy} -> Maybe [Text]
inUseBy) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe [Text]
a -> CertificateDetail
s {$sel:inUseBy:CertificateDetail' :: Maybe [Text]
inUseBy = Maybe [Text]
a} :: CertificateDetail) ((Maybe [Text] -> f (Maybe [Text]))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe [Text] -> f (Maybe [Text]))
    -> Maybe [Text] -> f (Maybe [Text]))
-> (Maybe [Text] -> f (Maybe [Text]))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [Text] [Text] [Text] [Text]
-> Iso (Maybe [Text]) (Maybe [Text]) (Maybe [Text]) (Maybe [Text])
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 [Text] [Text] [Text] [Text]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The time at which the certificate was requested.
certificateDetail_createdAt :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.UTCTime)
certificateDetail_createdAt :: (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail -> f CertificateDetail
certificateDetail_createdAt = (CertificateDetail -> Maybe POSIX)
-> (CertificateDetail -> Maybe POSIX -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:CertificateDetail' :: CertificateDetail -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe POSIX
a -> CertificateDetail
s {$sel:createdAt:CertificateDetail' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: CertificateDetail) ((Maybe POSIX -> f (Maybe POSIX))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The Amazon Resource Name (ARN) of the certificate. For more information
-- about ARNs, see
-- <https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html Amazon Resource Names (ARNs)>
-- in the /Amazon Web Services General Reference/.
certificateDetail_certificateArn :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.Text)
certificateDetail_certificateArn :: (Maybe Text -> f (Maybe Text))
-> CertificateDetail -> f CertificateDetail
certificateDetail_certificateArn = (CertificateDetail -> Maybe Text)
-> (CertificateDetail -> Maybe Text -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe Text
certificateArn :: Maybe Text
$sel:certificateArn:CertificateDetail' :: CertificateDetail -> Maybe Text
certificateArn} -> Maybe Text
certificateArn) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe Text
a -> CertificateDetail
s {$sel:certificateArn:CertificateDetail' :: Maybe Text
certificateArn = Maybe Text
a} :: CertificateDetail)

-- | The serial number of the certificate.
certificateDetail_serial :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.Text)
certificateDetail_serial :: (Maybe Text -> f (Maybe Text))
-> CertificateDetail -> f CertificateDetail
certificateDetail_serial = (CertificateDetail -> Maybe Text)
-> (CertificateDetail -> Maybe Text -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe Text
serial :: Maybe Text
$sel:serial:CertificateDetail' :: CertificateDetail -> Maybe Text
serial} -> Maybe Text
serial) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe Text
a -> CertificateDetail
s {$sel:serial:CertificateDetail' :: Maybe Text
serial = Maybe Text
a} :: CertificateDetail)

-- | Specifies whether the certificate is eligible for renewal. At this time,
-- only exported private certificates can be renewed with the
-- RenewCertificate command.
certificateDetail_renewalEligibility :: Lens.Lens' CertificateDetail (Prelude.Maybe RenewalEligibility)
certificateDetail_renewalEligibility :: (Maybe RenewalEligibility -> f (Maybe RenewalEligibility))
-> CertificateDetail -> f CertificateDetail
certificateDetail_renewalEligibility = (CertificateDetail -> Maybe RenewalEligibility)
-> (CertificateDetail
    -> Maybe RenewalEligibility -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe RenewalEligibility)
     (Maybe RenewalEligibility)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe RenewalEligibility
renewalEligibility :: Maybe RenewalEligibility
$sel:renewalEligibility:CertificateDetail' :: CertificateDetail -> Maybe RenewalEligibility
renewalEligibility} -> Maybe RenewalEligibility
renewalEligibility) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe RenewalEligibility
a -> CertificateDetail
s {$sel:renewalEligibility:CertificateDetail' :: Maybe RenewalEligibility
renewalEligibility = Maybe RenewalEligibility
a} :: CertificateDetail)

-- | Contains a list of Extended Key Usage X.509 v3 extension objects. Each
-- object specifies a purpose for which the certificate public key can be
-- used and consists of a name and an object identifier (OID).
certificateDetail_extendedKeyUsages :: Lens.Lens' CertificateDetail (Prelude.Maybe [ExtendedKeyUsage])
certificateDetail_extendedKeyUsages :: (Maybe [ExtendedKeyUsage] -> f (Maybe [ExtendedKeyUsage]))
-> CertificateDetail -> f CertificateDetail
certificateDetail_extendedKeyUsages = (CertificateDetail -> Maybe [ExtendedKeyUsage])
-> (CertificateDetail
    -> Maybe [ExtendedKeyUsage] -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe [ExtendedKeyUsage])
     (Maybe [ExtendedKeyUsage])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe [ExtendedKeyUsage]
extendedKeyUsages :: Maybe [ExtendedKeyUsage]
$sel:extendedKeyUsages:CertificateDetail' :: CertificateDetail -> Maybe [ExtendedKeyUsage]
extendedKeyUsages} -> Maybe [ExtendedKeyUsage]
extendedKeyUsages) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe [ExtendedKeyUsage]
a -> CertificateDetail
s {$sel:extendedKeyUsages:CertificateDetail' :: Maybe [ExtendedKeyUsage]
extendedKeyUsages = Maybe [ExtendedKeyUsage]
a} :: CertificateDetail) ((Maybe [ExtendedKeyUsage] -> f (Maybe [ExtendedKeyUsage]))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe [ExtendedKeyUsage] -> f (Maybe [ExtendedKeyUsage]))
    -> Maybe [ExtendedKeyUsage] -> f (Maybe [ExtendedKeyUsage]))
-> (Maybe [ExtendedKeyUsage] -> f (Maybe [ExtendedKeyUsage]))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [ExtendedKeyUsage]
  [ExtendedKeyUsage]
  [ExtendedKeyUsage]
  [ExtendedKeyUsage]
-> Iso
     (Maybe [ExtendedKeyUsage])
     (Maybe [ExtendedKeyUsage])
     (Maybe [ExtendedKeyUsage])
     (Maybe [ExtendedKeyUsage])
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
  [ExtendedKeyUsage]
  [ExtendedKeyUsage]
  [ExtendedKeyUsage]
  [ExtendedKeyUsage]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The date and time at which the certificate was imported. This value
-- exists only when the certificate type is @IMPORTED@.
certificateDetail_importedAt :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.UTCTime)
certificateDetail_importedAt :: (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail -> f CertificateDetail
certificateDetail_importedAt = (CertificateDetail -> Maybe POSIX)
-> (CertificateDetail -> Maybe POSIX -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe POSIX
importedAt :: Maybe POSIX
$sel:importedAt:CertificateDetail' :: CertificateDetail -> Maybe POSIX
importedAt} -> Maybe POSIX
importedAt) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe POSIX
a -> CertificateDetail
s {$sel:importedAt:CertificateDetail' :: Maybe POSIX
importedAt = Maybe POSIX
a} :: CertificateDetail) ((Maybe POSIX -> f (Maybe POSIX))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | A list of Key Usage X.509 v3 extension objects. Each object is a string
-- value that identifies the purpose of the public key contained in the
-- certificate. Possible extension values include DIGITAL_SIGNATURE,
-- KEY_ENCHIPHERMENT, NON_REPUDIATION, and more.
certificateDetail_keyUsages :: Lens.Lens' CertificateDetail (Prelude.Maybe [KeyUsage])
certificateDetail_keyUsages :: (Maybe [KeyUsage] -> f (Maybe [KeyUsage]))
-> CertificateDetail -> f CertificateDetail
certificateDetail_keyUsages = (CertificateDetail -> Maybe [KeyUsage])
-> (CertificateDetail -> Maybe [KeyUsage] -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe [KeyUsage])
     (Maybe [KeyUsage])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe [KeyUsage]
keyUsages :: Maybe [KeyUsage]
$sel:keyUsages:CertificateDetail' :: CertificateDetail -> Maybe [KeyUsage]
keyUsages} -> Maybe [KeyUsage]
keyUsages) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe [KeyUsage]
a -> CertificateDetail
s {$sel:keyUsages:CertificateDetail' :: Maybe [KeyUsage]
keyUsages = Maybe [KeyUsage]
a} :: CertificateDetail) ((Maybe [KeyUsage] -> f (Maybe [KeyUsage]))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe [KeyUsage] -> f (Maybe [KeyUsage]))
    -> Maybe [KeyUsage] -> f (Maybe [KeyUsage]))
-> (Maybe [KeyUsage] -> f (Maybe [KeyUsage]))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso [KeyUsage] [KeyUsage] [KeyUsage] [KeyUsage]
-> Iso
     (Maybe [KeyUsage])
     (Maybe [KeyUsage])
     (Maybe [KeyUsage])
     (Maybe [KeyUsage])
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 [KeyUsage] [KeyUsage] [KeyUsage] [KeyUsage]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The time at which the certificate was revoked. This value exists only
-- when the certificate status is @REVOKED@.
certificateDetail_revokedAt :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.UTCTime)
certificateDetail_revokedAt :: (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail -> f CertificateDetail
certificateDetail_revokedAt = (CertificateDetail -> Maybe POSIX)
-> (CertificateDetail -> Maybe POSIX -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe POSIX
revokedAt :: Maybe POSIX
$sel:revokedAt:CertificateDetail' :: CertificateDetail -> Maybe POSIX
revokedAt} -> Maybe POSIX
revokedAt) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe POSIX
a -> CertificateDetail
s {$sel:revokedAt:CertificateDetail' :: Maybe POSIX
revokedAt = Maybe POSIX
a} :: CertificateDetail) ((Maybe POSIX -> f (Maybe POSIX))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The time before which the certificate is not valid.
certificateDetail_notBefore :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.UTCTime)
certificateDetail_notBefore :: (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail -> f CertificateDetail
certificateDetail_notBefore = (CertificateDetail -> Maybe POSIX)
-> (CertificateDetail -> Maybe POSIX -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe POSIX
notBefore :: Maybe POSIX
$sel:notBefore:CertificateDetail' :: CertificateDetail -> Maybe POSIX
notBefore} -> Maybe POSIX
notBefore) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe POSIX
a -> CertificateDetail
s {$sel:notBefore:CertificateDetail' :: Maybe POSIX
notBefore = Maybe POSIX
a} :: CertificateDetail) ((Maybe POSIX -> f (Maybe POSIX))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The reason the certificate was revoked. This value exists only when the
-- certificate status is @REVOKED@.
certificateDetail_revocationReason :: Lens.Lens' CertificateDetail (Prelude.Maybe RevocationReason)
certificateDetail_revocationReason :: (Maybe RevocationReason -> f (Maybe RevocationReason))
-> CertificateDetail -> f CertificateDetail
certificateDetail_revocationReason = (CertificateDetail -> Maybe RevocationReason)
-> (CertificateDetail
    -> Maybe RevocationReason -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe RevocationReason)
     (Maybe RevocationReason)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe RevocationReason
revocationReason :: Maybe RevocationReason
$sel:revocationReason:CertificateDetail' :: CertificateDetail -> Maybe RevocationReason
revocationReason} -> Maybe RevocationReason
revocationReason) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe RevocationReason
a -> CertificateDetail
s {$sel:revocationReason:CertificateDetail' :: Maybe RevocationReason
revocationReason = Maybe RevocationReason
a} :: CertificateDetail)

-- | The fully qualified domain name for the certificate, such as
-- www.example.com or example.com.
certificateDetail_domainName :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.Text)
certificateDetail_domainName :: (Maybe Text -> f (Maybe Text))
-> CertificateDetail -> f CertificateDetail
certificateDetail_domainName = (CertificateDetail -> Maybe Text)
-> (CertificateDetail -> Maybe Text -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe Text
domainName :: Maybe Text
$sel:domainName:CertificateDetail' :: CertificateDetail -> Maybe Text
domainName} -> Maybe Text
domainName) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe Text
a -> CertificateDetail
s {$sel:domainName:CertificateDetail' :: Maybe Text
domainName = Maybe Text
a} :: CertificateDetail)

-- | Contains information about the status of ACM\'s
-- <https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html managed renewal>
-- for the certificate. This field exists only when the certificate type is
-- @AMAZON_ISSUED@.
certificateDetail_renewalSummary :: Lens.Lens' CertificateDetail (Prelude.Maybe RenewalSummary)
certificateDetail_renewalSummary :: (Maybe RenewalSummary -> f (Maybe RenewalSummary))
-> CertificateDetail -> f CertificateDetail
certificateDetail_renewalSummary = (CertificateDetail -> Maybe RenewalSummary)
-> (CertificateDetail -> Maybe RenewalSummary -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe RenewalSummary)
     (Maybe RenewalSummary)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe RenewalSummary
renewalSummary :: Maybe RenewalSummary
$sel:renewalSummary:CertificateDetail' :: CertificateDetail -> Maybe RenewalSummary
renewalSummary} -> Maybe RenewalSummary
renewalSummary) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe RenewalSummary
a -> CertificateDetail
s {$sel:renewalSummary:CertificateDetail' :: Maybe RenewalSummary
renewalSummary = Maybe RenewalSummary
a} :: CertificateDetail)

-- | The algorithm that was used to generate the public-private key pair.
certificateDetail_keyAlgorithm :: Lens.Lens' CertificateDetail (Prelude.Maybe KeyAlgorithm)
certificateDetail_keyAlgorithm :: (Maybe KeyAlgorithm -> f (Maybe KeyAlgorithm))
-> CertificateDetail -> f CertificateDetail
certificateDetail_keyAlgorithm = (CertificateDetail -> Maybe KeyAlgorithm)
-> (CertificateDetail -> Maybe KeyAlgorithm -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe KeyAlgorithm)
     (Maybe KeyAlgorithm)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe KeyAlgorithm
keyAlgorithm :: Maybe KeyAlgorithm
$sel:keyAlgorithm:CertificateDetail' :: CertificateDetail -> Maybe KeyAlgorithm
keyAlgorithm} -> Maybe KeyAlgorithm
keyAlgorithm) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe KeyAlgorithm
a -> CertificateDetail
s {$sel:keyAlgorithm:CertificateDetail' :: Maybe KeyAlgorithm
keyAlgorithm = Maybe KeyAlgorithm
a} :: CertificateDetail)

-- | The source of the certificate. For certificates provided by ACM, this
-- value is @AMAZON_ISSUED@. For certificates that you imported with
-- ImportCertificate, this value is @IMPORTED@. ACM does not provide
-- <https://docs.aws.amazon.com/acm/latest/userguide/acm-renewal.html managed renewal>
-- for imported certificates. For more information about the differences
-- between certificates that you import and those that ACM provides, see
-- <https://docs.aws.amazon.com/acm/latest/userguide/import-certificate.html Importing Certificates>
-- in the /Amazon Web Services Certificate Manager User Guide/.
certificateDetail_type :: Lens.Lens' CertificateDetail (Prelude.Maybe CertificateType)
certificateDetail_type :: (Maybe CertificateType -> f (Maybe CertificateType))
-> CertificateDetail -> f CertificateDetail
certificateDetail_type = (CertificateDetail -> Maybe CertificateType)
-> (CertificateDetail
    -> Maybe CertificateType -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe CertificateType)
     (Maybe CertificateType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe CertificateType
type' :: Maybe CertificateType
$sel:type':CertificateDetail' :: CertificateDetail -> Maybe CertificateType
type'} -> Maybe CertificateType
type') (\s :: CertificateDetail
s@CertificateDetail' {} Maybe CertificateType
a -> CertificateDetail
s {$sel:type':CertificateDetail' :: Maybe CertificateType
type' = Maybe CertificateType
a} :: CertificateDetail)

-- | Value that specifies whether to add the certificate to a transparency
-- log. Certificate transparency makes it possible to detect SSL
-- certificates that have been mistakenly or maliciously issued. A browser
-- might respond to certificate that has not been logged by showing an
-- error message. The logs are cryptographically secure.
certificateDetail_options :: Lens.Lens' CertificateDetail (Prelude.Maybe CertificateOptions)
certificateDetail_options :: (Maybe CertificateOptions -> f (Maybe CertificateOptions))
-> CertificateDetail -> f CertificateDetail
certificateDetail_options = (CertificateDetail -> Maybe CertificateOptions)
-> (CertificateDetail
    -> Maybe CertificateOptions -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe CertificateOptions)
     (Maybe CertificateOptions)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe CertificateOptions
options :: Maybe CertificateOptions
$sel:options:CertificateDetail' :: CertificateDetail -> Maybe CertificateOptions
options} -> Maybe CertificateOptions
options) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe CertificateOptions
a -> CertificateDetail
s {$sel:options:CertificateDetail' :: Maybe CertificateOptions
options = Maybe CertificateOptions
a} :: CertificateDetail)

-- | The time at which the certificate was issued. This value exists only
-- when the certificate type is @AMAZON_ISSUED@.
certificateDetail_issuedAt :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.UTCTime)
certificateDetail_issuedAt :: (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail -> f CertificateDetail
certificateDetail_issuedAt = (CertificateDetail -> Maybe POSIX)
-> (CertificateDetail -> Maybe POSIX -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe POSIX
issuedAt :: Maybe POSIX
$sel:issuedAt:CertificateDetail' :: CertificateDetail -> Maybe POSIX
issuedAt} -> Maybe POSIX
issuedAt) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe POSIX
a -> CertificateDetail
s {$sel:issuedAt:CertificateDetail' :: Maybe POSIX
issuedAt = Maybe POSIX
a} :: CertificateDetail) ((Maybe POSIX -> f (Maybe POSIX))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The algorithm that was used to sign the certificate.
certificateDetail_signatureAlgorithm :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.Text)
certificateDetail_signatureAlgorithm :: (Maybe Text -> f (Maybe Text))
-> CertificateDetail -> f CertificateDetail
certificateDetail_signatureAlgorithm = (CertificateDetail -> Maybe Text)
-> (CertificateDetail -> Maybe Text -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe Text
signatureAlgorithm :: Maybe Text
$sel:signatureAlgorithm:CertificateDetail' :: CertificateDetail -> Maybe Text
signatureAlgorithm} -> Maybe Text
signatureAlgorithm) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe Text
a -> CertificateDetail
s {$sel:signatureAlgorithm:CertificateDetail' :: Maybe Text
signatureAlgorithm = Maybe Text
a} :: CertificateDetail)

-- | Contains information about the initial validation of each domain name
-- that occurs as a result of the RequestCertificate request. This field
-- exists only when the certificate type is @AMAZON_ISSUED@.
certificateDetail_domainValidationOptions :: Lens.Lens' CertificateDetail (Prelude.Maybe (Prelude.NonEmpty DomainValidation))
certificateDetail_domainValidationOptions :: (Maybe (NonEmpty DomainValidation)
 -> f (Maybe (NonEmpty DomainValidation)))
-> CertificateDetail -> f CertificateDetail
certificateDetail_domainValidationOptions = (CertificateDetail -> Maybe (NonEmpty DomainValidation))
-> (CertificateDetail
    -> Maybe (NonEmpty DomainValidation) -> CertificateDetail)
-> Lens
     CertificateDetail
     CertificateDetail
     (Maybe (NonEmpty DomainValidation))
     (Maybe (NonEmpty DomainValidation))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe (NonEmpty DomainValidation)
domainValidationOptions :: Maybe (NonEmpty DomainValidation)
$sel:domainValidationOptions:CertificateDetail' :: CertificateDetail -> Maybe (NonEmpty DomainValidation)
domainValidationOptions} -> Maybe (NonEmpty DomainValidation)
domainValidationOptions) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe (NonEmpty DomainValidation)
a -> CertificateDetail
s {$sel:domainValidationOptions:CertificateDetail' :: Maybe (NonEmpty DomainValidation)
domainValidationOptions = Maybe (NonEmpty DomainValidation)
a} :: CertificateDetail) ((Maybe (NonEmpty DomainValidation)
  -> f (Maybe (NonEmpty DomainValidation)))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe (NonEmpty DomainValidation)
     -> f (Maybe (NonEmpty DomainValidation)))
    -> Maybe (NonEmpty DomainValidation)
    -> f (Maybe (NonEmpty DomainValidation)))
-> (Maybe (NonEmpty DomainValidation)
    -> f (Maybe (NonEmpty DomainValidation)))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (NonEmpty DomainValidation)
  (NonEmpty DomainValidation)
  (NonEmpty DomainValidation)
  (NonEmpty DomainValidation)
-> Iso
     (Maybe (NonEmpty DomainValidation))
     (Maybe (NonEmpty DomainValidation))
     (Maybe (NonEmpty DomainValidation))
     (Maybe (NonEmpty DomainValidation))
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
  (NonEmpty DomainValidation)
  (NonEmpty DomainValidation)
  (NonEmpty DomainValidation)
  (NonEmpty DomainValidation)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of the certificate authority that issued and signed the
-- certificate.
certificateDetail_issuer :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.Text)
certificateDetail_issuer :: (Maybe Text -> f (Maybe Text))
-> CertificateDetail -> f CertificateDetail
certificateDetail_issuer = (CertificateDetail -> Maybe Text)
-> (CertificateDetail -> Maybe Text -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe Text
issuer :: Maybe Text
$sel:issuer:CertificateDetail' :: CertificateDetail -> Maybe Text
issuer} -> Maybe Text
issuer) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe Text
a -> CertificateDetail
s {$sel:issuer:CertificateDetail' :: Maybe Text
issuer = Maybe Text
a} :: CertificateDetail)

-- | The time after which the certificate is not valid.
certificateDetail_notAfter :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.UTCTime)
certificateDetail_notAfter :: (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail -> f CertificateDetail
certificateDetail_notAfter = (CertificateDetail -> Maybe POSIX)
-> (CertificateDetail -> Maybe POSIX -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe POSIX) (Maybe POSIX)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe POSIX
notAfter :: Maybe POSIX
$sel:notAfter:CertificateDetail' :: CertificateDetail -> Maybe POSIX
notAfter} -> Maybe POSIX
notAfter) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe POSIX
a -> CertificateDetail
s {$sel:notAfter:CertificateDetail' :: Maybe POSIX
notAfter = Maybe POSIX
a} :: CertificateDetail) ((Maybe POSIX -> f (Maybe POSIX))
 -> CertificateDetail -> f CertificateDetail)
-> ((Maybe UTCTime -> f (Maybe UTCTime))
    -> Maybe POSIX -> f (Maybe POSIX))
-> (Maybe UTCTime -> f (Maybe UTCTime))
-> CertificateDetail
-> f CertificateDetail
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso POSIX POSIX UTCTime UTCTime
-> Iso (Maybe POSIX) (Maybe POSIX) (Maybe UTCTime) (Maybe UTCTime)
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 POSIX POSIX UTCTime UTCTime
forall (a :: Format). Iso' (Time a) UTCTime
Core._Time

-- | The Amazon Resource Name (ARN) of the ACM PCA private certificate
-- authority (CA) that issued the certificate. This has the following
-- format:
--
-- @arn:aws:acm-pca:region:account:certificate-authority\/12345678-1234-1234-1234-123456789012@
certificateDetail_certificateAuthorityArn :: Lens.Lens' CertificateDetail (Prelude.Maybe Prelude.Text)
certificateDetail_certificateAuthorityArn :: (Maybe Text -> f (Maybe Text))
-> CertificateDetail -> f CertificateDetail
certificateDetail_certificateAuthorityArn = (CertificateDetail -> Maybe Text)
-> (CertificateDetail -> Maybe Text -> CertificateDetail)
-> Lens
     CertificateDetail CertificateDetail (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CertificateDetail' {Maybe Text
certificateAuthorityArn :: Maybe Text
$sel:certificateAuthorityArn:CertificateDetail' :: CertificateDetail -> Maybe Text
certificateAuthorityArn} -> Maybe Text
certificateAuthorityArn) (\s :: CertificateDetail
s@CertificateDetail' {} Maybe Text
a -> CertificateDetail
s {$sel:certificateAuthorityArn:CertificateDetail' :: Maybe Text
certificateAuthorityArn = Maybe Text
a} :: CertificateDetail)

instance Core.FromJSON CertificateDetail where
  parseJSON :: Value -> Parser CertificateDetail
parseJSON =
    String
-> (Object -> Parser CertificateDetail)
-> Value
-> Parser CertificateDetail
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"CertificateDetail"
      ( \Object
x ->
          Maybe Text
-> Maybe CertificateStatus
-> Maybe FailureReason
-> Maybe (NonEmpty Text)
-> Maybe [Text]
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe RenewalEligibility
-> Maybe [ExtendedKeyUsage]
-> Maybe POSIX
-> Maybe [KeyUsage]
-> Maybe POSIX
-> Maybe POSIX
-> Maybe RevocationReason
-> Maybe Text
-> Maybe RenewalSummary
-> Maybe KeyAlgorithm
-> Maybe CertificateType
-> Maybe CertificateOptions
-> Maybe POSIX
-> Maybe Text
-> Maybe (NonEmpty DomainValidation)
-> Maybe Text
-> Maybe POSIX
-> Maybe Text
-> CertificateDetail
CertificateDetail'
            (Maybe Text
 -> Maybe CertificateStatus
 -> Maybe FailureReason
 -> Maybe (NonEmpty Text)
 -> Maybe [Text]
 -> Maybe POSIX
 -> Maybe Text
 -> Maybe Text
 -> Maybe RenewalEligibility
 -> Maybe [ExtendedKeyUsage]
 -> Maybe POSIX
 -> Maybe [KeyUsage]
 -> Maybe POSIX
 -> Maybe POSIX
 -> Maybe RevocationReason
 -> Maybe Text
 -> Maybe RenewalSummary
 -> Maybe KeyAlgorithm
 -> Maybe CertificateType
 -> Maybe CertificateOptions
 -> Maybe POSIX
 -> Maybe Text
 -> Maybe (NonEmpty DomainValidation)
 -> Maybe Text
 -> Maybe POSIX
 -> Maybe Text
 -> CertificateDetail)
-> Parser (Maybe Text)
-> Parser
     (Maybe CertificateStatus
      -> Maybe FailureReason
      -> Maybe (NonEmpty Text)
      -> Maybe [Text]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Text
      -> Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"Subject")
            Parser
  (Maybe CertificateStatus
   -> Maybe FailureReason
   -> Maybe (NonEmpty Text)
   -> Maybe [Text]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Text
   -> Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe CertificateStatus)
-> Parser
     (Maybe FailureReason
      -> Maybe (NonEmpty Text)
      -> Maybe [Text]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Text
      -> Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe CertificateStatus)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"Status")
            Parser
  (Maybe FailureReason
   -> Maybe (NonEmpty Text)
   -> Maybe [Text]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Text
   -> Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe FailureReason)
-> Parser
     (Maybe (NonEmpty Text)
      -> Maybe [Text]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Text
      -> Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe FailureReason)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"FailureReason")
            Parser
  (Maybe (NonEmpty Text)
   -> Maybe [Text]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Text
   -> Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe (NonEmpty Text))
-> Parser
     (Maybe [Text]
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe Text
      -> Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (NonEmpty Text))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"SubjectAlternativeNames")
            Parser
  (Maybe [Text]
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe Text
   -> Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe [Text])
-> Parser
     (Maybe POSIX
      -> Maybe Text
      -> Maybe Text
      -> Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [Text]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"InUseBy" Parser (Maybe (Maybe [Text]))
-> Maybe [Text] -> Parser (Maybe [Text])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [Text]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe POSIX
   -> Maybe Text
   -> Maybe Text
   -> Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe Text
      -> Maybe Text
      -> Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"CreatedAt")
            Parser
  (Maybe Text
   -> Maybe Text
   -> Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe Text)
-> Parser
     (Maybe Text
      -> Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"CertificateArn")
            Parser
  (Maybe Text
   -> Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe Text)
-> Parser
     (Maybe RenewalEligibility
      -> Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"Serial")
            Parser
  (Maybe RenewalEligibility
   -> Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe RenewalEligibility)
-> Parser
     (Maybe [ExtendedKeyUsage]
      -> Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe RenewalEligibility)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"RenewalEligibility")
            Parser
  (Maybe [ExtendedKeyUsage]
   -> Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe [ExtendedKeyUsage])
-> Parser
     (Maybe POSIX
      -> Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x Object -> Text -> Parser (Maybe (Maybe [ExtendedKeyUsage]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"ExtendedKeyUsages"
                            Parser (Maybe (Maybe [ExtendedKeyUsage]))
-> Maybe [ExtendedKeyUsage] -> Parser (Maybe [ExtendedKeyUsage])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [ExtendedKeyUsage]
forall a. Monoid a => a
Prelude.mempty
                        )
            Parser
  (Maybe POSIX
   -> Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe [KeyUsage]
      -> Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"ImportedAt")
            Parser
  (Maybe [KeyUsage]
   -> Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe [KeyUsage])
-> Parser
     (Maybe POSIX
      -> Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (Maybe [KeyUsage]))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"KeyUsages" Parser (Maybe (Maybe [KeyUsage]))
-> Maybe [KeyUsage] -> Parser (Maybe [KeyUsage])
forall a. Parser (Maybe a) -> a -> Parser a
Core..!= Maybe [KeyUsage]
forall a. Monoid a => a
Prelude.mempty)
            Parser
  (Maybe POSIX
   -> Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe POSIX
      -> Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"RevokedAt")
            Parser
  (Maybe POSIX
   -> Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe RevocationReason
      -> Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"NotBefore")
            Parser
  (Maybe RevocationReason
   -> Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe RevocationReason)
-> Parser
     (Maybe Text
      -> Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe RevocationReason)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"RevocationReason")
            Parser
  (Maybe Text
   -> Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe Text)
-> Parser
     (Maybe RenewalSummary
      -> Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"DomainName")
            Parser
  (Maybe RenewalSummary
   -> Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe RenewalSummary)
-> Parser
     (Maybe KeyAlgorithm
      -> Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe RenewalSummary)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"RenewalSummary")
            Parser
  (Maybe KeyAlgorithm
   -> Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe KeyAlgorithm)
-> Parser
     (Maybe CertificateType
      -> Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe KeyAlgorithm)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"KeyAlgorithm")
            Parser
  (Maybe CertificateType
   -> Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe CertificateType)
-> Parser
     (Maybe CertificateOptions
      -> Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe CertificateType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"Type")
            Parser
  (Maybe CertificateOptions
   -> Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe CertificateOptions)
-> Parser
     (Maybe POSIX
      -> Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe CertificateOptions)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"Options")
            Parser
  (Maybe POSIX
   -> Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe POSIX)
-> Parser
     (Maybe Text
      -> Maybe (NonEmpty DomainValidation)
      -> Maybe Text
      -> Maybe POSIX
      -> Maybe Text
      -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"IssuedAt")
            Parser
  (Maybe Text
   -> Maybe (NonEmpty DomainValidation)
   -> Maybe Text
   -> Maybe POSIX
   -> Maybe Text
   -> CertificateDetail)
-> Parser (Maybe Text)
-> Parser
     (Maybe (NonEmpty DomainValidation)
      -> Maybe Text -> Maybe POSIX -> Maybe Text -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"SignatureAlgorithm")
            Parser
  (Maybe (NonEmpty DomainValidation)
   -> Maybe Text -> Maybe POSIX -> Maybe Text -> CertificateDetail)
-> Parser (Maybe (NonEmpty DomainValidation))
-> Parser
     (Maybe Text -> Maybe POSIX -> Maybe Text -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe (NonEmpty DomainValidation))
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"DomainValidationOptions")
            Parser
  (Maybe Text -> Maybe POSIX -> Maybe Text -> CertificateDetail)
-> Parser (Maybe Text)
-> Parser (Maybe POSIX -> Maybe Text -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"Issuer")
            Parser (Maybe POSIX -> Maybe Text -> CertificateDetail)
-> Parser (Maybe POSIX) -> Parser (Maybe Text -> CertificateDetail)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe POSIX)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"NotAfter")
            Parser (Maybe Text -> CertificateDetail)
-> Parser (Maybe Text) -> Parser CertificateDetail
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Text)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"CertificateAuthorityArn")
      )

instance Prelude.Hashable CertificateDetail

instance Prelude.NFData CertificateDetail