{-# 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.CopyDistribution
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Creates a staging distribution using the configuration of the provided
-- primary distribution. A staging distribution is a copy of an existing
-- distribution (called the primary distribution) that you can use in a
-- continuous deployment workflow.
--
-- After you create a staging distribution, you can use
-- @UpdateDistribution@ to modify the staging distribution\'s
-- configuration. Then you can use @CreateContinuousDeploymentPolicy@ to
-- incrementally move traffic to the staging distribution.
module Amazonka.CloudFront.CopyDistribution
  ( -- * Creating a Request
    CopyDistribution (..),
    newCopyDistribution,

    -- * Request Lenses
    copyDistribution_ifMatch,
    copyDistribution_staging,
    copyDistribution_primaryDistributionId,
    copyDistribution_callerReference,

    -- * Destructuring the Response
    CopyDistributionResponse (..),
    newCopyDistributionResponse,

    -- * Response Lenses
    copyDistributionResponse_distribution,
    copyDistributionResponse_eTag,
    copyDistributionResponse_location,
    copyDistributionResponse_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:/ 'newCopyDistribution' smart constructor.
data CopyDistribution = CopyDistribution'
  { -- | The version identifier of the primary distribution whose configuration
    -- you are copying. This is the @ETag@ value returned in the response to
    -- @GetDistribution@ and @GetDistributionConfig@.
    CopyDistribution -> Maybe Text
ifMatch :: Prelude.Maybe Prelude.Text,
    -- | The type of distribution that your primary distribution will be copied
    -- to. The only valid value is @True@, indicating that you are copying to a
    -- staging distribution.
    CopyDistribution -> Maybe Bool
staging :: Prelude.Maybe Prelude.Bool,
    -- | The identifier of the primary distribution whose configuration you are
    -- copying. To get a distribution ID, use @ListDistributions@.
    CopyDistribution -> Text
primaryDistributionId :: Prelude.Text,
    -- | A value that uniquely identifies a request to create a resource. This
    -- helps to prevent CloudFront from creating a duplicate resource if you
    -- accidentally resubmit an identical request.
    CopyDistribution -> Text
callerReference :: Prelude.Text
  }
  deriving (CopyDistribution -> CopyDistribution -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyDistribution -> CopyDistribution -> Bool
$c/= :: CopyDistribution -> CopyDistribution -> Bool
== :: CopyDistribution -> CopyDistribution -> Bool
$c== :: CopyDistribution -> CopyDistribution -> Bool
Prelude.Eq, ReadPrec [CopyDistribution]
ReadPrec CopyDistribution
Int -> ReadS CopyDistribution
ReadS [CopyDistribution]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CopyDistribution]
$creadListPrec :: ReadPrec [CopyDistribution]
readPrec :: ReadPrec CopyDistribution
$creadPrec :: ReadPrec CopyDistribution
readList :: ReadS [CopyDistribution]
$creadList :: ReadS [CopyDistribution]
readsPrec :: Int -> ReadS CopyDistribution
$creadsPrec :: Int -> ReadS CopyDistribution
Prelude.Read, Int -> CopyDistribution -> ShowS
[CopyDistribution] -> ShowS
CopyDistribution -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyDistribution] -> ShowS
$cshowList :: [CopyDistribution] -> ShowS
show :: CopyDistribution -> String
$cshow :: CopyDistribution -> String
showsPrec :: Int -> CopyDistribution -> ShowS
$cshowsPrec :: Int -> CopyDistribution -> ShowS
Prelude.Show, forall x. Rep CopyDistribution x -> CopyDistribution
forall x. CopyDistribution -> Rep CopyDistribution x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CopyDistribution x -> CopyDistribution
$cfrom :: forall x. CopyDistribution -> Rep CopyDistribution x
Prelude.Generic)

