{-# 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.EMRServerless.Types.Application
-- 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.EMRServerless.Types.Application where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EMRServerless.Types.ApplicationState
import Amazonka.EMRServerless.Types.Architecture
import Amazonka.EMRServerless.Types.AutoStartConfig
import Amazonka.EMRServerless.Types.AutoStopConfig
import Amazonka.EMRServerless.Types.ImageConfiguration
import Amazonka.EMRServerless.Types.InitialCapacityConfig
import Amazonka.EMRServerless.Types.MaximumAllowedResources
import Amazonka.EMRServerless.Types.NetworkConfiguration
import Amazonka.EMRServerless.Types.WorkerTypeSpecification
import qualified Amazonka.Prelude as Prelude

-- | Information about an application. EMR Serverless uses applications to
-- run jobs.
--
-- /See:/ 'newApplication' smart constructor.
data Application = Application'
  { -- | The CPU architecture of an application.
    Application -> Maybe Architecture
architecture :: Prelude.Maybe Architecture,
    -- | The configuration for an application to automatically start on job
    -- submission.
    Application -> Maybe AutoStartConfig
autoStartConfiguration :: Prelude.Maybe AutoStartConfig,
    -- | The configuration for an application to automatically stop after a
    -- certain amount of time being idle.
    Application -> Maybe AutoStopConfig
autoStopConfiguration :: Prelude.Maybe AutoStopConfig,
    -- | The image configuration applied to all worker types.
    Application -> Maybe ImageConfiguration
imageConfiguration :: Prelude.Maybe ImageConfiguration,
    -- | The initial capacity of the application.
    Application -> Maybe (HashMap Text InitialCapacityConfig)
initialCapacity :: Prelude.Maybe (Prelude.HashMap Prelude.Text InitialCapacityConfig),
    -- | The maximum capacity of the application. This is cumulative across all
    -- workers at any given point in time during the lifespan of the
    -- application is created. No new resources will be created once any one of
    -- the defined limits is hit.
    Application -> Maybe MaximumAllowedResources
maximumCapacity :: Prelude.Maybe MaximumAllowedResources,
    -- | The name of the application.
    Application -> Maybe Text
name :: Prelude.Maybe Prelude.Text,
    -- | The network configuration for customer VPC connectivity for the
    -- application.
    Application -> Maybe NetworkConfiguration
networkConfiguration :: Prelude.Maybe NetworkConfiguration,
    -- | The state details of the application.
    Application -> Maybe Text
stateDetails :: Prelude.Maybe Prelude.Text,
    -- | The tags assigned to the application.
    Application -> Maybe (HashMap Text Text)
tags :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | The specification applied to each worker type.
    Application -> Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications :: Prelude.Maybe (Prelude.HashMap Prelude.Text WorkerTypeSpecification),
    -- | The ID of the application.
    Application -> Text
applicationId :: Prelude.Text,
    -- | The ARN of the application.
    Application -> Text
arn :: Prelude.Text,
    -- | The EMR release associated with the application.
    Application -> Text
releaseLabel :: Prelude.Text,
    -- | The type of application, such as Spark or Hive.
    Application -> Text
type' :: Prelude.Text,
    -- | The state of the application.
    Application -> ApplicationState
state :: ApplicationState,
    -- | The date and time when the application run was created.
    Application -> POSIX
createdAt :: Data.POSIX,
    -- | The date and time when the application run was last updated.
    Application -> POSIX
updatedAt :: Data.POSIX
  }
  deriving (Application -> Application -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Application -> Application -> Bool
$c/= :: Application -> Application -> Bool
== :: Application -> Application -> Bool
$c== :: Application -> Application -> Bool
Prelude.Eq, ReadPrec [Application]
ReadPrec Application
Int -> ReadS Application
ReadS [Application]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Application]
$creadListPrec :: ReadPrec [Application]
readPrec :: ReadPrec Application
$creadPrec :: ReadPrec Application
readList :: ReadS [Application]
$creadList :: ReadS [Application]
readsPrec :: Int -> ReadS Application
$creadsPrec :: Int -> ReadS Application
Prelude.Read, Int -> Application -> ShowS
[Application] -> ShowS
Application -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Application] -> ShowS
$cshowList :: [Application] -> ShowS
show :: Application -> String
$cshow :: Application -> String
showsPrec :: Int -> Application -> ShowS
$cshowsPrec :: Int -> Application -> ShowS
Prelude.Show, forall x. Rep Application x -> Application
forall x. Application -> Rep Application x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Application x -> Application
$cfrom :: forall x. Application -> Rep Application x
Prelude.Generic)

-- |
-- Create a value of 'Application' 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:
--
-- 'architecture', 'application_architecture' - The CPU architecture of an application.
--
-- 'autoStartConfiguration', 'application_autoStartConfiguration' - The configuration for an application to automatically start on job
-- submission.
--
-- 'autoStopConfiguration', 'application_autoStopConfiguration' - The configuration for an application to automatically stop after a
-- certain amount of time being idle.
--
-- 'imageConfiguration', 'application_imageConfiguration' - The image configuration applied to all worker types.
--
-- 'initialCapacity', 'application_initialCapacity' - The initial capacity of the application.
--
-- 'maximumCapacity', 'application_maximumCapacity' - The maximum capacity of the application. This is cumulative across all
-- workers at any given point in time during the lifespan of the
-- application is created. No new resources will be created once any one of
-- the defined limits is hit.
--
-- 'name', 'application_name' - The name of the application.
--
-- 'networkConfiguration', 'application_networkConfiguration' - The network configuration for customer VPC connectivity for the
-- application.
--
-- 'stateDetails', 'application_stateDetails' - The state details of the application.
--
-- 'tags', 'application_tags' - The tags assigned to the application.
--
-- 'workerTypeSpecifications', 'application_workerTypeSpecifications' - The specification applied to each worker type.
--
-- 'applicationId', 'application_applicationId' - The ID of the application.
--
-- 'arn', 'application_arn' - The ARN of the application.
--
-- 'releaseLabel', 'application_releaseLabel' - The EMR release associated with the application.
--
-- 'type'', 'application_type' - The type of application, such as Spark or Hive.
--
-- 'state', 'application_state' - The state of the application.
--
-- 'createdAt', 'application_createdAt' - The date and time when the application run was created.
--
-- 'updatedAt', 'application_updatedAt' - The date and time when the application run was last updated.
newApplication ::
  -- | 'applicationId'
  Prelude.Text ->
  -- | 'arn'
  Prelude.Text ->
  -- | 'releaseLabel'
  Prelude.Text ->
  -- | 'type''
  Prelude.Text ->
  -- | 'state'
  ApplicationState ->
  -- | 'createdAt'
  Prelude.UTCTime ->
  -- | 'updatedAt'
  Prelude.UTCTime ->
  Application
newApplication :: Text
-> Text
-> Text
-> Text
-> ApplicationState
-> UTCTime
-> UTCTime
-> Application
newApplication
  Text
pApplicationId_
  Text
pArn_
  Text
pReleaseLabel_
  Text
pType_
  ApplicationState
pState_
  UTCTime
pCreatedAt_
  UTCTime
