{-# 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.DynamoDB.RestoreTableFromBackup
-- 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 new table from an existing backup. Any number of users can
-- execute up to 4 concurrent restores (any type of restore) in a given
-- account.
--
-- You can call @RestoreTableFromBackup@ at a maximum rate of 10 times per
-- second.
--
-- You must manually set up the following on the restored table:
--
-- -   Auto scaling policies
--
-- -   IAM policies
--
-- -   Amazon CloudWatch metrics and alarms
--
-- -   Tags
--
-- -   Stream settings
--
-- -   Time to Live (TTL) settings
module Amazonka.DynamoDB.RestoreTableFromBackup
  ( -- * Creating a Request
    RestoreTableFromBackup (..),
    newRestoreTableFromBackup,

    -- * Request Lenses
    restoreTableFromBackup_billingModeOverride,
    restoreTableFromBackup_globalSecondaryIndexOverride,
    restoreTableFromBackup_localSecondaryIndexOverride,
    restoreTableFromBackup_provisionedThroughputOverride,
    restoreTableFromBackup_sSESpecificationOverride,
    restoreTableFromBackup_targetTableName,
    restoreTableFromBackup_backupArn,

    -- * Destructuring the Response
    RestoreTableFromBackupResponse (..),
    newRestoreTableFromBackupResponse,

    -- * Response Lenses
    restoreTableFromBackupResponse_tableDescription,
    restoreTableFromBackupResponse_httpStatus,
  )
where

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

-- | /See:/ 'newRestoreTableFromBackup' smart constructor.
data RestoreTableFromBackup = RestoreTableFromBackup'
  { -- | The billing mode of the restored table.
    RestoreTableFromBackup -> Maybe BillingMode
billingModeOverride :: Prelude.Maybe BillingMode,
    -- | List of global secondary indexes for the restored table. The indexes
    -- provided should match existing secondary indexes. You can choose to
    -- exclude some or all of the indexes at the time of restore.
    RestoreTableFromBackup -> Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride :: Prelude.Maybe [GlobalSecondaryIndex],
    -- | List of local secondary indexes for the restored table. The indexes
    -- provided should match existing secondary indexes. You can choose to
    -- exclude some or all of the indexes at the time of restore.
    RestoreTableFromBackup -> Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride :: Prelude.Maybe [LocalSecondaryIndex],
    -- | Provisioned throughput settings for the restored table.
    RestoreTableFromBackup -> Maybe ProvisionedThroughput
provisionedThroughputOverride :: Prelude.Maybe ProvisionedThroughput,
    -- | The new server-side encryption settings for the restored table.
    RestoreTableFromBackup -> Maybe SSESpecification
sSESpecificationOverride :: Prelude.Maybe SSESpecification,
    -- | The name of the new table to which the backup must be restored.
    RestoreTableFromBackup -> Text
targetTableName :: Prelude.Text,
    -- | The Amazon Resource Name (ARN) associated with the backup.
    RestoreTableFromBackup -> Text
backupArn :: Prelude.Text
  }
  deriving (RestoreTableFromBackup -> RestoreTableFromBackup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreTableFromBackup -> RestoreTableFromBackup -> Bool
$c/= :: RestoreTableFromBackup -> RestoreTableFromBackup -> Bool
== :: RestoreTableFromBackup -> RestoreTableFromBackup -> Bool
$c== :: RestoreTableFromBackup -> RestoreTableFromBackup -> Bool
Prelude.Eq, ReadPrec [RestoreTableFromBackup]
ReadPrec RestoreTableFromBackup
Int -> ReadS RestoreTableFromBackup
ReadS [RestoreTableFromBackup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreTableFromBackup]
$creadListPrec :: ReadPrec [RestoreTableFromBackup]
readPrec :: ReadPrec RestoreTableFromBackup
$creadPrec :: ReadPrec RestoreTableFromBackup
readList :: ReadS [RestoreTableFromBackup]
$creadList :: ReadS [RestoreTableFromBackup]
readsPrec :: Int -> ReadS RestoreTableFromBackup
$creadsPrec :: Int -> ReadS RestoreTableFromBackup
Prelude.Read, Int -> RestoreTableFromBackup -> ShowS
[RestoreTableFromBackup] -> ShowS
RestoreTableFromBackup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreTableFromBackup] -> ShowS
$cshowList :: [RestoreTableFromBackup] -> ShowS
show :: RestoreTableFromBackup -> String
$cshow :: RestoreTableFromBackup -> String
showsPrec :: Int -> RestoreTableFromBackup -> ShowS
$cshowsPrec :: Int -> RestoreTableFromBackup -> ShowS
Prelude.Show, forall x. Rep RestoreTableFromBackup x -> RestoreTableFromBackup
forall x. RestoreTableFromBackup -> Rep RestoreTableFromBackup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RestoreTableFromBackup x -> RestoreTableFromBackup
$cfrom :: forall x. RestoreTableFromBackup -> Rep RestoreTableFromBackup x
Prelude.Generic)

-- |
-- Create a value of 'RestoreTableFromBackup' 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:
--
-- 'billingModeOverride', 'restoreTableFromBackup_billingModeOverride' - The billing mode of the restored table.
--
-- 'globalSecondaryIndexOverride', 'restoreTableFromBackup_globalSecondaryIndexOverride' - List of global secondary indexes for the restored table. The indexes
-- provided should match existing secondary indexes. You can choose to
-- exclude some or all of the indexes at the time of restore.
--
-- 'localSecondaryIndexOverride', 'restoreTableFromBackup_localSecondaryIndexOverride' - List of local secondary indexes for the restored table. The indexes
-- provided should match existing secondary indexes. You can choose to
-- exclude some or all of the indexes at the time of restore.
--
-- 'provisionedThroughputOverride', 'restoreTableFromBackup_provisionedThroughputOverride' - Provisioned throughput settings for the restored table.
--
-- 'sSESpecificationOverride', 'restoreTableFromBackup_sSESpecificationOverride' - The new server-side encryption settings for the restored table.
--
-- 'targetTableName', 'restoreTableFromBackup_targetTableName' - The name of the new table to which the backup must be restored.
--
-- 'backupArn', 'restoreTableFromBackup_backupArn' - The Amazon Resource Name (ARN) associated with the backup.
newRestoreTableFromBackup ::
  -- | 'targetTableName'
  Prelude.Text ->
  -- | 'backupArn'
  Prelude.Text ->
  RestoreTableFromBackup
newRestoreTableFromBackup :: Text -> Text -> RestoreTableFromBackup
newRestoreTableFromBackup
  Text
pTargetTableName_
  Text
pBackupArn_ =
    RestoreTableFromBackup'
      { $sel:billingModeOverride:RestoreTableFromBackup' :: Maybe BillingMode
billingModeOverride =
          forall a. Maybe a
Prelude.Nothing,
        $sel:globalSecondaryIndexOverride:RestoreTableFromBackup' :: Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride = forall a. Maybe a
Prelude.Nothing,
        $sel:localSecondaryIndexOverride:RestoreTableFromBackup' :: Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride = forall a. Maybe a
Prelude.Nothing,
        $sel:provisionedThroughputOverride:RestoreTableFromBackup' :: Maybe ProvisionedThroughput
provisionedThroughputOverride = forall a. Maybe a
Prelude.Nothing,
        $sel:sSESpecificationOverride:RestoreTableFromBackup' :: Maybe SSESpecification
sSESpecificationOverride = forall a. Maybe a
Prelude.Nothing,
        $sel:targetTableName:RestoreTableFromBackup' :: Text
targetTableName = Text
pTargetTableName_,
        $sel:backupArn:RestoreTableFromBackup' :: Text
backupArn = Text
pBackupArn_
      }

