{-# 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.RestoreVolumeFromSnapshot
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Returns an Amazon FSx for OpenZFS volume to the state saved by the
-- specified snapshot.
module Amazonka.FSx.RestoreVolumeFromSnapshot
  ( -- * Creating a Request
    RestoreVolumeFromSnapshot (..),
    newRestoreVolumeFromSnapshot,

    -- * Request Lenses
    restoreVolumeFromSnapshot_clientRequestToken,
    restoreVolumeFromSnapshot_options,
    restoreVolumeFromSnapshot_volumeId,
    restoreVolumeFromSnapshot_snapshotId,

    -- * Destructuring the Response
    RestoreVolumeFromSnapshotResponse (..),
    newRestoreVolumeFromSnapshotResponse,

    -- * Response Lenses
    restoreVolumeFromSnapshotResponse_administrativeActions,
    restoreVolumeFromSnapshotResponse_lifecycle,
    restoreVolumeFromSnapshotResponse_volumeId,
    restoreVolumeFromSnapshotResponse_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:/ 'newRestoreVolumeFromSnapshot' smart constructor.
data RestoreVolumeFromSnapshot = RestoreVolumeFromSnapshot'
  { RestoreVolumeFromSnapshot -> Maybe Text
clientRequestToken :: Prelude.Maybe Prelude.Text,
    -- | The settings used when restoring the specified volume from snapshot.
    --
    -- -   @DELETE_INTERMEDIATE_SNAPSHOTS@ - Deletes snapshots between the
    --     current state and the specified snapshot. If there are intermediate
    --     snapshots and this option isn\'t used, @RestoreVolumeFromSnapshot@
    --     fails.
    --
    -- -   @DELETE_CLONED_VOLUMES@ - Deletes any dependent clone volumes
    --     created from intermediate snapshots. If there are any dependent
    --     clone volumes and this option isn\'t used,
    --     @RestoreVolumeFromSnapshot@ fails.
    RestoreVolumeFromSnapshot -> Maybe [RestoreOpenZFSVolumeOption]
options :: Prelude.Maybe [RestoreOpenZFSVolumeOption],
    -- | The ID of the volume that you are restoring.
    RestoreVolumeFromSnapshot -> Text
volumeId :: Prelude.Text,
    -- | The ID of the source snapshot. Specifies the snapshot that you are
    -- restoring from.
    RestoreVolumeFromSnapshot -> Text
snapshotId :: Prelude.Text
  }
  deriving (RestoreVolumeFromSnapshot -> RestoreVolumeFromSnapshot -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreVolumeFromSnapshot -> RestoreVolumeFromSnapshot -> Bool
$c/= :: RestoreVolumeFromSnapshot -> RestoreVolumeFromSnapshot -> Bool
== :: RestoreVolumeFromSnapshot -> RestoreVolumeFromSnapshot -> Bool
$c== :: RestoreVolumeFromSnapshot -> RestoreVolumeFromSnapshot -> Bool
Prelude.Eq, ReadPrec [RestoreVolumeFromSnapshot]
ReadPrec RestoreVolumeFromSnapshot
Int -> ReadS RestoreVolumeFromSnapshot
ReadS [RestoreVolumeFromSnapshot]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreVolumeFromSnapshot]
$creadListPrec :: ReadPrec [RestoreVolumeFromSnapshot]
readPrec :: ReadPrec RestoreVolumeFromSnapshot
$creadPrec :: ReadPrec RestoreVolumeFromSnapshot
readList :: ReadS [RestoreVolumeFromSnapshot]
$creadList :: ReadS [RestoreVolumeFromSnapshot]
readsPrec :: Int -> ReadS RestoreVolumeFromSnapshot
$creadsPrec :: Int -> ReadS RestoreVolumeFromSnapshot
Prelude.Read, Int -> RestoreVolumeFromSnapshot -> ShowS
[RestoreVolumeFromSnapshot] -> ShowS
RestoreVolumeFromSnapshot -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreVolumeFromSnapshot] -> ShowS
$cshowList :: [RestoreVolumeFromSnapshot] -> ShowS
show :: RestoreVolumeFromSnapshot -> String
$cshow :: RestoreVolumeFromSnapshot -> String
showsPrec :: Int -> RestoreVolumeFromSnapshot -> ShowS
$cshowsPrec :: Int -> RestoreVolumeFromSnapshot -> ShowS
Prelude.Show, forall x.
Rep RestoreVolumeFromSnapshot x -> RestoreVolumeFromSnapshot
forall x.
RestoreVolumeFromSnapshot -> Rep RestoreVolumeFromSnapshot x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RestoreVolumeFromSnapshot x -> RestoreVolumeFromSnapshot
$cfrom :: forall x.
RestoreVolumeFromSnapshot -> Rep RestoreVolumeFromSnapshot x
Prelude.Generic)