-- |
-- Create a value of 'CopyDistribution' 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:
--
-- 'ifMatch', 'copyDistribution_ifMatch' - The version identifier of the primary distribution whose configuration
-- you are copying. This is the @ETag@ value returned in the response to
-- @GetDistribution@ and @GetDistributionConfig@.
--
-- 'staging', 'copyDistribution_staging' - The type of distribution that your primary distribution will be copied
-- to. The only valid value is @True@, indicating that you are copying to a
-- staging distribution.
--
-- 'primaryDistributionId', 'copyDistribution_primaryDistributionId' - The identifier of the primary distribution whose configuration you are
-- copying. To get a distribution ID, use @ListDistributions@.
--
-- 'callerReference', 'copyDistribution_callerReference' - A value that uniquely identifies a request to create a resource. This
-- helps to prevent CloudFront from creating a duplicate resource if you
-- accidentally resubmit an identical request.
newCopyDistribution ::
  -- | 'primaryDistributionId'
  Prelude.Text ->
  -- | 'callerReference'
  Prelude.Text ->
  CopyDistribution
newCopyDistribution :: Text -> Text -> CopyDistribution
newCopyDistribution
  Text
pPrimaryDistributionId_
  Text
pCallerReference_ =
    CopyDistribution'
      { $sel:ifMatch:CopyDistribution' :: Maybe Text
ifMatch = forall a. Maybe a
Prelude.Nothing,
        $sel:staging:CopyDistribution' :: Maybe Bool
staging = forall a. Maybe a
Prelude.Nothing,
        $sel:primaryDistributionId:CopyDistribution' :: Text
primaryDistributionId = Text
pPrimaryDistributionId_,
        $sel:callerReference:CopyDistribution' :: Text
callerReference = Text
pCallerReference_
      }

-- | The version identifier of the primary distribution whose configuration
-- you are copying. This is the @ETag@ value returned in the response to
-- @GetDistribution@ and @GetDistributionConfig@.
copyDistribution_ifMatch :: Lens.Lens' CopyDistribution (Prelude.Maybe Prelude.Text)
copyDistribution_ifMatch :: Lens' CopyDistribution (Maybe Text)
copyDistribution_ifMatch = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyDistribution' {Maybe Text
ifMatch :: Maybe Text
$sel:ifMatch:CopyDistribution' :: CopyDistribution -> Maybe Text
ifMatch} -> Maybe Text
ifMatch) (\s :: CopyDistribution
s@CopyDistribution' {} Maybe Text
a -> CopyDistribution
s {$sel:ifMatch:CopyDistribution' :: Maybe Text
ifMatch = Maybe Text
a} :: CopyDistribution)

-- | The type of distribution that your primary distribution will be copied
-- to. The only valid value is @True@, indicating that you are copying to a
-- staging distribution.
copyDistribution_staging :: Lens.Lens' CopyDistribution (Prelude.Maybe Prelude.Bool)
copyDistribution_staging :: Lens' CopyDistribution (Maybe Bool)
copyDistribution_staging = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyDistribution' {Maybe Bool
staging :: Maybe Bool
$sel:staging:CopyDistribution' :: CopyDistribution -> Maybe Bool
staging} -> Maybe Bool
staging) (\s :: CopyDistribution
s@CopyDistribution' {} Maybe Bool
a -> CopyDistribution
s {$sel:staging:CopyDistribution' :: Maybe Bool
staging = Maybe Bool
a} :: CopyDistribution)

-- | The identifier of the primary distribution whose configuration you are
-- copying. To get a distribution ID, use @ListDistributions@.
copyDistribution_primaryDistributionId :: Lens.Lens' CopyDistribution Prelude.Text
copyDistribution_primaryDistributionId :: Lens' CopyDistribution Text
copyDistribution_primaryDistributionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyDistribution' {Text
primaryDistributionId :: Text
$sel:primaryDistributionId:CopyDistribution' :: CopyDistribution -> Text
primaryDistributionId} -> Text
primaryDistributionId) (\s :: CopyDistribution
s@CopyDistribution' {} Text
a -> CopyDistribution
s {$sel:primaryDistributionId:CopyDistribution' :: Text
primaryDistributionId = Text
a} :: CopyDistribution)

-- | A value that uniquely identifies a request to create a resource. This
-- helps to prevent CloudFront from creating a duplicate resource if you
-- accidentally resubmit an identical request.
copyDistribution_callerReference :: Lens.Lens' CopyDistribution Prelude.Text
copyDistribution_callerReference :: Lens' CopyDistribution Text
copyDistribution_callerReference = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyDistribution' {Text
callerReference :: Text
$sel:callerReference:CopyDistribution' :: CopyDistribution -> Text
callerReference} -> Text
callerReference) (\s :: CopyDistribution
s@CopyDistribution' {} Text
a -> CopyDistribution
s {$sel:callerReference:CopyDistribution' :: Text
callerReference = Text
a} :: CopyDistribution)

instance Core.AWSRequest CopyDistribution where
  type
    AWSResponse CopyDistribution =
      CopyDistributionResponse
  request :: (Service -> Service)
-> CopyDistribution -> Request CopyDistribution
request Service -> Service
overrides =
    forall a. (ToRequest a, ToElement a) => Service -> a -> Request a
Request.postXML (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy CopyDistribution
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse CopyDistribution)))
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 Distribution
-> Maybe Text -> Maybe Text -> Int -> CopyDistributionResponse
CopyDistributionResponse'
            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.<*> (ResponseHeaders
h forall a.
FromText a =>
ResponseHeaders -> HeaderName -> Either String (Maybe a)
Data..#? HeaderName
"ETag")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (ResponseHeaders
h forall a.
FromText a =>
ResponseHeaders -> HeaderName -> Either String (Maybe a)
Data..#? HeaderName
"Location")
            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 CopyDistribution where
  hashWithSalt :: Int -> CopyDistribution -> Int
hashWithSalt Int
_salt CopyDistribution' {Maybe Bool
Maybe Text
Text
callerReference :: Text
primaryDistributionId :: Text
staging :: Maybe Bool
ifMatch :: Maybe Text
$sel:callerReference:CopyDistribution' :: CopyDistribution -> Text
$sel:primaryDistributionId:CopyDistribution' :: CopyDistribution -> Text
$sel:staging:CopyDistribution' :: CopyDistribution -> Maybe Bool
$sel:ifMatch:CopyDistribution' :: CopyDistribution -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
ifMatch
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
staging
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
primaryDistributionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
callerReference

instance Prelude.NFData CopyDistribution where
  rnf :: CopyDistribution -> ()
rnf CopyDistribution' {Maybe Bool
Maybe Text
Text
callerReference :: Text
primaryDistributionId :: Text
staging :: Maybe Bool
ifMatch :: Maybe Text
$sel:callerReference:CopyDistribution' :: CopyDistribution -> Text
$sel:primaryDistributionId:CopyDistribution' :: CopyDistribution -> Text
$sel:staging:CopyDistribution' :: CopyDistribution -> Maybe Bool
$sel:ifMatch:CopyDistribution' :: CopyDistribution -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
ifMatch
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
staging
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
primaryDistributionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
callerReference

instance Data.ToElement CopyDistribution where
  toElement :: CopyDistribution -> Element
toElement =
    forall a. ToXML a => Name -> a -> Element
Data.mkElement
      Name
"{http://cloudfront.amazonaws.com/doc/2020-05-31/}CopyDistributionRequest"

instance Data.ToHeaders CopyDistribution where
  toHeaders :: CopyDistribution -> ResponseHeaders
toHeaders CopyDistribution' {Maybe Bool
Maybe Text
Text
callerReference :: Text
primaryDistributionId :: Text
staging :: Maybe Bool
ifMatch :: Maybe Text
$sel:callerReference:CopyDistribution' :: CopyDistribution -> Text
$sel:primaryDistributionId:CopyDistribution' :: CopyDistribution -> Text
$sel:staging:CopyDistribution' :: CopyDistribution -> Maybe Bool
$sel:ifMatch:CopyDistribution' :: CopyDistribution -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ HeaderName
"If-Match" forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# Maybe Text
ifMatch,
        HeaderName
"Staging" forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# Maybe Bool
staging
      ]

instance Data.ToPath CopyDistribution where
  toPath :: CopyDistribution -> ByteString
toPath CopyDistribution' {Maybe Bool
Maybe Text
Text
callerReference :: Text
primaryDistributionId :: Text
staging :: Maybe Bool
ifMatch :: Maybe Text
$sel:callerReference:CopyDistribution' :: CopyDistribution -> Text
$sel:primaryDistributionId:CopyDistribution' :: CopyDistribution -> Text
$sel:staging:CopyDistribution' :: CopyDistribution -> Maybe Bool
$sel:ifMatch:CopyDistribution' :: CopyDistribution -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/2020-05-31/distribution/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
primaryDistributionId,
        ByteString
"/copy"
      ]

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

instance Data.ToXML CopyDistribution where
  toXML :: CopyDistribution -> XML
toXML CopyDistribution' {Maybe Bool
Maybe Text
Text
callerReference :: Text
primaryDistributionId :: Text
staging :: Maybe Bool
ifMatch :: Maybe Text
$sel:callerReference:CopyDistribution' :: CopyDistribution -> Text
$sel:primaryDistributionId:CopyDistribution' :: CopyDistribution -> Text
$sel:staging:CopyDistribution' :: CopyDistribution -> Maybe Bool
$sel:ifMatch:CopyDistribution' :: CopyDistribution -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [Name
"CallerReference" forall a. ToXML a => Name -> a -> XML
Data.@= Text
callerReference]

-- | /See:/ 'newCopyDistributionResponse' smart constructor.
data CopyDistributionResponse = CopyDistributionResponse'
  { CopyDistributionResponse -> Maybe Distribution
distribution :: Prelude.Maybe Distribution,
    -- | The version identifier for the current version of the staging
    -- distribution.
    CopyDistributionResponse -> Maybe Text
eTag :: Prelude.Maybe Prelude.Text,
    -- | The URL of the staging distribution.
    CopyDistributionResponse -> Maybe Text
location :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    CopyDistributionResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CopyDistributionResponse -> CopyDistributionResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CopyDistributionResponse -> CopyDistributionResponse -> Bool
$c/= :: CopyDistributionResponse -> CopyDistributionResponse -> Bool
== :: CopyDistributionResponse -> CopyDistributionResponse -> Bool
$c== :: CopyDistributionResponse -> CopyDistributionResponse -> Bool
Prelude.Eq, Int -> CopyDistributionResponse -> ShowS
[CopyDistributionResponse] -> ShowS
CopyDistributionResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CopyDistributionResponse] -> ShowS
$cshowList :: [CopyDistributionResponse] -> ShowS
show :: CopyDistributionResponse -> String
$cshow :: CopyDistributionResponse -> String
showsPrec :: Int -> CopyDistributionResponse -> ShowS
$cshowsPrec :: Int -> CopyDistributionResponse -> ShowS
Prelude.Show, forall x.
Rep CopyDistributionResponse x -> CopyDistributionResponse
forall x.
CopyDistributionResponse -> Rep CopyDistributionResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CopyDistributionResponse x -> CopyDistributionResponse
$cfrom :: forall x.
CopyDistributionResponse -> Rep CopyDistributionResponse x
Prelude.Generic)

-- |
-- Create a value of 'CopyDistributionResponse' 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:
--
-- 'distribution', 'copyDistributionResponse_distribution' - Undocumented member.
--
-- 'eTag', 'copyDistributionResponse_eTag' - The version identifier for the current version of the staging
-- distribution.
--
-- 'location', 'copyDistributionResponse_location' - The URL of the staging distribution.
--
-- 'httpStatus', 'copyDistributionResponse_httpStatus' - The response's http status code.
newCopyDistributionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CopyDistributionResponse
newCopyDistributionResponse :: Int -> CopyDistributionResponse
newCopyDistributionResponse Int
pHttpStatus_ =
  CopyDistributionResponse'
    { $sel:distribution:CopyDistributionResponse' :: Maybe Distribution
distribution =
        forall a. Maybe a
Prelude.Nothing,
      $sel:eTag:CopyDistributionResponse' :: Maybe Text
eTag = forall a. Maybe a
Prelude.Nothing,
      $sel:location:CopyDistributionResponse' :: Maybe Text
location = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CopyDistributionResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Undocumented member.
copyDistributionResponse_distribution :: Lens.Lens' CopyDistributionResponse (Prelude.Maybe Distribution)
copyDistributionResponse_distribution :: Lens' CopyDistributionResponse (Maybe Distribution)
copyDistributionResponse_distribution = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyDistributionResponse' {Maybe Distribution
distribution :: Maybe Distribution
$sel:distribution:CopyDistributionResponse' :: CopyDistributionResponse -> Maybe Distribution
distribution} -> Maybe Distribution
distribution) (\s :: CopyDistributionResponse
s@CopyDistributionResponse' {} Maybe Distribution
a -> CopyDistributionResponse
s {$sel:distribution:CopyDistributionResponse' :: Maybe Distribution
distribution = Maybe Distribution
a} :: CopyDistributionResponse)

-- | The version identifier for the current version of the staging
-- distribution.
copyDistributionResponse_eTag :: Lens.Lens' CopyDistributionResponse (Prelude.Maybe Prelude.Text)
copyDistributionResponse_eTag :: Lens' CopyDistributionResponse (Maybe Text)
copyDistributionResponse_eTag = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyDistributionResponse' {Maybe Text
eTag :: Maybe Text
$sel:eTag:CopyDistributionResponse' :: CopyDistributionResponse -> Maybe Text
eTag} -> Maybe Text
eTag) (\s :: CopyDistributionResponse
s@CopyDistributionResponse' {} Maybe Text
a -> CopyDistributionResponse
s {$sel:eTag:CopyDistributionResponse' :: Maybe Text
eTag = Maybe Text
a} :: CopyDistributionResponse)

-- | The URL of the staging distribution.
copyDistributionResponse_location :: Lens.Lens' CopyDistributionResponse (Prelude.Maybe Prelude.Text)
copyDistributionResponse_location :: Lens' CopyDistributionResponse (Maybe Text)
copyDistributionResponse_location = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CopyDistributionResponse' {Maybe Text
location :: Maybe Text
$sel:location:CopyDistributionResponse' :: CopyDistributionResponse -> Maybe Text
location} -> Maybe Text
location) (\s :: CopyDistributionResponse
s@CopyDistributionResponse' {} Maybe Text
a -> CopyDistributionResponse
s {$sel:location:CopyDistributionResponse' :: Maybe Text
location = Maybe Text
a} :: CopyDistributionResponse)

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

instance Prelude.NFData CopyDistributionResponse where
  rnf :: CopyDistributionResponse -> ()
rnf CopyDistributionResponse' {Int
Maybe Text
Maybe Distribution
httpStatus :: Int
location :: Maybe Text
eTag :: Maybe Text
distribution :: Maybe Distribution
$sel:httpStatus:CopyDistributionResponse' :: CopyDistributionResponse -> Int
$sel:location:CopyDistributionResponse' :: CopyDistributionResponse -> Maybe Text
$sel:eTag:CopyDistributionResponse' :: CopyDistributionResponse -> Maybe Text
$sel:distribution:CopyDistributionResponse' :: CopyDistributionResponse -> Maybe Distribution
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Distribution
distribution
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
eTag
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
location
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus