{-# 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.BackupStorage.PutObject
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Upload object that can store object metadata String and data blob in
-- single API call using inline chunk field.
module Amazonka.BackupStorage.PutObject
  ( -- * Creating a Request
    PutObject (..),
    newPutObject,

    -- * Request Lenses
    putObject_inlineChunkChecksum,
    putObject_inlineChunkChecksumAlgorithm,
    putObject_inlineChunkLength,
    putObject_metadataString,
    putObject_objectChecksum,
    putObject_objectChecksumAlgorithm,
    putObject_throwOnDuplicate,
    putObject_backupJobId,
    putObject_objectName,
    putObject_inlineChunk,

    -- * Destructuring the Response
    PutObjectResponse (..),
    newPutObjectResponse,

    -- * Response Lenses
    putObjectResponse_httpStatus,
    putObjectResponse_inlineChunkChecksum,
    putObjectResponse_inlineChunkChecksumAlgorithm,
    putObjectResponse_objectChecksum,
    putObjectResponse_objectChecksumAlgorithm,
  )
where

import Amazonka.BackupStorage.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:/ 'newPutObject' smart constructor.
data PutObject = PutObject'
  { -- | Inline chunk checksum
    PutObject -> Maybe Text
inlineChunkChecksum :: Prelude.Maybe Prelude.Text,
    -- | Inline chunk checksum algorithm
    PutObject -> Maybe Text
inlineChunkChecksumAlgorithm :: Prelude.Maybe Prelude.Text,
    -- | Length of the inline chunk data.
    PutObject -> Maybe Integer
inlineChunkLength :: Prelude.Maybe Prelude.Integer,
    -- | Store user defined metadata like backup checksum, disk ids, restore
    -- metadata etc.
    PutObject -> Maybe Text
metadataString :: Prelude.Maybe Prelude.Text,
    -- | object checksum
    PutObject -> Maybe Text
objectChecksum :: Prelude.Maybe Prelude.Text,
    -- | object checksum algorithm
    PutObject -> Maybe SummaryChecksumAlgorithm
objectChecksumAlgorithm :: Prelude.Maybe SummaryChecksumAlgorithm,
    -- | Throw an exception if Object name is already exist.
    PutObject -> Maybe Bool
throwOnDuplicate :: Prelude.Maybe Prelude.Bool,
    -- | Backup job Id for the in-progress backup.
    PutObject -> Text
backupJobId :: Prelude.Text,
    -- | The name of the Object to be uploaded.
    PutObject -> Text
objectName :: Prelude.Text,
    -- | Inline chunk data to be uploaded.
    PutObject -> HashedBody
inlineChunk :: Data.HashedBody
  }
  deriving (Int -> PutObject -> ShowS
[PutObject] -> ShowS
PutObject -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutObject] -> ShowS
$cshowList :: [PutObject] -> ShowS
show :: PutObject -> String
$cshow :: PutObject -> String
showsPrec :: Int -> PutObject -> ShowS
$cshowsPrec :: Int -> PutObject -> ShowS
Prelude.Show, forall x. Rep PutObject x -> PutObject
forall x. PutObject -> Rep PutObject x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PutObject x -> PutObject
$cfrom :: forall x. PutObject -> Rep PutObject x
Prelude.Generic)

-- |
-- Create a value of 'PutObject' 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:
--
-- 'inlineChunkChecksum', 'putObject_inlineChunkChecksum' - Inline chunk checksum
--
-- 'inlineChunkChecksumAlgorithm', 'putObject_inlineChunkChecksumAlgorithm' - Inline chunk checksum algorithm
--
-- 'inlineChunkLength', 'putObject_inlineChunkLength' - Length of the inline chunk data.
--
-- 'metadataString', 'putObject_metadataString' - Store user defined metadata like backup checksum, disk ids, restore
-- metadata etc.
--
-- 'objectChecksum', 'putObject_objectChecksum' - object checksum
--
-- 'objectChecksumAlgorithm', 'putObject_objectChecksumAlgorithm' - object checksum algorithm
--
-- 'throwOnDuplicate', 'putObject_throwOnDuplicate' - Throw an exception if Object name is already exist.
--
-- 'backupJobId', 'putObject_backupJobId' - Backup job Id for the in-progress backup.
--
-- 'objectName', 'putObject_objectName' - The name of the Object to be uploaded.
--
-- 'inlineChunk', 'putObject_inlineChunk' - Inline chunk data to be uploaded.
newPutObject ::
  -- | 'backupJobId'
  Prelude.Text ->
  -- | 'objectName'
  Prelude.Text ->
  -- | 'inlineChunk'
  Data.HashedBody ->
  PutObject
newPutObject :: Text -> Text -> HashedBody -> PutObject
newPutObject Text
pBackupJobId_ Text
pObjectName_ HashedBody
pInlineChunk_ =
  PutObject'
    { $sel:inlineChunkChecksum:PutObject' :: Maybe Text
inlineChunkChecksum = forall a. Maybe a
Prelude.Nothing,
      $sel:inlineChunkChecksumAlgorithm:PutObject' :: Maybe Text
inlineChunkChecksumAlgorithm = forall a. Maybe a
Prelude.Nothing,
      $sel:inlineChunkLength:PutObject' :: Maybe Integer
inlineChunkLength = forall a. Maybe a
Prelude.Nothing,
      $sel:metadataString:PutObject' :: Maybe Text
metadataString = forall a. Maybe a
Prelude.Nothing,
      $sel:objectChecksum:PutObject' :: Maybe Text
objectChecksum = forall a. Maybe a
Prelude.Nothing,
      $sel:objectChecksumAlgorithm:PutObject' :: Maybe SummaryChecksumAlgorithm
objectChecksumAlgorithm = forall a. Maybe a
Prelude.Nothing,
      $sel:throwOnDuplicate:PutObject' :: Maybe Bool
throwOnDuplicate = forall a. Maybe a
Prelude.Nothing,
      $sel:backupJobId:PutObject' :: Text
backupJobId = Text
pBackupJobId_,
      $sel:objectName:PutObject' :: Text
objectName = Text
pObjectName_,
      $sel:inlineChunk:PutObject' :: HashedBody
inlineChunk = HashedBody
pInlineChunk_
    }

-- | Inline chunk checksum
putObject_inlineChunkChecksum :: Lens.Lens' PutObject (Prelude.Maybe Prelude.Text)
putObject_inlineChunkChecksum :: Lens' PutObject (Maybe Text)
putObject_inlineChunkChecksum = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Maybe Text
inlineChunkChecksum :: Maybe Text
$sel:inlineChunkChecksum:PutObject' :: PutObject -> Maybe Text
inlineChunkChecksum} -> Maybe Text
inlineChunkChecksum) (\s :: PutObject
s@PutObject' {} Maybe Text
a -> PutObject
s {$sel:inlineChunkChecksum:PutObject' :: Maybe Text
inlineChunkChecksum = Maybe Text
a} :: PutObject)

-- | Inline chunk checksum algorithm
putObject_inlineChunkChecksumAlgorithm :: Lens.Lens' PutObject (Prelude.Maybe Prelude.Text)
putObject_inlineChunkChecksumAlgorithm :: Lens' PutObject (Maybe Text)
putObject_inlineChunkChecksumAlgorithm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Maybe Text
inlineChunkChecksumAlgorithm :: Maybe Text
$sel:inlineChunkChecksumAlgorithm:PutObject' :: PutObject -> Maybe Text
inlineChunkChecksumAlgorithm} -> Maybe Text
inlineChunkChecksumAlgorithm) (\s :: PutObject
s@PutObject' {} Maybe Text
a -> PutObject
s {$sel:inlineChunkChecksumAlgorithm:PutObject' :: Maybe Text
inlineChunkChecksumAlgorithm = Maybe Text
a} :: PutObject)

-- | Length of the inline chunk data.
putObject_inlineChunkLength :: Lens.Lens' PutObject (Prelude.Maybe Prelude.Integer)
putObject_inlineChunkLength :: Lens' PutObject (Maybe Integer)
putObject_inlineChunkLength = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Maybe Integer
inlineChunkLength :: Maybe Integer
$sel:inlineChunkLength:PutObject' :: PutObject -> Maybe Integer
inlineChunkLength} -> Maybe Integer
inlineChunkLength) (\s :: PutObject
s@PutObject' {} Maybe Integer
a -> PutObject
s {$sel:inlineChunkLength:PutObject' :: Maybe Integer
inlineChunkLength = Maybe Integer
a} :: PutObject)