-- |
-- Create a value of 'RestoreVolumeFromSnapshot' 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', 'restoreVolumeFromSnapshot_clientRequestToken' - Undocumented member.
--
-- 'options', 'restoreVolumeFromSnapshot_options' - The settings used when restoring the specified volume from snapshot.
--
-- -   @DELETE_INTERMEDIATE_SNAPSHOTS@ - Deletes snapshots between the
--     current state and the specified snapshot. If there are intermediate
--     snapshots and this option isn\'t used, @RestoreVolumeFromSnapshot@
--     fails.
--
-- -   @DELETE_CLONED_VOLUMES@ - Deletes any dependent clone volumes
--     created from intermediate snapshots. If there are any dependent
--     clone volumes and this option isn\'t used,
--     @RestoreVolumeFromSnapshot@ fails.
--
-- 'volumeId', 'restoreVolumeFromSnapshot_volumeId' - The ID of the volume that you are restoring.
--
-- 'snapshotId', 'restoreVolumeFromSnapshot_snapshotId' - The ID of the source snapshot. Specifies the snapshot that you are
-- restoring from.
newRestoreVolumeFromSnapshot ::
  -- | 'volumeId'
  Prelude.Text ->
  -- | 'snapshotId'
  Prelude.Text ->
  RestoreVolumeFromSnapshot
newRestoreVolumeFromSnapshot :: Text -> Text -> RestoreVolumeFromSnapshot
newRestoreVolumeFromSnapshot Text
pVolumeId_ Text
pSnapshotId_ =
  RestoreVolumeFromSnapshot'
    { $sel:clientRequestToken:RestoreVolumeFromSnapshot' :: Maybe Text
clientRequestToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:options:RestoreVolumeFromSnapshot' :: Maybe [RestoreOpenZFSVolumeOption]
options = forall a. Maybe a
Prelude.Nothing,
      $sel:volumeId:RestoreVolumeFromSnapshot' :: Text
volumeId = Text
pVolumeId_,
      $sel:snapshotId:RestoreVolumeFromSnapshot' :: Text
snapshotId = Text
pSnapshotId_
    }

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

-- | The settings used when restoring the specified volume from snapshot.
--
-- -   @DELETE_INTERMEDIATE_SNAPSHOTS@ - Deletes snapshots between the
--     current state and the specified snapshot. If there are intermediate
--     snapshots and this option isn\'t used, @RestoreVolumeFromSnapshot@
--     fails.
--
-- -   @DELETE_CLONED_VOLUMES@ - Deletes any dependent clone volumes
--     created from intermediate snapshots. If there are any dependent
--     clone volumes and this option isn\'t used,
--     @RestoreVolumeFromSnapshot@ fails.
restoreVolumeFromSnapshot_options :: Lens.Lens' RestoreVolumeFromSnapshot (Prelude.Maybe [RestoreOpenZFSVolumeOption])
restoreVolumeFromSnapshot_options :: Lens'
  RestoreVolumeFromSnapshot (Maybe [RestoreOpenZFSVolumeOption])
