{-# 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.Redshift.Types.ReservedNode
-- 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.Redshift.Types.ReservedNode where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.Redshift.Internal
import Amazonka.Redshift.Types.RecurringCharge
import Amazonka.Redshift.Types.ReservedNodeOfferingType

-- | Describes a reserved node. You can call the
-- DescribeReservedNodeOfferings API to obtain the available reserved node
-- offerings.
--
-- /See:/ 'newReservedNode' smart constructor.
data ReservedNode = ReservedNode'
  { -- | The currency code for the reserved cluster.
    ReservedNode -> Maybe Text
currencyCode :: Prelude.Maybe Prelude.Text,
    -- | The duration of the node reservation in seconds.
    ReservedNode -> Maybe Int
duration :: Prelude.Maybe Prelude.Int,
    -- | The fixed cost Amazon Redshift charges you for this reserved node.
    ReservedNode -> Maybe Double
fixedPrice :: Prelude.Maybe Prelude.Double,
    -- | The number of reserved compute nodes.
    ReservedNode -> Maybe Int
nodeCount :: Prelude.Maybe Prelude.Int,
    -- | The node type of the reserved node.
    ReservedNode -> Maybe Text
nodeType :: Prelude.Maybe Prelude.Text,
    -- | The anticipated utilization of the reserved node, as defined in the
    -- reserved node offering.
    ReservedNode -> Maybe Text
offeringType :: Prelude.Maybe Prelude.Text,
    -- | The recurring charges for the reserved node.
    ReservedNode -> Maybe [RecurringCharge]
recurringCharges :: Prelude.Maybe [RecurringCharge],
    -- | The unique identifier for the reservation.
    ReservedNode -> Maybe Text
reservedNodeId :: Prelude.Maybe Prelude.Text,
    -- | The identifier for the reserved node offering.
    ReservedNode -> Maybe Text
reservedNodeOfferingId :: Prelude.Maybe Prelude.Text,
    ReservedNode -> Maybe ReservedNodeOfferingType
reservedNodeOfferingType :: Prelude.Maybe ReservedNodeOfferingType,
    -- | The time the reservation started. You purchase a reserved node offering
    -- for a duration. This is the start time of that duration.
    ReservedNode -> Maybe ISO8601
startTime :: Prelude.Maybe Data.ISO8601,
    -- | The state of the reserved compute node.
    --
    -- Possible Values:
    --
    -- -   pending-payment-This reserved node has recently been purchased, and
    --     the sale has been approved, but payment has not yet been confirmed.
    --
    -- -   active-This reserved node is owned by the caller and is available
    --     for use.
    --
    -- -   payment-failed-Payment failed for the purchase attempt.
    --
    -- -   retired-The reserved node is no longer available.
    --
    -- -   exchanging-The owner is exchanging the reserved node for another
    --     reserved node.
    ReservedNode -> Maybe Text
state :: Prelude.Maybe Prelude.Text,
    -- | The hourly rate Amazon Redshift charges you for this reserved node.
    ReservedNode -> Maybe Double
usagePrice :: Prelude.Maybe Prelude.Double
  }
  deriving (ReservedNode -> ReservedNode -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReservedNode -> ReservedNode -> Bool
$c/= :: ReservedNode -> ReservedNode -> Bool
== :: ReservedNode -> ReservedNode -> Bool
$c== :: ReservedNode -> ReservedNode -> Bool
Prelude.Eq, ReadPrec [ReservedNode]
ReadPrec ReservedNode
Int -> ReadS ReservedNode
ReadS [ReservedNode]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ReservedNode]
$creadListPrec :: ReadPrec [ReservedNode]
readPrec :: ReadPrec ReservedNode
$creadPrec :: ReadPrec ReservedNode
readList :: ReadS [ReservedNode]
$creadList :: ReadS [ReservedNode]
readsPrec :: Int -> ReadS ReservedNode
$creadsPrec :: Int -> ReadS ReservedNode
Prelude.Read, Int -> ReservedNode -> ShowS
[ReservedNode] -> ShowS
ReservedNode -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReservedNode] -> ShowS
$cshowList :: [ReservedNode] -> ShowS
show :: ReservedNode -> String
$cshow :: ReservedNode -> String
showsPrec :: Int -> ReservedNode -> ShowS
$cshowsPrec :: Int -> ReservedNode -> ShowS
Prelude.Show, forall x. Rep ReservedNode x -> ReservedNode
forall x. ReservedNode -> Rep ReservedNode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ReservedNode x -> ReservedNode
$cfrom :: forall x. ReservedNode -> Rep ReservedNode x
Prelude.Generic)

-- |
-- Create a value of 'ReservedNode' 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:
--
-- 'currencyCode', 'reservedNode_currencyCode' - The currency code for the reserved cluster.
--
-- 'duration', 'reservedNode_duration' - The duration of the node reservation in seconds.
--
-- 'fixedPrice', 'reservedNode_fixedPrice' - The fixed cost Amazon Redshift charges you for this reserved node.
--
-- 'nodeCount', 'reservedNode_nodeCount' - The number of reserved compute nodes.
--
-- 'nodeType', 'reservedNode_nodeType' - The node type of the reserved node.
--
-- 'offeringType', 'reservedNode_offeringType' - The anticipated utilization of the reserved node, as defined in the
-- reserved node offering.
--
-- 'recurringCharges', 'reservedNode_recurringCharges' - The recurring charges for the reserved node.
--
-- 'reservedNodeId', 'reservedNode_reservedNodeId' - The unique identifier for the reservation.
--
-- 'reservedNodeOfferingId', 'reservedNode_reservedNodeOfferingId' - The identifier for the reserved node offering.
--
-- 'reservedNodeOfferingType', 'reservedNode_reservedNodeOfferingType' -
--
-- 'startTime', 'reservedNode_startTime' - The time the reservation started. You purchase a reserved node offering
-- for a duration. This is the start time of that duration.
--
-- 'state', 'reservedNode_state' - The state of the reserved compute node.
--
-- Possible Values:
--
-- -   pending-payment-This reserved node has recently been purchased, and
--     the sale has been approved, but payment has not yet been confirmed.
--
-- -   active-This reserved node is owned by the caller and is available
--     for use.
--
-- -   payment-failed-Payment failed for the purchase attempt.
--
-- -   retired-The reserved node is no longer available.
--
-- -   exchanging-The owner is exchanging the reserved node for another
--     reserved node.
--
-- 'usagePrice', 'reservedNode_usagePrice' - The hourly rate Amazon Redshift charges you for this reserved node.
newReservedNode ::
  ReservedNode
newReservedNode :: ReservedNode
newReservedNode =
  ReservedNode'
    { $sel:currencyCode:ReservedNode' :: Maybe Text
currencyCode = forall a. Maybe a
Prelude.Nothing,
      $sel:duration:ReservedNode' :: Maybe Int
duration = forall a. Maybe a
Prelude.Nothing,
      $sel:fixedPrice:ReservedNode' :: Maybe Double
fixedPrice = forall a. Maybe a
Prelude.Nothing,
      $sel:nodeCount:ReservedNode' :: Maybe Int
nodeCount = forall a. Maybe a
Prelude.Nothing,
      $sel:nodeType:ReservedNode' :: Maybe Text
nodeType = forall a. Maybe a
Prelude.Nothing,
      $sel:offeringType:ReservedNode' :: Maybe Text
offeringType = forall a. Maybe a
Prelude.Nothing,
      $sel:recurringCharges:ReservedNode' :: Maybe [RecurringCharge]
recurringCharges = forall a. Maybe a
Prelude.Nothing,
      $sel:reservedNodeId:ReservedNode' :: Maybe Text
reservedNodeId = forall a. Maybe a
Prelude.Nothing,
      $sel:reservedNodeOfferingId:ReservedNode' :: Maybe Text
reservedNodeOfferingId = forall a. Maybe a
Prelude.Nothing,
      $sel:reservedNodeOfferingType:ReservedNode' :: Maybe ReservedNodeOfferingType
reservedNodeOfferingType = forall a. Maybe a
Prelude.Nothing,
      $sel:startTime:ReservedNode' :: Maybe ISO8601
startTime = forall a. Maybe a
Prelude.Nothing,
      $sel:state:ReservedNode' :: Maybe Text
state = forall a. Maybe a
Prelude.Nothing,
      $sel:usagePrice:ReservedNode' :: Maybe Double
usagePrice = forall a. Maybe a
Prelude.Nothing
    }