-- | Store user defined metadata like backup checksum, disk ids, restore
-- metadata etc.
putObject_metadataString :: Lens.Lens' PutObject (Prelude.Maybe Prelude.Text)
putObject_metadataString :: Lens' PutObject (Maybe Text)
putObject_metadataString = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Maybe Text
metadataString :: Maybe Text
$sel:metadataString:PutObject' :: PutObject -> Maybe Text
metadataString} -> Maybe Text
metadataString) (\s :: PutObject
s@PutObject' {} Maybe Text
a -> PutObject
s {$sel:metadataString:PutObject' :: Maybe Text
metadataString = Maybe Text
a} :: PutObject)

-- | object checksum
putObject_objectChecksum :: Lens.Lens' PutObject (Prelude.Maybe Prelude.Text)
putObject_objectChecksum :: Lens' PutObject (Maybe Text)
putObject_objectChecksum = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Maybe Text
objectChecksum :: Maybe Text
$sel:objectChecksum:PutObject' :: PutObject -> Maybe Text
objectChecksum} -> Maybe Text
objectChecksum) (\s :: PutObject
s@PutObject' {} Maybe Text
a -> PutObject
s {$sel:objectChecksum:PutObject' :: Maybe Text
objectChecksum = Maybe Text
a} :: PutObject)

-- | object checksum algorithm
putObject_objectChecksumAlgorithm :: Lens.Lens' PutObject (Prelude.Maybe SummaryChecksumAlgorithm)
putObject_objectChecksumAlgorithm :: Lens' PutObject (Maybe SummaryChecksumAlgorithm)
putObject_objectChecksumAlgorithm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Maybe SummaryChecksumAlgorithm
objectChecksumAlgorithm :: Maybe SummaryChecksumAlgorithm
$sel:objectChecksumAlgorithm:PutObject' :: PutObject -> Maybe SummaryChecksumAlgorithm
objectChecksumAlgorithm} -> Maybe SummaryChecksumAlgorithm
objectChecksumAlgorithm) (\s :: PutObject
s@PutObject' {} Maybe SummaryChecksumAlgorithm
a -> PutObject
s {$sel:objectChecksumAlgorithm:PutObject' :: Maybe SummaryChecksumAlgorithm
objectChecksumAlgorithm = Maybe SummaryChecksumAlgorithm
a} :: PutObject)

-- | Throw an exception if Object name is already exist.
putObject_throwOnDuplicate :: Lens.Lens' PutObject (Prelude.Maybe Prelude.Bool)
putObject_throwOnDuplicate :: Lens' PutObject (Maybe Bool)
putObject_throwOnDuplicate = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Maybe Bool
throwOnDuplicate :: Maybe Bool
$sel:throwOnDuplicate:PutObject' :: PutObject -> Maybe Bool
throwOnDuplicate} -> Maybe Bool
throwOnDuplicate) (\s :: PutObject
s@PutObject' {} Maybe Bool
a -> PutObject
s {$sel:throwOnDuplicate:PutObject' :: Maybe Bool
throwOnDuplicate = Maybe Bool
a} :: PutObject)

-- | Backup job Id for the in-progress backup.
putObject_backupJobId :: Lens.Lens' PutObject Prelude.Text
putObject_backupJobId :: Lens' PutObject Text
putObject_backupJobId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Text
backupJobId :: Text
$sel:backupJobId:PutObject' :: PutObject -> Text
backupJobId} -> Text
backupJobId) (\s :: PutObject
s@PutObject' {} Text
a -> PutObject
s {$sel:backupJobId:PutObject' :: Text
backupJobId = Text
a} :: PutObject)

-- | The name of the Object to be uploaded.
putObject_objectName :: Lens.Lens' PutObject Prelude.Text
putObject_objectName :: Lens' PutObject Text
putObject_objectName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {Text
objectName :: Text
$sel:objectName:PutObject' :: PutObject -> Text
objectName} -> Text
objectName) (\s :: PutObject
s@PutObject' {} Text
a -> PutObject
s {$sel:objectName:PutObject' :: Text
objectName = Text
a} :: PutObject)

-- | Inline chunk data to be uploaded.
putObject_inlineChunk :: Lens.Lens' PutObject Data.HashedBody
putObject_inlineChunk :: Lens' PutObject HashedBody
putObject_inlineChunk = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObject' {HashedBody
inlineChunk :: HashedBody
$sel:inlineChunk:PutObject' :: PutObject -> HashedBody
inlineChunk} -> HashedBody
inlineChunk) (\s :: PutObject
s@PutObject' {} HashedBody
a -> PutObject
s {$sel:inlineChunk:PutObject' :: HashedBody
inlineChunk = HashedBody
a} :: PutObject)

instance Core.AWSRequest PutObject where
  type AWSResponse PutObject = PutObjectResponse
  request :: (Service -> Service) -> PutObject -> Request PutObject
request Service -> Service
overrides =
    forall a. (ToRequest a, ToBody a) => Service -> a -> Request a
Request.putBody (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy PutObject
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse PutObject)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Int
-> Text
-> DataChecksumAlgorithm
-> Text
-> SummaryChecksumAlgorithm
-> PutObjectResponse
PutObjectResponse'
            forall (f :: * -> *) a b. Functor 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))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"InlineChunkChecksum")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"InlineChunkChecksumAlgorithm")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"ObjectChecksum")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String a
Data..:> Key
"ObjectChecksumAlgorithm")
      )

instance Data.ToBody PutObject where
  toBody :: PutObject -> RequestBody
toBody PutObject' {Maybe Bool
Maybe Integer
Maybe Text
Maybe SummaryChecksumAlgorithm
Text
HashedBody
inlineChunk :: HashedBody
objectName :: Text
backupJobId :: Text
throwOnDuplicate :: Maybe Bool
objectChecksumAlgorithm :: Maybe SummaryChecksumAlgorithm
objectChecksum :: Maybe Text
metadataString :: Maybe Text
inlineChunkLength :: Maybe Integer
inlineChunkChecksumAlgorithm :: Maybe Text
inlineChunkChecksum :: Maybe Text
$sel:inlineChunk:PutObject' :: PutObject -> HashedBody
$sel:objectName:PutObject' :: PutObject -> Text
$sel:backupJobId:PutObject' :: PutObject -> Text
$sel:throwOnDuplicate:PutObject' :: PutObject -> Maybe Bool
$sel:objectChecksumAlgorithm:PutObject' :: PutObject -> Maybe SummaryChecksumAlgorithm
$sel:objectChecksum:PutObject' :: PutObject -> Maybe Text
$sel:metadataString:PutObject' :: PutObject -> Maybe Text
$sel:inlineChunkLength:PutObject' :: PutObject -> Maybe Integer
$sel:inlineChunkChecksumAlgorithm:PutObject' :: PutObject -> Maybe Text
$sel:inlineChunkChecksum:PutObject' :: PutObject -> Maybe Text
..} = forall a. ToBody a => a -> RequestBody
Data.toBody HashedBody
inlineChunk

instance Data.ToHeaders PutObject where
  toHeaders :: PutObject -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToPath PutObject where
  toPath :: PutObject -> ByteString
toPath PutObject' {Maybe Bool
Maybe Integer
Maybe Text
Maybe SummaryChecksumAlgorithm
Text
HashedBody
inlineChunk :: HashedBody
objectName :: Text
backupJobId :: Text
throwOnDuplicate :: Maybe Bool
objectChecksumAlgorithm :: Maybe SummaryChecksumAlgorithm
objectChecksum :: Maybe Text
metadataString :: Maybe Text
inlineChunkLength :: Maybe Integer
inlineChunkChecksumAlgorithm :: Maybe Text
inlineChunkChecksum :: Maybe Text
$sel:inlineChunk:PutObject' :: PutObject -> HashedBody
$sel:objectName:PutObject' :: PutObject -> Text
$sel:backupJobId:PutObject' :: PutObject -> Text
$sel:throwOnDuplicate:PutObject' :: PutObject -> Maybe Bool
$sel:objectChecksumAlgorithm:PutObject' :: PutObject -> Maybe SummaryChecksumAlgorithm
$sel:objectChecksum:PutObject' :: PutObject -> Maybe Text
$sel:metadataString:PutObject' :: PutObject -> Maybe Text
$sel:inlineChunkLength:PutObject' :: PutObject -> Maybe Integer
$sel:inlineChunkChecksumAlgorithm:PutObject' :: PutObject -> Maybe Text
$sel:inlineChunkChecksum:PutObject' :: PutObject -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"/backup-jobs/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
backupJobId,
        ByteString
"/object/",
        forall a. ToByteString a => a -> ByteString
Data.toBS Text
objectName,
        ByteString
"/put-object"
      ]

instance Data.ToQuery PutObject where
  toQuery :: PutObject -> QueryString
toQuery PutObject' {Maybe Bool
Maybe Integer
Maybe Text
Maybe SummaryChecksumAlgorithm
Text
HashedBody
inlineChunk :: HashedBody
objectName :: Text
backupJobId :: Text
throwOnDuplicate :: Maybe Bool
objectChecksumAlgorithm :: Maybe SummaryChecksumAlgorithm
objectChecksum :: Maybe Text
metadataString :: Maybe Text
inlineChunkLength :: Maybe Integer
inlineChunkChecksumAlgorithm :: Maybe Text
inlineChunkChecksum :: Maybe Text
$sel:inlineChunk:PutObject' :: PutObject -> HashedBody
$sel:objectName:PutObject' :: PutObject -> Text
$sel:backupJobId:PutObject' :: PutObject -> Text
$sel:throwOnDuplicate:PutObject' :: PutObject -> Maybe Bool
$sel:objectChecksumAlgorithm:PutObject' :: PutObject -> Maybe SummaryChecksumAlgorithm
$sel:objectChecksum:PutObject' :: PutObject -> Maybe Text
$sel:metadataString:PutObject' :: PutObject -> Maybe Text
$sel:inlineChunkLength:PutObject' :: PutObject -> Maybe Integer
$sel:inlineChunkChecksumAlgorithm:PutObject' :: PutObject -> Maybe Text
$sel:inlineChunkChecksum:PutObject' :: PutObject -> Maybe Text
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ ByteString
"checksum" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
inlineChunkChecksum,
        ByteString
"checksum-algorithm"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
inlineChunkChecksumAlgorithm,
        ByteString
"length" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Integer
inlineChunkLength,
        ByteString
"metadata-string" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
metadataString,
        ByteString
"object-checksum" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Text
objectChecksum,
        ByteString
"object-checksum-algorithm"
          forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe SummaryChecksumAlgorithm
objectChecksumAlgorithm,
        ByteString
"throwOnDuplicate" forall a. ToQuery a => ByteString -> a -> QueryString
Data.=: Maybe Bool
throwOnDuplicate
      ]

-- | /See:/ 'newPutObjectResponse' smart constructor.
data PutObjectResponse = PutObjectResponse'
  { -- | The response's http status code.
    PutObjectResponse -> Int
httpStatus :: Prelude.Int,
    -- | Inline chunk checksum
    PutObjectResponse -> Text
inlineChunkChecksum :: Prelude.Text,
    -- | Inline chunk checksum algorithm
    PutObjectResponse -> DataChecksumAlgorithm
inlineChunkChecksumAlgorithm :: DataChecksumAlgorithm,
    -- | object checksum
    PutObjectResponse -> Text
objectChecksum :: Prelude.Text,
    -- | object checksum algorithm
    PutObjectResponse -> SummaryChecksumAlgorithm
objectChecksumAlgorithm :: SummaryChecksumAlgorithm
  }
  deriving (PutObjectResponse -> PutObjectResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PutObjectResponse -> PutObjectResponse -> Bool
$c/= :: PutObjectResponse -> PutObjectResponse -> Bool
== :: PutObjectResponse -> PutObjectResponse -> Bool
$c== :: PutObjectResponse -> PutObjectResponse -> Bool
Prelude.Eq, ReadPrec [PutObjectResponse]
ReadPrec PutObjectResponse
Int -> ReadS PutObjectResponse
ReadS [PutObjectResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PutObjectResponse]
$creadListPrec :: ReadPrec [PutObjectResponse]
readPrec :: ReadPrec PutObjectResponse
$creadPrec :: ReadPrec PutObjectResponse
readList :: ReadS [PutObjectResponse]
$creadList :: ReadS [PutObjectResponse]
readsPrec :: Int -> ReadS PutObjectResponse
$creadsPrec :: Int -> ReadS PutObjectResponse
Prelude.Read, Int -> PutObjectResponse -> ShowS
[PutObjectResponse] -> ShowS
PutObjectResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PutObjectResponse] -> ShowS
$cshowList :: [PutObjectResponse] -> ShowS
show :: PutObjectResponse -> String
$cshow :: PutObjectResponse -> String
showsPrec :: Int -> PutObjectResponse -> ShowS
$cshowsPrec :: Int -> PutObjectResponse -> ShowS
Prelude.Show, forall x. Rep PutObjectResponse x -> PutObjectResponse
forall x. PutObjectResponse -> Rep PutObjectResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PutObjectResponse x -> PutObjectResponse
$cfrom :: forall x. PutObjectResponse -> Rep PutObjectResponse x
Prelude.Generic)

-- |
-- Create a value of 'PutObjectResponse' 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:
--
-- 'httpStatus', 'putObjectResponse_httpStatus' - The response's http status code.
--
-- 'inlineChunkChecksum', 'putObjectResponse_inlineChunkChecksum' - Inline chunk checksum
--
-- 'inlineChunkChecksumAlgorithm', 'putObjectResponse_inlineChunkChecksumAlgorithm' - Inline chunk checksum algorithm
--
-- 'objectChecksum', 'putObjectResponse_objectChecksum' - object checksum
--
-- 'objectChecksumAlgorithm', 'putObjectResponse_objectChecksumAlgorithm' - object checksum algorithm
newPutObjectResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  -- | 'inlineChunkChecksum'
  Prelude.Text ->
  -- | 'inlineChunkChecksumAlgorithm'
  DataChecksumAlgorithm ->
  -- | 'objectChecksum'
  Prelude.Text ->
  -- | 'objectChecksumAlgorithm'
  SummaryChecksumAlgorithm ->
  PutObjectResponse
newPutObjectResponse :: Int
-> Text
-> DataChecksumAlgorithm
-> Text
-> SummaryChecksumAlgorithm
-> PutObjectResponse
newPutObjectResponse
  Int
pHttpStatus_
  Text
pInlineChunkChecksum_
  DataChecksumAlgorithm
pInlineChunkChecksumAlgorithm_
  Text
pObjectChecksum_
  SummaryChecksumAlgorithm
pObjectChecksumAlgorithm_ =
    PutObjectResponse'
      { $sel:httpStatus:PutObjectResponse' :: Int
httpStatus = Int
pHttpStatus_,
        $sel:inlineChunkChecksum:PutObjectResponse' :: Text
inlineChunkChecksum = Text
pInlineChunkChecksum_,
        $sel:inlineChunkChecksumAlgorithm:PutObjectResponse' :: DataChecksumAlgorithm
inlineChunkChecksumAlgorithm =
          DataChecksumAlgorithm
pInlineChunkChecksumAlgorithm_,
        $sel:objectChecksum:PutObjectResponse' :: Text
objectChecksum = Text
pObjectChecksum_,
        $sel:objectChecksumAlgorithm:PutObjectResponse' :: SummaryChecksumAlgorithm
objectChecksumAlgorithm = SummaryChecksumAlgorithm
pObjectChecksumAlgorithm_
      }

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

-- | Inline chunk checksum
putObjectResponse_inlineChunkChecksum :: Lens.Lens' PutObjectResponse Prelude.Text
putObjectResponse_inlineChunkChecksum :: Lens' PutObjectResponse Text
putObjectResponse_inlineChunkChecksum = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObjectResponse' {Text
inlineChunkChecksum :: Text
$sel:inlineChunkChecksum:PutObjectResponse' :: PutObjectResponse -> Text
inlineChunkChecksum} -> Text
inlineChunkChecksum) (\s :: PutObjectResponse
s@PutObjectResponse' {} Text
a -> PutObjectResponse
s {$sel:inlineChunkChecksum:PutObjectResponse' :: Text
inlineChunkChecksum = Text
a} :: PutObjectResponse)

-- | Inline chunk checksum algorithm
putObjectResponse_inlineChunkChecksumAlgorithm :: Lens.Lens' PutObjectResponse DataChecksumAlgorithm
putObjectResponse_inlineChunkChecksumAlgorithm :: Lens' PutObjectResponse DataChecksumAlgorithm
putObjectResponse_inlineChunkChecksumAlgorithm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObjectResponse' {DataChecksumAlgorithm
inlineChunkChecksumAlgorithm :: DataChecksumAlgorithm
$sel:inlineChunkChecksumAlgorithm:PutObjectResponse' :: PutObjectResponse -> DataChecksumAlgorithm
inlineChunkChecksumAlgorithm} -> DataChecksumAlgorithm
inlineChunkChecksumAlgorithm) (\s :: PutObjectResponse
s@PutObjectResponse' {} DataChecksumAlgorithm
a -> PutObjectResponse
s {$sel:inlineChunkChecksumAlgorithm:PutObjectResponse' :: DataChecksumAlgorithm
inlineChunkChecksumAlgorithm = DataChecksumAlgorithm
a} :: PutObjectResponse)

-- | object checksum
putObjectResponse_objectChecksum :: Lens.Lens' PutObjectResponse Prelude.Text
putObjectResponse_objectChecksum :: Lens' PutObjectResponse Text
putObjectResponse_objectChecksum = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObjectResponse' {Text
objectChecksum :: Text
$sel:objectChecksum:PutObjectResponse' :: PutObjectResponse -> Text
objectChecksum} -> Text
objectChecksum) (\s :: PutObjectResponse
s@PutObjectResponse' {} Text
a -> PutObjectResponse
s {$sel:objectChecksum:PutObjectResponse' :: Text
objectChecksum = Text
a} :: PutObjectResponse)

-- | object checksum algorithm
putObjectResponse_objectChecksumAlgorithm :: Lens.Lens' PutObjectResponse SummaryChecksumAlgorithm
putObjectResponse_objectChecksumAlgorithm :: Lens' PutObjectResponse SummaryChecksumAlgorithm
putObjectResponse_objectChecksumAlgorithm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PutObjectResponse' {SummaryChecksumAlgorithm
objectChecksumAlgorithm :: SummaryChecksumAlgorithm
$sel:objectChecksumAlgorithm:PutObjectResponse' :: PutObjectResponse -> SummaryChecksumAlgorithm
objectChecksumAlgorithm} -> SummaryChecksumAlgorithm
objectChecksumAlgorithm) (\s :: PutObjectResponse
s@PutObjectResponse' {} SummaryChecksumAlgorithm
a -> PutObjectResponse
s {$sel:objectChecksumAlgorithm:PutObjectResponse' :: SummaryChecksumAlgorithm
objectChecksumAlgorithm = SummaryChecksumAlgorithm
a} :: PutObjectResponse)

instance Prelude.NFData PutObjectResponse where
  rnf :: PutObjectResponse -> ()
rnf PutObjectResponse' {Int
Text
DataChecksumAlgorithm
SummaryChecksumAlgorithm
objectChecksumAlgorithm :: SummaryChecksumAlgorithm
objectChecksum :: Text
inlineChunkChecksumAlgorithm :: DataChecksumAlgorithm
inlineChunkChecksum :: Text
httpStatus :: Int
$sel:objectChecksumAlgorithm:PutObjectResponse' :: PutObjectResponse -> SummaryChecksumAlgorithm
$sel:objectChecksum:PutObjectResponse' :: PutObjectResponse -> Text
$sel:inlineChunkChecksumAlgorithm:PutObjectResponse' :: PutObjectResponse -> DataChecksumAlgorithm
$sel:inlineChunkChecksum:PutObjectResponse' :: PutObjectResponse -> Text
$sel:httpStatus:PutObjectResponse' :: PutObjectResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
inlineChunkChecksum
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf DataChecksumAlgorithm
inlineChunkChecksumAlgorithm
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
objectChecksum
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf SummaryChecksumAlgorithm
objectChecksumAlgorithm