restoreVolumeFromSnapshot_options = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreVolumeFromSnapshot' {Maybe [RestoreOpenZFSVolumeOption]
options :: Maybe [RestoreOpenZFSVolumeOption]
$sel:options:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Maybe [RestoreOpenZFSVolumeOption]
options} -> Maybe [RestoreOpenZFSVolumeOption]
options) (\s :: RestoreVolumeFromSnapshot
s@RestoreVolumeFromSnapshot' {} Maybe [RestoreOpenZFSVolumeOption]
a -> RestoreVolumeFromSnapshot
s {$sel:options:RestoreVolumeFromSnapshot' :: Maybe [RestoreOpenZFSVolumeOption]
options = Maybe [RestoreOpenZFSVolumeOption]
a} :: RestoreVolumeFromSnapshot) 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

-- | The ID of the volume that you are restoring.
restoreVolumeFromSnapshot_volumeId :: Lens.Lens' RestoreVolumeFromSnapshot Prelude.Text
restoreVolumeFromSnapshot_volumeId :: Lens' RestoreVolumeFromSnapshot Text
restoreVolumeFromSnapshot_volumeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreVolumeFromSnapshot' {Text
volumeId :: Text
$sel:volumeId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
volumeId} -> Text
volumeId) (\s :: RestoreVolumeFromSnapshot
s@RestoreVolumeFromSnapshot' {} Text
a -> RestoreVolumeFromSnapshot
s {$sel:volumeId:RestoreVolumeFromSnapshot' :: Text
volumeId = Text
a} :: RestoreVolumeFromSnapshot)

-- | The ID of the source snapshot. Specifies the snapshot that you are
-- restoring from.
restoreVolumeFromSnapshot_snapshotId :: Lens.Lens' RestoreVolumeFromSnapshot Prelude.Text
restoreVolumeFromSnapshot_snapshotId :: Lens' RestoreVolumeFromSnapshot Text
restoreVolumeFromSnapshot_snapshotId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreVolumeFromSnapshot' {Text
snapshotId :: Text
$sel:snapshotId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
snapshotId} -> Text
snapshotId) (\s :: RestoreVolumeFromSnapshot
s@RestoreVolumeFromSnapshot' {} Text
a -> RestoreVolumeFromSnapshot
s {$sel:snapshotId:RestoreVolumeFromSnapshot' :: Text
snapshotId = Text
a} :: RestoreVolumeFromSnapshot)

instance Core.AWSRequest RestoreVolumeFromSnapshot where
  type
    AWSResponse RestoreVolumeFromSnapshot =
      RestoreVolumeFromSnapshotResponse
  request :: (Service -> Service)
-> RestoreVolumeFromSnapshot -> Request RestoreVolumeFromSnapshot
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 RestoreVolumeFromSnapshot
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RestoreVolumeFromSnapshot)))
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 [AdministrativeAction]
-> Maybe VolumeLifecycle
-> Maybe Text
-> Int
-> RestoreVolumeFromSnapshotResponse
RestoreVolumeFromSnapshotResponse'
            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
"AdministrativeActions"
                            forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                        )
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Lifecycle")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"VolumeId")
            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 RestoreVolumeFromSnapshot where
  hashWithSalt :: Int -> RestoreVolumeFromSnapshot -> Int
hashWithSalt Int
_salt RestoreVolumeFromSnapshot' {Maybe [RestoreOpenZFSVolumeOption]
Maybe Text
Text
snapshotId :: Text
volumeId :: Text
options :: Maybe [RestoreOpenZFSVolumeOption]
clientRequestToken :: Maybe Text
$sel:snapshotId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
$sel:volumeId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
$sel:options:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Maybe [RestoreOpenZFSVolumeOption]
$sel:clientRequestToken:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> 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 [RestoreOpenZFSVolumeOption]
options
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
volumeId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
snapshotId

instance Prelude.NFData RestoreVolumeFromSnapshot where
  rnf :: RestoreVolumeFromSnapshot -> ()