-- | The currency code for the reserved cluster.
reservedNode_currencyCode :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Text)
reservedNode_currencyCode :: Lens' ReservedNode (Maybe Text)
reservedNode_currencyCode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Text
currencyCode :: Maybe Text
$sel:currencyCode:ReservedNode' :: ReservedNode -> Maybe Text
currencyCode} -> Maybe Text
currencyCode) (\s :: ReservedNode
s@ReservedNode' {} Maybe Text
a -> ReservedNode
s {$sel:currencyCode:ReservedNode' :: Maybe Text
currencyCode = Maybe Text
a} :: ReservedNode)

-- | The duration of the node reservation in seconds.
reservedNode_duration :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Int)
reservedNode_duration :: Lens' ReservedNode (Maybe Int)
reservedNode_duration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Int
duration :: Maybe Int
$sel:duration:ReservedNode' :: ReservedNode -> Maybe Int
duration} -> Maybe Int
duration) (\s :: ReservedNode
s@ReservedNode' {} Maybe Int
a -> ReservedNode
s {$sel:duration:ReservedNode' :: Maybe Int
duration = Maybe Int
a} :: ReservedNode)

-- | The fixed cost Amazon Redshift charges you for this reserved node.
reservedNode_fixedPrice :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Double)
reservedNode_fixedPrice :: Lens' ReservedNode (Maybe Double)
reservedNode_fixedPrice = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Double
fixedPrice :: Maybe Double
$sel:fixedPrice:ReservedNode' :: ReservedNode -> Maybe Double
fixedPrice} -> Maybe Double
fixedPrice) (\s :: ReservedNode
s@ReservedNode' {} Maybe Double
a -> ReservedNode
s {$sel:fixedPrice:ReservedNode' :: Maybe Double
fixedPrice = Maybe Double
a} :: ReservedNode)

-- | The number of reserved compute nodes.
reservedNode_nodeCount :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Int)
reservedNode_nodeCount :: Lens' ReservedNode (Maybe Int)
reservedNode_nodeCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Int
nodeCount :: Maybe Int
$sel:nodeCount:ReservedNode' :: ReservedNode -> Maybe Int
nodeCount} -> Maybe Int
nodeCount) (\s :: ReservedNode
s@ReservedNode' {} Maybe Int
a -> ReservedNode
s {$sel:nodeCount:ReservedNode' :: Maybe Int
nodeCount = Maybe Int
a} :: ReservedNode)

-- | The node type of the reserved node.
reservedNode_nodeType :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Text)
reservedNode_nodeType :: Lens' ReservedNode (Maybe Text)
reservedNode_nodeType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Text
nodeType :: Maybe Text
$sel:nodeType:ReservedNode' :: ReservedNode -> Maybe Text
nodeType} -> Maybe Text
nodeType) (\s :: ReservedNode
s@ReservedNode' {} Maybe Text
a -> ReservedNode
s {$sel:nodeType:ReservedNode' :: Maybe Text
nodeType = Maybe Text
a} :: ReservedNode)

-- | The anticipated utilization of the reserved node, as defined in the
-- reserved node offering.
reservedNode_offeringType :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Text)
reservedNode_offeringType :: Lens' ReservedNode (Maybe Text)
reservedNode_offeringType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Text
offeringType :: Maybe Text
$sel:offeringType:ReservedNode' :: ReservedNode -> Maybe Text
offeringType} -> Maybe Text
offeringType) (\s :: ReservedNode
s@ReservedNode' {} Maybe Text
a -> ReservedNode
s {$sel:offeringType:ReservedNode' :: Maybe Text
offeringType = Maybe Text
a} :: ReservedNode)

-- | The recurring charges for the reserved node.
reservedNode_recurringCharges :: Lens.Lens' ReservedNode (Prelude.Maybe [RecurringCharge])
reservedNode_recurringCharges :: Lens' ReservedNode (Maybe [RecurringCharge])
reservedNode_recurringCharges = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe [RecurringCharge]
recurringCharges :: Maybe [RecurringCharge]
$sel:recurringCharges:ReservedNode' :: ReservedNode -> Maybe [RecurringCharge]
recurringCharges} -> Maybe [RecurringCharge]
recurringCharges) (\s :: ReservedNode
s@ReservedNode' {} Maybe [RecurringCharge]
a -> ReservedNode
s {$sel:recurringCharges:ReservedNode' :: Maybe [RecurringCharge]
recurringCharges = Maybe [RecurringCharge]
a} :: ReservedNode) 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 unique identifier for the reservation.
reservedNode_reservedNodeId :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Text)
reservedNode_reservedNodeId :: Lens' ReservedNode (Maybe Text)
reservedNode_reservedNodeId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Text
reservedNodeId :: Maybe Text
$sel:reservedNodeId:ReservedNode' :: ReservedNode -> Maybe Text
reservedNodeId} -> Maybe Text
reservedNodeId) (\s :: ReservedNode
s@ReservedNode' {} Maybe Text
a -> ReservedNode
s {$sel:reservedNodeId:ReservedNode' :: Maybe Text
reservedNodeId = Maybe Text
a} :: ReservedNode)

-- | The identifier for the reserved node offering.
reservedNode_reservedNodeOfferingId :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Text)
reservedNode_reservedNodeOfferingId :: Lens' ReservedNode (Maybe Text)
reservedNode_reservedNodeOfferingId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Text
reservedNodeOfferingId :: Maybe Text
$sel:reservedNodeOfferingId:ReservedNode' :: ReservedNode -> Maybe Text
reservedNodeOfferingId} -> Maybe Text
reservedNodeOfferingId) (\s :: ReservedNode
s@ReservedNode' {} Maybe Text
a -> ReservedNode
s {$sel:reservedNodeOfferingId:ReservedNode' :: Maybe Text
reservedNodeOfferingId = Maybe Text
a} :: ReservedNode)

reservedNode_reservedNodeOfferingType :: Lens.Lens' ReservedNode (Prelude.Maybe ReservedNodeOfferingType)
reservedNode_reservedNodeOfferingType :: Lens' ReservedNode (Maybe ReservedNodeOfferingType)
reservedNode_reservedNodeOfferingType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe ReservedNodeOfferingType
reservedNodeOfferingType :: Maybe ReservedNodeOfferingType
$sel:reservedNodeOfferingType:ReservedNode' :: ReservedNode -> Maybe ReservedNodeOfferingType
reservedNodeOfferingType} -> Maybe ReservedNodeOfferingType
reservedNodeOfferingType) (\s :: ReservedNode
s@ReservedNode' {} Maybe ReservedNodeOfferingType
a -> ReservedNode
s {$sel:reservedNodeOfferingType:ReservedNode' :: Maybe ReservedNodeOfferingType
reservedNodeOfferingType = Maybe ReservedNodeOfferingType
a} :: ReservedNode)

-- | The time the reservation started. You purchase a reserved node offering
-- for a duration. This is the start time of that duration.
reservedNode_startTime :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.UTCTime)
reservedNode_startTime :: Lens' ReservedNode (Maybe UTCTime)
reservedNode_startTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe ISO8601
startTime :: Maybe ISO8601
$sel:startTime:ReservedNode' :: ReservedNode -> Maybe ISO8601
startTime} -> Maybe ISO8601
startTime) (\s :: ReservedNode
s@ReservedNode' {} Maybe ISO8601
a -> ReservedNode
s {$sel:startTime:ReservedNode' :: Maybe ISO8601
startTime = Maybe ISO8601
a} :: ReservedNode) 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 (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The state of the reserved compute node.
--
-- Possible Values:
--
-- -   pending-payment-This reserved node has recently been purchased, and
--     the sale has been approved, but payment has not yet been confirmed.
--
-- -   active-This reserved node is owned by the caller and is available
--     for use.
--
-- -   payment-failed-Payment failed for the purchase attempt.
--
-- -   retired-The reserved node is no longer available.
--
-- -   exchanging-The owner is exchanging the reserved node for another
--     reserved node.
reservedNode_state :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Text)
reservedNode_state :: Lens' ReservedNode (Maybe Text)
reservedNode_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Text
state :: Maybe Text
$sel:state:ReservedNode' :: ReservedNode -> Maybe Text
state} -> Maybe Text
state) (\s :: ReservedNode
s@ReservedNode' {} Maybe Text
a -> ReservedNode
s {$sel:state:ReservedNode' :: Maybe Text
state = Maybe Text
a} :: ReservedNode)

-- | The hourly rate Amazon Redshift charges you for this reserved node.
reservedNode_usagePrice :: Lens.Lens' ReservedNode (Prelude.Maybe Prelude.Double)
reservedNode_usagePrice :: Lens' ReservedNode (Maybe Double)
reservedNode_usagePrice = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ReservedNode' {Maybe Double
usagePrice :: Maybe Double
$sel:usagePrice:ReservedNode' :: ReservedNode -> Maybe Double
usagePrice} -> Maybe Double
usagePrice) (\s :: ReservedNode
s@ReservedNode' {} Maybe Double
a -> ReservedNode
s {$sel:usagePrice:ReservedNode' :: Maybe Double
usagePrice = Maybe Double
a} :: ReservedNode)

instance Data.FromXML ReservedNode where
  parseXML :: [Node] -> Either String ReservedNode
parseXML [Node]
x =
    Maybe Text
-> Maybe Int
-> Maybe Double
-> Maybe Int
-> Maybe Text
-> Maybe Text
-> Maybe [RecurringCharge]
-> Maybe Text
-> Maybe Text
-> Maybe ReservedNodeOfferingType
-> Maybe ISO8601
-> Maybe Text
-> Maybe Double
-> ReservedNode
ReservedNode'
      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
"CurrencyCode")
      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
"Duration")
      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
"FixedPrice")
      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
"NodeCount")
      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
"NodeType")
      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
"OfferingType")
      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
"RecurringCharges"
                      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
"RecurringCharge")
                  )
      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
"ReservedNodeId")
      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
"ReservedNodeOfferingId")
      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
"ReservedNodeOfferingType")
      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
"StartTime")
      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
"State")
      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
"UsagePrice")

instance Prelude.Hashable ReservedNode where
  hashWithSalt :: Int -> ReservedNode -> Int
hashWithSalt Int
_salt ReservedNode' {Maybe Double
Maybe Int
Maybe [RecurringCharge]
Maybe Text
Maybe ISO8601
Maybe ReservedNodeOfferingType
usagePrice :: Maybe Double
state :: Maybe Text
startTime :: Maybe ISO8601
reservedNodeOfferingType :: Maybe ReservedNodeOfferingType
reservedNodeOfferingId :: Maybe Text
reservedNodeId :: Maybe Text
recurringCharges :: Maybe [RecurringCharge]
offeringType :: Maybe Text
nodeType :: Maybe Text
nodeCount :: Maybe Int
fixedPrice :: Maybe Double
duration :: Maybe Int
currencyCode :: Maybe Text
$sel:usagePrice:ReservedNode' :: ReservedNode -> Maybe Double
$sel:state:ReservedNode' :: ReservedNode -> Maybe Text
$sel:startTime:ReservedNode' :: ReservedNode -> Maybe ISO8601
$sel:reservedNodeOfferingType:ReservedNode' :: ReservedNode -> Maybe ReservedNodeOfferingType
$sel:reservedNodeOfferingId:ReservedNode' :: ReservedNode -> Maybe Text
$sel:reservedNodeId:ReservedNode' :: ReservedNode -> Maybe Text
$sel:recurringCharges:ReservedNode' :: ReservedNode -> Maybe [RecurringCharge]
$sel:offeringType:ReservedNode' :: ReservedNode -> Maybe Text
$sel:nodeType:ReservedNode' :: ReservedNode -> Maybe Text
$sel:nodeCount:ReservedNode' :: ReservedNode -> Maybe Int
$sel:fixedPrice:ReservedNode' :: ReservedNode -> Maybe Double
$sel:duration:ReservedNode' :: ReservedNode -> Maybe Int
$sel:currencyCode:ReservedNode' :: ReservedNode -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
currencyCode
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
duration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
fixedPrice
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
nodeCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
nodeType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
offeringType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [RecurringCharge]
recurringCharges
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
reservedNodeId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
reservedNodeOfferingId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ReservedNodeOfferingType
reservedNodeOfferingType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ISO8601
startTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
usagePrice

instance Prelude.NFData ReservedNode where
  rnf :: ReservedNode -> ()
rnf ReservedNode' {Maybe Double
Maybe Int
Maybe [RecurringCharge]
Maybe Text
Maybe ISO8601
Maybe ReservedNodeOfferingType
usagePrice :: Maybe Double
state :: Maybe Text
startTime :: Maybe ISO8601
reservedNodeOfferingType :: Maybe ReservedNodeOfferingType
reservedNodeOfferingId :: Maybe Text
reservedNodeId :: Maybe Text
recurringCharges :: Maybe [RecurringCharge]
offeringType :: Maybe Text
nodeType :: Maybe Text
nodeCount :: Maybe Int
fixedPrice :: Maybe Double
duration :: Maybe Int
currencyCode :: Maybe Text
$sel:usagePrice:ReservedNode' :: ReservedNode -> Maybe Double
$sel:state:ReservedNode' :: ReservedNode -> Maybe Text
$sel:startTime:ReservedNode' :: ReservedNode -> Maybe ISO8601
$sel:reservedNodeOfferingType:ReservedNode' :: ReservedNode -> Maybe ReservedNodeOfferingType
$sel:reservedNodeOfferingId:ReservedNode' :: ReservedNode -> Maybe Text
$sel:reservedNodeId:ReservedNode' :: ReservedNode -> Maybe Text
$sel:recurringCharges:ReservedNode' :: ReservedNode -> Maybe [RecurringCharge]
$sel:offeringType:ReservedNode' :: ReservedNode -> Maybe Text
$sel:nodeType:ReservedNode' :: ReservedNode -> Maybe Text
$sel:nodeCount:ReservedNode' :: ReservedNode -> Maybe Int
$sel:fixedPrice:ReservedNode' :: ReservedNode -> Maybe Double
$sel:duration:ReservedNode' :: ReservedNode -> Maybe Int
$sel:currencyCode:ReservedNode' :: ReservedNode -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
currencyCode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
duration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
fixedPrice
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
nodeCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
nodeType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
offeringType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [RecurringCharge]
recurringCharges
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
reservedNodeId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
reservedNodeOfferingId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ReservedNodeOfferingType
reservedNodeOfferingType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ISO8601
startTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
usagePrice