{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE OverloadedStrings  #-}
{-# LANGUAGE RecordWildCards    #-}

{-# OPTIONS_GHC -fno-warn-unused-imports #-}

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

-- |
-- Module      : Network.AWS.ElasticBeanstalk.Types.Product
-- Copyright   : (c) 2013-2016 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
module Network.AWS.ElasticBeanstalk.Types.Product where

import           Network.AWS.ElasticBeanstalk.Types.Sum
import           Network.AWS.Lens
import           Network.AWS.Prelude

-- | Describes the properties of an application.
--
-- /See:/ 'applicationDescription' smart constructor.
data ApplicationDescription = ApplicationDescription'
    { _adVersions               :: !(Maybe [Text])
    , _adDateUpdated            :: !(Maybe ISO8601)
    , _adDateCreated            :: !(Maybe ISO8601)
    , _adApplicationName        :: !(Maybe Text)
    , _adConfigurationTemplates :: !(Maybe [Text])
    , _adDescription            :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ApplicationDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'adVersions'
--
-- * 'adDateUpdated'
--
-- * 'adDateCreated'
--
-- * 'adApplicationName'
--
-- * 'adConfigurationTemplates'
--
-- * 'adDescription'
applicationDescription
    :: ApplicationDescription
applicationDescription =
    ApplicationDescription'
    { _adVersions = Nothing
    , _adDateUpdated = Nothing
    , _adDateCreated = Nothing
    , _adApplicationName = Nothing
    , _adConfigurationTemplates = Nothing
    , _adDescription = Nothing
    }

-- | The names of the versions for this application.
adVersions :: Lens' ApplicationDescription [Text]
adVersions = lens _adVersions (\ s a -> s{_adVersions = a}) . _Default . _Coerce;

-- | The date when the application was last modified.
adDateUpdated :: Lens' ApplicationDescription (Maybe UTCTime)
adDateUpdated = lens _adDateUpdated (\ s a -> s{_adDateUpdated = a}) . mapping _Time;

-- | The date when the application was created.
adDateCreated :: Lens' ApplicationDescription (Maybe UTCTime)
adDateCreated = lens _adDateCreated (\ s a -> s{_adDateCreated = a}) . mapping _Time;

-- | The name of the application.
adApplicationName :: Lens' ApplicationDescription (Maybe Text)
adApplicationName = lens _adApplicationName (\ s a -> s{_adApplicationName = a});

-- | The names of the configuration templates associated with this application.
adConfigurationTemplates :: Lens' ApplicationDescription [Text]
adConfigurationTemplates = lens _adConfigurationTemplates (\ s a -> s{_adConfigurationTemplates = a}) . _Default . _Coerce;

-- | User-defined description of the application.
adDescription :: Lens' ApplicationDescription (Maybe Text)
adDescription = lens _adDescription (\ s a -> s{_adDescription = a});

instance FromXML ApplicationDescription where
        parseXML x
          = ApplicationDescription' <$>
              (x .@? "Versions" .!@ mempty >>=
                 may (parseXMLList "member"))
                <*> (x .@? "DateUpdated")
                <*> (x .@? "DateCreated")
                <*> (x .@? "ApplicationName")
                <*>
                (x .@? "ConfigurationTemplates" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*> (x .@? "Description")

instance Hashable ApplicationDescription

instance NFData ApplicationDescription

-- | Result message containing a single description of an application.
--
-- /See:/ 'applicationDescriptionMessage' smart constructor.
newtype ApplicationDescriptionMessage = ApplicationDescriptionMessage'
    { _admApplication :: Maybe ApplicationDescription
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ApplicationDescriptionMessage' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'admApplication'
applicationDescriptionMessage
    :: ApplicationDescriptionMessage
applicationDescriptionMessage =
    ApplicationDescriptionMessage'
    { _admApplication = Nothing
    }

-- | The < ApplicationDescription> of the application.
admApplication :: Lens' ApplicationDescriptionMessage (Maybe ApplicationDescription)
admApplication = lens _admApplication (\ s a -> s{_admApplication = a});

instance FromXML ApplicationDescriptionMessage where
        parseXML x
          = ApplicationDescriptionMessage' <$>
              (x .@? "Application")

instance Hashable ApplicationDescriptionMessage

instance NFData ApplicationDescriptionMessage

-- | Represents the application metrics for a specified environment.
--
-- /See:/ 'applicationMetrics' smart constructor.
data ApplicationMetrics = ApplicationMetrics'
    { _amRequestCount :: !(Maybe Int)
    , _amLatency      :: !(Maybe Latency)
    , _amStatusCodes  :: !(Maybe StatusCodes)
    , _amDuration     :: !(Maybe Int)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ApplicationMetrics' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'amRequestCount'
--
-- * 'amLatency'
--
-- * 'amStatusCodes'
--
-- * 'amDuration'
applicationMetrics
    :: ApplicationMetrics
applicationMetrics =
    ApplicationMetrics'
    { _amRequestCount = Nothing
    , _amLatency = Nothing
    , _amStatusCodes = Nothing
    , _amDuration = Nothing
    }

-- | Average number of requests handled by the web server per second over the last 10 seconds.
amRequestCount :: Lens' ApplicationMetrics (Maybe Int)
amRequestCount = lens _amRequestCount (\ s a -> s{_amRequestCount = a});

-- | Represents the average latency for the slowest X percent of requests over the last 10 seconds. Latencies are in seconds with one milisecond resolution.
amLatency :: Lens' ApplicationMetrics (Maybe Latency)
amLatency = lens _amLatency (\ s a -> s{_amLatency = a});

-- | Represents the percentage of requests over the last 10 seconds that resulted in each type of status code response.
amStatusCodes :: Lens' ApplicationMetrics (Maybe StatusCodes)
amStatusCodes = lens _amStatusCodes (\ s a -> s{_amStatusCodes = a});

-- | The amount of time that the metrics cover (usually 10 seconds). For example, you might have 5 requests ('request_count') within the most recent time slice of 10 seconds ('duration').
amDuration :: Lens' ApplicationMetrics (Maybe Int)
amDuration = lens _amDuration (\ s a -> s{_amDuration = a});

instance FromXML ApplicationMetrics where
        parseXML x
          = ApplicationMetrics' <$>
              (x .@? "RequestCount") <*> (x .@? "Latency") <*>
                (x .@? "StatusCodes")
                <*> (x .@? "Duration")

instance Hashable ApplicationMetrics

instance NFData ApplicationMetrics

-- | Describes the properties of an application version.
--
-- /See:/ 'applicationVersionDescription' smart constructor.
data ApplicationVersionDescription = ApplicationVersionDescription'
    { _avdStatus          :: !(Maybe ApplicationVersionStatus)
    , _avdSourceBundle    :: !(Maybe S3Location)
    , _avdDateUpdated     :: !(Maybe ISO8601)
    , _avdDateCreated     :: !(Maybe ISO8601)
    , _avdVersionLabel    :: !(Maybe Text)
    , _avdApplicationName :: !(Maybe Text)
    , _avdDescription     :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ApplicationVersionDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'avdStatus'
--
-- * 'avdSourceBundle'
--
-- * 'avdDateUpdated'
--
-- * 'avdDateCreated'
--
-- * 'avdVersionLabel'
--
-- * 'avdApplicationName'
--
-- * 'avdDescription'
applicationVersionDescription
    :: ApplicationVersionDescription
applicationVersionDescription =
    ApplicationVersionDescription'
    { _avdStatus = Nothing
    , _avdSourceBundle = Nothing
    , _avdDateUpdated = Nothing
    , _avdDateCreated = Nothing
    , _avdVersionLabel = Nothing
    , _avdApplicationName = Nothing
    , _avdDescription = Nothing
    }

-- | The processing status of the application version.
avdStatus :: Lens' ApplicationVersionDescription (Maybe ApplicationVersionStatus)
avdStatus = lens _avdStatus (\ s a -> s{_avdStatus = a});

-- | The location where the source bundle is located for this version.
avdSourceBundle :: Lens' ApplicationVersionDescription (Maybe S3Location)
avdSourceBundle = lens _avdSourceBundle (\ s a -> s{_avdSourceBundle = a});

-- | The last modified date of the application version.
avdDateUpdated :: Lens' ApplicationVersionDescription (Maybe UTCTime)
avdDateUpdated = lens _avdDateUpdated (\ s a -> s{_avdDateUpdated = a}) . mapping _Time;

-- | The creation date of the application version.
avdDateCreated :: Lens' ApplicationVersionDescription (Maybe UTCTime)
avdDateCreated = lens _avdDateCreated (\ s a -> s{_avdDateCreated = a}) . mapping _Time;

-- | A label uniquely identifying the version for the associated application.
avdVersionLabel :: Lens' ApplicationVersionDescription (Maybe Text)
avdVersionLabel = lens _avdVersionLabel (\ s a -> s{_avdVersionLabel = a});

-- | The name of the application associated with this release.
avdApplicationName :: Lens' ApplicationVersionDescription (Maybe Text)
avdApplicationName = lens _avdApplicationName (\ s a -> s{_avdApplicationName = a});

-- | The description of this application version.
avdDescription :: Lens' ApplicationVersionDescription (Maybe Text)
avdDescription = lens _avdDescription (\ s a -> s{_avdDescription = a});

instance FromXML ApplicationVersionDescription where
        parseXML x
          = ApplicationVersionDescription' <$>
              (x .@? "Status") <*> (x .@? "SourceBundle") <*>
                (x .@? "DateUpdated")
                <*> (x .@? "DateCreated")
                <*> (x .@? "VersionLabel")
                <*> (x .@? "ApplicationName")
                <*> (x .@? "Description")

instance Hashable ApplicationVersionDescription

instance NFData ApplicationVersionDescription

-- | Result message wrapping a single description of an application version.
--
-- /See:/ 'applicationVersionDescriptionMessage' smart constructor.
newtype ApplicationVersionDescriptionMessage = ApplicationVersionDescriptionMessage'
    { _avdmApplicationVersion :: Maybe ApplicationVersionDescription
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ApplicationVersionDescriptionMessage' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'avdmApplicationVersion'
applicationVersionDescriptionMessage
    :: ApplicationVersionDescriptionMessage
applicationVersionDescriptionMessage =
    ApplicationVersionDescriptionMessage'
    { _avdmApplicationVersion = Nothing
    }

-- | The < ApplicationVersionDescription> of the application version.
avdmApplicationVersion :: Lens' ApplicationVersionDescriptionMessage (Maybe ApplicationVersionDescription)
avdmApplicationVersion = lens _avdmApplicationVersion (\ s a -> s{_avdmApplicationVersion = a});

instance FromXML ApplicationVersionDescriptionMessage
         where
        parseXML x
          = ApplicationVersionDescriptionMessage' <$>
              (x .@? "ApplicationVersion")

instance Hashable
         ApplicationVersionDescriptionMessage

instance NFData ApplicationVersionDescriptionMessage

-- | Describes an Auto Scaling launch configuration.
--
-- /See:/ 'autoScalingGroup' smart constructor.
newtype AutoScalingGroup = AutoScalingGroup'
    { _asgName :: Maybe Text
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'AutoScalingGroup' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'asgName'
autoScalingGroup
    :: AutoScalingGroup
autoScalingGroup =
    AutoScalingGroup'
    { _asgName = Nothing
    }

-- | The name of the 'AutoScalingGroup' .
asgName :: Lens' AutoScalingGroup (Maybe Text)
asgName = lens _asgName (\ s a -> s{_asgName = a});

instance FromXML AutoScalingGroup where
        parseXML x = AutoScalingGroup' <$> (x .@? "Name")

instance Hashable AutoScalingGroup

instance NFData AutoScalingGroup

-- | Represents CPU utilization information from the specified instance that belongs to the AWS Elastic Beanstalk environment. Use the 'instanceId' property to specify the application instance for which you\'d like to return data.
--
-- /See:/ 'cpuUtilization' smart constructor.
data CPUUtilization = CPUUtilization'
    { _cuSoftIRQ :: !(Maybe Double)
    , _cuIdle    :: !(Maybe Double)
    , _cuIRQ     :: !(Maybe Double)
    , _cuSystem  :: !(Maybe Double)
    , _cuUser    :: !(Maybe Double)
    , _cuIOWait  :: !(Maybe Double)
    , _cuNice    :: !(Maybe Double)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'CPUUtilization' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'cuSoftIRQ'
--
-- * 'cuIdle'
--
-- * 'cuIRQ'
--
-- * 'cuSystem'
--
-- * 'cuUser'
--
-- * 'cuIOWait'
--
-- * 'cuNice'
cpuUtilization
    :: CPUUtilization
cpuUtilization =
    CPUUtilization'
    { _cuSoftIRQ = Nothing
    , _cuIdle = Nothing
    , _cuIRQ = Nothing
    , _cuSystem = Nothing
    , _cuUser = Nothing
    , _cuIOWait = Nothing
    , _cuNice = Nothing
    }

-- | Percentage of time that the CPU has spent in the 'SoftIRQ' state over the last 10 seconds.
cuSoftIRQ :: Lens' CPUUtilization (Maybe Double)
cuSoftIRQ = lens _cuSoftIRQ (\ s a -> s{_cuSoftIRQ = a});

-- | Percentage of time that the CPU has spent in the 'Idle' state over the last 10 seconds.
cuIdle :: Lens' CPUUtilization (Maybe Double)
cuIdle = lens _cuIdle (\ s a -> s{_cuIdle = a});

-- | Percentage of time that the CPU has spent in the 'IRQ' state over the last 10 seconds.
cuIRQ :: Lens' CPUUtilization (Maybe Double)
cuIRQ = lens _cuIRQ (\ s a -> s{_cuIRQ = a});

-- | Percentage of time that the CPU has spent in the 'System' state over the last 10 seconds.
cuSystem :: Lens' CPUUtilization (Maybe Double)
cuSystem = lens _cuSystem (\ s a -> s{_cuSystem = a});

-- | Percentage of time that the CPU has spent in the 'User' state over the last 10 seconds.
cuUser :: Lens' CPUUtilization (Maybe Double)
cuUser = lens _cuUser (\ s a -> s{_cuUser = a});

-- | Percentage of time that the CPU has spent in the 'I\/O Wait' state over the last 10 seconds.
cuIOWait :: Lens' CPUUtilization (Maybe Double)
cuIOWait = lens _cuIOWait (\ s a -> s{_cuIOWait = a});

-- | Percentage of time that the CPU has spent in the 'Nice' state over the last 10 seconds.
cuNice :: Lens' CPUUtilization (Maybe Double)
cuNice = lens _cuNice (\ s a -> s{_cuNice = a});

instance FromXML CPUUtilization where
        parseXML x
          = CPUUtilization' <$>
              (x .@? "SoftIRQ") <*> (x .@? "Idle") <*>
                (x .@? "IRQ")
                <*> (x .@? "System")
                <*> (x .@? "User")
                <*> (x .@? "IOWait")
                <*> (x .@? "Nice")

instance Hashable CPUUtilization

instance NFData CPUUtilization

-- | Describes the possible values for a configuration option.
--
-- /See:/ 'configurationOptionDescription' smart constructor.
data ConfigurationOptionDescription = ConfigurationOptionDescription'
    { _codMaxValue       :: !(Maybe Int)
    , _codRegex          :: !(Maybe OptionRestrictionRegex)
    , _codMaxLength      :: !(Maybe Int)
    , _codUserDefined    :: !(Maybe Bool)
    , _codNamespace      :: !(Maybe Text)
    , _codValueOptions   :: !(Maybe [Text])
    , _codName           :: !(Maybe Text)
    , _codChangeSeverity :: !(Maybe Text)
    , _codDefaultValue   :: !(Maybe Text)
    , _codValueType      :: !(Maybe ConfigurationOptionValueType)
    , _codMinValue       :: !(Maybe Int)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ConfigurationOptionDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'codMaxValue'
--
-- * 'codRegex'
--
-- * 'codMaxLength'
--
-- * 'codUserDefined'
--
-- * 'codNamespace'
--
-- * 'codValueOptions'
--
-- * 'codName'
--
-- * 'codChangeSeverity'
--
-- * 'codDefaultValue'
--
-- * 'codValueType'
--
-- * 'codMinValue'
configurationOptionDescription
    :: ConfigurationOptionDescription
configurationOptionDescription =
    ConfigurationOptionDescription'
    { _codMaxValue = Nothing
    , _codRegex = Nothing
    , _codMaxLength = Nothing
    , _codUserDefined = Nothing
    , _codNamespace = Nothing
    , _codValueOptions = Nothing
    , _codName = Nothing
    , _codChangeSeverity = Nothing
    , _codDefaultValue = Nothing
    , _codValueType = Nothing
    , _codMinValue = Nothing
    }

-- | If specified, the configuration option must be a numeric value less than this value.
codMaxValue :: Lens' ConfigurationOptionDescription (Maybe Int)
codMaxValue = lens _codMaxValue (\ s a -> s{_codMaxValue = a});

-- | If specified, the configuration option must be a string value that satisfies this regular expression.
codRegex :: Lens' ConfigurationOptionDescription (Maybe OptionRestrictionRegex)
codRegex = lens _codRegex (\ s a -> s{_codRegex = a});

-- | If specified, the configuration option must be a string value no longer than this value.
codMaxLength :: Lens' ConfigurationOptionDescription (Maybe Int)
codMaxLength = lens _codMaxLength (\ s a -> s{_codMaxLength = a});

-- | An indication of whether the user defined this configuration option:
--
-- -   'true' : This configuration option was defined by the user. It is a valid choice for specifying if this as an 'Option to Remove' when updating configuration settings.
--
-- -   'false' : This configuration was not defined by the user.
--
-- Constraint: You can remove only 'UserDefined' options from a configuration.
--
-- Valid Values: 'true' | 'false'
codUserDefined :: Lens' ConfigurationOptionDescription (Maybe Bool)
codUserDefined = lens _codUserDefined (\ s a -> s{_codUserDefined = a});

-- | A unique namespace identifying the option\'s associated AWS resource.
codNamespace :: Lens' ConfigurationOptionDescription (Maybe Text)
codNamespace = lens _codNamespace (\ s a -> s{_codNamespace = a});

-- | If specified, values for the configuration option are selected from this list.
codValueOptions :: Lens' ConfigurationOptionDescription [Text]
codValueOptions = lens _codValueOptions (\ s a -> s{_codValueOptions = a}) . _Default . _Coerce;

-- | The name of the configuration option.
codName :: Lens' ConfigurationOptionDescription (Maybe Text)
codName = lens _codName (\ s a -> s{_codName = a});

-- | An indication of which action is required if the value for this configuration option changes:
--
-- -   'NoInterruption' : There is no interruption to the environment or application availability.
-- -   'RestartEnvironment' : The environment is entirely restarted, all AWS resources are deleted and recreated, and the environment is unavailable during the process.
-- -   'RestartApplicationServer' : The environment is available the entire time. However, a short application outage occurs when the application servers on the running Amazon EC2 instances are restarted.
codChangeSeverity :: Lens' ConfigurationOptionDescription (Maybe Text)
codChangeSeverity = lens _codChangeSeverity (\ s a -> s{_codChangeSeverity = a});

-- | The default value for this configuration option.
codDefaultValue :: Lens' ConfigurationOptionDescription (Maybe Text)
codDefaultValue = lens _codDefaultValue (\ s a -> s{_codDefaultValue = a});

-- | An indication of which type of values this option has and whether it is allowable to select one or more than one of the possible values:
--
-- -   'Scalar' : Values for this option are a single selection from the possible values, or an unformatted string, or numeric value governed by the 'MIN\/MAX\/Regex' constraints.
-- -   'List' : Values for this option are multiple selections from the possible values.
-- -   'Boolean' : Values for this option are either 'true' or 'false' .
-- -   'Json' : Values for this option are a JSON representation of a 'ConfigDocument'.
codValueType :: Lens' ConfigurationOptionDescription (Maybe ConfigurationOptionValueType)
codValueType = lens _codValueType (\ s a -> s{_codValueType = a});

-- | If specified, the configuration option must be a numeric value greater than this value.
codMinValue :: Lens' ConfigurationOptionDescription (Maybe Int)
codMinValue = lens _codMinValue (\ s a -> s{_codMinValue = a});

instance FromXML ConfigurationOptionDescription where
        parseXML x
          = ConfigurationOptionDescription' <$>
              (x .@? "MaxValue") <*> (x .@? "Regex") <*>
                (x .@? "MaxLength")
                <*> (x .@? "UserDefined")
                <*> (x .@? "Namespace")
                <*>
                (x .@? "ValueOptions" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*> (x .@? "Name")
                <*> (x .@? "ChangeSeverity")
                <*> (x .@? "DefaultValue")
                <*> (x .@? "ValueType")
                <*> (x .@? "MinValue")

instance Hashable ConfigurationOptionDescription

instance NFData ConfigurationOptionDescription

-- | A specification identifying an individual configuration option along with its current value. For a list of possible option values, go to <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/command-options.html Option Values> in the /AWS Elastic Beanstalk Developer Guide/.
--
-- /See:/ 'configurationOptionSetting' smart constructor.
data ConfigurationOptionSetting = ConfigurationOptionSetting'
    { _cosOptionName   :: !(Maybe Text)
    , _cosResourceName :: !(Maybe Text)
    , _cosNamespace    :: !(Maybe Text)
    , _cosValue        :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ConfigurationOptionSetting' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'cosOptionName'
--
-- * 'cosResourceName'
--
-- * 'cosNamespace'
--
-- * 'cosValue'
configurationOptionSetting
    :: ConfigurationOptionSetting
configurationOptionSetting =
    ConfigurationOptionSetting'
    { _cosOptionName = Nothing
    , _cosResourceName = Nothing
    , _cosNamespace = Nothing
    , _cosValue = Nothing
    }

-- | The name of the configuration option.
cosOptionName :: Lens' ConfigurationOptionSetting (Maybe Text)
cosOptionName = lens _cosOptionName (\ s a -> s{_cosOptionName = a});

-- | A unique resource name for a time-based scaling configuration option.
cosResourceName :: Lens' ConfigurationOptionSetting (Maybe Text)
cosResourceName = lens _cosResourceName (\ s a -> s{_cosResourceName = a});

-- | A unique namespace identifying the option\'s associated AWS resource.
cosNamespace :: Lens' ConfigurationOptionSetting (Maybe Text)
cosNamespace = lens _cosNamespace (\ s a -> s{_cosNamespace = a});

-- | The current value for the configuration option.
cosValue :: Lens' ConfigurationOptionSetting (Maybe Text)
cosValue = lens _cosValue (\ s a -> s{_cosValue = a});

instance FromXML ConfigurationOptionSetting where
        parseXML x
          = ConfigurationOptionSetting' <$>
              (x .@? "OptionName") <*> (x .@? "ResourceName") <*>
                (x .@? "Namespace")
                <*> (x .@? "Value")

instance Hashable ConfigurationOptionSetting

instance NFData ConfigurationOptionSetting

instance ToQuery ConfigurationOptionSetting where
        toQuery ConfigurationOptionSetting'{..}
          = mconcat
              ["OptionName" =: _cosOptionName,
               "ResourceName" =: _cosResourceName,
               "Namespace" =: _cosNamespace, "Value" =: _cosValue]

-- | Describes the settings for a configuration set.
--
-- /See:/ 'configurationSettingsDescription' smart constructor.
data ConfigurationSettingsDescription = ConfigurationSettingsDescription'
    { _csdTemplateName      :: !(Maybe Text)
    , _csdOptionSettings    :: !(Maybe [ConfigurationOptionSetting])
    , _csdDateUpdated       :: !(Maybe ISO8601)
    , _csdDateCreated       :: !(Maybe ISO8601)
    , _csdEnvironmentName   :: !(Maybe Text)
    , _csdApplicationName   :: !(Maybe Text)
    , _csdDeploymentStatus  :: !(Maybe ConfigurationDeploymentStatus)
    , _csdSolutionStackName :: !(Maybe Text)
    , _csdDescription       :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ConfigurationSettingsDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'csdTemplateName'
--
-- * 'csdOptionSettings'
--
-- * 'csdDateUpdated'
--
-- * 'csdDateCreated'
--
-- * 'csdEnvironmentName'
--
-- * 'csdApplicationName'
--
-- * 'csdDeploymentStatus'
--
-- * 'csdSolutionStackName'
--
-- * 'csdDescription'
configurationSettingsDescription
    :: ConfigurationSettingsDescription
configurationSettingsDescription =
    ConfigurationSettingsDescription'
    { _csdTemplateName = Nothing
    , _csdOptionSettings = Nothing
    , _csdDateUpdated = Nothing
    , _csdDateCreated = Nothing
    , _csdEnvironmentName = Nothing
    , _csdApplicationName = Nothing
    , _csdDeploymentStatus = Nothing
    , _csdSolutionStackName = Nothing
    , _csdDescription = Nothing
    }

-- | If not 'null', the name of the configuration template for this configuration set.
csdTemplateName :: Lens' ConfigurationSettingsDescription (Maybe Text)
csdTemplateName = lens _csdTemplateName (\ s a -> s{_csdTemplateName = a});

-- | A list of the configuration options and their values in this configuration set.
csdOptionSettings :: Lens' ConfigurationSettingsDescription [ConfigurationOptionSetting]
csdOptionSettings = lens _csdOptionSettings (\ s a -> s{_csdOptionSettings = a}) . _Default . _Coerce;

-- | The date (in UTC time) when this configuration set was last modified.
csdDateUpdated :: Lens' ConfigurationSettingsDescription (Maybe UTCTime)
csdDateUpdated = lens _csdDateUpdated (\ s a -> s{_csdDateUpdated = a}) . mapping _Time;

-- | The date (in UTC time) when this configuration set was created.
csdDateCreated :: Lens' ConfigurationSettingsDescription (Maybe UTCTime)
csdDateCreated = lens _csdDateCreated (\ s a -> s{_csdDateCreated = a}) . mapping _Time;

-- | If not 'null', the name of the environment for this configuration set.
csdEnvironmentName :: Lens' ConfigurationSettingsDescription (Maybe Text)
csdEnvironmentName = lens _csdEnvironmentName (\ s a -> s{_csdEnvironmentName = a});

-- | The name of the application associated with this configuration set.
csdApplicationName :: Lens' ConfigurationSettingsDescription (Maybe Text)
csdApplicationName = lens _csdApplicationName (\ s a -> s{_csdApplicationName = a});

-- | If this configuration set is associated with an environment, the 'DeploymentStatus' parameter indicates the deployment status of this configuration set:
--
-- -   'null': This configuration is not associated with a running environment.
-- -   'pending': This is a draft configuration that is not deployed to the associated environment but is in the process of deploying.
-- -   'deployed': This is the configuration that is currently deployed to the associated running environment.
-- -   'failed': This is a draft configuration that failed to successfully deploy.
csdDeploymentStatus :: Lens' ConfigurationSettingsDescription (Maybe ConfigurationDeploymentStatus)
csdDeploymentStatus = lens _csdDeploymentStatus (\ s a -> s{_csdDeploymentStatus = a});

-- | The name of the solution stack this configuration set uses.
csdSolutionStackName :: Lens' ConfigurationSettingsDescription (Maybe Text)
csdSolutionStackName = lens _csdSolutionStackName (\ s a -> s{_csdSolutionStackName = a});

-- | Describes this configuration set.
csdDescription :: Lens' ConfigurationSettingsDescription (Maybe Text)
csdDescription = lens _csdDescription (\ s a -> s{_csdDescription = a});

instance FromXML ConfigurationSettingsDescription
         where
        parseXML x
          = ConfigurationSettingsDescription' <$>
              (x .@? "TemplateName") <*>
                (x .@? "OptionSettings" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*> (x .@? "DateUpdated")
                <*> (x .@? "DateCreated")
                <*> (x .@? "EnvironmentName")
                <*> (x .@? "ApplicationName")
                <*> (x .@? "DeploymentStatus")
                <*> (x .@? "SolutionStackName")
                <*> (x .@? "Description")

instance Hashable ConfigurationSettingsDescription

instance NFData ConfigurationSettingsDescription

-- | Information about an application version deployment.
--
-- /See:/ 'deployment' smart constructor.
data Deployment = Deployment'
    { _dDeploymentId   :: !(Maybe Integer)
    , _dStatus         :: !(Maybe Text)
    , _dDeploymentTime :: !(Maybe ISO8601)
    , _dVersionLabel   :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'Deployment' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'dDeploymentId'
--
-- * 'dStatus'
--
-- * 'dDeploymentTime'
--
-- * 'dVersionLabel'
deployment
    :: Deployment
deployment =
    Deployment'
    { _dDeploymentId = Nothing
    , _dStatus = Nothing
    , _dDeploymentTime = Nothing
    , _dVersionLabel = Nothing
    }

-- | The ID of the deployment. This number increases by one each time that you deploy source code or change instance configuration settings.
dDeploymentId :: Lens' Deployment (Maybe Integer)
dDeploymentId = lens _dDeploymentId (\ s a -> s{_dDeploymentId = a});

-- | The status of the deployment:
--
-- -   'In Progress' : The deployment is in progress.
-- -   'Deployed' : The deployment succeeded.
-- -   'Failed' : The deployment failed.
dStatus :: Lens' Deployment (Maybe Text)
dStatus = lens _dStatus (\ s a -> s{_dStatus = a});

-- | For in-progress deployments, the time that the deloyment started.
--
-- For completed deployments, the time that the deployment ended.
dDeploymentTime :: Lens' Deployment (Maybe UTCTime)
dDeploymentTime = lens _dDeploymentTime (\ s a -> s{_dDeploymentTime = a}) . mapping _Time;

-- | The version label of the application version in the deployment.
dVersionLabel :: Lens' Deployment (Maybe Text)
dVersionLabel = lens _dVersionLabel (\ s a -> s{_dVersionLabel = a});

instance FromXML Deployment where
        parseXML x
          = Deployment' <$>
              (x .@? "DeploymentId") <*> (x .@? "Status") <*>
                (x .@? "DeploymentTime")
                <*> (x .@? "VersionLabel")

instance Hashable Deployment

instance NFData Deployment

-- | Describes the properties of an environment.
--
-- /See:/ 'environmentDescription' smart constructor.
data EnvironmentDescription = EnvironmentDescription'
    { _eStatus                       :: !(Maybe EnvironmentStatus)
    , _eCNAME                        :: !(Maybe Text)
    , _eTemplateName                 :: !(Maybe Text)
    , _eAbortableOperationInProgress :: !(Maybe Bool)
    , _eEndpointURL                  :: !(Maybe Text)
    , _eResources                    :: !(Maybe EnvironmentResourcesDescription)
    , _eDateUpdated                  :: !(Maybe ISO8601)
    , _eDateCreated                  :: !(Maybe ISO8601)
    , _eHealth                       :: !(Maybe EnvironmentHealth)
    , _eVersionLabel                 :: !(Maybe Text)
    , _eTier                         :: !(Maybe EnvironmentTier)
    , _eEnvironmentName              :: !(Maybe Text)
    , _eApplicationName              :: !(Maybe Text)
    , _eSolutionStackName            :: !(Maybe Text)
    , _eEnvironmentId                :: !(Maybe Text)
    , _eHealthStatus                 :: !(Maybe EnvironmentHealthStatus)
    , _eEnvironmentLinks             :: !(Maybe [EnvironmentLink])
    , _eDescription                  :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EnvironmentDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'eStatus'
--
-- * 'eCNAME'
--
-- * 'eTemplateName'
--
-- * 'eAbortableOperationInProgress'
--
-- * 'eEndpointURL'
--
-- * 'eResources'
--
-- * 'eDateUpdated'
--
-- * 'eDateCreated'
--
-- * 'eHealth'
--
-- * 'eVersionLabel'
--
-- * 'eTier'
--
-- * 'eEnvironmentName'
--
-- * 'eApplicationName'
--
-- * 'eSolutionStackName'
--
-- * 'eEnvironmentId'
--
-- * 'eHealthStatus'
--
-- * 'eEnvironmentLinks'
--
-- * 'eDescription'
environmentDescription
    :: EnvironmentDescription
environmentDescription =
    EnvironmentDescription'
    { _eStatus = Nothing
    , _eCNAME = Nothing
    , _eTemplateName = Nothing
    , _eAbortableOperationInProgress = Nothing
    , _eEndpointURL = Nothing
    , _eResources = Nothing
    , _eDateUpdated = Nothing
    , _eDateCreated = Nothing
    , _eHealth = Nothing
    , _eVersionLabel = Nothing
    , _eTier = Nothing
    , _eEnvironmentName = Nothing
    , _eApplicationName = Nothing
    , _eSolutionStackName = Nothing
    , _eEnvironmentId = Nothing
    , _eHealthStatus = Nothing
    , _eEnvironmentLinks = Nothing
    , _eDescription = Nothing
    }

-- | The current operational status of the environment:
--
-- -   'Launching': Environment is in the process of initial deployment.
-- -   'Updating': Environment is in the process of updating its configuration settings or application version.
-- -   'Ready': Environment is available to have an action performed on it, such as update or terminate.
-- -   'Terminating': Environment is in the shut-down process.
-- -   'Terminated': Environment is not running.
eStatus :: Lens' EnvironmentDescription (Maybe EnvironmentStatus)
eStatus = lens _eStatus (\ s a -> s{_eStatus = a});

-- | The URL to the CNAME for this environment.
eCNAME :: Lens' EnvironmentDescription (Maybe Text)
eCNAME = lens _eCNAME (\ s a -> s{_eCNAME = a});

-- | The name of the configuration template used to originally launch this environment.
eTemplateName :: Lens' EnvironmentDescription (Maybe Text)
eTemplateName = lens _eTemplateName (\ s a -> s{_eTemplateName = a});

-- | Indicates if there is an in-progress environment configuration update or application version deployment that you can cancel.
--
-- 'true:' There is an update in progress.
--
-- 'false:' There are no updates currently in progress.
eAbortableOperationInProgress :: Lens' EnvironmentDescription (Maybe Bool)
eAbortableOperationInProgress = lens _eAbortableOperationInProgress (\ s a -> s{_eAbortableOperationInProgress = a});

-- | For load-balanced, autoscaling environments, the URL to the LoadBalancer. For single-instance environments, the IP address of the instance.
eEndpointURL :: Lens' EnvironmentDescription (Maybe Text)
eEndpointURL = lens _eEndpointURL (\ s a -> s{_eEndpointURL = a});

-- | The description of the AWS resources used by this environment.
eResources :: Lens' EnvironmentDescription (Maybe EnvironmentResourcesDescription)
eResources = lens _eResources (\ s a -> s{_eResources = a});

-- | The last modified date for this environment.
eDateUpdated :: Lens' EnvironmentDescription (Maybe UTCTime)
eDateUpdated = lens _eDateUpdated (\ s a -> s{_eDateUpdated = a}) . mapping _Time;

-- | The creation date for this environment.
eDateCreated :: Lens' EnvironmentDescription (Maybe UTCTime)
eDateCreated = lens _eDateCreated (\ s a -> s{_eDateCreated = a}) . mapping _Time;

-- | Describes the health status of the environment. AWS Elastic Beanstalk indicates the failure levels for a running environment:
--
-- -   'Red': Indicates the environment is not responsive. Occurs when three or more consecutive failures occur for an environment.
-- -   'Yellow': Indicates that something is wrong. Occurs when two consecutive failures occur for an environment.
-- -   'Green': Indicates the environment is healthy and fully functional.
-- -   'Grey': Default health for a new environment. The environment is not fully launched and health checks have not started or health checks are suspended during an 'UpdateEnvironment' or 'RestartEnvironement' request.
--
-- Default: 'Grey'
eHealth :: Lens' EnvironmentDescription (Maybe EnvironmentHealth)
eHealth = lens _eHealth (\ s a -> s{_eHealth = a});

-- | The application version deployed in this environment.
eVersionLabel :: Lens' EnvironmentDescription (Maybe Text)
eVersionLabel = lens _eVersionLabel (\ s a -> s{_eVersionLabel = a});

-- | Describes the current tier of this environment.
eTier :: Lens' EnvironmentDescription (Maybe EnvironmentTier)
eTier = lens _eTier (\ s a -> s{_eTier = a});

-- | The name of this environment.
eEnvironmentName :: Lens' EnvironmentDescription (Maybe Text)
eEnvironmentName = lens _eEnvironmentName (\ s a -> s{_eEnvironmentName = a});

-- | The name of the application associated with this environment.
eApplicationName :: Lens' EnvironmentDescription (Maybe Text)
eApplicationName = lens _eApplicationName (\ s a -> s{_eApplicationName = a});

-- | The name of the 'SolutionStack' deployed with this environment.
eSolutionStackName :: Lens' EnvironmentDescription (Maybe Text)
eSolutionStackName = lens _eSolutionStackName (\ s a -> s{_eSolutionStackName = a});

-- | The ID of this environment.
eEnvironmentId :: Lens' EnvironmentDescription (Maybe Text)
eEnvironmentId = lens _eEnvironmentId (\ s a -> s{_eEnvironmentId = a});

-- | Returns the health status of the application running in your environment. For more information, see <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html Health Colors and Statuses>.
eHealthStatus :: Lens' EnvironmentDescription (Maybe EnvironmentHealthStatus)
eHealthStatus = lens _eHealthStatus (\ s a -> s{_eHealthStatus = a});

-- | A list of links to other environments in the same group.
eEnvironmentLinks :: Lens' EnvironmentDescription [EnvironmentLink]
eEnvironmentLinks = lens _eEnvironmentLinks (\ s a -> s{_eEnvironmentLinks = a}) . _Default . _Coerce;

-- | Describes this environment.
eDescription :: Lens' EnvironmentDescription (Maybe Text)
eDescription = lens _eDescription (\ s a -> s{_eDescription = a});

instance FromXML EnvironmentDescription where
        parseXML x
          = EnvironmentDescription' <$>
              (x .@? "Status") <*> (x .@? "CNAME") <*>
                (x .@? "TemplateName")
                <*> (x .@? "AbortableOperationInProgress")
                <*> (x .@? "EndpointURL")
                <*> (x .@? "Resources")
                <*> (x .@? "DateUpdated")
                <*> (x .@? "DateCreated")
                <*> (x .@? "Health")
                <*> (x .@? "VersionLabel")
                <*> (x .@? "Tier")
                <*> (x .@? "EnvironmentName")
                <*> (x .@? "ApplicationName")
                <*> (x .@? "SolutionStackName")
                <*> (x .@? "EnvironmentId")
                <*> (x .@? "HealthStatus")
                <*>
                (x .@? "EnvironmentLinks" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*> (x .@? "Description")

instance Hashable EnvironmentDescription

instance NFData EnvironmentDescription

-- | Result message containing a list of environment descriptions.
--
-- /See:/ 'environmentDescriptionsMessage' smart constructor.
newtype EnvironmentDescriptionsMessage = EnvironmentDescriptionsMessage'
    { _edmEnvironments :: Maybe [EnvironmentDescription]
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EnvironmentDescriptionsMessage' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'edmEnvironments'
environmentDescriptionsMessage
    :: EnvironmentDescriptionsMessage
environmentDescriptionsMessage =
    EnvironmentDescriptionsMessage'
    { _edmEnvironments = Nothing
    }

-- | Returns an < EnvironmentDescription> list.
edmEnvironments :: Lens' EnvironmentDescriptionsMessage [EnvironmentDescription]
edmEnvironments = lens _edmEnvironments (\ s a -> s{_edmEnvironments = a}) . _Default . _Coerce;

instance FromXML EnvironmentDescriptionsMessage where
        parseXML x
          = EnvironmentDescriptionsMessage' <$>
              (x .@? "Environments" .!@ mempty >>=
                 may (parseXMLList "member"))

instance Hashable EnvironmentDescriptionsMessage

instance NFData EnvironmentDescriptionsMessage

-- | The information retrieved from the Amazon EC2 instances.
--
-- /See:/ 'environmentInfoDescription' smart constructor.
data EnvironmentInfoDescription = EnvironmentInfoDescription'
    { _eidSampleTimestamp :: !(Maybe ISO8601)
    , _eidEC2InstanceId   :: !(Maybe Text)
    , _eidInfoType        :: !(Maybe EnvironmentInfoType)
    , _eidMessage         :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EnvironmentInfoDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'eidSampleTimestamp'
--
-- * 'eidEC2InstanceId'
--
-- * 'eidInfoType'
--
-- * 'eidMessage'
environmentInfoDescription
    :: EnvironmentInfoDescription
environmentInfoDescription =
    EnvironmentInfoDescription'
    { _eidSampleTimestamp = Nothing
    , _eidEC2InstanceId = Nothing
    , _eidInfoType = Nothing
    , _eidMessage = Nothing
    }

-- | The time stamp when this information was retrieved.
eidSampleTimestamp :: Lens' EnvironmentInfoDescription (Maybe UTCTime)
eidSampleTimestamp = lens _eidSampleTimestamp (\ s a -> s{_eidSampleTimestamp = a}) . mapping _Time;

-- | The Amazon EC2 Instance ID for this information.
eidEC2InstanceId :: Lens' EnvironmentInfoDescription (Maybe Text)
eidEC2InstanceId = lens _eidEC2InstanceId (\ s a -> s{_eidEC2InstanceId = a});

-- | The type of information retrieved.
eidInfoType :: Lens' EnvironmentInfoDescription (Maybe EnvironmentInfoType)
eidInfoType = lens _eidInfoType (\ s a -> s{_eidInfoType = a});

-- | The retrieved information.
eidMessage :: Lens' EnvironmentInfoDescription (Maybe Text)
eidMessage = lens _eidMessage (\ s a -> s{_eidMessage = a});

instance FromXML EnvironmentInfoDescription where
        parseXML x
          = EnvironmentInfoDescription' <$>
              (x .@? "SampleTimestamp") <*> (x .@? "Ec2InstanceId")
                <*> (x .@? "InfoType")
                <*> (x .@? "Message")

instance Hashable EnvironmentInfoDescription

instance NFData EnvironmentInfoDescription

-- | A link to another environment, defined in the environment\'s manifest. Links provide connection information in system properties that can be used to connect to another environment in the same group. See <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environment-cfg-manifest.html Environment Manifest (env.yaml)> for details.
--
-- /See:/ 'environmentLink' smart constructor.
data EnvironmentLink = EnvironmentLink'
    { _elLinkName        :: !(Maybe Text)
    , _elEnvironmentName :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EnvironmentLink' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'elLinkName'
--
-- * 'elEnvironmentName'
environmentLink
    :: EnvironmentLink
environmentLink =
    EnvironmentLink'
    { _elLinkName = Nothing
    , _elEnvironmentName = Nothing
    }

-- | The name of the link.
elLinkName :: Lens' EnvironmentLink (Maybe Text)
elLinkName = lens _elLinkName (\ s a -> s{_elLinkName = a});

-- | The name of the linked environment (the dependency).
elEnvironmentName :: Lens' EnvironmentLink (Maybe Text)
elEnvironmentName = lens _elEnvironmentName (\ s a -> s{_elEnvironmentName = a});

instance FromXML EnvironmentLink where
        parseXML x
          = EnvironmentLink' <$>
              (x .@? "LinkName") <*> (x .@? "EnvironmentName")

instance Hashable EnvironmentLink

instance NFData EnvironmentLink

-- | Describes the AWS resources in use by this environment. This data is live.
--
-- /See:/ 'environmentResourceDescription' smart constructor.
data EnvironmentResourceDescription = EnvironmentResourceDescription'
    { _erdQueues               :: !(Maybe [Queue])
    , _erdTriggers             :: !(Maybe [Trigger])
    , _erdLoadBalancers        :: !(Maybe [LoadBalancer])
    , _erdEnvironmentName      :: !(Maybe Text)
    , _erdInstances            :: !(Maybe [Instance])
    , _erdLaunchConfigurations :: !(Maybe [LaunchConfiguration])
    , _erdAutoScalingGroups    :: !(Maybe [AutoScalingGroup])
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EnvironmentResourceDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'erdQueues'
--
-- * 'erdTriggers'
--
-- * 'erdLoadBalancers'
--
-- * 'erdEnvironmentName'
--
-- * 'erdInstances'
--
-- * 'erdLaunchConfigurations'
--
-- * 'erdAutoScalingGroups'
environmentResourceDescription
    :: EnvironmentResourceDescription
environmentResourceDescription =
    EnvironmentResourceDescription'
    { _erdQueues = Nothing
    , _erdTriggers = Nothing
    , _erdLoadBalancers = Nothing
    , _erdEnvironmentName = Nothing
    , _erdInstances = Nothing
    , _erdLaunchConfigurations = Nothing
    , _erdAutoScalingGroups = Nothing
    }

-- | The queues used by this environment.
erdQueues :: Lens' EnvironmentResourceDescription [Queue]
erdQueues = lens _erdQueues (\ s a -> s{_erdQueues = a}) . _Default . _Coerce;

-- | The 'AutoScaling' triggers in use by this environment.
erdTriggers :: Lens' EnvironmentResourceDescription [Trigger]
erdTriggers = lens _erdTriggers (\ s a -> s{_erdTriggers = a}) . _Default . _Coerce;

-- | The LoadBalancers in use by this environment.
erdLoadBalancers :: Lens' EnvironmentResourceDescription [LoadBalancer]
erdLoadBalancers = lens _erdLoadBalancers (\ s a -> s{_erdLoadBalancers = a}) . _Default . _Coerce;

-- | The name of the environment.
erdEnvironmentName :: Lens' EnvironmentResourceDescription (Maybe Text)
erdEnvironmentName = lens _erdEnvironmentName (\ s a -> s{_erdEnvironmentName = a});

-- | The Amazon EC2 instances used by this environment.
erdInstances :: Lens' EnvironmentResourceDescription [Instance]
erdInstances = lens _erdInstances (\ s a -> s{_erdInstances = a}) . _Default . _Coerce;

-- | The Auto Scaling launch configurations in use by this environment.
erdLaunchConfigurations :: Lens' EnvironmentResourceDescription [LaunchConfiguration]
erdLaunchConfigurations = lens _erdLaunchConfigurations (\ s a -> s{_erdLaunchConfigurations = a}) . _Default . _Coerce;

-- | The 'AutoScalingGroups' used by this environment.
erdAutoScalingGroups :: Lens' EnvironmentResourceDescription [AutoScalingGroup]
erdAutoScalingGroups = lens _erdAutoScalingGroups (\ s a -> s{_erdAutoScalingGroups = a}) . _Default . _Coerce;

instance FromXML EnvironmentResourceDescription where
        parseXML x
          = EnvironmentResourceDescription' <$>
              (x .@? "Queues" .!@ mempty >>=
                 may (parseXMLList "member"))
                <*>
                (x .@? "Triggers" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*>
                (x .@? "LoadBalancers" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*> (x .@? "EnvironmentName")
                <*>
                (x .@? "Instances" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*>
                (x .@? "LaunchConfigurations" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*>
                (x .@? "AutoScalingGroups" .!@ mempty >>=
                   may (parseXMLList "member"))

instance Hashable EnvironmentResourceDescription

instance NFData EnvironmentResourceDescription

-- | Describes the AWS resources in use by this environment. This data is not live data.
--
-- /See:/ 'environmentResourcesDescription' smart constructor.
newtype EnvironmentResourcesDescription = EnvironmentResourcesDescription'
    { _erdLoadBalancer :: Maybe LoadBalancerDescription
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EnvironmentResourcesDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'erdLoadBalancer'
environmentResourcesDescription
    :: EnvironmentResourcesDescription
environmentResourcesDescription =
    EnvironmentResourcesDescription'
    { _erdLoadBalancer = Nothing
    }

-- | Describes the LoadBalancer.
erdLoadBalancer :: Lens' EnvironmentResourcesDescription (Maybe LoadBalancerDescription)
erdLoadBalancer = lens _erdLoadBalancer (\ s a -> s{_erdLoadBalancer = a});

instance FromXML EnvironmentResourcesDescription
         where
        parseXML x
          = EnvironmentResourcesDescription' <$>
              (x .@? "LoadBalancer")

instance Hashable EnvironmentResourcesDescription

instance NFData EnvironmentResourcesDescription

-- | Describes the properties of an environment tier
--
-- /See:/ 'environmentTier' smart constructor.
data EnvironmentTier = EnvironmentTier'
    { _etName    :: !(Maybe Text)
    , _etVersion :: !(Maybe Text)
    , _etType    :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EnvironmentTier' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'etName'
--
-- * 'etVersion'
--
-- * 'etType'
environmentTier
    :: EnvironmentTier
environmentTier =
    EnvironmentTier'
    { _etName = Nothing
    , _etVersion = Nothing
    , _etType = Nothing
    }

-- | The name of this environment tier.
etName :: Lens' EnvironmentTier (Maybe Text)
etName = lens _etName (\ s a -> s{_etName = a});

-- | The version of this environment tier.
etVersion :: Lens' EnvironmentTier (Maybe Text)
etVersion = lens _etVersion (\ s a -> s{_etVersion = a});

-- | The type of this environment tier.
etType :: Lens' EnvironmentTier (Maybe Text)
etType = lens _etType (\ s a -> s{_etType = a});

instance FromXML EnvironmentTier where
        parseXML x
          = EnvironmentTier' <$>
              (x .@? "Name") <*> (x .@? "Version") <*>
                (x .@? "Type")

instance Hashable EnvironmentTier

instance NFData EnvironmentTier

instance ToQuery EnvironmentTier where
        toQuery EnvironmentTier'{..}
          = mconcat
              ["Name" =: _etName, "Version" =: _etVersion,
               "Type" =: _etType]

-- | Describes an event.
--
-- /See:/ 'eventDescription' smart constructor.
data EventDescription = EventDescription'
    { _edRequestId       :: !(Maybe Text)
    , _edTemplateName    :: !(Maybe Text)
    , _edSeverity        :: !(Maybe EventSeverity)
    , _edVersionLabel    :: !(Maybe Text)
    , _edEnvironmentName :: !(Maybe Text)
    , _edApplicationName :: !(Maybe Text)
    , _edEventDate       :: !(Maybe ISO8601)
    , _edMessage         :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'EventDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'edRequestId'
--
-- * 'edTemplateName'
--
-- * 'edSeverity'
--
-- * 'edVersionLabel'
--
-- * 'edEnvironmentName'
--
-- * 'edApplicationName'
--
-- * 'edEventDate'
--
-- * 'edMessage'
eventDescription
    :: EventDescription
eventDescription =
    EventDescription'
    { _edRequestId = Nothing
    , _edTemplateName = Nothing
    , _edSeverity = Nothing
    , _edVersionLabel = Nothing
    , _edEnvironmentName = Nothing
    , _edApplicationName = Nothing
    , _edEventDate = Nothing
    , _edMessage = Nothing
    }

-- | The web service request ID for the activity of this event.
edRequestId :: Lens' EventDescription (Maybe Text)
edRequestId = lens _edRequestId (\ s a -> s{_edRequestId = a});

-- | The name of the configuration associated with this event.
edTemplateName :: Lens' EventDescription (Maybe Text)
edTemplateName = lens _edTemplateName (\ s a -> s{_edTemplateName = a});

-- | The severity level of this event.
edSeverity :: Lens' EventDescription (Maybe EventSeverity)
edSeverity = lens _edSeverity (\ s a -> s{_edSeverity = a});

-- | The release label for the application version associated with this event.
edVersionLabel :: Lens' EventDescription (Maybe Text)
edVersionLabel = lens _edVersionLabel (\ s a -> s{_edVersionLabel = a});

-- | The name of the environment associated with this event.
edEnvironmentName :: Lens' EventDescription (Maybe Text)
edEnvironmentName = lens _edEnvironmentName (\ s a -> s{_edEnvironmentName = a});

-- | The application associated with the event.
edApplicationName :: Lens' EventDescription (Maybe Text)
edApplicationName = lens _edApplicationName (\ s a -> s{_edApplicationName = a});

-- | The date when the event occurred.
edEventDate :: Lens' EventDescription (Maybe UTCTime)
edEventDate = lens _edEventDate (\ s a -> s{_edEventDate = a}) . mapping _Time;

-- | The event message.
edMessage :: Lens' EventDescription (Maybe Text)
edMessage = lens _edMessage (\ s a -> s{_edMessage = a});

instance FromXML EventDescription where
        parseXML x
          = EventDescription' <$>
              (x .@? "RequestId") <*> (x .@? "TemplateName") <*>
                (x .@? "Severity")
                <*> (x .@? "VersionLabel")
                <*> (x .@? "EnvironmentName")
                <*> (x .@? "ApplicationName")
                <*> (x .@? "EventDate")
                <*> (x .@? "Message")

instance Hashable EventDescription

instance NFData EventDescription

-- | The description of an Amazon EC2 instance.
--
-- /See:/ 'instance'' smart constructor.
newtype Instance = Instance'
    { _iId :: Maybe Text
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'Instance' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'iId'
instance'
    :: Instance
instance' =
    Instance'
    { _iId = Nothing
    }

-- | The ID of the Amazon EC2 instance.
iId :: Lens' Instance (Maybe Text)
iId = lens _iId (\ s a -> s{_iId = a});

instance FromXML Instance where
        parseXML x = Instance' <$> (x .@? "Id")

instance Hashable Instance

instance NFData Instance

-- | Represents summary information about the health of an instance. For more information, see <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html Health Colors and Statuses>.
--
-- /See:/ 'instanceHealthSummary' smart constructor.
data InstanceHealthSummary = InstanceHealthSummary'
    { _ihsOK       :: !(Maybe Int)
    , _ihsPending  :: !(Maybe Int)
    , _ihsSevere   :: !(Maybe Int)
    , _ihsUnknown  :: !(Maybe Int)
    , _ihsNoData   :: !(Maybe Int)
    , _ihsWarning  :: !(Maybe Int)
    , _ihsDegraded :: !(Maybe Int)
    , _ihsInfo     :: !(Maybe Int)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'InstanceHealthSummary' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'ihsOK'
--
-- * 'ihsPending'
--
-- * 'ihsSevere'
--
-- * 'ihsUnknown'
--
-- * 'ihsNoData'
--
-- * 'ihsWarning'
--
-- * 'ihsDegraded'
--
-- * 'ihsInfo'
instanceHealthSummary
    :: InstanceHealthSummary
instanceHealthSummary =
    InstanceHealthSummary'
    { _ihsOK = Nothing
    , _ihsPending = Nothing
    , _ihsSevere = Nothing
    , _ihsUnknown = Nothing
    , _ihsNoData = Nothing
    , _ihsWarning = Nothing
    , _ihsDegraded = Nothing
    , _ihsInfo = Nothing
    }

-- | __Green.__ An instance is passing health checks and the health agent is not reporting any problems.
ihsOK :: Lens' InstanceHealthSummary (Maybe Int)
ihsOK = lens _ihsOK (\ s a -> s{_ihsOK = a});

-- | __Grey.__ An operation is in progress on an instance within the command timeout.
ihsPending :: Lens' InstanceHealthSummary (Maybe Int)
ihsPending = lens _ihsPending (\ s a -> s{_ihsPending = a});

-- | __Red.__ The health agent is reporting a very high number of request failures or other issues for an instance or environment.
ihsSevere :: Lens' InstanceHealthSummary (Maybe Int)
ihsSevere = lens _ihsSevere (\ s a -> s{_ihsSevere = a});

-- | __Grey.__ AWS Elastic Beanstalk and the health agent are reporting an insufficient amount of data on an instance.
ihsUnknown :: Lens' InstanceHealthSummary (Maybe Int)
ihsUnknown = lens _ihsUnknown (\ s a -> s{_ihsUnknown = a});

-- | __Grey.__ AWS Elastic Beanstalk and the health agent are reporting no data on an instance.
ihsNoData :: Lens' InstanceHealthSummary (Maybe Int)
ihsNoData = lens _ihsNoData (\ s a -> s{_ihsNoData = a});

-- | __Yellow.__ The health agent is reporting a moderate number of request failures or other issues for an instance or environment.
ihsWarning :: Lens' InstanceHealthSummary (Maybe Int)
ihsWarning = lens _ihsWarning (\ s a -> s{_ihsWarning = a});

-- | __Red.__ The health agent is reporting a high number of request failures or other issues for an instance or environment.
ihsDegraded :: Lens' InstanceHealthSummary (Maybe Int)
ihsDegraded = lens _ihsDegraded (\ s a -> s{_ihsDegraded = a});

-- | __Green.__ An operation is in progress on an instance.
ihsInfo :: Lens' InstanceHealthSummary (Maybe Int)
ihsInfo = lens _ihsInfo (\ s a -> s{_ihsInfo = a});

instance FromXML InstanceHealthSummary where
        parseXML x
          = InstanceHealthSummary' <$>
              (x .@? "Ok") <*> (x .@? "Pending") <*>
                (x .@? "Severe")
                <*> (x .@? "Unknown")
                <*> (x .@? "NoData")
                <*> (x .@? "Warning")
                <*> (x .@? "Degraded")
                <*> (x .@? "Info")

instance Hashable InstanceHealthSummary

instance NFData InstanceHealthSummary

-- | Represents the average latency for the slowest X percent of requests over the last 10 seconds.
--
-- /See:/ 'latency' smart constructor.
data Latency = Latency'
    { _lP75  :: !(Maybe Double)
    , _lP50  :: !(Maybe Double)
    , _lP85  :: !(Maybe Double)
    , _lP999 :: !(Maybe Double)
    , _lP90  :: !(Maybe Double)
    , _lP95  :: !(Maybe Double)
    , _lP99  :: !(Maybe Double)
    , _lP10  :: !(Maybe Double)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'Latency' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'lP75'
--
-- * 'lP50'
--
-- * 'lP85'
--
-- * 'lP999'
--
-- * 'lP90'
--
-- * 'lP95'
--
-- * 'lP99'
--
-- * 'lP10'
latency
    :: Latency
latency =
    Latency'
    { _lP75 = Nothing
    , _lP50 = Nothing
    , _lP85 = Nothing
    , _lP999 = Nothing
    , _lP90 = Nothing
    , _lP95 = Nothing
    , _lP99 = Nothing
    , _lP10 = Nothing
    }

-- | The average latency for the slowest 25 percent of requests over the last 10 seconds.
lP75 :: Lens' Latency (Maybe Double)
lP75 = lens _lP75 (\ s a -> s{_lP75 = a});

-- | The average latency for the slowest 50 percent of requests over the last 10 seconds.
lP50 :: Lens' Latency (Maybe Double)
lP50 = lens _lP50 (\ s a -> s{_lP50 = a});

-- | The average latency for the slowest 15 percent of requests over the last 10 seconds.
lP85 :: Lens' Latency (Maybe Double)
lP85 = lens _lP85 (\ s a -> s{_lP85 = a});

-- | The average latency for the slowest 0.1 percent of requests over the last 10 seconds.
lP999 :: Lens' Latency (Maybe Double)
lP999 = lens _lP999 (\ s a -> s{_lP999 = a});

-- | The average latency for the slowest 10 percent of requests over the last 10 seconds.
lP90 :: Lens' Latency (Maybe Double)
lP90 = lens _lP90 (\ s a -> s{_lP90 = a});

-- | The average latency for the slowest 5 percent of requests over the last 10 seconds.
lP95 :: Lens' Latency (Maybe Double)
lP95 = lens _lP95 (\ s a -> s{_lP95 = a});

-- | The average latency for the slowest 1 percent of requests over the last 10 seconds.
lP99 :: Lens' Latency (Maybe Double)
lP99 = lens _lP99 (\ s a -> s{_lP99 = a});

-- | The average latency for the slowest 90 percent of requests over the last 10 seconds.
lP10 :: Lens' Latency (Maybe Double)
lP10 = lens _lP10 (\ s a -> s{_lP10 = a});

instance FromXML Latency where
        parseXML x
          = Latency' <$>
              (x .@? "P75") <*> (x .@? "P50") <*> (x .@? "P85") <*>
                (x .@? "P999")
                <*> (x .@? "P90")
                <*> (x .@? "P95")
                <*> (x .@? "P99")
                <*> (x .@? "P10")

instance Hashable Latency

instance NFData Latency

-- | Describes an Auto Scaling launch configuration.
--
-- /See:/ 'launchConfiguration' smart constructor.
newtype LaunchConfiguration = LaunchConfiguration'
    { _lcName :: Maybe Text
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'LaunchConfiguration' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'lcName'
launchConfiguration
    :: LaunchConfiguration
launchConfiguration =
    LaunchConfiguration'
    { _lcName = Nothing
    }

-- | The name of the launch configuration.
lcName :: Lens' LaunchConfiguration (Maybe Text)
lcName = lens _lcName (\ s a -> s{_lcName = a});

instance FromXML LaunchConfiguration where
        parseXML x = LaunchConfiguration' <$> (x .@? "Name")

instance Hashable LaunchConfiguration

instance NFData LaunchConfiguration

-- | Describes the properties of a Listener for the LoadBalancer.
--
-- /See:/ 'listener' smart constructor.
data Listener = Listener'
    { _lProtocol :: !(Maybe Text)
    , _lPort     :: !(Maybe Int)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'Listener' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'lProtocol'
--
-- * 'lPort'
listener
    :: Listener
listener =
    Listener'
    { _lProtocol = Nothing
    , _lPort = Nothing
    }

-- | The protocol that is used by the Listener.
lProtocol :: Lens' Listener (Maybe Text)
lProtocol = lens _lProtocol (\ s a -> s{_lProtocol = a});

-- | The port that is used by the Listener.
lPort :: Lens' Listener (Maybe Int)
lPort = lens _lPort (\ s a -> s{_lPort = a});

instance FromXML Listener where
        parseXML x
          = Listener' <$> (x .@? "Protocol") <*> (x .@? "Port")

instance Hashable Listener

instance NFData Listener

-- | Describes a LoadBalancer.
--
-- /See:/ 'loadBalancer' smart constructor.
newtype LoadBalancer = LoadBalancer'
    { _lbName :: Maybe Text
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'LoadBalancer' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'lbName'
loadBalancer
    :: LoadBalancer
loadBalancer =
    LoadBalancer'
    { _lbName = Nothing
    }

-- | The name of the LoadBalancer.
lbName :: Lens' LoadBalancer (Maybe Text)
lbName = lens _lbName (\ s a -> s{_lbName = a});

instance FromXML LoadBalancer where
        parseXML x = LoadBalancer' <$> (x .@? "Name")

instance Hashable LoadBalancer

instance NFData LoadBalancer

-- | Describes the details of a LoadBalancer.
--
-- /See:/ 'loadBalancerDescription' smart constructor.
data LoadBalancerDescription = LoadBalancerDescription'
    { _lbdLoadBalancerName :: !(Maybe Text)
    , _lbdDomain           :: !(Maybe Text)
    , _lbdListeners        :: !(Maybe [Listener])
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'LoadBalancerDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'lbdLoadBalancerName'
--
-- * 'lbdDomain'
--
-- * 'lbdListeners'
loadBalancerDescription
    :: LoadBalancerDescription
loadBalancerDescription =
    LoadBalancerDescription'
    { _lbdLoadBalancerName = Nothing
    , _lbdDomain = Nothing
    , _lbdListeners = Nothing
    }

-- | The name of the LoadBalancer.
lbdLoadBalancerName :: Lens' LoadBalancerDescription (Maybe Text)
lbdLoadBalancerName = lens _lbdLoadBalancerName (\ s a -> s{_lbdLoadBalancerName = a});

-- | The domain name of the LoadBalancer.
lbdDomain :: Lens' LoadBalancerDescription (Maybe Text)
lbdDomain = lens _lbdDomain (\ s a -> s{_lbdDomain = a});

-- | A list of Listeners used by the LoadBalancer.
lbdListeners :: Lens' LoadBalancerDescription [Listener]
lbdListeners = lens _lbdListeners (\ s a -> s{_lbdListeners = a}) . _Default . _Coerce;

instance FromXML LoadBalancerDescription where
        parseXML x
          = LoadBalancerDescription' <$>
              (x .@? "LoadBalancerName") <*> (x .@? "Domain") <*>
                (x .@? "Listeners" .!@ mempty >>=
                   may (parseXMLList "member"))

instance Hashable LoadBalancerDescription

instance NFData LoadBalancerDescription

-- | The record of an upcoming or in-progress managed action.
--
-- /See:/ 'managedAction' smart constructor.
data ManagedAction = ManagedAction'
    { _maStatus            :: !(Maybe ActionStatus)
    , _maActionId          :: !(Maybe Text)
    , _maWindowStartTime   :: !(Maybe ISO8601)
    , _maActionDescription :: !(Maybe Text)
    , _maActionType        :: !(Maybe ActionType)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ManagedAction' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'maStatus'
--
-- * 'maActionId'
--
-- * 'maWindowStartTime'
--
-- * 'maActionDescription'
--
-- * 'maActionType'
managedAction
    :: ManagedAction
managedAction =
    ManagedAction'
    { _maStatus = Nothing
    , _maActionId = Nothing
    , _maWindowStartTime = Nothing
    , _maActionDescription = Nothing
    , _maActionType = Nothing
    }

-- | The status of the managed action. If the action is 'Scheduled', you can apply it immediately with < ApplyEnvironmentManagedAction>.
maStatus :: Lens' ManagedAction (Maybe ActionStatus)
maStatus = lens _maStatus (\ s a -> s{_maStatus = a});

-- | A unique identifier for the managed action.
maActionId :: Lens' ManagedAction (Maybe Text)
maActionId = lens _maActionId (\ s a -> s{_maActionId = a});

-- | The start time of the maintenance window in which the managed action will execute.
maWindowStartTime :: Lens' ManagedAction (Maybe UTCTime)
maWindowStartTime = lens _maWindowStartTime (\ s a -> s{_maWindowStartTime = a}) . mapping _Time;

-- | A description of the managed action.
maActionDescription :: Lens' ManagedAction (Maybe Text)
maActionDescription = lens _maActionDescription (\ s a -> s{_maActionDescription = a});

-- | The type of managed action.
maActionType :: Lens' ManagedAction (Maybe ActionType)
maActionType = lens _maActionType (\ s a -> s{_maActionType = a});

instance FromXML ManagedAction where
        parseXML x
          = ManagedAction' <$>
              (x .@? "Status") <*> (x .@? "ActionId") <*>
                (x .@? "WindowStartTime")
                <*> (x .@? "ActionDescription")
                <*> (x .@? "ActionType")

instance Hashable ManagedAction

instance NFData ManagedAction

-- | The record of a completed or failed managed action.
--
-- /See:/ 'managedActionHistoryItem' smart constructor.
data ManagedActionHistoryItem = ManagedActionHistoryItem'
    { _mahiStatus             :: !(Maybe ActionHistoryStatus)
    , _mahiFailureType        :: !(Maybe FailureType)
    , _mahiActionId           :: !(Maybe Text)
    , _mahiFailureDescription :: !(Maybe Text)
    , _mahiFinishedTime       :: !(Maybe ISO8601)
    , _mahiActionDescription  :: !(Maybe Text)
    , _mahiExecutedTime       :: !(Maybe ISO8601)
    , _mahiActionType         :: !(Maybe ActionType)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ManagedActionHistoryItem' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'mahiStatus'
--
-- * 'mahiFailureType'
--
-- * 'mahiActionId'
--
-- * 'mahiFailureDescription'
--
-- * 'mahiFinishedTime'
--
-- * 'mahiActionDescription'
--
-- * 'mahiExecutedTime'
--
-- * 'mahiActionType'
managedActionHistoryItem
    :: ManagedActionHistoryItem
managedActionHistoryItem =
    ManagedActionHistoryItem'
    { _mahiStatus = Nothing
    , _mahiFailureType = Nothing
    , _mahiActionId = Nothing
    , _mahiFailureDescription = Nothing
    , _mahiFinishedTime = Nothing
    , _mahiActionDescription = Nothing
    , _mahiExecutedTime = Nothing
    , _mahiActionType = Nothing
    }

-- | The status of the action.
mahiStatus :: Lens' ManagedActionHistoryItem (Maybe ActionHistoryStatus)
mahiStatus = lens _mahiStatus (\ s a -> s{_mahiStatus = a});

-- | If the action failed, the type of failure.
mahiFailureType :: Lens' ManagedActionHistoryItem (Maybe FailureType)
mahiFailureType = lens _mahiFailureType (\ s a -> s{_mahiFailureType = a});

-- | A unique identifier for the managed action.
mahiActionId :: Lens' ManagedActionHistoryItem (Maybe Text)
mahiActionId = lens _mahiActionId (\ s a -> s{_mahiActionId = a});

-- | If the action failed, a description of the failure.
mahiFailureDescription :: Lens' ManagedActionHistoryItem (Maybe Text)
mahiFailureDescription = lens _mahiFailureDescription (\ s a -> s{_mahiFailureDescription = a});

-- | The date and time that the action finished executing.
mahiFinishedTime :: Lens' ManagedActionHistoryItem (Maybe UTCTime)
mahiFinishedTime = lens _mahiFinishedTime (\ s a -> s{_mahiFinishedTime = a}) . mapping _Time;

-- | A description of the managed action.
mahiActionDescription :: Lens' ManagedActionHistoryItem (Maybe Text)
mahiActionDescription = lens _mahiActionDescription (\ s a -> s{_mahiActionDescription = a});

-- | The date and time that the action started executing.
mahiExecutedTime :: Lens' ManagedActionHistoryItem (Maybe UTCTime)
mahiExecutedTime = lens _mahiExecutedTime (\ s a -> s{_mahiExecutedTime = a}) . mapping _Time;

-- | The type of the managed action.
mahiActionType :: Lens' ManagedActionHistoryItem (Maybe ActionType)
mahiActionType = lens _mahiActionType (\ s a -> s{_mahiActionType = a});

instance FromXML ManagedActionHistoryItem where
        parseXML x
          = ManagedActionHistoryItem' <$>
              (x .@? "Status") <*> (x .@? "FailureType") <*>
                (x .@? "ActionId")
                <*> (x .@? "FailureDescription")
                <*> (x .@? "FinishedTime")
                <*> (x .@? "ActionDescription")
                <*> (x .@? "ExecutedTime")
                <*> (x .@? "ActionType")

instance Hashable ManagedActionHistoryItem

instance NFData ManagedActionHistoryItem

-- | A regular expression representing a restriction on a string configuration option value.
--
-- /See:/ 'optionRestrictionRegex' smart constructor.
data OptionRestrictionRegex = OptionRestrictionRegex'
    { _orrPattern :: !(Maybe Text)
    , _orrLabel   :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'OptionRestrictionRegex' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'orrPattern'
--
-- * 'orrLabel'
optionRestrictionRegex
    :: OptionRestrictionRegex
optionRestrictionRegex =
    OptionRestrictionRegex'
    { _orrPattern = Nothing
    , _orrLabel = Nothing
    }

-- | The regular expression pattern that a string configuration option value with this restriction must match.
orrPattern :: Lens' OptionRestrictionRegex (Maybe Text)
orrPattern = lens _orrPattern (\ s a -> s{_orrPattern = a});

-- | A unique name representing this regular expression.
orrLabel :: Lens' OptionRestrictionRegex (Maybe Text)
orrLabel = lens _orrLabel (\ s a -> s{_orrLabel = a});

instance FromXML OptionRestrictionRegex where
        parseXML x
          = OptionRestrictionRegex' <$>
              (x .@? "Pattern") <*> (x .@? "Label")

instance Hashable OptionRestrictionRegex

instance NFData OptionRestrictionRegex

-- | A specification identifying an individual configuration option.
--
-- /See:/ 'optionSpecification' smart constructor.
data OptionSpecification = OptionSpecification'
    { _osOptionName   :: !(Maybe Text)
    , _osResourceName :: !(Maybe Text)
    , _osNamespace    :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'OptionSpecification' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'osOptionName'
--
-- * 'osResourceName'
--
-- * 'osNamespace'
optionSpecification
    :: OptionSpecification
optionSpecification =
    OptionSpecification'
    { _osOptionName = Nothing
    , _osResourceName = Nothing
    , _osNamespace = Nothing
    }

-- | The name of the configuration option.
osOptionName :: Lens' OptionSpecification (Maybe Text)
osOptionName = lens _osOptionName (\ s a -> s{_osOptionName = a});

-- | A unique resource name for a time-based scaling configuration option.
osResourceName :: Lens' OptionSpecification (Maybe Text)
osResourceName = lens _osResourceName (\ s a -> s{_osResourceName = a});

-- | A unique namespace identifying the option\'s associated AWS resource.
osNamespace :: Lens' OptionSpecification (Maybe Text)
osNamespace = lens _osNamespace (\ s a -> s{_osNamespace = a});

instance Hashable OptionSpecification

instance NFData OptionSpecification

instance ToQuery OptionSpecification where
        toQuery OptionSpecification'{..}
          = mconcat
              ["OptionName" =: _osOptionName,
               "ResourceName" =: _osResourceName,
               "Namespace" =: _osNamespace]

-- | Describes a queue.
--
-- /See:/ 'queue' smart constructor.
data Queue = Queue'
    { _qURL  :: !(Maybe Text)
    , _qName :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'Queue' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'qURL'
--
-- * 'qName'
queue
    :: Queue
queue =
    Queue'
    { _qURL = Nothing
    , _qName = Nothing
    }

-- | The URL of the queue.
qURL :: Lens' Queue (Maybe Text)
qURL = lens _qURL (\ s a -> s{_qURL = a});

-- | The name of the queue.
qName :: Lens' Queue (Maybe Text)
qName = lens _qName (\ s a -> s{_qName = a});

instance FromXML Queue where
        parseXML x
          = Queue' <$> (x .@? "URL") <*> (x .@? "Name")

instance Hashable Queue

instance NFData Queue

-- | A specification of a location in Amazon S3.
--
-- /See:/ 's3Location' smart constructor.
data S3Location = S3Location'
    { _slS3Key    :: !(Maybe Text)
    , _slS3Bucket :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'S3Location' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'slS3Key'
--
-- * 'slS3Bucket'
s3Location
    :: S3Location
s3Location =
    S3Location'
    { _slS3Key = Nothing
    , _slS3Bucket = Nothing
    }

-- | The Amazon S3 key where the data is located.
slS3Key :: Lens' S3Location (Maybe Text)
slS3Key = lens _slS3Key (\ s a -> s{_slS3Key = a});

-- | The Amazon S3 bucket where the data is located.
slS3Bucket :: Lens' S3Location (Maybe Text)
slS3Bucket = lens _slS3Bucket (\ s a -> s{_slS3Bucket = a});

instance FromXML S3Location where
        parseXML x
          = S3Location' <$>
              (x .@? "S3Key") <*> (x .@? "S3Bucket")

instance Hashable S3Location

instance NFData S3Location

instance ToQuery S3Location where
        toQuery S3Location'{..}
          = mconcat
              ["S3Key" =: _slS3Key, "S3Bucket" =: _slS3Bucket]

-- | Represents health information from the specified instance that belongs to the AWS Elastic Beanstalk environment. Use the 'InstanceId' property to specify the application instance for which you\'d like to return data.
--
-- /See:/ 'singleInstanceHealth' smart constructor.
data SingleInstanceHealth = SingleInstanceHealth'
    { _sihInstanceId         :: !(Maybe Text)
    , _sihCauses             :: !(Maybe [Text])
    , _sihSystem             :: !(Maybe SystemStatus)
    , _sihApplicationMetrics :: !(Maybe ApplicationMetrics)
    , _sihColor              :: !(Maybe Text)
    , _sihInstanceType       :: !(Maybe Text)
    , _sihAvailabilityZone   :: !(Maybe Text)
    , _sihHealthStatus       :: !(Maybe Text)
    , _sihDeployment         :: !(Maybe Deployment)
    , _sihLaunchedAt         :: !(Maybe ISO8601)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'SingleInstanceHealth' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'sihInstanceId'
--
-- * 'sihCauses'
--
-- * 'sihSystem'
--
-- * 'sihApplicationMetrics'
--
-- * 'sihColor'
--
-- * 'sihInstanceType'
--
-- * 'sihAvailabilityZone'
--
-- * 'sihHealthStatus'
--
-- * 'sihDeployment'
--
-- * 'sihLaunchedAt'
singleInstanceHealth
    :: SingleInstanceHealth
singleInstanceHealth =
    SingleInstanceHealth'
    { _sihInstanceId = Nothing
    , _sihCauses = Nothing
    , _sihSystem = Nothing
    , _sihApplicationMetrics = Nothing
    , _sihColor = Nothing
    , _sihInstanceType = Nothing
    , _sihAvailabilityZone = Nothing
    , _sihHealthStatus = Nothing
    , _sihDeployment = Nothing
    , _sihLaunchedAt = Nothing
    }

-- | The ID of the Amazon EC2 instance.
sihInstanceId :: Lens' SingleInstanceHealth (Maybe Text)
sihInstanceId = lens _sihInstanceId (\ s a -> s{_sihInstanceId = a});

-- | Represents the causes, which provide more information about the current health status.
sihCauses :: Lens' SingleInstanceHealth [Text]
sihCauses = lens _sihCauses (\ s a -> s{_sihCauses = a}) . _Default . _Coerce;

-- | Undocumented member.
sihSystem :: Lens' SingleInstanceHealth (Maybe SystemStatus)
sihSystem = lens _sihSystem (\ s a -> s{_sihSystem = a});

-- | Undocumented member.
sihApplicationMetrics :: Lens' SingleInstanceHealth (Maybe ApplicationMetrics)
sihApplicationMetrics = lens _sihApplicationMetrics (\ s a -> s{_sihApplicationMetrics = a});

-- | Represents the color indicator that gives you information about the health of the EC2 instance. For more information, see <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html Health Colors and Statuses>.
sihColor :: Lens' SingleInstanceHealth (Maybe Text)
sihColor = lens _sihColor (\ s a -> s{_sihColor = a});

-- | The instance\'s type.
sihInstanceType :: Lens' SingleInstanceHealth (Maybe Text)
sihInstanceType = lens _sihInstanceType (\ s a -> s{_sihInstanceType = a});

-- | The availability zone in which the instance runs.
sihAvailabilityZone :: Lens' SingleInstanceHealth (Maybe Text)
sihAvailabilityZone = lens _sihAvailabilityZone (\ s a -> s{_sihAvailabilityZone = a});

-- | Returns the health status of the specified instance. For more information, see <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-status.html Health Colors and Statuses>.
sihHealthStatus :: Lens' SingleInstanceHealth (Maybe Text)
sihHealthStatus = lens _sihHealthStatus (\ s a -> s{_sihHealthStatus = a});

-- | Information about the most recent deployment to an instance.
sihDeployment :: Lens' SingleInstanceHealth (Maybe Deployment)
sihDeployment = lens _sihDeployment (\ s a -> s{_sihDeployment = a});

-- | The time at which the EC2 instance was launched.
sihLaunchedAt :: Lens' SingleInstanceHealth (Maybe UTCTime)
sihLaunchedAt = lens _sihLaunchedAt (\ s a -> s{_sihLaunchedAt = a}) . mapping _Time;

instance FromXML SingleInstanceHealth where
        parseXML x
          = SingleInstanceHealth' <$>
              (x .@? "InstanceId") <*>
                (x .@? "Causes" .!@ mempty >>=
                   may (parseXMLList "member"))
                <*> (x .@? "System")
                <*> (x .@? "ApplicationMetrics")
                <*> (x .@? "Color")
                <*> (x .@? "InstanceType")
                <*> (x .@? "AvailabilityZone")
                <*> (x .@? "HealthStatus")
                <*> (x .@? "Deployment")
                <*> (x .@? "LaunchedAt")

instance Hashable SingleInstanceHealth

instance NFData SingleInstanceHealth

-- | Describes the solution stack.
--
-- /See:/ 'solutionStackDescription' smart constructor.
data SolutionStackDescription = SolutionStackDescription'
    { _ssdPermittedFileTypes :: !(Maybe [Text])
    , _ssdSolutionStackName  :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'SolutionStackDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'ssdPermittedFileTypes'
--
-- * 'ssdSolutionStackName'
solutionStackDescription
    :: SolutionStackDescription
solutionStackDescription =
    SolutionStackDescription'
    { _ssdPermittedFileTypes = Nothing
    , _ssdSolutionStackName = Nothing
    }

-- | The permitted file types allowed for a solution stack.
ssdPermittedFileTypes :: Lens' SolutionStackDescription [Text]
ssdPermittedFileTypes = lens _ssdPermittedFileTypes (\ s a -> s{_ssdPermittedFileTypes = a}) . _Default . _Coerce;

-- | The name of the solution stack.
ssdSolutionStackName :: Lens' SolutionStackDescription (Maybe Text)
ssdSolutionStackName = lens _ssdSolutionStackName (\ s a -> s{_ssdSolutionStackName = a});

instance FromXML SolutionStackDescription where
        parseXML x
          = SolutionStackDescription' <$>
              (x .@? "PermittedFileTypes" .!@ mempty >>=
                 may (parseXMLList "member"))
                <*> (x .@? "SolutionStackName")

instance Hashable SolutionStackDescription

instance NFData SolutionStackDescription

-- | A specification for an environment configuration
--
-- /See:/ 'sourceConfiguration' smart constructor.
data SourceConfiguration = SourceConfiguration'
    { _scTemplateName    :: !(Maybe Text)
    , _scApplicationName :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'SourceConfiguration' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'scTemplateName'
--
-- * 'scApplicationName'
sourceConfiguration
    :: SourceConfiguration
sourceConfiguration =
    SourceConfiguration'
    { _scTemplateName = Nothing
    , _scApplicationName = Nothing
    }

-- | The name of the configuration template.
scTemplateName :: Lens' SourceConfiguration (Maybe Text)
scTemplateName = lens _scTemplateName (\ s a -> s{_scTemplateName = a});

-- | The name of the application associated with the configuration.
scApplicationName :: Lens' SourceConfiguration (Maybe Text)
scApplicationName = lens _scApplicationName (\ s a -> s{_scApplicationName = a});

instance Hashable SourceConfiguration

instance NFData SourceConfiguration

instance ToQuery SourceConfiguration where
        toQuery SourceConfiguration'{..}
          = mconcat
              ["TemplateName" =: _scTemplateName,
               "ApplicationName" =: _scApplicationName]

-- | Represents the percentage of requests over the last 10 seconds that resulted in each type of status code response. For more information, see <http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html Status Code Definitions>.
--
-- /See:/ 'statusCodes' smart constructor.
data StatusCodes = StatusCodes'
    { _scStatus2xx :: !(Maybe Int)
    , _scStatus3xx :: !(Maybe Int)
    , _scStatus4xx :: !(Maybe Int)
    , _scStatus5xx :: !(Maybe Int)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'StatusCodes' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'scStatus2xx'
--
-- * 'scStatus3xx'
--
-- * 'scStatus4xx'
--
-- * 'scStatus5xx'
statusCodes
    :: StatusCodes
statusCodes =
    StatusCodes'
    { _scStatus2xx = Nothing
    , _scStatus3xx = Nothing
    , _scStatus4xx = Nothing
    , _scStatus5xx = Nothing
    }

-- | The percentage of requests over the last 10 seconds that resulted in a 2xx (200, 201, etc.) status code.
scStatus2xx :: Lens' StatusCodes (Maybe Int)
scStatus2xx = lens _scStatus2xx (\ s a -> s{_scStatus2xx = a});

-- | The percentage of requests over the last 10 seconds that resulted in a 3xx (300, 301, etc.) status code.
scStatus3xx :: Lens' StatusCodes (Maybe Int)
scStatus3xx = lens _scStatus3xx (\ s a -> s{_scStatus3xx = a});

-- | The percentage of requests over the last 10 seconds that resulted in a 4xx (400, 401, etc.) status code.
scStatus4xx :: Lens' StatusCodes (Maybe Int)
scStatus4xx = lens _scStatus4xx (\ s a -> s{_scStatus4xx = a});

-- | The percentage of requests over the last 10 seconds that resulted in a 5xx (500, 501, etc.) status code.
scStatus5xx :: Lens' StatusCodes (Maybe Int)
scStatus5xx = lens _scStatus5xx (\ s a -> s{_scStatus5xx = a});

instance FromXML StatusCodes where
        parseXML x
          = StatusCodes' <$>
              (x .@? "Status2xx") <*> (x .@? "Status3xx") <*>
                (x .@? "Status4xx")
                <*> (x .@? "Status5xx")

instance Hashable StatusCodes

instance NFData StatusCodes

-- | Represents CPU utilization and load average information for applications running in the specified environment.
--
-- /See:/ 'systemStatus' smart constructor.
data SystemStatus = SystemStatus'
    { _ssCPUUtilization :: !(Maybe CPUUtilization)
    , _ssLoadAverage    :: !(Maybe [Double])
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'SystemStatus' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'ssCPUUtilization'
--
-- * 'ssLoadAverage'
systemStatus
    :: SystemStatus
systemStatus =
    SystemStatus'
    { _ssCPUUtilization = Nothing
    , _ssLoadAverage = Nothing
    }

-- | Undocumented member.
ssCPUUtilization :: Lens' SystemStatus (Maybe CPUUtilization)
ssCPUUtilization = lens _ssCPUUtilization (\ s a -> s{_ssCPUUtilization = a});

-- | Load average in the last 1-minute and 5-minute periods. For more information, see <http://docs.aws.amazon.com/elasticbeanstalk/latest/dg/health-enhanced-metrics.html#health-enhanced-metrics-os Operating System Metrics>.
ssLoadAverage :: Lens' SystemStatus [Double]
ssLoadAverage = lens _ssLoadAverage (\ s a -> s{_ssLoadAverage = a}) . _Default . _Coerce;

instance FromXML SystemStatus where
        parseXML x
          = SystemStatus' <$>
              (x .@? "CPUUtilization") <*>
                (x .@? "LoadAverage" .!@ mempty >>=
                   may (parseXMLList "member"))

instance Hashable SystemStatus

instance NFData SystemStatus

-- | Describes a tag applied to a resource in an environment.
--
-- /See:/ 'tag' smart constructor.
data Tag = Tag'
    { _tagValue :: !(Maybe Text)
    , _tagKey   :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'Tag' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'tagValue'
--
-- * 'tagKey'
tag
    :: Tag
tag =
    Tag'
    { _tagValue = Nothing
    , _tagKey = Nothing
    }

-- | The value of the tag.
tagValue :: Lens' Tag (Maybe Text)
tagValue = lens _tagValue (\ s a -> s{_tagValue = a});

-- | The key of the tag.
tagKey :: Lens' Tag (Maybe Text)
tagKey = lens _tagKey (\ s a -> s{_tagKey = a});

instance Hashable Tag

instance NFData Tag

instance ToQuery Tag where
        toQuery Tag'{..}
          = mconcat ["Value" =: _tagValue, "Key" =: _tagKey]

-- | Describes a trigger.
--
-- /See:/ 'trigger' smart constructor.
newtype Trigger = Trigger'
    { _tName :: Maybe Text
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'Trigger' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'tName'
trigger
    :: Trigger
trigger =
    Trigger'
    { _tName = Nothing
    }

-- | The name of the trigger.
tName :: Lens' Trigger (Maybe Text)
tName = lens _tName (\ s a -> s{_tName = a});

instance FromXML Trigger where
        parseXML x = Trigger' <$> (x .@? "Name")

instance Hashable Trigger

instance NFData Trigger

-- | An error or warning for a desired configuration option value.
--
-- /See:/ 'validationMessage' smart constructor.
data ValidationMessage = ValidationMessage'
    { _vmOptionName :: !(Maybe Text)
    , _vmSeverity   :: !(Maybe ValidationSeverity)
    , _vmNamespace  :: !(Maybe Text)
    , _vmMessage    :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ValidationMessage' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'vmOptionName'
--
-- * 'vmSeverity'
--
-- * 'vmNamespace'
--
-- * 'vmMessage'
validationMessage
    :: ValidationMessage
validationMessage =
    ValidationMessage'
    { _vmOptionName = Nothing
    , _vmSeverity = Nothing
    , _vmNamespace = Nothing
    , _vmMessage = Nothing
    }

-- |
vmOptionName :: Lens' ValidationMessage (Maybe Text)
vmOptionName = lens _vmOptionName (\ s a -> s{_vmOptionName = a});

-- | An indication of the severity of this message:
--
-- -   'error': This message indicates that this is not a valid setting for an option.
-- -   'warning': This message is providing information you should take into account.
vmSeverity :: Lens' ValidationMessage (Maybe ValidationSeverity)
vmSeverity = lens _vmSeverity (\ s a -> s{_vmSeverity = a});

-- |
vmNamespace :: Lens' ValidationMessage (Maybe Text)
vmNamespace = lens _vmNamespace (\ s a -> s{_vmNamespace = a});

-- | A message describing the error or warning.
vmMessage :: Lens' ValidationMessage (Maybe Text)
vmMessage = lens _vmMessage (\ s a -> s{_vmMessage = a});

instance FromXML ValidationMessage where
        parseXML x
          = ValidationMessage' <$>
              (x .@? "OptionName") <*> (x .@? "Severity") <*>
                (x .@? "Namespace")
                <*> (x .@? "Message")

instance Hashable ValidationMessage

instance NFData ValidationMessage