rnf RestoreVolumeFromSnapshot' {Maybe [RestoreOpenZFSVolumeOption]
Maybe Text
Text
snapshotId :: Text
volumeId :: Text
options :: Maybe [RestoreOpenZFSVolumeOption]
clientRequestToken :: Maybe Text
$sel:snapshotId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
$sel:volumeId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
$sel:options:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Maybe [RestoreOpenZFSVolumeOption]
$sel:clientRequestToken:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> 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 [RestoreOpenZFSVolumeOption]
options
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
volumeId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
snapshotId

instance Data.ToHeaders RestoreVolumeFromSnapshot where
  toHeaders :: RestoreVolumeFromSnapshot -> 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.RestoreVolumeFromSnapshot" ::
                          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 RestoreVolumeFromSnapshot where
  toJSON :: RestoreVolumeFromSnapshot -> Value
toJSON RestoreVolumeFromSnapshot' {Maybe [RestoreOpenZFSVolumeOption]
Maybe Text
Text
snapshotId :: Text
volumeId :: Text
options :: Maybe [RestoreOpenZFSVolumeOption]
clientRequestToken :: Maybe Text
$sel:snapshotId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
$sel:volumeId:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Text
$sel:options:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> Maybe [RestoreOpenZFSVolumeOption]
$sel:clientRequestToken:RestoreVolumeFromSnapshot' :: RestoreVolumeFromSnapshot -> 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
"Options" 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 [RestoreOpenZFSVolumeOption]
options,
            forall a. a -> Maybe a
Prelude.Just (Key
"VolumeId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
volumeId),
            forall a. a -> Maybe a
Prelude.Just (Key
"SnapshotId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
snapshotId)
          ]
      )

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

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

-- | /See:/ 'newRestoreVolumeFromSnapshotResponse' smart constructor.
data RestoreVolumeFromSnapshotResponse = RestoreVolumeFromSnapshotResponse'
  { -- | A list of administrative actions for the file system that are in process
    -- or waiting to be processed. Administrative actions describe changes to
    -- the Amazon FSx system.
    RestoreVolumeFromSnapshotResponse -> Maybe [AdministrativeAction]
administrativeActions :: Prelude.Maybe [AdministrativeAction],
    -- | The lifecycle state of the volume being restored.
    RestoreVolumeFromSnapshotResponse -> Maybe VolumeLifecycle
lifecycle :: Prelude.Maybe VolumeLifecycle,
    -- | The ID of the volume that you restored.
    RestoreVolumeFromSnapshotResponse -> Maybe Text
volumeId :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    RestoreVolumeFromSnapshotResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RestoreVolumeFromSnapshotResponse
-> RestoreVolumeFromSnapshotResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreVolumeFromSnapshotResponse
-> RestoreVolumeFromSnapshotResponse -> Bool
$c/= :: RestoreVolumeFromSnapshotResponse
-> RestoreVolumeFromSnapshotResponse -> Bool
== :: RestoreVolumeFromSnapshotResponse
-> RestoreVolumeFromSnapshotResponse -> Bool
$c== :: RestoreVolumeFromSnapshotResponse
-> RestoreVolumeFromSnapshotResponse -> Bool
Prelude.Eq, ReadPrec [RestoreVolumeFromSnapshotResponse]
ReadPrec RestoreVolumeFromSnapshotResponse
Int -> ReadS RestoreVolumeFromSnapshotResponse
ReadS [RestoreVolumeFromSnapshotResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreVolumeFromSnapshotResponse]
$creadListPrec :: ReadPrec [RestoreVolumeFromSnapshotResponse]
readPrec :: ReadPrec RestoreVolumeFromSnapshotResponse
$creadPrec :: ReadPrec RestoreVolumeFromSnapshotResponse
readList :: ReadS [RestoreVolumeFromSnapshotResponse]
$creadList :: ReadS [RestoreVolumeFromSnapshotResponse]
readsPrec :: Int -> ReadS RestoreVolumeFromSnapshotResponse
$creadsPrec :: Int -> ReadS RestoreVolumeFromSnapshotResponse
Prelude.Read, Int -> RestoreVolumeFromSnapshotResponse -> ShowS
[RestoreVolumeFromSnapshotResponse] -> ShowS
RestoreVolumeFromSnapshotResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreVolumeFromSnapshotResponse] -> ShowS
$cshowList :: [RestoreVolumeFromSnapshotResponse] -> ShowS
show :: RestoreVolumeFromSnapshotResponse -> String
$cshow :: RestoreVolumeFromSnapshotResponse -> String
showsPrec :: Int -> RestoreVolumeFromSnapshotResponse -> ShowS
$cshowsPrec :: Int -> RestoreVolumeFromSnapshotResponse -> ShowS
Prelude.Show, forall x.
Rep RestoreVolumeFromSnapshotResponse x
-> RestoreVolumeFromSnapshotResponse
forall x.
RestoreVolumeFromSnapshotResponse
-> Rep RestoreVolumeFromSnapshotResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RestoreVolumeFromSnapshotResponse x
-> RestoreVolumeFromSnapshotResponse
$cfrom :: forall x.
RestoreVolumeFromSnapshotResponse
-> Rep RestoreVolumeFromSnapshotResponse x
Prelude.Generic)

-- |
-- Create a value of 'RestoreVolumeFromSnapshotResponse' 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:
--
-- 'administrativeActions', 'restoreVolumeFromSnapshotResponse_administrativeActions' - A list of administrative actions for the file system that are in process
-- or waiting to be processed. Administrative actions describe changes to
-- the Amazon FSx system.
--
-- 'lifecycle', 'restoreVolumeFromSnapshotResponse_lifecycle' - The lifecycle state of the volume being restored.
--
-- 'volumeId', 'restoreVolumeFromSnapshotResponse_volumeId' - The ID of the volume that you restored.
--
-- 'httpStatus', 'restoreVolumeFromSnapshotResponse_httpStatus' - The response's http status code.
newRestoreVolumeFromSnapshotResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RestoreVolumeFromSnapshotResponse
newRestoreVolumeFromSnapshotResponse :: Int -> RestoreVolumeFromSnapshotResponse
newRestoreVolumeFromSnapshotResponse Int
pHttpStatus_ =
  RestoreVolumeFromSnapshotResponse'
    { $sel:administrativeActions:RestoreVolumeFromSnapshotResponse' :: Maybe [AdministrativeAction]
administrativeActions =
        forall a. Maybe a
Prelude.Nothing,
      $sel:lifecycle:RestoreVolumeFromSnapshotResponse' :: Maybe VolumeLifecycle
lifecycle = forall a. Maybe a
Prelude.Nothing,
      $sel:volumeId:RestoreVolumeFromSnapshotResponse' :: Maybe Text
volumeId = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RestoreVolumeFromSnapshotResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | A list of administrative actions for the file system that are in process
-- or waiting to be processed. Administrative actions describe changes to
-- the Amazon FSx system.
restoreVolumeFromSnapshotResponse_administrativeActions :: Lens.Lens' RestoreVolumeFromSnapshotResponse (Prelude.Maybe [AdministrativeAction])
restoreVolumeFromSnapshotResponse_administrativeActions :: Lens'
  RestoreVolumeFromSnapshotResponse (Maybe [AdministrativeAction])
restoreVolumeFromSnapshotResponse_administrativeActions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreVolumeFromSnapshotResponse' {Maybe [AdministrativeAction]
administrativeActions :: Maybe [AdministrativeAction]
$sel:administrativeActions:RestoreVolumeFromSnapshotResponse' :: RestoreVolumeFromSnapshotResponse -> Maybe [AdministrativeAction]
administrativeActions} -> Maybe [AdministrativeAction]
administrativeActions) (\s :: RestoreVolumeFromSnapshotResponse
s@RestoreVolumeFromSnapshotResponse' {} Maybe [AdministrativeAction]
a -> RestoreVolumeFromSnapshotResponse
s {$sel:administrativeActions:RestoreVolumeFromSnapshotResponse' :: Maybe [AdministrativeAction]
administrativeActions = Maybe [AdministrativeAction]
a} :: RestoreVolumeFromSnapshotResponse) 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