-- | The billing mode of the restored table.
restoreTableFromBackup_billingModeOverride :: Lens.Lens' RestoreTableFromBackup (Prelude.Maybe BillingMode)
restoreTableFromBackup_billingModeOverride :: Lens' RestoreTableFromBackup (Maybe BillingMode)
restoreTableFromBackup_billingModeOverride = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackup' {Maybe BillingMode
billingModeOverride :: Maybe BillingMode
$sel:billingModeOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe BillingMode
billingModeOverride} -> Maybe BillingMode
billingModeOverride) (\s :: RestoreTableFromBackup
s@RestoreTableFromBackup' {} Maybe BillingMode
a -> RestoreTableFromBackup
s {$sel:billingModeOverride:RestoreTableFromBackup' :: Maybe BillingMode
billingModeOverride = Maybe BillingMode
a} :: RestoreTableFromBackup)

-- | List of global secondary indexes for the restored table. The indexes
-- provided should match existing secondary indexes. You can choose to
-- exclude some or all of the indexes at the time of restore.
restoreTableFromBackup_globalSecondaryIndexOverride :: Lens.Lens' RestoreTableFromBackup (Prelude.Maybe [GlobalSecondaryIndex])
restoreTableFromBackup_globalSecondaryIndexOverride :: Lens' RestoreTableFromBackup (Maybe [GlobalSecondaryIndex])
restoreTableFromBackup_globalSecondaryIndexOverride = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackup' {Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride :: Maybe [GlobalSecondaryIndex]
$sel:globalSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride} -> Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride) (\s :: RestoreTableFromBackup
s@RestoreTableFromBackup' {} Maybe [GlobalSecondaryIndex]
a -> RestoreTableFromBackup
s {$sel:globalSecondaryIndexOverride:RestoreTableFromBackup' :: Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride = Maybe [GlobalSecondaryIndex]
a} :: RestoreTableFromBackup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | List of local secondary indexes for the restored table. The indexes
-- provided should match existing secondary indexes. You can choose to
-- exclude some or all of the indexes at the time of restore.
restoreTableFromBackup_localSecondaryIndexOverride :: Lens.Lens' RestoreTableFromBackup (Prelude.Maybe [LocalSecondaryIndex])
restoreTableFromBackup_localSecondaryIndexOverride :: Lens' RestoreTableFromBackup (Maybe [LocalSecondaryIndex])
restoreTableFromBackup_localSecondaryIndexOverride = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackup' {Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride :: Maybe [LocalSecondaryIndex]
$sel:localSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride} -> Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride) (\s :: RestoreTableFromBackup
s@RestoreTableFromBackup' {} Maybe [LocalSecondaryIndex]
a -> RestoreTableFromBackup
s {$sel:localSecondaryIndexOverride:RestoreTableFromBackup' :: Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride = Maybe [LocalSecondaryIndex]
a} :: RestoreTableFromBackup) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. 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 forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Provisioned throughput settings for the restored table.
restoreTableFromBackup_provisionedThroughputOverride :: Lens.Lens' RestoreTableFromBackup (Prelude.Maybe ProvisionedThroughput)
restoreTableFromBackup_provisionedThroughputOverride :: Lens' RestoreTableFromBackup (Maybe ProvisionedThroughput)
restoreTableFromBackup_provisionedThroughputOverride = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackup' {Maybe ProvisionedThroughput
provisionedThroughputOverride :: Maybe ProvisionedThroughput
$sel:provisionedThroughputOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe ProvisionedThroughput
provisionedThroughputOverride} -> Maybe ProvisionedThroughput
provisionedThroughputOverride) (\s :: RestoreTableFromBackup
s@RestoreTableFromBackup' {} Maybe ProvisionedThroughput
a -> RestoreTableFromBackup
s {$sel:provisionedThroughputOverride:RestoreTableFromBackup' :: Maybe ProvisionedThroughput
provisionedThroughputOverride = Maybe ProvisionedThroughput
a} :: RestoreTableFromBackup)

