{-# 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.CloudFront.ListConflictingAliases
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Gets a list of aliases (also called CNAMEs or alternate domain names)
-- that conflict or overlap with the provided alias, and the associated
-- CloudFront distributions and Amazon Web Services accounts for each
-- conflicting alias. In the returned list, the distribution and account
-- IDs are partially hidden, which allows you to identify the distributions
-- and accounts that you own, but helps to protect the information of ones
-- that you don\'t own.
--
-- Use this operation to find aliases that are in use in CloudFront that
-- conflict or overlap with the provided alias. For example, if you provide
-- @www.example.com@ as input, the returned list can include
-- @www.example.com@ and the overlapping wildcard alternate domain name
-- (@*.example.com@), if they exist. If you provide @*.example.com@ as
-- input, the returned list can include @*.example.com@ and any alternate
-- domain names covered by that wildcard (for example, @www.example.com@,
-- @test.example.com@, @dev.example.com@, and so on), if they exist.
--
-- To list conflicting aliases, you provide the alias to search and the ID
-- of a distribution in your account that has an attached SSL\/TLS
-- certificate that includes the provided alias. For more information,
-- including how to set up the distribution and certificate, see
-- <https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/CNAMEs.html#alternate-domain-names-move Moving an alternate domain name to a different distribution>
-- in the /Amazon CloudFront Developer Guide/.
--
-- You can optionally specify the maximum number of items to receive in the
-- response. If the total number of items in the list exceeds the maximum
-- that you specify, or the default maximum, the response is paginated. To
-- get the next page of items, send a subsequent request that specifies the
-- @NextMarker@ value from the current response as the @Marker@ value in
-- the subsequent request.
module Amazonka.CloudFront.ListConflictingAliases
  ( -- * Creating a Request
    ListConflictingAliases (..),
    newListConflictingAliases,

    -- * Request Lenses
    listConflictingAliases_marker,
    listConflictingAliases_maxItems,
    listConflictingAliases_distributionId,
    listConflictingAliases_alias,

    -- * Destructuring the Response
    ListConflictingAliasesResponse (..),
    newListConflictingAliasesResponse,

    -- * Response Lenses
    listConflictingAliasesResponse_conflictingAliasesList,
    listConflictingAliasesResponse_httpStatus,
  )
where

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

-- | /See:/ 'newListConflictingAliases' smart constructor.
data ListConflictingAliases = ListConflictingAliases'
  { -- | Use this field when paginating results to indicate where to begin in the
    -- list of conflicting aliases. The response includes conflicting aliases
    -- in the list that occur after the marker. To get the next page of the
    -- list, set this field\'s value to the value of @NextMarker@ from the
    -- current page\'s response.
    ListConflictingAliases -> Maybe Text
marker :: Prelude.Maybe Prelude.Text,
    -- | The maximum number of conflicting aliases that you want in the response.
    ListConflictingAliases -> Maybe Int
maxItems :: Prelude.Maybe Prelude.Int,
    -- | The ID of a distribution in your account that has an attached SSL\/TLS
    -- certificate that includes the provided alias.
    ListConflictingAliases -> Text
distributionId :: Prelude.Text,
    -- | The alias (also called a CNAME) to search for conflicting aliases.
    ListConflictingAliases -> Text
alias :: Prelude.Text
  }
  deriving (ListConflictingAliases -> ListConflictingAliases -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListConflictingAliases -> ListConflictingAliases -> Bool
$c/= :: ListConflictingAliases -> ListConflictingAliases -> Bool
== :: ListConflictingAliases -> ListConflictingAliases -> Bool
$c== :: ListConflictingAliases -> ListConflictingAliases -> Bool
Prelude.Eq, ReadPrec [ListConflictingAliases]
ReadPrec ListConflictingAliases
Int -> ReadS ListConflictingAliases
ReadS [ListConflictingAliases]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListConflictingAliases]
$creadListPrec :: ReadPrec [ListConflictingAliases]
readPrec :: ReadPrec ListConflictingAliases
$creadPrec :: ReadPrec ListConflictingAliases
readList :: ReadS [ListConflictingAliases]
$creadList :: ReadS [ListConflictingAliases]
readsPrec :: Int -> ReadS ListConflictingAliases
$creadsPrec :: Int -> ReadS ListConflictingAliases
Prelude.Read, Int -> ListConflictingAliases -> ShowS
[ListConflictingAliases] -> ShowS
ListConflictingAliases -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListConflictingAliases] -> ShowS
$cshowList :: [ListConflictingAliases] -> ShowS
show :: ListConflictingAliases -> String
$cshow :: ListConflictingAliases -> String
showsPrec :: Int -> ListConflictingAliases -> ShowS
$cshowsPrec :: Int -> ListConflictingAliases -> ShowS
Prelude.Show, forall x. Rep ListConflictingAliases x -> ListConflictingAliases
forall x. ListConflictingAliases -> Rep ListConflictingAliases x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ListConflictingAliases x -> ListConflictingAliases
$cfrom :: forall x. ListConflictingAliases -> Rep ListConflictingAliases x
Prelude.Generic)

-- |
-- Create a value of 'ListConflictingAliases' 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:
--
-- 'marker', 'listConflictingAliases_marker' - Use this field when paginating results to indicate where to begin in the
-- list of conflicting aliases. The response includes conflicting aliases
-- in the list that occur after the marker. To get the next page of the
-- list, set this field\'s value to the value of @NextMarker@ from the
-- current page\'s response.
--
-- 'maxItems', 'listConflictingAliases_maxItems' - The maximum number of conflicting aliases that you want in the response.
--
-- 'distributionId', 'listConflictingAliases_distributionId' - The ID of a distribution in your account that has an attached SSL\/TLS
-- certificate that includes the provided alias.
--
-- 'alias', 'listConflictingAliases_alias' - The alias (also called a CNAME) to search for conflicting aliases.
newListConflictingAliases ::
  -- | 'distributionId'
  Prelude.Text ->
  -- | 'alias'
  Prelude.Text ->
  ListConflictingAliases
newListConflictingAliases :: Text -> Text -> ListConflictingAliases
newListConflictingAliases Text
pDistributionId_ Text
pAlias_ =
  ListConflictingAliases'
    { $sel:marker:ListConflictingAliases' :: Maybe Text
marker = forall a. Maybe a
Prelude.Nothing,
      $sel:maxItems:ListConflictingAliases' :: Maybe Int
maxItems = forall a. Maybe a
Prelude.Nothing,
      $sel:distributionId:ListConflictingAliases' :: Text
distributionId = Text
pDistributionId_,
      $sel:alias:ListConflictingAliases' :: Text
alias = Text
pAlias_
    }

-- | Use this field when paginating results to indicate where to begin in the
-- list of conflicting aliases. The response includes conflicting aliases
-- in the list that occur after the marker. To get the next page of the
-- list, set this field\'s value to the value of @NextMarker@ from the
-- current page\'s response.
listConflictingAliases_marker :: Lens.Lens' ListConflictingAliases (Prelude.Maybe Prelude.Text)
listConflictingAliases_marker :: Lens' ListConflictingAliases (Maybe Text)
listConflictingAliases_marker = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListConflictingAliases' {Maybe Text
marker :: Maybe Text
$sel:marker:ListConflictingAliases' :: ListConflictingAliases -> Maybe Text
marker} -> Maybe Text
marker) (\s :: ListConflictingAliases
s@ListConflictingAliases' {} Maybe Text
a -> ListConflictingAliases
s {$sel:marker:ListConflictingAliases' :: Maybe Text
marker = Maybe Text
a} :: ListConflictingAliases)

-- | The maximum number of conflicting aliases that you want in the response.
listConflictingAliases_maxItems :: Lens.Lens' ListConflictingAliases (Prelude.Maybe Prelude.Int)
listConflictingAliases_maxItems :: Lens' ListConflictingAliases (Maybe Int)
listConflictingAliases_maxItems = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListConflictingAliases' {Maybe Int
maxItems :: Maybe Int
$sel:maxItems:ListConflictingAliases' :: ListConflictingAliases -> Maybe Int
maxItems} -> Maybe Int
maxItems) (\s :: ListConflictingAliases
s@ListConflictingAliases' {} Maybe Int
a -> ListConflictingAliases
s {$sel:maxItems:ListConflictingAliases' :: Maybe Int
maxItems = Maybe Int
a} :: ListConflictingAliases)

-- | The ID of a distribution in your account that has an attached SSL\/TLS
-- certificate that includes the provided alias.
listConflictingAliases_distributionId :: Lens.Lens' ListConflictingAliases Prelude.Text
listConflictingAliases_distributionId :: Lens' ListConflictingAliases Text
listConflictingAliases_distributionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListConflictingAliases' {Text
distributionId :: Text
$sel:distributionId:ListConflictingAliases' :: ListConflictingAliases -> Text
distributionId} -> Text
distributionId) (\s :: ListConflictingAliases
s@ListConflictingAliases' {} Text
a -> ListConflictingAliases
s {$sel:distributionId:ListConflictingAliases' :: Text
distributionId = Text
a} :: ListConflictingAliases)