-- | The lifecycle state of the volume being restored.
restoreVolumeFromSnapshotResponse_lifecycle :: Lens.Lens' RestoreVolumeFromSnapshotResponse (Prelude.Maybe VolumeLifecycle)
restoreVolumeFromSnapshotResponse_lifecycle :: Lens' RestoreVolumeFromSnapshotResponse (Maybe VolumeLifecycle)
restoreVolumeFromSnapshotResponse_lifecycle = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreVolumeFromSnapshotResponse' {Maybe VolumeLifecycle
lifecycle :: Maybe VolumeLifecycle
$sel:lifecycle:RestoreVolumeFromSnapshotResponse' :: RestoreVolumeFromSnapshotResponse -> Maybe VolumeLifecycle
lifecycle} -> Maybe VolumeLifecycle
lifecycle) (\s :: RestoreVolumeFromSnapshotResponse
s@RestoreVolumeFromSnapshotResponse' {} Maybe VolumeLifecycle
a -> RestoreVolumeFromSnapshotResponse
s {$sel:lifecycle:RestoreVolumeFromSnapshotResponse' :: Maybe VolumeLifecycle
lifecycle = Maybe VolumeLifecycle
a} :: RestoreVolumeFromSnapshotResponse)

-- | The ID of the volume that you restored.
restoreVolumeFromSnapshotResponse_volumeId :: Lens.Lens' RestoreVolumeFromSnapshotResponse (Prelude.Maybe Prelude.Text)
restoreVolumeFromSnapshotResponse_volumeId :: Lens' RestoreVolumeFromSnapshotResponse (Maybe Text)
restoreVolumeFromSnapshotResponse_volumeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreVolumeFromSnapshotResponse' {Maybe Text
volumeId :: Maybe Text
$sel:volumeId:RestoreVolumeFromSnapshotResponse' :: RestoreVolumeFromSnapshotResponse -> Maybe Text
volumeId} -> Maybe Text
volumeId) (\s :: RestoreVolumeFromSnapshotResponse
s@RestoreVolumeFromSnapshotResponse' {} Maybe Text
a -> RestoreVolumeFromSnapshotResponse
s {$sel:volumeId:RestoreVolumeFromSnapshotResponse' :: Maybe Text
volumeId = Maybe Text
a} :: RestoreVolumeFromSnapshotResponse)

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

instance
  Prelude.NFData
    RestoreVolumeFromSnapshotResponse
  where
  rnf :: RestoreVolumeFromSnapshotResponse -> ()
rnf RestoreVolumeFromSnapshotResponse' {Int
Maybe [AdministrativeAction]
Maybe Text
Maybe VolumeLifecycle
httpStatus :: Int
volumeId :: Maybe Text
lifecycle :: Maybe VolumeLifecycle
administrativeActions :: Maybe [AdministrativeAction]
$sel:httpStatus:RestoreVolumeFromSnapshotResponse' :: RestoreVolumeFromSnapshotResponse -> Int
$sel:volumeId:RestoreVolumeFromSnapshotResponse' :: RestoreVolumeFromSnapshotResponse -> Maybe Text
$sel:lifecycle:RestoreVolumeFromSnapshotResponse' :: RestoreVolumeFromSnapshotResponse -> Maybe VolumeLifecycle
$sel:administrativeActions:RestoreVolumeFromSnapshotResponse' :: RestoreVolumeFromSnapshotResponse -> Maybe [AdministrativeAction]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [AdministrativeAction]
administrativeActions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe VolumeLifecycle
lifecycle
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
volumeId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus