{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.EC2.Types.VolumeStatusItem
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.EC2.Types.VolumeStatusItem where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.VolumeStatusAction
import Amazonka.EC2.Types.VolumeStatusAttachmentStatus
import Amazonka.EC2.Types.VolumeStatusEvent
import Amazonka.EC2.Types.VolumeStatusInfo
import qualified Amazonka.Prelude as Prelude

-- | Describes the volume status.
--
-- /See:/ 'newVolumeStatusItem' smart constructor.
data VolumeStatusItem = VolumeStatusItem'
  { -- | The details of the operation.
    VolumeStatusItem -> Maybe [VolumeStatusAction]
actions :: Prelude.Maybe [VolumeStatusAction],
    -- | Information about the instances to which the volume is attached.
    VolumeStatusItem -> Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses :: Prelude.Maybe [VolumeStatusAttachmentStatus],
    -- | The Availability Zone of the volume.
    VolumeStatusItem -> Maybe Text
availabilityZone :: Prelude.Maybe Prelude.Text,
    -- | A list of events associated with the volume.
    VolumeStatusItem -> Maybe [VolumeStatusEvent]
events :: Prelude.Maybe [VolumeStatusEvent],
    -- | The Amazon Resource Name (ARN) of the Outpost.
    VolumeStatusItem -> Maybe Text
outpostArn :: Prelude.Maybe Prelude.Text,
    -- | The volume ID.
    VolumeStatusItem -> Maybe Text
volumeId :: Prelude.Maybe Prelude.Text,
    -- | The volume status.
    VolumeStatusItem -> Maybe VolumeStatusInfo
volumeStatus :: Prelude.Maybe VolumeStatusInfo
  }
  deriving (VolumeStatusItem -> VolumeStatusItem -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VolumeStatusItem -> VolumeStatusItem -> Bool
$c/= :: VolumeStatusItem -> VolumeStatusItem -> Bool
== :: VolumeStatusItem -> VolumeStatusItem -> Bool
$c== :: VolumeStatusItem -> VolumeStatusItem -> Bool
Prelude.Eq, ReadPrec [VolumeStatusItem]
ReadPrec VolumeStatusItem
Int -> ReadS VolumeStatusItem
ReadS [VolumeStatusItem]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [VolumeStatusItem]
$creadListPrec :: ReadPrec [VolumeStatusItem]
readPrec :: ReadPrec VolumeStatusItem
$creadPrec :: ReadPrec VolumeStatusItem
readList :: ReadS [VolumeStatusItem]
$creadList :: ReadS [VolumeStatusItem]
readsPrec :: Int -> ReadS VolumeStatusItem
$creadsPrec :: Int -> ReadS VolumeStatusItem
Prelude.Read, Int -> VolumeStatusItem -> ShowS
[VolumeStatusItem] -> ShowS
VolumeStatusItem -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [VolumeStatusItem] -> ShowS
$cshowList :: [VolumeStatusItem] -> ShowS
show :: VolumeStatusItem -> String
$cshow :: VolumeStatusItem -> String
showsPrec :: Int -> VolumeStatusItem -> ShowS
$cshowsPrec :: Int -> VolumeStatusItem -> ShowS
Prelude.Show, forall x. Rep VolumeStatusItem x -> VolumeStatusItem
forall x. VolumeStatusItem -> Rep VolumeStatusItem x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep VolumeStatusItem x -> VolumeStatusItem
$cfrom :: forall x. VolumeStatusItem -> Rep VolumeStatusItem x
Prelude.Generic)

-- |
-- Create a value of 'VolumeStatusItem' 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:
--
-- 'actions', 'volumeStatusItem_actions' - The details of the operation.
--
-- 'attachmentStatuses', 'volumeStatusItem_attachmentStatuses' - Information about the instances to which the volume is attached.
--
-- 'availabilityZone', 'volumeStatusItem_availabilityZone' - The Availability Zone of the volume.
--
-- 'events', 'volumeStatusItem_events' - A list of events associated with the volume.
--
-- 'outpostArn', 'volumeStatusItem_outpostArn' - The Amazon Resource Name (ARN) of the Outpost.
--
-- 'volumeId', 'volumeStatusItem_volumeId' - The volume ID.
--
-- 'volumeStatus', 'volumeStatusItem_volumeStatus' - The volume status.
newVolumeStatusItem ::
  VolumeStatusItem
newVolumeStatusItem :: VolumeStatusItem
newVolumeStatusItem =
  VolumeStatusItem'
    { $sel:actions:VolumeStatusItem' :: Maybe [VolumeStatusAction]
actions = forall a. Maybe a
Prelude.Nothing,
      $sel:attachmentStatuses:VolumeStatusItem' :: Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses = forall a. Maybe a
Prelude.Nothing,
      $sel:availabilityZone:VolumeStatusItem' :: Maybe Text
availabilityZone = forall a. Maybe a
Prelude.Nothing,
      $sel:events:VolumeStatusItem' :: Maybe [VolumeStatusEvent]
events = forall a. Maybe a
Prelude.Nothing,
      $sel:outpostArn:VolumeStatusItem' :: Maybe Text
outpostArn = forall a. Maybe a
Prelude.Nothing,
      $sel:volumeId:VolumeStatusItem' :: Maybe Text
volumeId = forall a. Maybe a
Prelude.Nothing,
      $sel:volumeStatus:VolumeStatusItem' :: Maybe VolumeStatusInfo
volumeStatus = forall a. Maybe a
Prelude.Nothing
    }

-- | The details of the operation.
volumeStatusItem_actions :: Lens.Lens' VolumeStatusItem (Prelude.Maybe [VolumeStatusAction])
volumeStatusItem_actions :: Lens' VolumeStatusItem (Maybe [VolumeStatusAction])
volumeStatusItem_actions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VolumeStatusItem' {Maybe [VolumeStatusAction]
actions :: Maybe [VolumeStatusAction]
$sel:actions:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusAction]
actions} -> Maybe [VolumeStatusAction]
actions) (\s :: VolumeStatusItem
s@VolumeStatusItem' {} Maybe [VolumeStatusAction]
a -> VolumeStatusItem
s {$sel:actions:VolumeStatusItem' :: Maybe [VolumeStatusAction]
actions = Maybe [VolumeStatusAction]
a} :: VolumeStatusItem) 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