pUpdatedAt_ =
    Application'
      { $sel:architecture:Application' :: Maybe Architecture
architecture = forall a. Maybe a
Prelude.Nothing,
        $sel:autoStartConfiguration:Application' :: Maybe AutoStartConfig
autoStartConfiguration = forall a. Maybe a
Prelude.Nothing,
        $sel:autoStopConfiguration:Application' :: Maybe AutoStopConfig
autoStopConfiguration = forall a. Maybe a
Prelude.Nothing,
        $sel:imageConfiguration:Application' :: Maybe ImageConfiguration
imageConfiguration = forall a. Maybe a
Prelude.Nothing,
        $sel:initialCapacity:Application' :: Maybe (HashMap Text InitialCapacityConfig)
initialCapacity = forall a. Maybe a
Prelude.Nothing,
        $sel:maximumCapacity:Application' :: Maybe MaximumAllowedResources
maximumCapacity = forall a. Maybe a
Prelude.Nothing,
        $sel:name:Application' :: Maybe Text
name = forall a. Maybe a
Prelude.Nothing,
        $sel:networkConfiguration:Application' :: Maybe NetworkConfiguration
networkConfiguration = forall a. Maybe a
Prelude.Nothing,
        $sel:stateDetails:Application' :: Maybe Text
stateDetails = forall a. Maybe a
Prelude.Nothing,
        $sel:tags:Application' :: Maybe (HashMap Text Text)
tags = forall a. Maybe a
Prelude.Nothing,
        $sel:workerTypeSpecifications:Application' :: Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications = forall a. Maybe a
Prelude.Nothing,
        $sel:applicationId:Application' :: Text
applicationId = Text
pApplicationId_,
        $sel:arn:Application' :: Text
arn = Text
pArn_,
        $sel:releaseLabel:Application' :: Text
releaseLabel = Text
pReleaseLabel_,
        $sel:type':Application' :: Text
type' = Text
pType_,
        $sel:state:Application' :: ApplicationState
state = ApplicationState
pState_,
        $sel:createdAt:Application' :: POSIX
createdAt = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pCreatedAt_,
        $sel:updatedAt:Application' :: POSIX
updatedAt = forall (a :: Format). Iso' (Time a) UTCTime
Data._Time forall t b. AReview t b -> b -> t
Lens.# UTCTime
pUpdatedAt_
      }

-- | The CPU architecture of an application.
application_architecture :: Lens.Lens' Application (Prelude.Maybe Architecture)
application_architecture :: Lens' Application (Maybe Architecture)
application_architecture = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe Architecture
architecture :: Maybe Architecture
$sel:architecture:Application' :: Application -> Maybe Architecture
architecture} -> Maybe Architecture
architecture) (\s :: Application
s@Application' {} Maybe Architecture
a -> Application
s {$sel:architecture:Application' :: Maybe Architecture
architecture = Maybe Architecture
a} :: Application)

-- | The configuration for an application to automatically start on job
-- submission.
application_autoStartConfiguration :: Lens.Lens' Application (Prelude.Maybe AutoStartConfig)
application_autoStartConfiguration :: Lens' Application (Maybe AutoStartConfig)
application_autoStartConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe AutoStartConfig
autoStartConfiguration :: Maybe AutoStartConfig
$sel:autoStartConfiguration:Application' :: Application -> Maybe AutoStartConfig
autoStartConfiguration} -> Maybe AutoStartConfig
autoStartConfiguration) (\s :: Application
s@Application' {} Maybe AutoStartConfig
a -> Application
s {$sel:autoStartConfiguration:Application' :: Maybe AutoStartConfig
autoStartConfiguration = Maybe AutoStartConfig
a} :: Application)

-- | The configuration for an application to automatically stop after a
-- certain amount of time being idle.
application_autoStopConfiguration :: Lens.Lens' Application (Prelude.Maybe AutoStopConfig)
application_autoStopConfiguration :: Lens' Application (Maybe AutoStopConfig)
application_autoStopConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe AutoStopConfig
autoStopConfiguration :: Maybe AutoStopConfig
$sel:autoStopConfiguration:Application' :: Application -> Maybe AutoStopConfig
autoStopConfiguration} -> Maybe AutoStopConfig
autoStopConfiguration) (\s :: Application
s@Application' {} Maybe AutoStopConfig
a -> Application
s {$sel:autoStopConfiguration:Application' :: Maybe AutoStopConfig
autoStopConfiguration = Maybe AutoStopConfig
a} :: Application)

-- | The image configuration applied to all worker types.
application_imageConfiguration :: Lens.Lens' Application (Prelude.Maybe ImageConfiguration)
application_imageConfiguration :: Lens' Application (Maybe ImageConfiguration)
application_imageConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe ImageConfiguration
imageConfiguration :: Maybe ImageConfiguration
$sel:imageConfiguration:Application' :: Application -> Maybe ImageConfiguration
imageConfiguration} -> Maybe ImageConfiguration
imageConfiguration) (\s :: Application
s@Application' {} Maybe ImageConfiguration
a -> Application
s {$sel:imageConfiguration:Application' :: Maybe ImageConfiguration
imageConfiguration = Maybe ImageConfiguration
a} :: Application)

-- | The initial capacity of the application.
application_initialCapacity :: Lens.Lens' Application (Prelude.Maybe (Prelude.HashMap Prelude.Text InitialCapacityConfig))
application_initialCapacity :: Lens' Application (Maybe (HashMap Text InitialCapacityConfig))
application_initialCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe (HashMap Text InitialCapacityConfig)
initialCapacity :: Maybe (HashMap Text InitialCapacityConfig)
$sel:initialCapacity:Application' :: Application -> Maybe (HashMap Text InitialCapacityConfig)
initialCapacity} -> Maybe (HashMap Text InitialCapacityConfig)
initialCapacity) (\s :: Application
s@Application' {} Maybe (HashMap Text InitialCapacityConfig)
a -> Application
s {$sel:initialCapacity:Application' :: Maybe (HashMap Text InitialCapacityConfig)
initialCapacity = Maybe (HashMap Text InitialCapacityConfig)
a} :: Application) 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 maximum capacity of the application. This is cumulative across all
-- workers at any given point in time during the lifespan of the
-- application is created. No new resources will be created once any one of
-- the defined limits is hit.
application_maximumCapacity :: Lens.Lens' Application (Prelude.Maybe MaximumAllowedResources)
application_maximumCapacity :: Lens' Application (Maybe MaximumAllowedResources)
application_maximumCapacity = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe MaximumAllowedResources
maximumCapacity :: Maybe MaximumAllowedResources
$sel:maximumCapacity:Application' :: Application -> Maybe MaximumAllowedResources
maximumCapacity} -> Maybe MaximumAllowedResources
maximumCapacity) (\s :: Application
s@Application' {} Maybe MaximumAllowedResources
a -> Application
s {$sel:maximumCapacity:Application' :: Maybe MaximumAllowedResources
maximumCapacity = Maybe MaximumAllowedResources
a} :: Application)

-- | The name of the application.
application_name :: Lens.Lens' Application (Prelude.Maybe Prelude.Text)
application_name :: Lens' Application (Maybe Text)
application_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe Text
name :: Maybe Text
$sel:name:Application' :: Application -> Maybe Text
name} -> Maybe Text
name) (\s :: Application
s@Application' {} Maybe Text
a -> Application
s {$sel:name:Application' :: Maybe Text
name = Maybe Text
a} :: Application)

-- | The network configuration for customer VPC connectivity for the
-- application.
application_networkConfiguration :: Lens.Lens' Application (Prelude.Maybe NetworkConfiguration)
application_networkConfiguration :: Lens' Application (Maybe NetworkConfiguration)
application_networkConfiguration = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe NetworkConfiguration
networkConfiguration :: Maybe NetworkConfiguration
$sel:networkConfiguration:Application' :: Application -> Maybe NetworkConfiguration
networkConfiguration} -> Maybe NetworkConfiguration
networkConfiguration) (\s :: Application
s@Application' {} Maybe NetworkConfiguration
a -> Application
s {$sel:networkConfiguration:Application' :: Maybe NetworkConfiguration
networkConfiguration = Maybe NetworkConfiguration
a} :: Application)

-- | The state details of the application.
application_stateDetails :: Lens.Lens' Application (Prelude.Maybe Prelude.Text)
application_stateDetails :: Lens' Application (Maybe Text)
application_stateDetails = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe Text
stateDetails :: Maybe Text
$sel:stateDetails:Application' :: Application -> Maybe Text
stateDetails} -> Maybe Text
stateDetails) (\s :: Application
s@Application' {} Maybe Text
a -> Application
s {$sel:stateDetails:Application' :: Maybe Text
stateDetails = Maybe Text
a} :: Application)

-- | The tags assigned to the application.
application_tags :: Lens.Lens' Application (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
application_tags :: Lens' Application (Maybe (HashMap Text Text))
application_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe (HashMap Text Text)
tags :: Maybe (HashMap Text Text)
$sel:tags:Application' :: Application -> Maybe (HashMap Text Text)
tags} -> Maybe (HashMap Text Text)
tags) (\s :: Application
s@Application' {} Maybe (HashMap Text Text)
a -> Application
s {$sel:tags:Application' :: Maybe (HashMap Text Text)
tags = Maybe (HashMap Text Text)
a} :: Application) 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 specification applied to each worker type.
application_workerTypeSpecifications :: Lens.Lens' Application (Prelude.Maybe (Prelude.HashMap Prelude.Text WorkerTypeSpecification))
application_workerTypeSpecifications :: Lens' Application (Maybe (HashMap Text WorkerTypeSpecification))
application_workerTypeSpecifications = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications :: Maybe (HashMap Text WorkerTypeSpecification)
$sel:workerTypeSpecifications:Application' :: Application -> Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications} -> Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications) (\s :: Application
s@Application' {} Maybe (HashMap Text WorkerTypeSpecification)
a -> Application
s {$sel:workerTypeSpecifications:Application' :: Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications = Maybe (HashMap Text WorkerTypeSpecification)
a} :: Application) 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 application.
application_applicationId :: Lens.Lens' Application Prelude.Text
application_applicationId :: Lens' Application Text
application_applicationId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Text
applicationId :: Text
$sel:applicationId:Application' :: Application -> Text
applicationId} -> Text
applicationId) (\s :: Application
s@Application' {} Text
a -> Application
s {$sel:applicationId:Application' :: Text
applicationId = Text
a} :: Application)

-- | The ARN of the application.
application_arn :: Lens.Lens' Application Prelude.Text
application_arn :: Lens' Application Text
application_arn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Text
arn :: Text
$sel:arn:Application' :: Application -> Text
arn} -> Text
arn) (\s :: Application
s@Application' {} Text
a -> Application
s {$sel:arn:Application' :: Text
arn = Text
a} :: Application)

-- | The EMR release associated with the application.
application_releaseLabel :: Lens.Lens' Application Prelude.Text
application_releaseLabel :: Lens' Application Text
application_releaseLabel = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Text
releaseLabel :: Text
$sel:releaseLabel:Application' :: Application -> Text
releaseLabel} -> Text
releaseLabel) (\s :: Application
s@Application' {} Text
a -> Application
s {$sel:releaseLabel:Application' :: Text
releaseLabel = Text
a} :: Application)

-- | The type of application, such as Spark or Hive.
application_type :: Lens.Lens' Application Prelude.Text
application_type :: Lens' Application Text
application_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {Text
type' :: Text
$sel:type':Application' :: Application -> Text
type'} -> Text
type') (\s :: Application
s@Application' {} Text
a -> Application
s {$sel:type':Application' :: Text
type' = Text
a} :: Application)

-- | The state of the application.
application_state :: Lens.Lens' Application ApplicationState
application_state :: Lens' Application ApplicationState
application_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {ApplicationState
state :: ApplicationState
$sel:state:Application' :: Application -> ApplicationState
state} -> ApplicationState
state) (\s :: Application
s@Application' {} ApplicationState
a -> Application
s {$sel:state:Application' :: ApplicationState
state = ApplicationState
a} :: Application)

-- | The date and time when the application run was created.
application_createdAt :: Lens.Lens' Application Prelude.UTCTime
application_createdAt :: Lens' Application UTCTime
application_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {POSIX
createdAt :: POSIX
$sel:createdAt:Application' :: Application -> POSIX
createdAt} -> POSIX
createdAt) (\s :: Application
s@Application' {} POSIX
a -> Application
s {$sel:createdAt:Application' :: POSIX
createdAt = POSIX
a} :: Application) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The date and time when the application run was last updated.
application_updatedAt :: Lens.Lens' Application Prelude.UTCTime
application_updatedAt :: Lens' Application UTCTime
application_updatedAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Application' {POSIX
updatedAt :: POSIX
$sel:updatedAt:Application' :: Application -> POSIX
updatedAt} -> POSIX
updatedAt) (\s :: Application
s@Application' {} POSIX
a -> Application
s {$sel:updatedAt:Application' :: POSIX
updatedAt = POSIX
a} :: Application) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

instance Data.FromJSON Application where
  parseJSON :: Value -> Parser Application
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Application"
      ( \Object
x ->
          Maybe Architecture
-> Maybe AutoStartConfig
-> Maybe AutoStopConfig
-> Maybe ImageConfiguration
-> Maybe (HashMap Text InitialCapacityConfig)
-> Maybe MaximumAllowedResources
-> Maybe Text
-> Maybe NetworkConfiguration
-> Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe (HashMap Text WorkerTypeSpecification)
-> Text
-> Text
-> Text
-> Text
-> ApplicationState
-> POSIX
-> POSIX
-> Application
Application'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"architecture")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"autoStartConfiguration")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"autoStopConfiguration")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"imageConfiguration")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ( Object
x
                            forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"initialCapacity"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= 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 -> Parser (Maybe a)
Data..:? Key
"maximumCapacity")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"networkConfiguration")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"stateDetails")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"tags" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= 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 -> Parser (Maybe a)
Data..:? Key
"workerTypeSpecifications"
                            forall a. Parser (Maybe a) -> a -> Parser a
Data..!= 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 -> Parser a
Data..: Key
"applicationId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"arn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"releaseLabel")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"type")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"state")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"createdAt")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"updatedAt")
      )

instance Prelude.Hashable Application where
  hashWithSalt :: Int -> Application -> Int
hashWithSalt Int
_salt Application' {Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap Text InitialCapacityConfig)
Maybe (HashMap Text WorkerTypeSpecification)
Maybe Architecture
Maybe AutoStartConfig
Maybe AutoStopConfig
Maybe ImageConfiguration
Maybe MaximumAllowedResources
Maybe NetworkConfiguration
Text
POSIX
ApplicationState
updatedAt :: POSIX
createdAt :: POSIX
state :: ApplicationState
type' :: Text
releaseLabel :: Text
arn :: Text
applicationId :: Text
workerTypeSpecifications :: Maybe (HashMap Text WorkerTypeSpecification)
tags :: Maybe (HashMap Text Text)
stateDetails :: Maybe Text
networkConfiguration :: Maybe NetworkConfiguration
name :: Maybe Text
maximumCapacity :: Maybe MaximumAllowedResources
initialCapacity :: Maybe (HashMap Text InitialCapacityConfig)
imageConfiguration :: Maybe ImageConfiguration
autoStopConfiguration :: Maybe AutoStopConfig
autoStartConfiguration :: Maybe AutoStartConfig
architecture :: Maybe Architecture
$sel:updatedAt:Application' :: Application -> POSIX
$sel:createdAt:Application' :: Application -> POSIX
$sel:state:Application' :: Application -> ApplicationState
$sel:type':Application' :: Application -> Text
$sel:releaseLabel:Application' :: Application -> Text
$sel:arn:Application' :: Application -> Text
$sel:applicationId:Application' :: Application -> Text
$sel:workerTypeSpecifications:Application' :: Application -> Maybe (HashMap Text WorkerTypeSpecification)
$sel:tags:Application' :: Application -> Maybe (HashMap Text Text)
$sel:stateDetails:Application' :: Application -> Maybe Text
$sel:networkConfiguration:Application' :: Application -> Maybe NetworkConfiguration
$sel:name:Application' :: Application -> Maybe Text
$sel:maximumCapacity:Application' :: Application -> Maybe MaximumAllowedResources
$sel:initialCapacity:Application' :: Application -> Maybe (HashMap Text InitialCapacityConfig)
$sel:imageConfiguration:Application' :: Application -> Maybe ImageConfiguration
$sel:autoStopConfiguration:Application' :: Application -> Maybe AutoStopConfig
$sel:autoStartConfiguration:Application' :: Application -> Maybe AutoStartConfig
$sel:architecture:Application' :: Application -> Maybe Architecture
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Architecture
architecture
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AutoStartConfig
autoStartConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AutoStopConfig
autoStopConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ImageConfiguration
imageConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text InitialCapacityConfig)
initialCapacity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe MaximumAllowedResources
maximumCapacity
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe NetworkConfiguration
networkConfiguration
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
stateDetails
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
tags
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
applicationId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
arn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
releaseLabel
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
type'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ApplicationState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
createdAt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` POSIX
updatedAt

instance Prelude.NFData Application where
  rnf :: Application -> ()
rnf Application' {Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap Text InitialCapacityConfig)
Maybe (HashMap Text WorkerTypeSpecification)
Maybe Architecture
Maybe AutoStartConfig
Maybe AutoStopConfig
Maybe ImageConfiguration
Maybe MaximumAllowedResources
Maybe NetworkConfiguration
Text
POSIX
ApplicationState
updatedAt :: POSIX
createdAt :: POSIX
state :: ApplicationState
type' :: Text
releaseLabel :: Text
arn :: Text
applicationId :: Text
workerTypeSpecifications :: Maybe (HashMap Text WorkerTypeSpecification)
tags :: Maybe (HashMap Text Text)
stateDetails :: Maybe Text
networkConfiguration :: Maybe NetworkConfiguration
name :: Maybe Text
maximumCapacity :: Maybe MaximumAllowedResources
initialCapacity :: Maybe (HashMap Text InitialCapacityConfig)
imageConfiguration :: Maybe ImageConfiguration
autoStopConfiguration :: Maybe AutoStopConfig
autoStartConfiguration :: Maybe AutoStartConfig
architecture :: Maybe Architecture
$sel:updatedAt:Application' :: Application -> POSIX
$sel:createdAt:Application' :: Application -> POSIX
$sel:state:Application' :: Application -> ApplicationState
$sel:type':Application' :: Application -> Text
$sel:releaseLabel:Application' :: Application -> Text
$sel:arn:Application' :: Application -> Text
$sel:applicationId:Application' :: Application -> Text
$sel:workerTypeSpecifications:Application' :: Application -> Maybe (HashMap Text WorkerTypeSpecification)
$sel:tags:Application' :: Application -> Maybe (HashMap Text Text)
$sel:stateDetails:Application' :: Application -> Maybe Text
$sel:networkConfiguration:Application' :: Application -> Maybe NetworkConfiguration
$sel:name:Application' :: Application -> Maybe Text
$sel:maximumCapacity:Application' :: Application -> Maybe MaximumAllowedResources
$sel:initialCapacity:Application' :: Application -> Maybe (HashMap Text InitialCapacityConfig)
$sel:imageConfiguration:Application' :: Application -> Maybe ImageConfiguration
$sel:autoStopConfiguration:Application' :: Application -> Maybe AutoStopConfig
$sel:autoStartConfiguration:Application' :: Application -> Maybe AutoStartConfig
$sel:architecture:Application' :: Application -> Maybe Architecture
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Architecture
architecture
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AutoStartConfig
autoStartConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AutoStopConfig
autoStopConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ImageConfiguration
imageConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text InitialCapacityConfig)
initialCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe MaximumAllowedResources
maximumCapacity
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe NetworkConfiguration
networkConfiguration
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
stateDetails
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
tags
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text WorkerTypeSpecification)
workerTypeSpecifications
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
applicationId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
arn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
releaseLabel
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
type'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ApplicationState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
createdAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf POSIX
updatedAt