{-# 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.FSx.CreateVolumeFromBackup
-- 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 Amazon FSx for NetApp ONTAP volume from an existing Amazon
-- FSx volume backup.
module Amazonka.FSx.CreateVolumeFromBackup
  ( -- * Creating a Request
    CreateVolumeFromBackup (..),
    newCreateVolumeFromBackup,

    -- * Request Lenses
    createVolumeFromBackup_clientRequestToken,
    createVolumeFromBackup_ontapConfiguration,
    createVolumeFromBackup_tags,
    createVolumeFromBackup_backupId,
    createVolumeFromBackup_name,

    -- * Destructuring the Response
    CreateVolumeFromBackupResponse (..),
    newCreateVolumeFromBackupResponse,

    -- * Response Lenses
    createVolumeFromBackupResponse_volume,
    createVolumeFromBackupResponse_httpStatus,
  )
where

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

-- | /See:/ 'newCreateVolumeFromBackup' smart constructor.
data CreateVolumeFromBackup = CreateVolumeFromBackup'
  { CreateVolumeFromBackup -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | Specifies the configuration of the ONTAP volume that you are creating.
    CreateVolumeFromBackup -> Maybe CreateOntapVolumeConfiguration
ontapConfiguration :: Prelude.Maybe CreateOntapVolumeConfiguration,
    CreateVolumeFromBackup -> Maybe (NonEmpty Tag)
tags :: Prelude.Maybe (Prelude.NonEmpty Tag),
    CreateVolumeFromBackup -> Text
backupId :: Prelude.Text,
    -- | The name of the new volume you\'re creating.
    CreateVolumeFromBackup -> Text
name :: Prelude.Text
  }
  deriving (CreateVolumeFromBackup -> CreateVolumeFromBackup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateVolumeFromBackup -> CreateVolumeFromBackup -> Bool
$c/= :: CreateVolumeFromBackup -> CreateVolumeFromBackup -> Bool
== :: CreateVolumeFromBackup -> CreateVolumeFromBackup -> Bool
$c== :: CreateVolumeFromBackup -> CreateVolumeFromBackup -> Bool
Prelude.Eq, ReadPrec [CreateVolumeFromBackup]
ReadPrec CreateVolumeFromBackup
Int -> ReadS CreateVolumeFromBackup
ReadS [CreateVolumeFromBackup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateVolumeFromBackup]
$creadListPrec :: ReadPrec [CreateVolumeFromBackup]
readPrec :: ReadPrec CreateVolumeFromBackup
$creadPrec :: ReadPrec CreateVolumeFromBackup
readList :: ReadS [CreateVolumeFromBackup]
$creadList :: ReadS [CreateVolumeFromBackup]
readsPrec :: Int -> ReadS CreateVolumeFromBackup
$creadsPrec :: Int -> ReadS CreateVolumeFromBackup
Prelude.Read, Int -> CreateVolumeFromBackup -> ShowS
[CreateVolumeFromBackup] -> ShowS
CreateVolumeFromBackup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateVolumeFromBackup] -> ShowS
$cshowList :: [CreateVolumeFromBackup] -> ShowS
show :: CreateVolumeFromBackup -> String
$cshow :: CreateVolumeFromBackup -> String
showsPrec :: Int -> CreateVolumeFromBackup -> ShowS
$cshowsPrec :: Int -> CreateVolumeFromBackup -> ShowS
Prelude.Show, forall x. Rep CreateVolumeFromBackup x -> CreateVolumeFromBackup
forall x. CreateVolumeFromBackup -> Rep CreateVolumeFromBackup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CreateVolumeFromBackup x -> CreateVolumeFromBackup
$cfrom :: forall x. CreateVolumeFromBackup -> Rep CreateVolumeFromBackup x
Prelude.Generic)

-- |
-- Create a value of 'CreateVolumeFromBackup' 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:
--
-- 'clientRequestToken', 'createVolumeFromBackup_clientRequestToken' - Undocumented member.
--
-- 'ontapConfiguration', 'createVolumeFromBackup_ontapConfiguration' - Specifies the configuration of the ONTAP volume that you are creating.
--
-- 'tags', 'createVolumeFromBackup_tags' - Undocumented member.
--
-- 'backupId', 'createVolumeFromBackup_backupId' - Undocumented member.
--
-- 'name', 'createVolumeFromBackup_name' - The name of the new volume you\'re creating.
newCreateVolumeFromBackup ::
  -- | 'backupId'
  Prelude.Text ->
  -- | 'name'
  Prelude.Text ->
  CreateVolumeFromBackup