-- | Information about the instances to which the volume is attached.
volumeStatusItem_attachmentStatuses :: Lens.Lens' VolumeStatusItem (Prelude.Maybe [VolumeStatusAttachmentStatus])
volumeStatusItem_attachmentStatuses :: Lens' VolumeStatusItem (Maybe [VolumeStatusAttachmentStatus])
volumeStatusItem_attachmentStatuses = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VolumeStatusItem' {Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses :: Maybe [VolumeStatusAttachmentStatus]
$sel:attachmentStatuses:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses} -> Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses) (\s :: VolumeStatusItem
s@VolumeStatusItem' {} Maybe [VolumeStatusAttachmentStatus]
a -> VolumeStatusItem
s {$sel:attachmentStatuses:VolumeStatusItem' :: Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses = Maybe [VolumeStatusAttachmentStatus]
a} :: VolumeStatusItem) 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 Availability Zone of the volume.
volumeStatusItem_availabilityZone :: Lens.Lens' VolumeStatusItem (Prelude.Maybe Prelude.Text)
volumeStatusItem_availabilityZone :: Lens' VolumeStatusItem (Maybe Text)
volumeStatusItem_availabilityZone = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VolumeStatusItem' {Maybe Text
availabilityZone :: Maybe Text
$sel:availabilityZone:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
availabilityZone} -> Maybe Text
availabilityZone) (\s :: VolumeStatusItem
s@VolumeStatusItem' {} Maybe Text
a -> VolumeStatusItem
s {$sel:availabilityZone:VolumeStatusItem' :: Maybe Text
availabilityZone = Maybe Text
a} :: VolumeStatusItem)

-- | A list of events associated with the volume.
volumeStatusItem_events :: Lens.Lens' VolumeStatusItem (Prelude.Maybe [VolumeStatusEvent])
volumeStatusItem_events :: Lens' VolumeStatusItem (Maybe [VolumeStatusEvent])
volumeStatusItem_events = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VolumeStatusItem' {Maybe [VolumeStatusEvent]
events :: Maybe [VolumeStatusEvent]
$sel:events:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusEvent]
events} -> Maybe [VolumeStatusEvent]
events) (\s :: VolumeStatusItem
s@VolumeStatusItem' {} Maybe [VolumeStatusEvent]
a -> VolumeStatusItem
s {$sel:events:VolumeStatusItem' :: Maybe [VolumeStatusEvent]
events = Maybe [VolumeStatusEvent]
a} :: VolumeStatusItem) 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 Amazon Resource Name (ARN) of the Outpost.
volumeStatusItem_outpostArn :: Lens.Lens' VolumeStatusItem (Prelude.Maybe Prelude.Text)
volumeStatusItem_outpostArn :: Lens' VolumeStatusItem (Maybe Text)
volumeStatusItem_outpostArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VolumeStatusItem' {Maybe Text
outpostArn :: Maybe Text
$sel:outpostArn:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
outpostArn} -> Maybe Text
outpostArn) (\s :: VolumeStatusItem
s@VolumeStatusItem' {} Maybe Text
a -> VolumeStatusItem
s {$sel:outpostArn:VolumeStatusItem' :: Maybe Text
outpostArn = Maybe Text
a} :: VolumeStatusItem)

-- | The volume ID.
volumeStatusItem_volumeId :: Lens.Lens' VolumeStatusItem (Prelude.Maybe Prelude.Text)
volumeStatusItem_volumeId :: Lens' VolumeStatusItem (Maybe Text)
volumeStatusItem_volumeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VolumeStatusItem' {Maybe Text
volumeId :: Maybe Text
$sel:volumeId:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
volumeId} -> Maybe Text
volumeId) (\s :: VolumeStatusItem
s@VolumeStatusItem' {} Maybe Text
a -> VolumeStatusItem
s {$sel:volumeId:VolumeStatusItem' :: Maybe Text
volumeId = Maybe Text
a} :: VolumeStatusItem)

-- | The volume status.
volumeStatusItem_volumeStatus :: Lens.Lens' VolumeStatusItem (Prelude.Maybe VolumeStatusInfo)
volumeStatusItem_volumeStatus :: Lens' VolumeStatusItem (Maybe VolumeStatusInfo)
volumeStatusItem_volumeStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\VolumeStatusItem' {Maybe VolumeStatusInfo
volumeStatus :: Maybe VolumeStatusInfo
$sel:volumeStatus:VolumeStatusItem' :: VolumeStatusItem -> Maybe VolumeStatusInfo
volumeStatus} -> Maybe VolumeStatusInfo
volumeStatus) (\s :: VolumeStatusItem
s@VolumeStatusItem' {} Maybe VolumeStatusInfo
a -> VolumeStatusItem
s {$sel:volumeStatus:VolumeStatusItem' :: Maybe VolumeStatusInfo
volumeStatus = Maybe VolumeStatusInfo
a} :: VolumeStatusItem)

instance Data.FromXML VolumeStatusItem where
  parseXML :: [Node] -> Either String VolumeStatusItem
parseXML [Node]
x =
    Maybe [VolumeStatusAction]
-> Maybe [VolumeStatusAttachmentStatus]
-> Maybe Text
-> Maybe [VolumeStatusEvent]
-> Maybe Text
-> Maybe Text
-> Maybe VolumeStatusInfo
-> VolumeStatusItem
VolumeStatusItem'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"actionsSet"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"attachmentStatuses"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"availabilityZone")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( [Node]
x
                      forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"eventsSet"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"outpostArn")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"volumeId")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"volumeStatus")

instance Prelude.Hashable VolumeStatusItem where
  hashWithSalt :: Int -> VolumeStatusItem -> Int
hashWithSalt Int
_salt VolumeStatusItem' {Maybe [VolumeStatusAction]
Maybe [VolumeStatusAttachmentStatus]
Maybe [VolumeStatusEvent]
Maybe Text
Maybe VolumeStatusInfo
volumeStatus :: Maybe VolumeStatusInfo
volumeId :: Maybe Text
outpostArn :: Maybe Text
events :: Maybe [VolumeStatusEvent]
availabilityZone :: Maybe Text
attachmentStatuses :: Maybe [VolumeStatusAttachmentStatus]
actions :: Maybe [VolumeStatusAction]
$sel:volumeStatus:VolumeStatusItem' :: VolumeStatusItem -> Maybe VolumeStatusInfo
$sel:volumeId:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
$sel:outpostArn:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
$sel:events:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusEvent]
$sel:availabilityZone:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
$sel:attachmentStatuses:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusAttachmentStatus]
$sel:actions:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusAction]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [VolumeStatusAction]
actions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
availabilityZone
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [VolumeStatusEvent]
events
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
outpostArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
volumeId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe VolumeStatusInfo
volumeStatus

instance Prelude.NFData VolumeStatusItem where
  rnf :: VolumeStatusItem -> ()
rnf VolumeStatusItem' {Maybe [VolumeStatusAction]
Maybe [VolumeStatusAttachmentStatus]
Maybe [VolumeStatusEvent]
Maybe Text
Maybe VolumeStatusInfo
volumeStatus :: Maybe VolumeStatusInfo
volumeId :: Maybe Text
outpostArn :: Maybe Text
events :: Maybe [VolumeStatusEvent]
availabilityZone :: Maybe Text
attachmentStatuses :: Maybe [VolumeStatusAttachmentStatus]
actions :: Maybe [VolumeStatusAction]
$sel:volumeStatus:VolumeStatusItem' :: VolumeStatusItem -> Maybe VolumeStatusInfo
$sel:volumeId:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
$sel:outpostArn:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
$sel:events:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusEvent]
$sel:availabilityZone:VolumeStatusItem' :: VolumeStatusItem -> Maybe Text
$sel:attachmentStatuses:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusAttachmentStatus]
$sel:actions:VolumeStatusItem' :: VolumeStatusItem -> Maybe [VolumeStatusAction]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [VolumeStatusAction]
actions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [VolumeStatusAttachmentStatus]
attachmentStatuses
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
availabilityZone
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [VolumeStatusEvent]
events
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
outpostArn
      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 Maybe VolumeStatusInfo
volumeStatus