module Network.AWS.ElasticSearch.Types.Product where
import Network.AWS.ElasticSearch.Types.Sum
import Network.AWS.Lens
import Network.AWS.Prelude
data AccessPoliciesStatus = AccessPoliciesStatus'
{ _apsOptions :: !Text
, _apsStatus :: !OptionStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
accessPoliciesStatus
:: Text
-> OptionStatus
-> AccessPoliciesStatus
accessPoliciesStatus pOptions_ pStatus_ =
AccessPoliciesStatus' {_apsOptions = pOptions_, _apsStatus = pStatus_}
apsOptions :: Lens' AccessPoliciesStatus Text
apsOptions = lens _apsOptions (\ s a -> s{_apsOptions = a});
apsStatus :: Lens' AccessPoliciesStatus OptionStatus
apsStatus = lens _apsStatus (\ s a -> s{_apsStatus = a});
instance FromJSON AccessPoliciesStatus where
parseJSON
= withObject "AccessPoliciesStatus"
(\ x ->
AccessPoliciesStatus' <$>
(x .: "Options") <*> (x .: "Status"))
instance Hashable AccessPoliciesStatus where
instance NFData AccessPoliciesStatus where
data AdditionalLimit = AdditionalLimit'
{ _alLimitName :: !(Maybe Text)
, _alLimitValues :: !(Maybe [Text])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
additionalLimit
:: AdditionalLimit
additionalLimit =
AdditionalLimit' {_alLimitName = Nothing, _alLimitValues = Nothing}
alLimitName :: Lens' AdditionalLimit (Maybe Text)
alLimitName = lens _alLimitName (\ s a -> s{_alLimitName = a});
alLimitValues :: Lens' AdditionalLimit [Text]
alLimitValues = lens _alLimitValues (\ s a -> s{_alLimitValues = a}) . _Default . _Coerce;
instance FromJSON AdditionalLimit where
parseJSON
= withObject "AdditionalLimit"
(\ x ->
AdditionalLimit' <$>
(x .:? "LimitName") <*>
(x .:? "LimitValues" .!= mempty))
instance Hashable AdditionalLimit where
instance NFData AdditionalLimit where
data AdvancedOptionsStatus = AdvancedOptionsStatus'
{ _aosOptions :: !(Map Text Text)
, _aosStatus :: !OptionStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
advancedOptionsStatus
:: OptionStatus
-> AdvancedOptionsStatus
advancedOptionsStatus pStatus_ =
AdvancedOptionsStatus' {_aosOptions = mempty, _aosStatus = pStatus_}
aosOptions :: Lens' AdvancedOptionsStatus (HashMap Text Text)
aosOptions = lens _aosOptions (\ s a -> s{_aosOptions = a}) . _Map;
aosStatus :: Lens' AdvancedOptionsStatus OptionStatus
aosStatus = lens _aosStatus (\ s a -> s{_aosStatus = a});
instance FromJSON AdvancedOptionsStatus where
parseJSON
= withObject "AdvancedOptionsStatus"
(\ x ->
AdvancedOptionsStatus' <$>
(x .:? "Options" .!= mempty) <*> (x .: "Status"))
instance Hashable AdvancedOptionsStatus where
instance NFData AdvancedOptionsStatus where
newtype DomainInfo = DomainInfo'
{ _diDomainName :: Maybe Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
domainInfo
:: DomainInfo
domainInfo = DomainInfo' {_diDomainName = Nothing}
diDomainName :: Lens' DomainInfo (Maybe Text)
diDomainName = lens _diDomainName (\ s a -> s{_diDomainName = a});
instance FromJSON DomainInfo where
parseJSON
= withObject "DomainInfo"
(\ x -> DomainInfo' <$> (x .:? "DomainName"))
instance Hashable DomainInfo where
instance NFData DomainInfo where
data EBSOptions = EBSOptions'
{ _eoVolumeSize :: !(Maybe Int)
, _eoIOPS :: !(Maybe Int)
, _eoVolumeType :: !(Maybe VolumeType)
, _eoEBSEnabled :: !(Maybe Bool)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
ebsOptions
:: EBSOptions
ebsOptions =
EBSOptions'
{ _eoVolumeSize = Nothing
, _eoIOPS = Nothing
, _eoVolumeType = Nothing
, _eoEBSEnabled = Nothing
}
eoVolumeSize :: Lens' EBSOptions (Maybe Int)
eoVolumeSize = lens _eoVolumeSize (\ s a -> s{_eoVolumeSize = a});
eoIOPS :: Lens' EBSOptions (Maybe Int)
eoIOPS = lens _eoIOPS (\ s a -> s{_eoIOPS = a});
eoVolumeType :: Lens' EBSOptions (Maybe VolumeType)
eoVolumeType = lens _eoVolumeType (\ s a -> s{_eoVolumeType = a});
eoEBSEnabled :: Lens' EBSOptions (Maybe Bool)
eoEBSEnabled = lens _eoEBSEnabled (\ s a -> s{_eoEBSEnabled = a});
instance FromJSON EBSOptions where
parseJSON
= withObject "EBSOptions"
(\ x ->
EBSOptions' <$>
(x .:? "VolumeSize") <*> (x .:? "Iops") <*>
(x .:? "VolumeType")
<*> (x .:? "EBSEnabled"))
instance Hashable EBSOptions where
instance NFData EBSOptions where
instance ToJSON EBSOptions where
toJSON EBSOptions'{..}
= object
(catMaybes
[("VolumeSize" .=) <$> _eoVolumeSize,
("Iops" .=) <$> _eoIOPS,
("VolumeType" .=) <$> _eoVolumeType,
("EBSEnabled" .=) <$> _eoEBSEnabled])
data EBSOptionsStatus = EBSOptionsStatus'
{ _eosOptions :: !EBSOptions
, _eosStatus :: !OptionStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
ebsOptionsStatus
:: EBSOptions
-> OptionStatus
-> EBSOptionsStatus
ebsOptionsStatus pOptions_ pStatus_ =
EBSOptionsStatus' {_eosOptions = pOptions_, _eosStatus = pStatus_}
eosOptions :: Lens' EBSOptionsStatus EBSOptions
eosOptions = lens _eosOptions (\ s a -> s{_eosOptions = a});
eosStatus :: Lens' EBSOptionsStatus OptionStatus
eosStatus = lens _eosStatus (\ s a -> s{_eosStatus = a});
instance FromJSON EBSOptionsStatus where
parseJSON
= withObject "EBSOptionsStatus"
(\ x ->
EBSOptionsStatus' <$>
(x .: "Options") <*> (x .: "Status"))
instance Hashable EBSOptionsStatus where
instance NFData EBSOptionsStatus where
data ElasticsearchClusterConfig = ElasticsearchClusterConfig'
{ _eccDedicatedMasterCount :: !(Maybe Int)
, _eccDedicatedMasterType :: !(Maybe ESPartitionInstanceType)
, _eccDedicatedMasterEnabled :: !(Maybe Bool)
, _eccInstanceCount :: !(Maybe Int)
, _eccZoneAwarenessEnabled :: !(Maybe Bool)
, _eccInstanceType :: !(Maybe ESPartitionInstanceType)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
elasticsearchClusterConfig
:: ElasticsearchClusterConfig
elasticsearchClusterConfig =
ElasticsearchClusterConfig'
{ _eccDedicatedMasterCount = Nothing
, _eccDedicatedMasterType = Nothing
, _eccDedicatedMasterEnabled = Nothing
, _eccInstanceCount = Nothing
, _eccZoneAwarenessEnabled = Nothing
, _eccInstanceType = Nothing
}
eccDedicatedMasterCount :: Lens' ElasticsearchClusterConfig (Maybe Int)
eccDedicatedMasterCount = lens _eccDedicatedMasterCount (\ s a -> s{_eccDedicatedMasterCount = a});
eccDedicatedMasterType :: Lens' ElasticsearchClusterConfig (Maybe ESPartitionInstanceType)
eccDedicatedMasterType = lens _eccDedicatedMasterType (\ s a -> s{_eccDedicatedMasterType = a});
eccDedicatedMasterEnabled :: Lens' ElasticsearchClusterConfig (Maybe Bool)
eccDedicatedMasterEnabled = lens _eccDedicatedMasterEnabled (\ s a -> s{_eccDedicatedMasterEnabled = a});
eccInstanceCount :: Lens' ElasticsearchClusterConfig (Maybe Int)
eccInstanceCount = lens _eccInstanceCount (\ s a -> s{_eccInstanceCount = a});
eccZoneAwarenessEnabled :: Lens' ElasticsearchClusterConfig (Maybe Bool)
eccZoneAwarenessEnabled = lens _eccZoneAwarenessEnabled (\ s a -> s{_eccZoneAwarenessEnabled = a});
eccInstanceType :: Lens' ElasticsearchClusterConfig (Maybe ESPartitionInstanceType)
eccInstanceType = lens _eccInstanceType (\ s a -> s{_eccInstanceType = a});
instance FromJSON ElasticsearchClusterConfig where
parseJSON
= withObject "ElasticsearchClusterConfig"
(\ x ->
ElasticsearchClusterConfig' <$>
(x .:? "DedicatedMasterCount") <*>
(x .:? "DedicatedMasterType")
<*> (x .:? "DedicatedMasterEnabled")
<*> (x .:? "InstanceCount")
<*> (x .:? "ZoneAwarenessEnabled")
<*> (x .:? "InstanceType"))
instance Hashable ElasticsearchClusterConfig where
instance NFData ElasticsearchClusterConfig where
instance ToJSON ElasticsearchClusterConfig where
toJSON ElasticsearchClusterConfig'{..}
= object
(catMaybes
[("DedicatedMasterCount" .=) <$>
_eccDedicatedMasterCount,
("DedicatedMasterType" .=) <$>
_eccDedicatedMasterType,
("DedicatedMasterEnabled" .=) <$>
_eccDedicatedMasterEnabled,
("InstanceCount" .=) <$> _eccInstanceCount,
("ZoneAwarenessEnabled" .=) <$>
_eccZoneAwarenessEnabled,
("InstanceType" .=) <$> _eccInstanceType])
data ElasticsearchClusterConfigStatus = ElasticsearchClusterConfigStatus'
{ _eccsOptions :: !ElasticsearchClusterConfig
, _eccsStatus :: !OptionStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
elasticsearchClusterConfigStatus
:: ElasticsearchClusterConfig
-> OptionStatus
-> ElasticsearchClusterConfigStatus
elasticsearchClusterConfigStatus pOptions_ pStatus_ =
ElasticsearchClusterConfigStatus'
{_eccsOptions = pOptions_, _eccsStatus = pStatus_}
eccsOptions :: Lens' ElasticsearchClusterConfigStatus ElasticsearchClusterConfig
eccsOptions = lens _eccsOptions (\ s a -> s{_eccsOptions = a});
eccsStatus :: Lens' ElasticsearchClusterConfigStatus OptionStatus
eccsStatus = lens _eccsStatus (\ s a -> s{_eccsStatus = a});
instance FromJSON ElasticsearchClusterConfigStatus
where
parseJSON
= withObject "ElasticsearchClusterConfigStatus"
(\ x ->
ElasticsearchClusterConfigStatus' <$>
(x .: "Options") <*> (x .: "Status"))
instance Hashable ElasticsearchClusterConfigStatus
where
instance NFData ElasticsearchClusterConfigStatus
where
data ElasticsearchDomainConfig = ElasticsearchDomainConfig'
{ _edcEBSOptions :: !(Maybe EBSOptionsStatus)
, _edcAccessPolicies :: !(Maybe AccessPoliciesStatus)
, _edcLogPublishingOptions :: !(Maybe LogPublishingOptionsStatus)
, _edcElasticsearchClusterConfig :: !(Maybe ElasticsearchClusterConfigStatus)
, _edcSnapshotOptions :: !(Maybe SnapshotOptionsStatus)
, _edcVPCOptions :: !(Maybe VPCDerivedInfoStatus)
, _edcAdvancedOptions :: !(Maybe AdvancedOptionsStatus)
, _edcElasticsearchVersion :: !(Maybe ElasticsearchVersionStatus)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
elasticsearchDomainConfig
:: ElasticsearchDomainConfig
elasticsearchDomainConfig =
ElasticsearchDomainConfig'
{ _edcEBSOptions = Nothing
, _edcAccessPolicies = Nothing
, _edcLogPublishingOptions = Nothing
, _edcElasticsearchClusterConfig = Nothing
, _edcSnapshotOptions = Nothing
, _edcVPCOptions = Nothing
, _edcAdvancedOptions = Nothing
, _edcElasticsearchVersion = Nothing
}
edcEBSOptions :: Lens' ElasticsearchDomainConfig (Maybe EBSOptionsStatus)
edcEBSOptions = lens _edcEBSOptions (\ s a -> s{_edcEBSOptions = a});
edcAccessPolicies :: Lens' ElasticsearchDomainConfig (Maybe AccessPoliciesStatus)
edcAccessPolicies = lens _edcAccessPolicies (\ s a -> s{_edcAccessPolicies = a});
edcLogPublishingOptions :: Lens' ElasticsearchDomainConfig (Maybe LogPublishingOptionsStatus)
edcLogPublishingOptions = lens _edcLogPublishingOptions (\ s a -> s{_edcLogPublishingOptions = a});
edcElasticsearchClusterConfig :: Lens' ElasticsearchDomainConfig (Maybe ElasticsearchClusterConfigStatus)
edcElasticsearchClusterConfig = lens _edcElasticsearchClusterConfig (\ s a -> s{_edcElasticsearchClusterConfig = a});
edcSnapshotOptions :: Lens' ElasticsearchDomainConfig (Maybe SnapshotOptionsStatus)
edcSnapshotOptions = lens _edcSnapshotOptions (\ s a -> s{_edcSnapshotOptions = a});
edcVPCOptions :: Lens' ElasticsearchDomainConfig (Maybe VPCDerivedInfoStatus)
edcVPCOptions = lens _edcVPCOptions (\ s a -> s{_edcVPCOptions = a});
edcAdvancedOptions :: Lens' ElasticsearchDomainConfig (Maybe AdvancedOptionsStatus)
edcAdvancedOptions = lens _edcAdvancedOptions (\ s a -> s{_edcAdvancedOptions = a});
edcElasticsearchVersion :: Lens' ElasticsearchDomainConfig (Maybe ElasticsearchVersionStatus)
edcElasticsearchVersion = lens _edcElasticsearchVersion (\ s a -> s{_edcElasticsearchVersion = a});
instance FromJSON ElasticsearchDomainConfig where
parseJSON
= withObject "ElasticsearchDomainConfig"
(\ x ->
ElasticsearchDomainConfig' <$>
(x .:? "EBSOptions") <*> (x .:? "AccessPolicies") <*>
(x .:? "LogPublishingOptions")
<*> (x .:? "ElasticsearchClusterConfig")
<*> (x .:? "SnapshotOptions")
<*> (x .:? "VPCOptions")
<*> (x .:? "AdvancedOptions")
<*> (x .:? "ElasticsearchVersion"))
instance Hashable ElasticsearchDomainConfig where
instance NFData ElasticsearchDomainConfig where
data ElasticsearchDomainStatus = ElasticsearchDomainStatus'
{ _edsEBSOptions :: !(Maybe EBSOptions)
, _edsAccessPolicies :: !(Maybe Text)
, _edsLogPublishingOptions :: !(Maybe (Map LogType LogPublishingOption))
, _edsCreated :: !(Maybe Bool)
, _edsSnapshotOptions :: !(Maybe SnapshotOptions)
, _edsDeleted :: !(Maybe Bool)
, _edsVPCOptions :: !(Maybe VPCDerivedInfo)
, _edsEndpoints :: !(Maybe (Map Text Text))
, _edsProcessing :: !(Maybe Bool)
, _edsEndpoint :: !(Maybe Text)
, _edsAdvancedOptions :: !(Maybe (Map Text Text))
, _edsElasticsearchVersion :: !(Maybe Text)
, _edsDomainId :: !Text
, _edsDomainName :: !Text
, _edsARN :: !Text
, _edsElasticsearchClusterConfig :: !ElasticsearchClusterConfig
} deriving (Eq, Read, Show, Data, Typeable, Generic)
elasticsearchDomainStatus
:: Text
-> Text
-> Text
-> ElasticsearchClusterConfig
-> ElasticsearchDomainStatus
elasticsearchDomainStatus pDomainId_ pDomainName_ pARN_ pElasticsearchClusterConfig_ =
ElasticsearchDomainStatus'
{ _edsEBSOptions = Nothing
, _edsAccessPolicies = Nothing
, _edsLogPublishingOptions = Nothing
, _edsCreated = Nothing
, _edsSnapshotOptions = Nothing
, _edsDeleted = Nothing
, _edsVPCOptions = Nothing
, _edsEndpoints = Nothing
, _edsProcessing = Nothing
, _edsEndpoint = Nothing
, _edsAdvancedOptions = Nothing
, _edsElasticsearchVersion = Nothing
, _edsDomainId = pDomainId_
, _edsDomainName = pDomainName_
, _edsARN = pARN_
, _edsElasticsearchClusterConfig = pElasticsearchClusterConfig_
}
edsEBSOptions :: Lens' ElasticsearchDomainStatus (Maybe EBSOptions)
edsEBSOptions = lens _edsEBSOptions (\ s a -> s{_edsEBSOptions = a});
edsAccessPolicies :: Lens' ElasticsearchDomainStatus (Maybe Text)
edsAccessPolicies = lens _edsAccessPolicies (\ s a -> s{_edsAccessPolicies = a});
edsLogPublishingOptions :: Lens' ElasticsearchDomainStatus (HashMap LogType LogPublishingOption)
edsLogPublishingOptions = lens _edsLogPublishingOptions (\ s a -> s{_edsLogPublishingOptions = a}) . _Default . _Map;
edsCreated :: Lens' ElasticsearchDomainStatus (Maybe Bool)
edsCreated = lens _edsCreated (\ s a -> s{_edsCreated = a});
edsSnapshotOptions :: Lens' ElasticsearchDomainStatus (Maybe SnapshotOptions)
edsSnapshotOptions = lens _edsSnapshotOptions (\ s a -> s{_edsSnapshotOptions = a});
edsDeleted :: Lens' ElasticsearchDomainStatus (Maybe Bool)
edsDeleted = lens _edsDeleted (\ s a -> s{_edsDeleted = a});
edsVPCOptions :: Lens' ElasticsearchDomainStatus (Maybe VPCDerivedInfo)
edsVPCOptions = lens _edsVPCOptions (\ s a -> s{_edsVPCOptions = a});
edsEndpoints :: Lens' ElasticsearchDomainStatus (HashMap Text Text)
edsEndpoints = lens _edsEndpoints (\ s a -> s{_edsEndpoints = a}) . _Default . _Map;
edsProcessing :: Lens' ElasticsearchDomainStatus (Maybe Bool)
edsProcessing = lens _edsProcessing (\ s a -> s{_edsProcessing = a});
edsEndpoint :: Lens' ElasticsearchDomainStatus (Maybe Text)
edsEndpoint = lens _edsEndpoint (\ s a -> s{_edsEndpoint = a});
edsAdvancedOptions :: Lens' ElasticsearchDomainStatus (HashMap Text Text)
edsAdvancedOptions = lens _edsAdvancedOptions (\ s a -> s{_edsAdvancedOptions = a}) . _Default . _Map;
edsElasticsearchVersion :: Lens' ElasticsearchDomainStatus (Maybe Text)
edsElasticsearchVersion = lens _edsElasticsearchVersion (\ s a -> s{_edsElasticsearchVersion = a});
edsDomainId :: Lens' ElasticsearchDomainStatus Text
edsDomainId = lens _edsDomainId (\ s a -> s{_edsDomainId = a});
edsDomainName :: Lens' ElasticsearchDomainStatus Text
edsDomainName = lens _edsDomainName (\ s a -> s{_edsDomainName = a});
edsARN :: Lens' ElasticsearchDomainStatus Text
edsARN = lens _edsARN (\ s a -> s{_edsARN = a});
edsElasticsearchClusterConfig :: Lens' ElasticsearchDomainStatus ElasticsearchClusterConfig
edsElasticsearchClusterConfig = lens _edsElasticsearchClusterConfig (\ s a -> s{_edsElasticsearchClusterConfig = a});
instance FromJSON ElasticsearchDomainStatus where
parseJSON
= withObject "ElasticsearchDomainStatus"
(\ x ->
ElasticsearchDomainStatus' <$>
(x .:? "EBSOptions") <*> (x .:? "AccessPolicies") <*>
(x .:? "LogPublishingOptions" .!= mempty)
<*> (x .:? "Created")
<*> (x .:? "SnapshotOptions")
<*> (x .:? "Deleted")
<*> (x .:? "VPCOptions")
<*> (x .:? "Endpoints" .!= mempty)
<*> (x .:? "Processing")
<*> (x .:? "Endpoint")
<*> (x .:? "AdvancedOptions" .!= mempty)
<*> (x .:? "ElasticsearchVersion")
<*> (x .: "DomainId")
<*> (x .: "DomainName")
<*> (x .: "ARN")
<*> (x .: "ElasticsearchClusterConfig"))
instance Hashable ElasticsearchDomainStatus where
instance NFData ElasticsearchDomainStatus where
data ElasticsearchVersionStatus = ElasticsearchVersionStatus'
{ _evsOptions :: !Text
, _evsStatus :: !OptionStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
elasticsearchVersionStatus
:: Text
-> OptionStatus
-> ElasticsearchVersionStatus
elasticsearchVersionStatus pOptions_ pStatus_ =
ElasticsearchVersionStatus' {_evsOptions = pOptions_, _evsStatus = pStatus_}
evsOptions :: Lens' ElasticsearchVersionStatus Text
evsOptions = lens _evsOptions (\ s a -> s{_evsOptions = a});
evsStatus :: Lens' ElasticsearchVersionStatus OptionStatus
evsStatus = lens _evsStatus (\ s a -> s{_evsStatus = a});
instance FromJSON ElasticsearchVersionStatus where
parseJSON
= withObject "ElasticsearchVersionStatus"
(\ x ->
ElasticsearchVersionStatus' <$>
(x .: "Options") <*> (x .: "Status"))
instance Hashable ElasticsearchVersionStatus where
instance NFData ElasticsearchVersionStatus where
data InstanceCountLimits = InstanceCountLimits'
{ _iclMaximumInstanceCount :: !(Maybe Int)
, _iclMinimumInstanceCount :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
instanceCountLimits
:: InstanceCountLimits
instanceCountLimits =
InstanceCountLimits'
{_iclMaximumInstanceCount = Nothing, _iclMinimumInstanceCount = Nothing}
iclMaximumInstanceCount :: Lens' InstanceCountLimits (Maybe Int)
iclMaximumInstanceCount = lens _iclMaximumInstanceCount (\ s a -> s{_iclMaximumInstanceCount = a});
iclMinimumInstanceCount :: Lens' InstanceCountLimits (Maybe Int)
iclMinimumInstanceCount = lens _iclMinimumInstanceCount (\ s a -> s{_iclMinimumInstanceCount = a});
instance FromJSON InstanceCountLimits where
parseJSON
= withObject "InstanceCountLimits"
(\ x ->
InstanceCountLimits' <$>
(x .:? "MaximumInstanceCount") <*>
(x .:? "MinimumInstanceCount"))
instance Hashable InstanceCountLimits where
instance NFData InstanceCountLimits where
newtype InstanceLimits = InstanceLimits'
{ _ilInstanceCountLimits :: Maybe InstanceCountLimits
} deriving (Eq, Read, Show, Data, Typeable, Generic)
instanceLimits
:: InstanceLimits
instanceLimits = InstanceLimits' {_ilInstanceCountLimits = Nothing}
ilInstanceCountLimits :: Lens' InstanceLimits (Maybe InstanceCountLimits)
ilInstanceCountLimits = lens _ilInstanceCountLimits (\ s a -> s{_ilInstanceCountLimits = a});
instance FromJSON InstanceLimits where
parseJSON
= withObject "InstanceLimits"
(\ x ->
InstanceLimits' <$> (x .:? "InstanceCountLimits"))
instance Hashable InstanceLimits where
instance NFData InstanceLimits where
data Limits = Limits'
{ _lInstanceLimits :: !(Maybe InstanceLimits)
, _lAdditionalLimits :: !(Maybe [AdditionalLimit])
, _lStorageTypes :: !(Maybe [StorageType])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
limits
:: Limits
limits =
Limits'
{ _lInstanceLimits = Nothing
, _lAdditionalLimits = Nothing
, _lStorageTypes = Nothing
}
lInstanceLimits :: Lens' Limits (Maybe InstanceLimits)
lInstanceLimits = lens _lInstanceLimits (\ s a -> s{_lInstanceLimits = a});
lAdditionalLimits :: Lens' Limits [AdditionalLimit]
lAdditionalLimits = lens _lAdditionalLimits (\ s a -> s{_lAdditionalLimits = a}) . _Default . _Coerce;
lStorageTypes :: Lens' Limits [StorageType]
lStorageTypes = lens _lStorageTypes (\ s a -> s{_lStorageTypes = a}) . _Default . _Coerce;
instance FromJSON Limits where
parseJSON
= withObject "Limits"
(\ x ->
Limits' <$>
(x .:? "InstanceLimits") <*>
(x .:? "AdditionalLimits" .!= mempty)
<*> (x .:? "StorageTypes" .!= mempty))
instance Hashable Limits where
instance NFData Limits where
data LogPublishingOption = LogPublishingOption'
{ _lpoEnabled :: !(Maybe Bool)
, _lpoCloudWatchLogsLogGroupARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
logPublishingOption
:: LogPublishingOption
logPublishingOption =
LogPublishingOption'
{_lpoEnabled = Nothing, _lpoCloudWatchLogsLogGroupARN = Nothing}
lpoEnabled :: Lens' LogPublishingOption (Maybe Bool)
lpoEnabled = lens _lpoEnabled (\ s a -> s{_lpoEnabled = a});
lpoCloudWatchLogsLogGroupARN :: Lens' LogPublishingOption (Maybe Text)
lpoCloudWatchLogsLogGroupARN = lens _lpoCloudWatchLogsLogGroupARN (\ s a -> s{_lpoCloudWatchLogsLogGroupARN = a});
instance FromJSON LogPublishingOption where
parseJSON
= withObject "LogPublishingOption"
(\ x ->
LogPublishingOption' <$>
(x .:? "Enabled") <*>
(x .:? "CloudWatchLogsLogGroupArn"))
instance Hashable LogPublishingOption where
instance NFData LogPublishingOption where
instance ToJSON LogPublishingOption where
toJSON LogPublishingOption'{..}
= object
(catMaybes
[("Enabled" .=) <$> _lpoEnabled,
("CloudWatchLogsLogGroupArn" .=) <$>
_lpoCloudWatchLogsLogGroupARN])
data LogPublishingOptionsStatus = LogPublishingOptionsStatus'
{ _lposStatus :: !(Maybe OptionStatus)
, _lposOptions :: !(Maybe (Map LogType LogPublishingOption))
} deriving (Eq, Read, Show, Data, Typeable, Generic)
logPublishingOptionsStatus
:: LogPublishingOptionsStatus
logPublishingOptionsStatus =
LogPublishingOptionsStatus' {_lposStatus = Nothing, _lposOptions = Nothing}
lposStatus :: Lens' LogPublishingOptionsStatus (Maybe OptionStatus)
lposStatus = lens _lposStatus (\ s a -> s{_lposStatus = a});
lposOptions :: Lens' LogPublishingOptionsStatus (HashMap LogType LogPublishingOption)
lposOptions = lens _lposOptions (\ s a -> s{_lposOptions = a}) . _Default . _Map;
instance FromJSON LogPublishingOptionsStatus where
parseJSON
= withObject "LogPublishingOptionsStatus"
(\ x ->
LogPublishingOptionsStatus' <$>
(x .:? "Status") <*> (x .:? "Options" .!= mempty))
instance Hashable LogPublishingOptionsStatus where
instance NFData LogPublishingOptionsStatus where
data OptionStatus = OptionStatus'
{ _osPendingDeletion :: !(Maybe Bool)
, _osUpdateVersion :: !(Maybe Nat)
, _osCreationDate :: !POSIX
, _osUpdateDate :: !POSIX
, _osState :: !OptionState
} deriving (Eq, Read, Show, Data, Typeable, Generic)
optionStatus
:: UTCTime
-> UTCTime
-> OptionState
-> OptionStatus
optionStatus pCreationDate_ pUpdateDate_ pState_ =
OptionStatus'
{ _osPendingDeletion = Nothing
, _osUpdateVersion = Nothing
, _osCreationDate = _Time # pCreationDate_
, _osUpdateDate = _Time # pUpdateDate_
, _osState = pState_
}
osPendingDeletion :: Lens' OptionStatus (Maybe Bool)
osPendingDeletion = lens _osPendingDeletion (\ s a -> s{_osPendingDeletion = a});
osUpdateVersion :: Lens' OptionStatus (Maybe Natural)
osUpdateVersion = lens _osUpdateVersion (\ s a -> s{_osUpdateVersion = a}) . mapping _Nat;
osCreationDate :: Lens' OptionStatus UTCTime
osCreationDate = lens _osCreationDate (\ s a -> s{_osCreationDate = a}) . _Time;
osUpdateDate :: Lens' OptionStatus UTCTime
osUpdateDate = lens _osUpdateDate (\ s a -> s{_osUpdateDate = a}) . _Time;
osState :: Lens' OptionStatus OptionState
osState = lens _osState (\ s a -> s{_osState = a});
instance FromJSON OptionStatus where
parseJSON
= withObject "OptionStatus"
(\ x ->
OptionStatus' <$>
(x .:? "PendingDeletion") <*> (x .:? "UpdateVersion")
<*> (x .: "CreationDate")
<*> (x .: "UpdateDate")
<*> (x .: "State"))
instance Hashable OptionStatus where
instance NFData OptionStatus where
newtype SnapshotOptions = SnapshotOptions'
{ _soAutomatedSnapshotStartHour :: Maybe Int
} deriving (Eq, Read, Show, Data, Typeable, Generic)
snapshotOptions
:: SnapshotOptions
snapshotOptions = SnapshotOptions' {_soAutomatedSnapshotStartHour = Nothing}
soAutomatedSnapshotStartHour :: Lens' SnapshotOptions (Maybe Int)
soAutomatedSnapshotStartHour = lens _soAutomatedSnapshotStartHour (\ s a -> s{_soAutomatedSnapshotStartHour = a});
instance FromJSON SnapshotOptions where
parseJSON
= withObject "SnapshotOptions"
(\ x ->
SnapshotOptions' <$>
(x .:? "AutomatedSnapshotStartHour"))
instance Hashable SnapshotOptions where
instance NFData SnapshotOptions where
instance ToJSON SnapshotOptions where
toJSON SnapshotOptions'{..}
= object
(catMaybes
[("AutomatedSnapshotStartHour" .=) <$>
_soAutomatedSnapshotStartHour])
data SnapshotOptionsStatus = SnapshotOptionsStatus'
{ _sosOptions :: !SnapshotOptions
, _sosStatus :: !OptionStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
snapshotOptionsStatus
:: SnapshotOptions
-> OptionStatus
-> SnapshotOptionsStatus
snapshotOptionsStatus pOptions_ pStatus_ =
SnapshotOptionsStatus' {_sosOptions = pOptions_, _sosStatus = pStatus_}
sosOptions :: Lens' SnapshotOptionsStatus SnapshotOptions
sosOptions = lens _sosOptions (\ s a -> s{_sosOptions = a});
sosStatus :: Lens' SnapshotOptionsStatus OptionStatus
sosStatus = lens _sosStatus (\ s a -> s{_sosStatus = a});
instance FromJSON SnapshotOptionsStatus where
parseJSON
= withObject "SnapshotOptionsStatus"
(\ x ->
SnapshotOptionsStatus' <$>
(x .: "Options") <*> (x .: "Status"))
instance Hashable SnapshotOptionsStatus where
instance NFData SnapshotOptionsStatus where
data StorageType = StorageType'
{ _stStorageTypeLimits :: !(Maybe [StorageTypeLimit])
, _stStorageSubTypeName :: !(Maybe Text)
, _stStorageTypeName :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
storageType
:: StorageType
storageType =
StorageType'
{ _stStorageTypeLimits = Nothing
, _stStorageSubTypeName = Nothing
, _stStorageTypeName = Nothing
}
stStorageTypeLimits :: Lens' StorageType [StorageTypeLimit]
stStorageTypeLimits = lens _stStorageTypeLimits (\ s a -> s{_stStorageTypeLimits = a}) . _Default . _Coerce;
stStorageSubTypeName :: Lens' StorageType (Maybe Text)
stStorageSubTypeName = lens _stStorageSubTypeName (\ s a -> s{_stStorageSubTypeName = a});
stStorageTypeName :: Lens' StorageType (Maybe Text)
stStorageTypeName = lens _stStorageTypeName (\ s a -> s{_stStorageTypeName = a});
instance FromJSON StorageType where
parseJSON
= withObject "StorageType"
(\ x ->
StorageType' <$>
(x .:? "StorageTypeLimits" .!= mempty) <*>
(x .:? "StorageSubTypeName")
<*> (x .:? "StorageTypeName"))
instance Hashable StorageType where
instance NFData StorageType where
data StorageTypeLimit = StorageTypeLimit'
{ _stlLimitName :: !(Maybe Text)
, _stlLimitValues :: !(Maybe [Text])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
storageTypeLimit
:: StorageTypeLimit
storageTypeLimit =
StorageTypeLimit' {_stlLimitName = Nothing, _stlLimitValues = Nothing}
stlLimitName :: Lens' StorageTypeLimit (Maybe Text)
stlLimitName = lens _stlLimitName (\ s a -> s{_stlLimitName = a});
stlLimitValues :: Lens' StorageTypeLimit [Text]
stlLimitValues = lens _stlLimitValues (\ s a -> s{_stlLimitValues = a}) . _Default . _Coerce;
instance FromJSON StorageTypeLimit where
parseJSON
= withObject "StorageTypeLimit"
(\ x ->
StorageTypeLimit' <$>
(x .:? "LimitName") <*>
(x .:? "LimitValues" .!= mempty))
instance Hashable StorageTypeLimit where
instance NFData StorageTypeLimit where
data Tag = Tag'
{ _tagKey :: !Text
, _tagValue :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
tag
:: Text
-> Text
-> Tag
tag pKey_ pValue_ = Tag' {_tagKey = pKey_, _tagValue = pValue_}
tagKey :: Lens' Tag Text
tagKey = lens _tagKey (\ s a -> s{_tagKey = a});
tagValue :: Lens' Tag Text
tagValue = lens _tagValue (\ s a -> s{_tagValue = a});
instance FromJSON Tag where
parseJSON
= withObject "Tag"
(\ x -> Tag' <$> (x .: "Key") <*> (x .: "Value"))
instance Hashable Tag where
instance NFData Tag where
instance ToJSON Tag where
toJSON Tag'{..}
= object
(catMaybes
[Just ("Key" .= _tagKey),
Just ("Value" .= _tagValue)])
data VPCDerivedInfo = VPCDerivedInfo'
{ _vdiSecurityGroupIds :: !(Maybe [Text])
, _vdiSubnetIds :: !(Maybe [Text])
, _vdiVPCId :: !(Maybe Text)
, _vdiAvailabilityZones :: !(Maybe [Text])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
vpcDerivedInfo
:: VPCDerivedInfo
vpcDerivedInfo =
VPCDerivedInfo'
{ _vdiSecurityGroupIds = Nothing
, _vdiSubnetIds = Nothing
, _vdiVPCId = Nothing
, _vdiAvailabilityZones = Nothing
}
vdiSecurityGroupIds :: Lens' VPCDerivedInfo [Text]
vdiSecurityGroupIds = lens _vdiSecurityGroupIds (\ s a -> s{_vdiSecurityGroupIds = a}) . _Default . _Coerce;
vdiSubnetIds :: Lens' VPCDerivedInfo [Text]
vdiSubnetIds = lens _vdiSubnetIds (\ s a -> s{_vdiSubnetIds = a}) . _Default . _Coerce;
vdiVPCId :: Lens' VPCDerivedInfo (Maybe Text)
vdiVPCId = lens _vdiVPCId (\ s a -> s{_vdiVPCId = a});
vdiAvailabilityZones :: Lens' VPCDerivedInfo [Text]
vdiAvailabilityZones = lens _vdiAvailabilityZones (\ s a -> s{_vdiAvailabilityZones = a}) . _Default . _Coerce;
instance FromJSON VPCDerivedInfo where
parseJSON
= withObject "VPCDerivedInfo"
(\ x ->
VPCDerivedInfo' <$>
(x .:? "SecurityGroupIds" .!= mempty) <*>
(x .:? "SubnetIds" .!= mempty)
<*> (x .:? "VPCId")
<*> (x .:? "AvailabilityZones" .!= mempty))
instance Hashable VPCDerivedInfo where
instance NFData VPCDerivedInfo where
data VPCDerivedInfoStatus = VPCDerivedInfoStatus'
{ _vdisOptions :: !VPCDerivedInfo
, _vdisStatus :: !OptionStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
vpcDerivedInfoStatus
:: VPCDerivedInfo
-> OptionStatus
-> VPCDerivedInfoStatus
vpcDerivedInfoStatus pOptions_ pStatus_ =
VPCDerivedInfoStatus' {_vdisOptions = pOptions_, _vdisStatus = pStatus_}
vdisOptions :: Lens' VPCDerivedInfoStatus VPCDerivedInfo
vdisOptions = lens _vdisOptions (\ s a -> s{_vdisOptions = a});
vdisStatus :: Lens' VPCDerivedInfoStatus OptionStatus
vdisStatus = lens _vdisStatus (\ s a -> s{_vdisStatus = a});
instance FromJSON VPCDerivedInfoStatus where
parseJSON
= withObject "VPCDerivedInfoStatus"
(\ x ->
VPCDerivedInfoStatus' <$>
(x .: "Options") <*> (x .: "Status"))
instance Hashable VPCDerivedInfoStatus where
instance NFData VPCDerivedInfoStatus where
data VPCOptions = VPCOptions'
{ _voSecurityGroupIds :: !(Maybe [Text])
, _voSubnetIds :: !(Maybe [Text])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
vpcOptions
:: VPCOptions
vpcOptions = VPCOptions' {_voSecurityGroupIds = Nothing, _voSubnetIds = Nothing}
voSecurityGroupIds :: Lens' VPCOptions [Text]
voSecurityGroupIds = lens _voSecurityGroupIds (\ s a -> s{_voSecurityGroupIds = a}) . _Default . _Coerce;
voSubnetIds :: Lens' VPCOptions [Text]
voSubnetIds = lens _voSubnetIds (\ s a -> s{_voSubnetIds = a}) . _Default . _Coerce;
instance Hashable VPCOptions where
instance NFData VPCOptions where
instance ToJSON VPCOptions where
toJSON VPCOptions'{..}
= object
(catMaybes
[("SecurityGroupIds" .=) <$> _voSecurityGroupIds,
("SubnetIds" .=) <$> _voSubnetIds])