-- | The new server-side encryption settings for the restored table.
restoreTableFromBackup_sSESpecificationOverride :: Lens.Lens' RestoreTableFromBackup (Prelude.Maybe SSESpecification)
restoreTableFromBackup_sSESpecificationOverride :: Lens' RestoreTableFromBackup (Maybe SSESpecification)
restoreTableFromBackup_sSESpecificationOverride = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackup' {Maybe SSESpecification
sSESpecificationOverride :: Maybe SSESpecification
$sel:sSESpecificationOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe SSESpecification
sSESpecificationOverride} -> Maybe SSESpecification
sSESpecificationOverride) (\s :: RestoreTableFromBackup
s@RestoreTableFromBackup' {} Maybe SSESpecification
a -> RestoreTableFromBackup
s {$sel:sSESpecificationOverride:RestoreTableFromBackup' :: Maybe SSESpecification
sSESpecificationOverride = Maybe SSESpecification
a} :: RestoreTableFromBackup)

-- | The name of the new table to which the backup must be restored.
restoreTableFromBackup_targetTableName :: Lens.Lens' RestoreTableFromBackup Prelude.Text
restoreTableFromBackup_targetTableName :: Lens' RestoreTableFromBackup Text
restoreTableFromBackup_targetTableName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackup' {Text
targetTableName :: Text
$sel:targetTableName:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
targetTableName} -> Text
targetTableName) (\s :: RestoreTableFromBackup
s@RestoreTableFromBackup' {} Text
a -> RestoreTableFromBackup
s {$sel:targetTableName:RestoreTableFromBackup' :: Text
targetTableName = Text
a} :: RestoreTableFromBackup)

-- | The Amazon Resource Name (ARN) associated with the backup.
restoreTableFromBackup_backupArn :: Lens.Lens' RestoreTableFromBackup Prelude.Text
restoreTableFromBackup_backupArn :: Lens' RestoreTableFromBackup Text
restoreTableFromBackup_backupArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackup' {Text
backupArn :: Text
$sel:backupArn:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
backupArn} -> Text
backupArn) (\s :: RestoreTableFromBackup
s@RestoreTableFromBackup' {} Text
a -> RestoreTableFromBackup
s {$sel:backupArn:RestoreTableFromBackup' :: Text
backupArn = Text
a} :: RestoreTableFromBackup)

instance Core.AWSRequest RestoreTableFromBackup where
  type
    AWSResponse RestoreTableFromBackup =
      RestoreTableFromBackupResponse
  request :: (Service -> Service)
-> RestoreTableFromBackup -> Request RestoreTableFromBackup
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy RestoreTableFromBackup
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RestoreTableFromBackup)))
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 ->
          Maybe TableDescription -> Int -> RestoreTableFromBackupResponse
RestoreTableFromBackupResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"TableDescription")
            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 RestoreTableFromBackup where
  hashWithSalt :: Int -> RestoreTableFromBackup -> Int
hashWithSalt Int
_salt RestoreTableFromBackup' {Maybe [LocalSecondaryIndex]
Maybe [GlobalSecondaryIndex]
Maybe SSESpecification
Maybe ProvisionedThroughput
Maybe BillingMode
Text
backupArn :: Text
targetTableName :: Text
sSESpecificationOverride :: Maybe SSESpecification
provisionedThroughputOverride :: Maybe ProvisionedThroughput
localSecondaryIndexOverride :: Maybe [LocalSecondaryIndex]
globalSecondaryIndexOverride :: Maybe [GlobalSecondaryIndex]
billingModeOverride :: Maybe BillingMode
$sel:backupArn:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
$sel:targetTableName:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
$sel:sSESpecificationOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe SSESpecification
$sel:provisionedThroughputOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe ProvisionedThroughput
$sel:localSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [LocalSecondaryIndex]
$sel:globalSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [GlobalSecondaryIndex]
$sel:billingModeOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe BillingMode
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe BillingMode
billingModeOverride
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ProvisionedThroughput
provisionedThroughputOverride
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SSESpecification
sSESpecificationOverride
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
targetTableName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
backupArn

instance Prelude.NFData RestoreTableFromBackup where
  rnf :: RestoreTableFromBackup -> ()
rnf RestoreTableFromBackup' {Maybe [LocalSecondaryIndex]
Maybe [GlobalSecondaryIndex]
Maybe SSESpecification
Maybe ProvisionedThroughput
Maybe BillingMode
Text
backupArn :: Text
targetTableName :: Text
sSESpecificationOverride :: Maybe SSESpecification
provisionedThroughputOverride :: Maybe ProvisionedThroughput
localSecondaryIndexOverride :: Maybe [LocalSecondaryIndex]
globalSecondaryIndexOverride :: Maybe [GlobalSecondaryIndex]
billingModeOverride :: Maybe BillingMode
$sel:backupArn:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
$sel:targetTableName:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
$sel:sSESpecificationOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe SSESpecification
$sel:provisionedThroughputOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe ProvisionedThroughput
$sel:localSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [LocalSecondaryIndex]
$sel:globalSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [GlobalSecondaryIndex]
$sel:billingModeOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe BillingMode
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe BillingMode
billingModeOverride
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ProvisionedThroughput
provisionedThroughputOverride
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SSESpecification
sSESpecificationOverride
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
targetTableName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
backupArn

instance Data.ToHeaders RestoreTableFromBackup where
  toHeaders :: RestoreTableFromBackup -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"DynamoDB_20120810.RestoreTableFromBackup" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON RestoreTableFromBackup where
  toJSON :: RestoreTableFromBackup -> Value
toJSON RestoreTableFromBackup' {Maybe [LocalSecondaryIndex]
Maybe [GlobalSecondaryIndex]
Maybe SSESpecification
Maybe ProvisionedThroughput
Maybe BillingMode
Text
backupArn :: Text
targetTableName :: Text
sSESpecificationOverride :: Maybe SSESpecification
provisionedThroughputOverride :: Maybe ProvisionedThroughput
localSecondaryIndexOverride :: Maybe [LocalSecondaryIndex]
globalSecondaryIndexOverride :: Maybe [GlobalSecondaryIndex]
billingModeOverride :: Maybe BillingMode
$sel:backupArn:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
$sel:targetTableName:RestoreTableFromBackup' :: RestoreTableFromBackup -> Text
$sel:sSESpecificationOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe SSESpecification
$sel:provisionedThroughputOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe ProvisionedThroughput
$sel:localSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [LocalSecondaryIndex]
$sel:globalSecondaryIndexOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe [GlobalSecondaryIndex]
$sel:billingModeOverride:RestoreTableFromBackup' :: RestoreTableFromBackup -> Maybe BillingMode
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"BillingModeOverride" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe BillingMode
billingModeOverride,
            (Key
"GlobalSecondaryIndexOverride" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [GlobalSecondaryIndex]
globalSecondaryIndexOverride,
            (Key
"LocalSecondaryIndexOverride" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [LocalSecondaryIndex]
localSecondaryIndexOverride,
            (Key
"ProvisionedThroughputOverride" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ProvisionedThroughput
provisionedThroughputOverride,
            (Key
"SSESpecificationOverride" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe SSESpecification
sSESpecificationOverride,
            forall a. a -> Maybe a
Prelude.Just
              (Key
"TargetTableName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
targetTableName),
            forall a. a -> Maybe a
Prelude.Just (Key
"BackupArn" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
backupArn)
          ]
      )

instance Data.ToPath RestoreTableFromBackup where
  toPath :: RestoreTableFromBackup -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | /See:/ 'newRestoreTableFromBackupResponse' smart constructor.
data RestoreTableFromBackupResponse = RestoreTableFromBackupResponse'
  { -- | The description of the table created from an existing backup.
    RestoreTableFromBackupResponse -> Maybe TableDescription
tableDescription :: Prelude.Maybe TableDescription,
    -- | The response's http status code.
    RestoreTableFromBackupResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RestoreTableFromBackupResponse
-> RestoreTableFromBackupResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreTableFromBackupResponse
-> RestoreTableFromBackupResponse -> Bool
$c/= :: RestoreTableFromBackupResponse
-> RestoreTableFromBackupResponse -> Bool
== :: RestoreTableFromBackupResponse
-> RestoreTableFromBackupResponse -> Bool
$c== :: RestoreTableFromBackupResponse
-> RestoreTableFromBackupResponse -> Bool
Prelude.Eq, ReadPrec [RestoreTableFromBackupResponse]
ReadPrec RestoreTableFromBackupResponse
Int -> ReadS RestoreTableFromBackupResponse
ReadS [RestoreTableFromBackupResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreTableFromBackupResponse]
$creadListPrec :: ReadPrec [RestoreTableFromBackupResponse]
readPrec :: ReadPrec RestoreTableFromBackupResponse
$creadPrec :: ReadPrec RestoreTableFromBackupResponse
readList :: ReadS [RestoreTableFromBackupResponse]
$creadList :: ReadS [RestoreTableFromBackupResponse]
readsPrec :: Int -> ReadS RestoreTableFromBackupResponse
$creadsPrec :: Int -> ReadS RestoreTableFromBackupResponse
Prelude.Read, Int -> RestoreTableFromBackupResponse -> ShowS
[RestoreTableFromBackupResponse] -> ShowS
RestoreTableFromBackupResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreTableFromBackupResponse] -> ShowS
$cshowList :: [RestoreTableFromBackupResponse] -> ShowS
show :: RestoreTableFromBackupResponse -> String
$cshow :: RestoreTableFromBackupResponse -> String
showsPrec :: Int -> RestoreTableFromBackupResponse -> ShowS
$cshowsPrec :: Int -> RestoreTableFromBackupResponse -> ShowS
Prelude.Show, forall x.
Rep RestoreTableFromBackupResponse x
-> RestoreTableFromBackupResponse
forall x.
RestoreTableFromBackupResponse
-> Rep RestoreTableFromBackupResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RestoreTableFromBackupResponse x
-> RestoreTableFromBackupResponse
$cfrom :: forall x.
RestoreTableFromBackupResponse
-> Rep RestoreTableFromBackupResponse x
Prelude.Generic)

-- |
-- Create a value of 'RestoreTableFromBackupResponse' 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:
--
-- 'tableDescription', 'restoreTableFromBackupResponse_tableDescription' - The description of the table created from an existing backup.
--
-- 'httpStatus', 'restoreTableFromBackupResponse_httpStatus' - The response's http status code.
newRestoreTableFromBackupResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RestoreTableFromBackupResponse
newRestoreTableFromBackupResponse :: Int -> RestoreTableFromBackupResponse
newRestoreTableFromBackupResponse Int
pHttpStatus_ =
  RestoreTableFromBackupResponse'
    { $sel:tableDescription:RestoreTableFromBackupResponse' :: Maybe TableDescription
tableDescription =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RestoreTableFromBackupResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The description of the table created from an existing backup.
restoreTableFromBackupResponse_tableDescription :: Lens.Lens' RestoreTableFromBackupResponse (Prelude.Maybe TableDescription)
restoreTableFromBackupResponse_tableDescription :: Lens' RestoreTableFromBackupResponse (Maybe TableDescription)
restoreTableFromBackupResponse_tableDescription = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromBackupResponse' {Maybe TableDescription
tableDescription :: Maybe TableDescription
$sel:tableDescription:RestoreTableFromBackupResponse' :: RestoreTableFromBackupResponse -> Maybe TableDescription
tableDescription} -> Maybe TableDescription
tableDescription) (\s :: RestoreTableFromBackupResponse
s@RestoreTableFromBackupResponse' {} Maybe TableDescription
a -> RestoreTableFromBackupResponse
s {$sel:tableDescription:RestoreTableFromBackupResponse' :: Maybe TableDescription
tableDescription = Maybe TableDescription
a} :: RestoreTableFromBackupResponse)

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

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