{-# 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.Glacier.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.Glacier.Types.Product where

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

-- | Contains the Amazon Glacier response to your request.
--
-- For information about the underlying REST API, go to <http://docs.aws.amazon.com/amazonglacier/latest/dev/api-archive-post.html Upload Archive>. For conceptual information, go to <http://docs.aws.amazon.com/amazonglacier/latest/dev/working-with-archives.html Working with Archives in Amazon Glacier>.
--
-- /See:/ 'archiveCreationOutput' smart constructor.
data ArchiveCreationOutput = ArchiveCreationOutput'
    { _acoArchiveId :: !(Maybe Text)
    , _acoChecksum  :: !(Maybe Text)
    , _acoLocation  :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'ArchiveCreationOutput' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'acoArchiveId'
--
-- * 'acoChecksum'
--
-- * 'acoLocation'
archiveCreationOutput
    :: ArchiveCreationOutput
archiveCreationOutput =
    ArchiveCreationOutput'
    { _acoArchiveId = Nothing
    , _acoChecksum = Nothing
    , _acoLocation = Nothing
    }

-- | The ID of the archive. This value is also included as part of the location.
acoArchiveId :: Lens' ArchiveCreationOutput (Maybe Text)
acoArchiveId = lens _acoArchiveId (\ s a -> s{_acoArchiveId = a});

-- | The checksum of the archive computed by Amazon Glacier.
acoChecksum :: Lens' ArchiveCreationOutput (Maybe Text)
acoChecksum = lens _acoChecksum (\ s a -> s{_acoChecksum = a});

-- | The relative URI path of the newly added archive resource.
acoLocation :: Lens' ArchiveCreationOutput (Maybe Text)
acoLocation = lens _acoLocation (\ s a -> s{_acoLocation = a});

instance FromJSON ArchiveCreationOutput where
        parseJSON
          = withObject "ArchiveCreationOutput"
              (\ x ->
                 ArchiveCreationOutput' <$>
                   (x .:? "x-amz-archive-id") <*>
                     (x .:? "x-amz-sha256-tree-hash")
                     <*> (x .:? "Location"))

instance Hashable ArchiveCreationOutput

instance NFData ArchiveCreationOutput

-- | Data retrieval policy.
--
-- /See:/ 'dataRetrievalPolicy' smart constructor.
newtype DataRetrievalPolicy = DataRetrievalPolicy'
    { _drpRules :: Maybe [DataRetrievalRule]
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'DataRetrievalPolicy' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'drpRules'
dataRetrievalPolicy
    :: DataRetrievalPolicy
dataRetrievalPolicy =
    DataRetrievalPolicy'
    { _drpRules = Nothing
    }

-- | The policy rule. Although this is a list type, currently there must be only one rule, which contains a Strategy field and optionally a BytesPerHour field.
drpRules :: Lens' DataRetrievalPolicy [DataRetrievalRule]
drpRules = lens _drpRules (\ s a -> s{_drpRules = a}) . _Default . _Coerce;

instance FromJSON DataRetrievalPolicy where
        parseJSON
          = withObject "DataRetrievalPolicy"
              (\ x ->
                 DataRetrievalPolicy' <$> (x .:? "Rules" .!= mempty))

instance Hashable DataRetrievalPolicy

instance NFData DataRetrievalPolicy

instance ToJSON DataRetrievalPolicy where
        toJSON DataRetrievalPolicy'{..}
          = object (catMaybes [("Rules" .=) <$> _drpRules])

-- | Data retrieval policy rule.
--
-- /See:/ 'dataRetrievalRule' smart constructor.
data DataRetrievalRule = DataRetrievalRule'
    { _drrStrategy     :: !(Maybe Text)
    , _drrBytesPerHour :: !(Maybe Integer)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'DataRetrievalRule' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'drrStrategy'
--
-- * 'drrBytesPerHour'
dataRetrievalRule
    :: DataRetrievalRule
dataRetrievalRule =
    DataRetrievalRule'
    { _drrStrategy = Nothing
    , _drrBytesPerHour = Nothing
    }

-- | The type of data retrieval policy to set.
--
-- Valid values: BytesPerHour|FreeTier|None
drrStrategy :: Lens' DataRetrievalRule (Maybe Text)
drrStrategy = lens _drrStrategy (\ s a -> s{_drrStrategy = a});

-- | The maximum number of bytes that can be retrieved in an hour.
--
-- This field is required only if the value of the Strategy field is 'BytesPerHour'. Your PUT operation will be rejected if the Strategy field is not set to 'BytesPerHour' and you set this field.
drrBytesPerHour :: Lens' DataRetrievalRule (Maybe Integer)
drrBytesPerHour = lens _drrBytesPerHour (\ s a -> s{_drrBytesPerHour = a});

instance FromJSON DataRetrievalRule where
        parseJSON
          = withObject "DataRetrievalRule"
              (\ x ->
                 DataRetrievalRule' <$>
                   (x .:? "Strategy") <*> (x .:? "BytesPerHour"))

instance Hashable DataRetrievalRule

instance NFData DataRetrievalRule

instance ToJSON DataRetrievalRule where
        toJSON DataRetrievalRule'{..}
          = object
              (catMaybes
                 [("Strategy" .=) <$> _drrStrategy,
                  ("BytesPerHour" .=) <$> _drrBytesPerHour])

-- | Contains the Amazon Glacier response to your request.
--
-- /See:/ 'describeVaultOutput' smart constructor.
data DescribeVaultOutput = DescribeVaultOutput'
    { _dvoVaultName         :: !(Maybe Text)
    , _dvoSizeInBytes       :: !(Maybe Integer)
    , _dvoLastInventoryDate :: !(Maybe Text)
    , _dvoVaultARN          :: !(Maybe Text)
    , _dvoCreationDate      :: !(Maybe Text)
    , _dvoNumberOfArchives  :: !(Maybe Integer)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'DescribeVaultOutput' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'dvoVaultName'
--
-- * 'dvoSizeInBytes'
--
-- * 'dvoLastInventoryDate'
--
-- * 'dvoVaultARN'
--
-- * 'dvoCreationDate'
--
-- * 'dvoNumberOfArchives'
describeVaultOutput
    :: DescribeVaultOutput
describeVaultOutput =
    DescribeVaultOutput'
    { _dvoVaultName = Nothing
    , _dvoSizeInBytes = Nothing
    , _dvoLastInventoryDate = Nothing
    , _dvoVaultARN = Nothing
    , _dvoCreationDate = Nothing
    , _dvoNumberOfArchives = Nothing
    }

-- | The name of the vault.
dvoVaultName :: Lens' DescribeVaultOutput (Maybe Text)
dvoVaultName = lens _dvoVaultName (\ s a -> s{_dvoVaultName = a});

-- | Total size, in bytes, of the archives in the vault as of the last inventory date. This field will return null if an inventory has not yet run on the vault, for example, if you just created the vault.
dvoSizeInBytes :: Lens' DescribeVaultOutput (Maybe Integer)
dvoSizeInBytes = lens _dvoSizeInBytes (\ s a -> s{_dvoSizeInBytes = a});

-- | The UTC date when Amazon Glacier completed the last vault inventory. A string representation of ISO 8601 date format, for example, \"2012-03-20T17:03:43.221Z\".
dvoLastInventoryDate :: Lens' DescribeVaultOutput (Maybe Text)
dvoLastInventoryDate = lens _dvoLastInventoryDate (\ s a -> s{_dvoLastInventoryDate = a});

-- | The Amazon Resource Name (ARN) of the vault.
dvoVaultARN :: Lens' DescribeVaultOutput (Maybe Text)
dvoVaultARN = lens _dvoVaultARN (\ s a -> s{_dvoVaultARN = a});

-- | The UTC date when the vault was created. A string representation of ISO 8601 date format, for example, \"2012-03-20T17:03:43.221Z\".
dvoCreationDate :: Lens' DescribeVaultOutput (Maybe Text)
dvoCreationDate = lens _dvoCreationDate (\ s a -> s{_dvoCreationDate = a});

-- | The number of archives in the vault as of the last inventory date. This field will return 'null' if an inventory has not yet run on the vault, for example, if you just created the vault.
dvoNumberOfArchives :: Lens' DescribeVaultOutput (Maybe Integer)
dvoNumberOfArchives = lens _dvoNumberOfArchives (\ s a -> s{_dvoNumberOfArchives = a});

instance FromJSON DescribeVaultOutput where
        parseJSON
          = withObject "DescribeVaultOutput"
              (\ x ->
                 DescribeVaultOutput' <$>
                   (x .:? "VaultName") <*> (x .:? "SizeInBytes") <*>
                     (x .:? "LastInventoryDate")
                     <*> (x .:? "VaultARN")
                     <*> (x .:? "CreationDate")
                     <*> (x .:? "NumberOfArchives"))

instance Hashable DescribeVaultOutput

instance NFData DescribeVaultOutput

-- | Describes an Amazon Glacier job.
--
-- /See:/ 'glacierJobDescription' smart constructor.
data GlacierJobDescription = GlacierJobDescription'
    { _gjdSHA256TreeHash               :: !(Maybe Text)
    , _gjdArchiveId                    :: !(Maybe Text)
    , _gjdJobId                        :: !(Maybe Text)
    , _gjdRetrievalByteRange           :: !(Maybe Text)
    , _gjdInventoryRetrievalParameters :: !(Maybe InventoryRetrievalJobDescription)
    , _gjdAction                       :: !(Maybe ActionCode)
    , _gjdJobDescription               :: !(Maybe Text)
    , _gjdSNSTopic                     :: !(Maybe Text)
    , _gjdStatusMessage                :: !(Maybe Text)
    , _gjdVaultARN                     :: !(Maybe Text)
    , _gjdArchiveSHA256TreeHash        :: !(Maybe Text)
    , _gjdCreationDate                 :: !(Maybe Text)
    , _gjdCompleted                    :: !(Maybe Bool)
    , _gjdCompletionDate               :: !(Maybe Text)
    , _gjdInventorySizeInBytes         :: !(Maybe Integer)
    , _gjdArchiveSizeInBytes           :: !(Maybe Integer)
    , _gjdStatusCode                   :: !(Maybe StatusCode)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'GlacierJobDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'gjdSHA256TreeHash'
--
-- * 'gjdArchiveId'
--
-- * 'gjdJobId'
--
-- * 'gjdRetrievalByteRange'
--
-- * 'gjdInventoryRetrievalParameters'
--
-- * 'gjdAction'
--
-- * 'gjdJobDescription'
--
-- * 'gjdSNSTopic'
--
-- * 'gjdStatusMessage'
--
-- * 'gjdVaultARN'
--
-- * 'gjdArchiveSHA256TreeHash'
--
-- * 'gjdCreationDate'
--
-- * 'gjdCompleted'
--
-- * 'gjdCompletionDate'
--
-- * 'gjdInventorySizeInBytes'
--
-- * 'gjdArchiveSizeInBytes'
--
-- * 'gjdStatusCode'
glacierJobDescription
    :: GlacierJobDescription
glacierJobDescription =
    GlacierJobDescription'
    { _gjdSHA256TreeHash = Nothing
    , _gjdArchiveId = Nothing
    , _gjdJobId = Nothing
    , _gjdRetrievalByteRange = Nothing
    , _gjdInventoryRetrievalParameters = Nothing
    , _gjdAction = Nothing
    , _gjdJobDescription = Nothing
    , _gjdSNSTopic = Nothing
    , _gjdStatusMessage = Nothing
    , _gjdVaultARN = Nothing
    , _gjdArchiveSHA256TreeHash = Nothing
    , _gjdCreationDate = Nothing
    , _gjdCompleted = Nothing
    , _gjdCompletionDate = Nothing
    , _gjdInventorySizeInBytes = Nothing
    , _gjdArchiveSizeInBytes = Nothing
    , _gjdStatusCode = Nothing
    }

-- | For an ArchiveRetrieval job, it is the checksum of the archive. Otherwise, the value is null.
--
-- The SHA256 tree hash value for the requested range of an archive. If the Initiate a Job request for an archive specified a tree-hash aligned range, then this field returns a value.
--
-- For the specific case when the whole archive is retrieved, this value is the same as the ArchiveSHA256TreeHash value.
--
-- This field is null in the following situations:
--
-- -   Archive retrieval jobs that specify a range that is not tree-hash aligned.
--
-- -   Archival jobs that specify a range that is equal to the whole archive and the job status is InProgress.
--
-- -   Inventory jobs.
--
gjdSHA256TreeHash :: Lens' GlacierJobDescription (Maybe Text)
gjdSHA256TreeHash = lens _gjdSHA256TreeHash (\ s a -> s{_gjdSHA256TreeHash = a});

-- | For an ArchiveRetrieval job, this is the archive ID requested for download. Otherwise, this field is null.
gjdArchiveId :: Lens' GlacierJobDescription (Maybe Text)
gjdArchiveId = lens _gjdArchiveId (\ s a -> s{_gjdArchiveId = a});

-- | An opaque string that identifies an Amazon Glacier job.
gjdJobId :: Lens' GlacierJobDescription (Maybe Text)
gjdJobId = lens _gjdJobId (\ s a -> s{_gjdJobId = a});

-- | The retrieved byte range for archive retrieval jobs in the form \"/StartByteValue/-/EndByteValue/\" If no range was specified in the archive retrieval, then the whole archive is retrieved and /StartByteValue/ equals 0 and /EndByteValue/ equals the size of the archive minus 1. For inventory retrieval jobs this field is null.
gjdRetrievalByteRange :: Lens' GlacierJobDescription (Maybe Text)
gjdRetrievalByteRange = lens _gjdRetrievalByteRange (\ s a -> s{_gjdRetrievalByteRange = a});

-- | Parameters used for range inventory retrieval.
gjdInventoryRetrievalParameters :: Lens' GlacierJobDescription (Maybe InventoryRetrievalJobDescription)
gjdInventoryRetrievalParameters = lens _gjdInventoryRetrievalParameters (\ s a -> s{_gjdInventoryRetrievalParameters = a});

-- | The job type. It is either ArchiveRetrieval or InventoryRetrieval.
gjdAction :: Lens' GlacierJobDescription (Maybe ActionCode)
gjdAction = lens _gjdAction (\ s a -> s{_gjdAction = a});

-- | The job description you provided when you initiated the job.
gjdJobDescription :: Lens' GlacierJobDescription (Maybe Text)
gjdJobDescription = lens _gjdJobDescription (\ s a -> s{_gjdJobDescription = a});

-- | An Amazon Simple Notification Service (Amazon SNS) topic that receives notification.
gjdSNSTopic :: Lens' GlacierJobDescription (Maybe Text)
gjdSNSTopic = lens _gjdSNSTopic (\ s a -> s{_gjdSNSTopic = a});

-- | A friendly message that describes the job status.
gjdStatusMessage :: Lens' GlacierJobDescription (Maybe Text)
gjdStatusMessage = lens _gjdStatusMessage (\ s a -> s{_gjdStatusMessage = a});

-- | The Amazon Resource Name (ARN) of the vault from which the archive retrieval was requested.
gjdVaultARN :: Lens' GlacierJobDescription (Maybe Text)
gjdVaultARN = lens _gjdVaultARN (\ s a -> s{_gjdVaultARN = a});

-- | The SHA256 tree hash of the entire archive for an archive retrieval. For inventory retrieval jobs, this field is null.
gjdArchiveSHA256TreeHash :: Lens' GlacierJobDescription (Maybe Text)
gjdArchiveSHA256TreeHash = lens _gjdArchiveSHA256TreeHash (\ s a -> s{_gjdArchiveSHA256TreeHash = a});

-- | The UTC date when the job was created. A string representation of ISO 8601 date format, for example, \"2012-03-20T17:03:43.221Z\".
gjdCreationDate :: Lens' GlacierJobDescription (Maybe Text)
gjdCreationDate = lens _gjdCreationDate (\ s a -> s{_gjdCreationDate = a});

-- | The job status. When a job is completed, you get the job\'s output.
gjdCompleted :: Lens' GlacierJobDescription (Maybe Bool)
gjdCompleted = lens _gjdCompleted (\ s a -> s{_gjdCompleted = a});

-- | The UTC time that the archive retrieval request completed. While the job is in progress, the value will be null.
gjdCompletionDate :: Lens' GlacierJobDescription (Maybe Text)
gjdCompletionDate = lens _gjdCompletionDate (\ s a -> s{_gjdCompletionDate = a});

-- | For an InventoryRetrieval job, this is the size in bytes of the inventory requested for download. For the ArchiveRetrieval job, the value is null.
gjdInventorySizeInBytes :: Lens' GlacierJobDescription (Maybe Integer)
gjdInventorySizeInBytes = lens _gjdInventorySizeInBytes (\ s a -> s{_gjdInventorySizeInBytes = a});

-- | For an ArchiveRetrieval job, this is the size in bytes of the archive being requested for download. For the InventoryRetrieval job, the value is null.
gjdArchiveSizeInBytes :: Lens' GlacierJobDescription (Maybe Integer)
gjdArchiveSizeInBytes = lens _gjdArchiveSizeInBytes (\ s a -> s{_gjdArchiveSizeInBytes = a});

-- | The status code can be InProgress, Succeeded, or Failed, and indicates the status of the job.
gjdStatusCode :: Lens' GlacierJobDescription (Maybe StatusCode)
gjdStatusCode = lens _gjdStatusCode (\ s a -> s{_gjdStatusCode = a});

instance FromJSON GlacierJobDescription where
        parseJSON
          = withObject "GlacierJobDescription"
              (\ x ->
                 GlacierJobDescription' <$>
                   (x .:? "SHA256TreeHash") <*> (x .:? "ArchiveId") <*>
                     (x .:? "JobId")
                     <*> (x .:? "RetrievalByteRange")
                     <*> (x .:? "InventoryRetrievalParameters")
                     <*> (x .:? "Action")
                     <*> (x .:? "JobDescription")
                     <*> (x .:? "SNSTopic")
                     <*> (x .:? "StatusMessage")
                     <*> (x .:? "VaultARN")
                     <*> (x .:? "ArchiveSHA256TreeHash")
                     <*> (x .:? "CreationDate")
                     <*> (x .:? "Completed")
                     <*> (x .:? "CompletionDate")
                     <*> (x .:? "InventorySizeInBytes")
                     <*> (x .:? "ArchiveSizeInBytes")
                     <*> (x .:? "StatusCode"))

instance Hashable GlacierJobDescription

instance NFData GlacierJobDescription

-- | Describes the options for a range inventory retrieval job.
--
-- /See:/ 'inventoryRetrievalJobDescription' smart constructor.
data InventoryRetrievalJobDescription = InventoryRetrievalJobDescription'
    { _irjdFormat    :: !(Maybe Text)
    , _irjdEndDate   :: !(Maybe Text)
    , _irjdStartDate :: !(Maybe Text)
    , _irjdMarker    :: !(Maybe Text)
    , _irjdLimit     :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'InventoryRetrievalJobDescription' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'irjdFormat'
--
-- * 'irjdEndDate'
--
-- * 'irjdStartDate'
--
-- * 'irjdMarker'
--
-- * 'irjdLimit'
inventoryRetrievalJobDescription
    :: InventoryRetrievalJobDescription
inventoryRetrievalJobDescription =
    InventoryRetrievalJobDescription'
    { _irjdFormat = Nothing
    , _irjdEndDate = Nothing
    , _irjdStartDate = Nothing
    , _irjdMarker = Nothing
    , _irjdLimit = Nothing
    }

-- | The output format for the vault inventory list, which is set by the __InitiateJob__ request when initiating a job to retrieve a vault inventory. Valid values are \"CSV\" and \"JSON\".
irjdFormat :: Lens' InventoryRetrievalJobDescription (Maybe Text)
irjdFormat = lens _irjdFormat (\ s a -> s{_irjdFormat = a});

-- | The end of the date range in UTC for vault inventory retrieval that includes archives created before this date. A string representation of ISO 8601 date format, for example, 2013-03-20T17:03:43Z.
irjdEndDate :: Lens' InventoryRetrievalJobDescription (Maybe Text)
irjdEndDate = lens _irjdEndDate (\ s a -> s{_irjdEndDate = a});

-- | The start of the date range in UTC for vault inventory retrieval that includes archives created on or after this date. A string representation of ISO 8601 date format, for example, 2013-03-20T17:03:43Z.
irjdStartDate :: Lens' InventoryRetrievalJobDescription (Maybe Text)
irjdStartDate = lens _irjdStartDate (\ s a -> s{_irjdStartDate = a});

-- | An opaque string that represents where to continue pagination of the vault inventory retrieval results. You use the marker in a new __InitiateJob__ request to obtain additional inventory items. If there are no more inventory items, this value is 'null'. For more information, see <http://docs.aws.amazon.com/amazonglacier/latest/dev/api-initiate-job-post.html#api-initiate-job-post-vault-inventory-list-filtering Range Inventory Retrieval>.
irjdMarker :: Lens' InventoryRetrievalJobDescription (Maybe Text)
irjdMarker = lens _irjdMarker (\ s a -> s{_irjdMarker = a});

-- | Specifies the maximum number of inventory items returned per vault inventory retrieval request. This limit is set when initiating the job with the a __InitiateJob__ request.
irjdLimit :: Lens' InventoryRetrievalJobDescription (Maybe Text)
irjdLimit = lens _irjdLimit (\ s a -> s{_irjdLimit = a});

instance FromJSON InventoryRetrievalJobDescription
         where
        parseJSON
          = withObject "InventoryRetrievalJobDescription"
              (\ x ->
                 InventoryRetrievalJobDescription' <$>
                   (x .:? "Format") <*> (x .:? "EndDate") <*>
                     (x .:? "StartDate")
                     <*> (x .:? "Marker")
                     <*> (x .:? "Limit"))

instance Hashable InventoryRetrievalJobDescription

instance NFData InventoryRetrievalJobDescription

-- | Provides options for specifying a range inventory retrieval job.
--
-- /See:/ 'inventoryRetrievalJobInput' smart constructor.
data InventoryRetrievalJobInput = InventoryRetrievalJobInput'
    { _irjiEndDate   :: !(Maybe Text)
    , _irjiStartDate :: !(Maybe Text)
    , _irjiMarker    :: !(Maybe Text)
    , _irjiLimit     :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'InventoryRetrievalJobInput' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'irjiEndDate'
--
-- * 'irjiStartDate'
--
-- * 'irjiMarker'
--
-- * 'irjiLimit'
inventoryRetrievalJobInput
    :: InventoryRetrievalJobInput
inventoryRetrievalJobInput =
    InventoryRetrievalJobInput'
    { _irjiEndDate = Nothing
    , _irjiStartDate = Nothing
    , _irjiMarker = Nothing
    , _irjiLimit = Nothing
    }

-- | The end of the date range in UTC for vault inventory retrieval that includes archives created before this date. A string representation of ISO 8601 date format, for example, 2013-03-20T17:03:43Z.
irjiEndDate :: Lens' InventoryRetrievalJobInput (Maybe Text)
irjiEndDate = lens _irjiEndDate (\ s a -> s{_irjiEndDate = a});

-- | The start of the date range in UTC for vault inventory retrieval that includes archives created on or after this date. A string representation of ISO 8601 date format, for example, 2013-03-20T17:03:43Z.
irjiStartDate :: Lens' InventoryRetrievalJobInput (Maybe Text)
irjiStartDate = lens _irjiStartDate (\ s a -> s{_irjiStartDate = a});

-- | An opaque string that represents where to continue pagination of the vault inventory retrieval results. You use the marker in a new __InitiateJob__ request to obtain additional inventory items. If there are no more inventory items, this value is 'null'.
irjiMarker :: Lens' InventoryRetrievalJobInput (Maybe Text)
irjiMarker = lens _irjiMarker (\ s a -> s{_irjiMarker = a});

-- | Specifies the maximum number of inventory items returned per vault inventory retrieval request. Valid values are greater than or equal to 1.
irjiLimit :: Lens' InventoryRetrievalJobInput (Maybe Text)
irjiLimit = lens _irjiLimit (\ s a -> s{_irjiLimit = a});

instance Hashable InventoryRetrievalJobInput

instance NFData InventoryRetrievalJobInput

instance ToJSON InventoryRetrievalJobInput where
        toJSON InventoryRetrievalJobInput'{..}
          = object
              (catMaybes
                 [("EndDate" .=) <$> _irjiEndDate,
                  ("StartDate" .=) <$> _irjiStartDate,
                  ("Marker" .=) <$> _irjiMarker,
                  ("Limit" .=) <$> _irjiLimit])

-- | Provides options for defining a job.
--
-- /See:/ 'jobParameters' smart constructor.
data JobParameters = JobParameters'
    { _jpArchiveId                    :: !(Maybe Text)
    , _jpFormat                       :: !(Maybe Text)
    , _jpRetrievalByteRange           :: !(Maybe Text)
    , _jpInventoryRetrievalParameters :: !(Maybe InventoryRetrievalJobInput)
    , _jpSNSTopic                     :: !(Maybe Text)
    , _jpType                         :: !(Maybe Text)
    , _jpDescription                  :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'JobParameters' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'jpArchiveId'
--
-- * 'jpFormat'
--
-- * 'jpRetrievalByteRange'
--
-- * 'jpInventoryRetrievalParameters'
--
-- * 'jpSNSTopic'
--
-- * 'jpType'
--
-- * 'jpDescription'
jobParameters
    :: JobParameters
jobParameters =
    JobParameters'
    { _jpArchiveId = Nothing
    , _jpFormat = Nothing
    , _jpRetrievalByteRange = Nothing
    , _jpInventoryRetrievalParameters = Nothing
    , _jpSNSTopic = Nothing
    , _jpType = Nothing
    , _jpDescription = Nothing
    }

-- | The ID of the archive that you want to retrieve. This field is required only if 'Type' is set to archive-retrieval. An error occurs if you specify this request parameter for an inventory retrieval job request.
jpArchiveId :: Lens' JobParameters (Maybe Text)
jpArchiveId = lens _jpArchiveId (\ s a -> s{_jpArchiveId = a});

-- | When initiating a job to retrieve a vault inventory, you can optionally add this parameter to your request to specify the output format. If you are initiating an inventory job and do not specify a Format field, JSON is the default format. Valid values are \"CSV\" and \"JSON\".
jpFormat :: Lens' JobParameters (Maybe Text)
jpFormat = lens _jpFormat (\ s a -> s{_jpFormat = a});

-- | The byte range to retrieve for an archive retrieval. in the form \"/StartByteValue/-/EndByteValue/\" If not specified, the whole archive is retrieved. If specified, the byte range must be megabyte (1024*1024) aligned which means that /StartByteValue/ must be divisible by 1 MB and /EndByteValue/ plus 1 must be divisible by 1 MB or be the end of the archive specified as the archive byte size value minus 1. If RetrievalByteRange is not megabyte aligned, this operation returns a 400 response.
--
-- An error occurs if you specify this field for an inventory retrieval job request.
jpRetrievalByteRange :: Lens' JobParameters (Maybe Text)
jpRetrievalByteRange = lens _jpRetrievalByteRange (\ s a -> s{_jpRetrievalByteRange = a});

-- | Input parameters used for range inventory retrieval.
jpInventoryRetrievalParameters :: Lens' JobParameters (Maybe InventoryRetrievalJobInput)
jpInventoryRetrievalParameters = lens _jpInventoryRetrievalParameters (\ s a -> s{_jpInventoryRetrievalParameters = a});

-- | The Amazon SNS topic ARN to which Amazon Glacier sends a notification when the job is completed and the output is ready for you to download. The specified topic publishes the notification to its subscribers. The SNS topic must exist.
jpSNSTopic :: Lens' JobParameters (Maybe Text)
jpSNSTopic = lens _jpSNSTopic (\ s a -> s{_jpSNSTopic = a});

-- | The job type. You can initiate a job to retrieve an archive or get an inventory of a vault. Valid values are \"archive-retrieval\" and \"inventory-retrieval\".
jpType :: Lens' JobParameters (Maybe Text)
jpType = lens _jpType (\ s a -> s{_jpType = a});

-- | The optional description for the job. The description must be less than or equal to 1,024 bytes. The allowable characters are 7-bit ASCII without control codes-specifically, ASCII values 32-126 decimal or 0x20-0x7E hexadecimal.
jpDescription :: Lens' JobParameters (Maybe Text)
jpDescription = lens _jpDescription (\ s a -> s{_jpDescription = a});

instance Hashable JobParameters

instance NFData JobParameters

instance ToJSON JobParameters where
        toJSON JobParameters'{..}
          = object
              (catMaybes
                 [("ArchiveId" .=) <$> _jpArchiveId,
                  ("Format" .=) <$> _jpFormat,
                  ("RetrievalByteRange" .=) <$> _jpRetrievalByteRange,
                  ("InventoryRetrievalParameters" .=) <$>
                    _jpInventoryRetrievalParameters,
                  ("SNSTopic" .=) <$> _jpSNSTopic,
                  ("Type" .=) <$> _jpType,
                  ("Description" .=) <$> _jpDescription])

-- | A list of the part sizes of the multipart upload.
--
-- /See:/ 'partListElement' smart constructor.
data PartListElement = PartListElement'
    { _pleSHA256TreeHash :: !(Maybe Text)
    , _pleRangeInBytes   :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'PartListElement' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'pleSHA256TreeHash'
--
-- * 'pleRangeInBytes'
partListElement
    :: PartListElement
partListElement =
    PartListElement'
    { _pleSHA256TreeHash = Nothing
    , _pleRangeInBytes = Nothing
    }

-- | The SHA256 tree hash value that Amazon Glacier calculated for the part. This field is never 'null'.
pleSHA256TreeHash :: Lens' PartListElement (Maybe Text)
pleSHA256TreeHash = lens _pleSHA256TreeHash (\ s a -> s{_pleSHA256TreeHash = a});

-- | The byte range of a part, inclusive of the upper value of the range.
pleRangeInBytes :: Lens' PartListElement (Maybe Text)
pleRangeInBytes = lens _pleRangeInBytes (\ s a -> s{_pleRangeInBytes = a});

instance FromJSON PartListElement where
        parseJSON
          = withObject "PartListElement"
              (\ x ->
                 PartListElement' <$>
                   (x .:? "SHA256TreeHash") <*> (x .:? "RangeInBytes"))

instance Hashable PartListElement

instance NFData PartListElement

-- | A list of in-progress multipart uploads for a vault.
--
-- /See:/ 'uploadListElement' smart constructor.
data UploadListElement = UploadListElement'
    { _uleMultipartUploadId  :: !(Maybe Text)
    , _ulePartSizeInBytes    :: !(Maybe Integer)
    , _uleArchiveDescription :: !(Maybe Text)
    , _uleVaultARN           :: !(Maybe Text)
    , _uleCreationDate       :: !(Maybe Text)
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'UploadListElement' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'uleMultipartUploadId'
--
-- * 'ulePartSizeInBytes'
--
-- * 'uleArchiveDescription'
--
-- * 'uleVaultARN'
--
-- * 'uleCreationDate'
uploadListElement
    :: UploadListElement
uploadListElement =
    UploadListElement'
    { _uleMultipartUploadId = Nothing
    , _ulePartSizeInBytes = Nothing
    , _uleArchiveDescription = Nothing
    , _uleVaultARN = Nothing
    , _uleCreationDate = Nothing
    }

-- | The ID of a multipart upload.
uleMultipartUploadId :: Lens' UploadListElement (Maybe Text)
uleMultipartUploadId = lens _uleMultipartUploadId (\ s a -> s{_uleMultipartUploadId = a});

-- | The part size, in bytes, specified in the Initiate Multipart Upload request. This is the size of all the parts in the upload except the last part, which may be smaller than this size.
ulePartSizeInBytes :: Lens' UploadListElement (Maybe Integer)
ulePartSizeInBytes = lens _ulePartSizeInBytes (\ s a -> s{_ulePartSizeInBytes = a});

-- | The description of the archive that was specified in the Initiate Multipart Upload request.
uleArchiveDescription :: Lens' UploadListElement (Maybe Text)
uleArchiveDescription = lens _uleArchiveDescription (\ s a -> s{_uleArchiveDescription = a});

-- | The Amazon Resource Name (ARN) of the vault that contains the archive.
uleVaultARN :: Lens' UploadListElement (Maybe Text)
uleVaultARN = lens _uleVaultARN (\ s a -> s{_uleVaultARN = a});

-- | The UTC time at which the multipart upload was initiated.
uleCreationDate :: Lens' UploadListElement (Maybe Text)
uleCreationDate = lens _uleCreationDate (\ s a -> s{_uleCreationDate = a});

instance FromJSON UploadListElement where
        parseJSON
          = withObject "UploadListElement"
              (\ x ->
                 UploadListElement' <$>
                   (x .:? "MultipartUploadId") <*>
                     (x .:? "PartSizeInBytes")
                     <*> (x .:? "ArchiveDescription")
                     <*> (x .:? "VaultARN")
                     <*> (x .:? "CreationDate"))

instance Hashable UploadListElement

instance NFData UploadListElement

-- | Contains the vault access policy.
--
-- /See:/ 'vaultAccessPolicy' smart constructor.
newtype VaultAccessPolicy = VaultAccessPolicy'
    { _vapPolicy :: Maybe Text
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'VaultAccessPolicy' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'vapPolicy'
vaultAccessPolicy
    :: VaultAccessPolicy
vaultAccessPolicy =
    VaultAccessPolicy'
    { _vapPolicy = Nothing
    }

-- | The vault access policy.
vapPolicy :: Lens' VaultAccessPolicy (Maybe Text)
vapPolicy = lens _vapPolicy (\ s a -> s{_vapPolicy = a});

instance FromJSON VaultAccessPolicy where
        parseJSON
          = withObject "VaultAccessPolicy"
              (\ x -> VaultAccessPolicy' <$> (x .:? "Policy"))

instance Hashable VaultAccessPolicy

instance NFData VaultAccessPolicy

instance ToJSON VaultAccessPolicy where
        toJSON VaultAccessPolicy'{..}
          = object (catMaybes [("Policy" .=) <$> _vapPolicy])

-- | Contains the vault lock policy.
--
-- /See:/ 'vaultLockPolicy' smart constructor.
newtype VaultLockPolicy = VaultLockPolicy'
    { _vlpPolicy :: Maybe Text
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'VaultLockPolicy' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'vlpPolicy'
vaultLockPolicy
    :: VaultLockPolicy
vaultLockPolicy =
    VaultLockPolicy'
    { _vlpPolicy = Nothing
    }

-- | The vault lock policy.
vlpPolicy :: Lens' VaultLockPolicy (Maybe Text)
vlpPolicy = lens _vlpPolicy (\ s a -> s{_vlpPolicy = a});

instance Hashable VaultLockPolicy

instance NFData VaultLockPolicy

instance ToJSON VaultLockPolicy where
        toJSON VaultLockPolicy'{..}
          = object (catMaybes [("Policy" .=) <$> _vlpPolicy])

-- | Represents a vault\'s notification configuration.
--
-- /See:/ 'vaultNotificationConfig' smart constructor.
data VaultNotificationConfig = VaultNotificationConfig'
    { _vncSNSTopic :: !(Maybe Text)
    , _vncEvents   :: !(Maybe [Text])
    } deriving (Eq,Read,Show,Data,Typeable,Generic)

-- | Creates a value of 'VaultNotificationConfig' with the minimum fields required to make a request.
--
-- Use one of the following lenses to modify other fields as desired:
--
-- * 'vncSNSTopic'
--
-- * 'vncEvents'
vaultNotificationConfig
    :: VaultNotificationConfig
vaultNotificationConfig =
    VaultNotificationConfig'
    { _vncSNSTopic = Nothing
    , _vncEvents = Nothing
    }

-- | The Amazon Simple Notification Service (Amazon SNS) topic Amazon Resource Name (ARN).
vncSNSTopic :: Lens' VaultNotificationConfig (Maybe Text)
vncSNSTopic = lens _vncSNSTopic (\ s a -> s{_vncSNSTopic = a});

-- | A list of one or more events for which Amazon Glacier will send a notification to the specified Amazon SNS topic.
vncEvents :: Lens' VaultNotificationConfig [Text]
vncEvents = lens _vncEvents (\ s a -> s{_vncEvents = a}) . _Default . _Coerce;

instance FromJSON VaultNotificationConfig where
        parseJSON
          = withObject "VaultNotificationConfig"
              (\ x ->
                 VaultNotificationConfig' <$>
                   (x .:? "SNSTopic") <*> (x .:? "Events" .!= mempty))

instance Hashable VaultNotificationConfig

instance NFData VaultNotificationConfig

instance ToJSON VaultNotificationConfig where
        toJSON VaultNotificationConfig'{..}
          = object
              (catMaybes
                 [("SNSTopic" .=) <$> _vncSNSTopic,
                  ("Events" .=) <$> _vncEvents])