newCreateVolumeFromBackup :: Text -> Text -> CreateVolumeFromBackup
newCreateVolumeFromBackup Text
pBackupId_ Text
pName_ =
  CreateVolumeFromBackup'
    { $sel:clientRequestToken:CreateVolumeFromBackup' :: Maybe Text
clientRequestToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:ontapConfiguration:CreateVolumeFromBackup' :: Maybe CreateOntapVolumeConfiguration
ontapConfiguration = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:CreateVolumeFromBackup' :: Maybe (NonEmpty Tag)
tags = forall a. Maybe a
Prelude.Nothing,
      $sel:backupId:CreateVolumeFromBackup' :: Text
backupId = Text
pBackupId_,
      $sel:name:CreateVolumeFromBackup' :: Text
name = Text
pName_
    }

-- | Undocumented member.
createVolumeFromBackup_clientRequestToken :: Lens.Lens' CreateVolumeFromBackup (Prelude.Maybe Prelude.Text)
createVolumeFromBackup_clientRequestToken :: Lens' CreateVolumeFromBackup (Maybe Text)
createVolumeFromBackup_clientRequestToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVolumeFromBackup' {Maybe Text
clientRequestToken :: Maybe Text
$sel:clientRequestToken:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe Text
clientRequestToken} -> Maybe Text
clientRequestToken) (\s :: CreateVolumeFromBackup
s@CreateVolumeFromBackup' {} Maybe Text
a -> CreateVolumeFromBackup
s {$sel:clientRequestToken:CreateVolumeFromBackup' :: Maybe Text
clientRequestToken = Maybe Text
a} :: CreateVolumeFromBackup)

-- | Specifies the configuration of the ONTAP volume that you are creating.
createVolumeFromBackup_ontapConfiguration :: Lens.Lens' CreateVolumeFromBackup (Prelude.Maybe CreateOntapVolumeConfiguration)
createVolumeFromBackup_ontapConfiguration :: Lens' CreateVolumeFromBackup (Maybe CreateOntapVolumeConfiguration)
createVolumeFromBackup_ontapConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVolumeFromBackup' {Maybe CreateOntapVolumeConfiguration
ontapConfiguration :: Maybe CreateOntapVolumeConfiguration
$sel:ontapConfiguration:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe CreateOntapVolumeConfiguration
ontapConfiguration} -> Maybe CreateOntapVolumeConfiguration
ontapConfiguration) (\s :: CreateVolumeFromBackup
s@CreateVolumeFromBackup' {} Maybe CreateOntapVolumeConfiguration
a -> CreateVolumeFromBackup
s {$sel:ontapConfiguration:CreateVolumeFromBackup' :: Maybe CreateOntapVolumeConfiguration
ontapConfiguration = Maybe CreateOntapVolumeConfiguration
a} :: CreateVolumeFromBackup)

-- | Undocumented member.
createVolumeFromBackup_tags :: Lens.Lens' CreateVolumeFromBackup (Prelude.Maybe (Prelude.NonEmpty Tag))
createVolumeFromBackup_tags :: Lens' CreateVolumeFromBackup (Maybe (NonEmpty Tag))
createVolumeFromBackup_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVolumeFromBackup' {Maybe (NonEmpty Tag)
tags :: Maybe (NonEmpty Tag)
$sel:tags:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe (NonEmpty Tag)
tags} -> Maybe (NonEmpty Tag)
tags) (\s :: CreateVolumeFromBackup
s@CreateVolumeFromBackup' {} Maybe (NonEmpty Tag)
a -> CreateVolumeFromBackup
s {$sel:tags:CreateVolumeFromBackup' :: Maybe (NonEmpty Tag)
tags = Maybe (NonEmpty Tag)
a} :: CreateVolumeFromBackup) 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

-- | Undocumented member.
createVolumeFromBackup_backupId :: Lens.Lens' CreateVolumeFromBackup Prelude.Text
createVolumeFromBackup_backupId :: Lens' CreateVolumeFromBackup Text
createVolumeFromBackup_backupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVolumeFromBackup' {Text
backupId :: Text
$sel:backupId:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
backupId} -> Text
backupId) (\s :: CreateVolumeFromBackup
s@CreateVolumeFromBackup' {} Text
a -> CreateVolumeFromBackup
s {$sel:backupId:CreateVolumeFromBackup' :: Text
backupId = Text
a} :: CreateVolumeFromBackup)

-- | The name of the new volume you\'re creating.
createVolumeFromBackup_name :: Lens.Lens' CreateVolumeFromBackup Prelude.Text
createVolumeFromBackup_name :: Lens' CreateVolumeFromBackup Text
createVolumeFromBackup_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVolumeFromBackup' {Text
name :: Text
$sel:name:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
name} -> Text
name) (\s :: CreateVolumeFromBackup
s@CreateVolumeFromBackup' {} Text
a -> CreateVolumeFromBackup
s {$sel:name:CreateVolumeFromBackup' :: Text
name = Text
a} :: CreateVolumeFromBackup)

instance Core.AWSRequest CreateVolumeFromBackup where
  type
    AWSResponse CreateVolumeFromBackup =
      CreateVolumeFromBackupResponse
  request :: (Service -> Service)
-> CreateVolumeFromBackup -> Request CreateVolumeFromBackup
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 CreateVolumeFromBackup
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse CreateVolumeFromBackup)))
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 Volume -> Int -> CreateVolumeFromBackupResponse
CreateVolumeFromBackupResponse'
            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
"Volume")
            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 CreateVolumeFromBackup where
  hashWithSalt :: Int -> CreateVolumeFromBackup -> Int
hashWithSalt Int
_salt CreateVolumeFromBackup' {Maybe (NonEmpty Tag)
Maybe Text
Maybe CreateOntapVolumeConfiguration
Text
name :: Text
backupId :: Text
tags :: Maybe (NonEmpty Tag)
ontapConfiguration :: Maybe CreateOntapVolumeConfiguration
clientRequestToken :: Maybe Text
$sel:name:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
$sel:backupId:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
$sel:tags:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe (NonEmpty Tag)
$sel:ontapConfiguration:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe CreateOntapVolumeConfiguration
$sel:clientRequestToken:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientRequestToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CreateOntapVolumeConfiguration
ontapConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Tag)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
backupId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData CreateVolumeFromBackup where
  rnf :: CreateVolumeFromBackup -> ()
rnf CreateVolumeFromBackup' {Maybe (NonEmpty Tag)
Maybe Text
Maybe CreateOntapVolumeConfiguration
Text
name :: Text
backupId :: Text
tags :: Maybe (NonEmpty Tag)
ontapConfiguration :: Maybe CreateOntapVolumeConfiguration
clientRequestToken :: Maybe Text
$sel:name:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
$sel:backupId:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
$sel:tags:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe (NonEmpty Tag)
$sel:ontapConfiguration:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe CreateOntapVolumeConfiguration
$sel:clientRequestToken:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientRequestToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CreateOntapVolumeConfiguration
ontapConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Tag)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
backupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name

instance Data.ToHeaders CreateVolumeFromBackup where
  toHeaders :: CreateVolumeFromBackup -> 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
"AWSSimbaAPIService_v20180301.CreateVolumeFromBackup" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON CreateVolumeFromBackup where
  toJSON :: CreateVolumeFromBackup -> Value
toJSON CreateVolumeFromBackup' {Maybe (NonEmpty Tag)
Maybe Text
Maybe CreateOntapVolumeConfiguration
Text
name :: Text
backupId :: Text
tags :: Maybe (NonEmpty Tag)
ontapConfiguration :: Maybe CreateOntapVolumeConfiguration
clientRequestToken :: Maybe Text
$sel:name:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
$sel:backupId:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Text
$sel:tags:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe (NonEmpty Tag)
$sel:ontapConfiguration:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe CreateOntapVolumeConfiguration
$sel:clientRequestToken:CreateVolumeFromBackup' :: CreateVolumeFromBackup -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientRequestToken" 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 Text
clientRequestToken,
            (Key
"OntapConfiguration" 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 CreateOntapVolumeConfiguration
ontapConfiguration,
            (Key
"Tags" 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 (NonEmpty Tag)
tags,
            forall a. a -> Maybe a
Prelude.Just (Key
"BackupId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
backupId),
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)
          ]
      )

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

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

-- | /See:/ 'newCreateVolumeFromBackupResponse' smart constructor.
data CreateVolumeFromBackupResponse = CreateVolumeFromBackupResponse'
  { -- | Returned after a successful @CreateVolumeFromBackup@ API operation,
    -- describing the volume just created.
    CreateVolumeFromBackupResponse -> Maybe Volume
volume :: Prelude.Maybe Volume,
    -- | The response's http status code.
    CreateVolumeFromBackupResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (CreateVolumeFromBackupResponse
-> CreateVolumeFromBackupResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CreateVolumeFromBackupResponse
-> CreateVolumeFromBackupResponse -> Bool
$c/= :: CreateVolumeFromBackupResponse
-> CreateVolumeFromBackupResponse -> Bool
== :: CreateVolumeFromBackupResponse
-> CreateVolumeFromBackupResponse -> Bool
$c== :: CreateVolumeFromBackupResponse
-> CreateVolumeFromBackupResponse -> Bool
Prelude.Eq, ReadPrec [CreateVolumeFromBackupResponse]
ReadPrec CreateVolumeFromBackupResponse
Int -> ReadS CreateVolumeFromBackupResponse
ReadS [CreateVolumeFromBackupResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CreateVolumeFromBackupResponse]
$creadListPrec :: ReadPrec [CreateVolumeFromBackupResponse]
readPrec :: ReadPrec CreateVolumeFromBackupResponse
$creadPrec :: ReadPrec CreateVolumeFromBackupResponse
readList :: ReadS [CreateVolumeFromBackupResponse]
$creadList :: ReadS [CreateVolumeFromBackupResponse]
readsPrec :: Int -> ReadS CreateVolumeFromBackupResponse
$creadsPrec :: Int -> ReadS CreateVolumeFromBackupResponse
Prelude.Read, Int -> CreateVolumeFromBackupResponse -> ShowS
[CreateVolumeFromBackupResponse] -> ShowS
CreateVolumeFromBackupResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CreateVolumeFromBackupResponse] -> ShowS
$cshowList :: [CreateVolumeFromBackupResponse] -> ShowS
show :: CreateVolumeFromBackupResponse -> String
$cshow :: CreateVolumeFromBackupResponse -> String
showsPrec :: Int -> CreateVolumeFromBackupResponse -> ShowS
$cshowsPrec :: Int -> CreateVolumeFromBackupResponse -> ShowS
Prelude.Show, forall x.
Rep CreateVolumeFromBackupResponse x
-> CreateVolumeFromBackupResponse
forall x.
CreateVolumeFromBackupResponse
-> Rep CreateVolumeFromBackupResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep CreateVolumeFromBackupResponse x
-> CreateVolumeFromBackupResponse
$cfrom :: forall x.
CreateVolumeFromBackupResponse
-> Rep CreateVolumeFromBackupResponse x
Prelude.Generic)

-- |
-- Create a value of 'CreateVolumeFromBackupResponse' 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:
--
-- 'volume', 'createVolumeFromBackupResponse_volume' - Returned after a successful @CreateVolumeFromBackup@ API operation,
-- describing the volume just created.
--
-- 'httpStatus', 'createVolumeFromBackupResponse_httpStatus' - The response's http status code.
newCreateVolumeFromBackupResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  CreateVolumeFromBackupResponse
newCreateVolumeFromBackupResponse :: Int -> CreateVolumeFromBackupResponse
newCreateVolumeFromBackupResponse Int
pHttpStatus_ =
  CreateVolumeFromBackupResponse'
    { $sel:volume:CreateVolumeFromBackupResponse' :: Maybe Volume
volume =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:CreateVolumeFromBackupResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Returned after a successful @CreateVolumeFromBackup@ API operation,
-- describing the volume just created.
createVolumeFromBackupResponse_volume :: Lens.Lens' CreateVolumeFromBackupResponse (Prelude.Maybe Volume)
createVolumeFromBackupResponse_volume :: Lens' CreateVolumeFromBackupResponse (Maybe Volume)
createVolumeFromBackupResponse_volume = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CreateVolumeFromBackupResponse' {Maybe Volume
volume :: Maybe Volume
$sel:volume:CreateVolumeFromBackupResponse' :: CreateVolumeFromBackupResponse -> Maybe Volume
volume} -> Maybe Volume
volume) (\s :: CreateVolumeFromBackupResponse
s@CreateVolumeFromBackupResponse' {} Maybe Volume
a -> CreateVolumeFromBackupResponse
s {$sel:volume:CreateVolumeFromBackupResponse' :: Maybe Volume
volume = Maybe Volume
a} :: CreateVolumeFromBackupResponse)

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

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