-- | The alias (also called a CNAME) to search for conflicting aliases.
listConflictingAliases_alias :: Lens.Lens' ListConflictingAliases Prelude.Text
listConflictingAliases_alias :: Lens' ListConflictingAliases Text
listConflictingAliases_alias = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListConflictingAliases' {Text
alias :: Text
$sel:alias:ListConflictingAliases' :: ListConflictingAliases -> Text
alias} -> Text
alias) (\s :: ListConflictingAliases
s@ListConflictingAliases' {} Text
a -> ListConflictingAliases
s {$sel:alias:ListConflictingAliases' :: Text
alias = Text
a} :: ListConflictingAliases)

instance Core.AWSRequest ListConflictingAliases where
  type
    AWSResponse ListConflictingAliases =
      ListConflictingAliasesResponse
  request :: (Service -> Service)
-> ListConflictingAliases -> Request ListConflictingAliases
request Service -> Service
overrides =
    forall a. ToRequest a => Service -> a -> Request a
Request.get (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy ListConflictingAliases
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse ListConflictingAliases)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> [Node] -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveXML
      ( \Int
s ResponseHeaders
h [Node]
x ->
          Maybe ConflictingAliasesList
-> Int -> ListConflictingAliasesResponse
ListConflictingAliasesResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (forall a. FromXML a => [Node] -> Either String a
Data.parseXML [Node]
x)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable ListConflictingAliases where
  hashWithSalt :: Int -> ListConflictingAliases -> Int
hashWithSalt Int
_salt ListConflictingAliases' {Maybe Int
Maybe Text
Text
alias :: Text
distributionId :: Text
maxItems :: Maybe Int
marker :: Maybe Text
$sel:alias:ListConflictingAliases' :: ListConflictingAliases -> Text
$sel:distributionId:ListConflictingAliases' :: ListConflictingAliases -> Text
$sel:maxItems:ListConflictingAliases' :: ListConflictingAliases -> Maybe Int
$sel:marker:ListConflictingAliases' :: ListConflictingAliases -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
marker
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
maxItems
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
distributionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
alias

instance Prelude.NFData ListConflictingAliases where
  rnf :: ListConflictingAliases -> ()
rnf ListConflictingAliases' {Maybe Int
Maybe Text
Text
alias :: Text
distributionId :: Text
maxItems :: Maybe Int
marker :: Maybe Text
$sel:alias:ListConflictingAliases' :: ListConflictingAliases -> Text
$sel:distributionId:ListConflictingAliases' :: ListConflictingAliases -> Text
$sel:maxItems:ListConflictingAliases' :: ListConflictingAliases -> Maybe Int
$sel:marker:ListConflictingAliases' :: ListConflictingAliases -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
marker
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
maxItems
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
distributionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
alias

instance Data.ToHeaders ListConflictingAliases where
  toHeaders :: ListConflictingAliases -> ResponseHeaders
toHeaders = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

instance Data.ToPath ListConflictingAliases where
  toPath :: ListConflictingAliases -> ByteString
toPath =
    forall a b. a -> b -> a
Prelude.const ByteString
"/2020-05-31/conflicting-alias"

instance Data.ToQuery ListConflictingAliases where
  toQuery :: ListConflictingAliases -> QueryString
toQuery ListConflictingAliases' {Maybe Int
Maybe Text
Text
alias :: Text
distributionId :: Text
maxItems :: Maybe Int
marker :: Maybe Text
$sel:alias:ListConflictingAliases' :: ListConflictingAliases -> Text
$sel:distributionId:ListConflictingAliases' :: ListConflictingAliases -> Text
$sel:maxItems:ListConflictingAliases' :: ListConflictingAliases -> Maybe Int
$sel:marker:ListConflictingAliases' :: ListConflictingAliases -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"Marker" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
marker,
        ByteString
"MaxItems" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Int
maxItems,
        ByteString
"DistributionId" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
distributionId,
        ByteString
"Alias" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Text
alias
      ]

-- | /See:/ 'newListConflictingAliasesResponse' smart constructor.
data ListConflictingAliasesResponse = ListConflictingAliasesResponse'
  { -- | A list of conflicting aliases.
    ListConflictingAliasesResponse -> Maybe ConflictingAliasesList
conflictingAliasesList :: Prelude.Maybe ConflictingAliasesList,
    -- | The response's http status code.
    ListConflictingAliasesResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ListConflictingAliasesResponse
-> ListConflictingAliasesResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ListConflictingAliasesResponse
-> ListConflictingAliasesResponse -> Bool
$c/= :: ListConflictingAliasesResponse
-> ListConflictingAliasesResponse -> Bool
== :: ListConflictingAliasesResponse
-> ListConflictingAliasesResponse -> Bool
$c== :: ListConflictingAliasesResponse
-> ListConflictingAliasesResponse -> Bool
Prelude.Eq, ReadPrec [ListConflictingAliasesResponse]
ReadPrec ListConflictingAliasesResponse
Int -> ReadS ListConflictingAliasesResponse
ReadS [ListConflictingAliasesResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ListConflictingAliasesResponse]
$creadListPrec :: ReadPrec [ListConflictingAliasesResponse]
readPrec :: ReadPrec ListConflictingAliasesResponse
$creadPrec :: ReadPrec ListConflictingAliasesResponse
readList :: ReadS [ListConflictingAliasesResponse]
$creadList :: ReadS [ListConflictingAliasesResponse]
readsPrec :: Int -> ReadS ListConflictingAliasesResponse
$creadsPrec :: Int -> ReadS ListConflictingAliasesResponse
Prelude.Read, Int -> ListConflictingAliasesResponse -> ShowS
[ListConflictingAliasesResponse] -> ShowS
ListConflictingAliasesResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ListConflictingAliasesResponse] -> ShowS
$cshowList :: [ListConflictingAliasesResponse] -> ShowS
show :: ListConflictingAliasesResponse -> String
$cshow :: ListConflictingAliasesResponse -> String
showsPrec :: Int -> ListConflictingAliasesResponse -> ShowS
$cshowsPrec :: Int -> ListConflictingAliasesResponse -> ShowS
Prelude.Show, forall x.
Rep ListConflictingAliasesResponse x
-> ListConflictingAliasesResponse
forall x.
ListConflictingAliasesResponse
-> Rep ListConflictingAliasesResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ListConflictingAliasesResponse x
-> ListConflictingAliasesResponse
$cfrom :: forall x.
ListConflictingAliasesResponse
-> Rep ListConflictingAliasesResponse x
Prelude.Generic)

-- |
-- Create a value of 'ListConflictingAliasesResponse' 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:
--
-- 'conflictingAliasesList', 'listConflictingAliasesResponse_conflictingAliasesList' - A list of conflicting aliases.
--
-- 'httpStatus', 'listConflictingAliasesResponse_httpStatus' - The response's http status code.
newListConflictingAliasesResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ListConflictingAliasesResponse
newListConflictingAliasesResponse :: Int -> ListConflictingAliasesResponse
newListConflictingAliasesResponse Int
pHttpStatus_ =
  ListConflictingAliasesResponse'
    { $sel:conflictingAliasesList:ListConflictingAliasesResponse' :: Maybe ConflictingAliasesList
conflictingAliasesList =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ListConflictingAliasesResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of conflicting aliases.
listConflictingAliasesResponse_conflictingAliasesList :: Lens.Lens' ListConflictingAliasesResponse (Prelude.Maybe ConflictingAliasesList)
listConflictingAliasesResponse_conflictingAliasesList :: Lens' ListConflictingAliasesResponse (Maybe ConflictingAliasesList)
listConflictingAliasesResponse_conflictingAliasesList = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ListConflictingAliasesResponse' {Maybe ConflictingAliasesList
conflictingAliasesList :: Maybe ConflictingAliasesList
$sel:conflictingAliasesList:ListConflictingAliasesResponse' :: ListConflictingAliasesResponse -> Maybe ConflictingAliasesList
conflictingAliasesList} -> Maybe ConflictingAliasesList
conflictingAliasesList) (\s :: ListConflictingAliasesResponse
s@ListConflictingAliasesResponse' {} Maybe ConflictingAliasesList
a -> ListConflictingAliasesResponse
s {$sel:conflictingAliasesList:ListConflictingAliasesResponse' :: Maybe ConflictingAliasesList
conflictingAliasesList = Maybe ConflictingAliasesList
a} :: ListConflictingAliasesResponse)

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

instance
  Prelude.NFData
    ListConflictingAliasesResponse
  where
  rnf :: ListConflictingAliasesResponse -> ()
rnf ListConflictingAliasesResponse' {Int
Maybe ConflictingAliasesList
httpStatus :: Int
conflictingAliasesList :: Maybe ConflictingAliasesList
$sel:httpStatus:ListConflictingAliasesResponse' :: ListConflictingAliasesResponse -> Int
$sel:conflictingAliasesList:ListConflictingAliasesResponse' :: ListConflictingAliasesResponse -> Maybe ConflictingAliasesList
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe ConflictingAliasesList
conflictingAliasesList
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus