{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module Network.AWS.AWSHealth.Types.Product where
import Network.AWS.AWSHealth.Types.Sum
import Network.AWS.Lens
import Network.AWS.Prelude
data AffectedEntity = AffectedEntity'
{ _aeLastUpdatedTime :: !(Maybe POSIX)
, _aeEntityValue :: !(Maybe Text)
, _aeAwsAccountId :: !(Maybe Text)
, _aeEventARN :: !(Maybe Text)
, _aeEntityARN :: !(Maybe Text)
, _aeTags :: !(Maybe (Map Text Text))
, _aeStatusCode :: !(Maybe EntityStatusCode)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
affectedEntity
:: AffectedEntity
affectedEntity =
AffectedEntity'
{ _aeLastUpdatedTime = Nothing
, _aeEntityValue = Nothing
, _aeAwsAccountId = Nothing
, _aeEventARN = Nothing
, _aeEntityARN = Nothing
, _aeTags = Nothing
, _aeStatusCode = Nothing
}
aeLastUpdatedTime :: Lens' AffectedEntity (Maybe UTCTime)
aeLastUpdatedTime = lens _aeLastUpdatedTime (\ s a -> s{_aeLastUpdatedTime = a}) . mapping _Time;
aeEntityValue :: Lens' AffectedEntity (Maybe Text)
aeEntityValue = lens _aeEntityValue (\ s a -> s{_aeEntityValue = a});
aeAwsAccountId :: Lens' AffectedEntity (Maybe Text)
aeAwsAccountId = lens _aeAwsAccountId (\ s a -> s{_aeAwsAccountId = a});
aeEventARN :: Lens' AffectedEntity (Maybe Text)
aeEventARN = lens _aeEventARN (\ s a -> s{_aeEventARN = a});
aeEntityARN :: Lens' AffectedEntity (Maybe Text)
aeEntityARN = lens _aeEntityARN (\ s a -> s{_aeEntityARN = a});
aeTags :: Lens' AffectedEntity (HashMap Text Text)
aeTags = lens _aeTags (\ s a -> s{_aeTags = a}) . _Default . _Map;
aeStatusCode :: Lens' AffectedEntity (Maybe EntityStatusCode)
aeStatusCode = lens _aeStatusCode (\ s a -> s{_aeStatusCode = a});
instance FromJSON AffectedEntity where
parseJSON
= withObject "AffectedEntity"
(\ x ->
AffectedEntity' <$>
(x .:? "lastUpdatedTime") <*> (x .:? "entityValue")
<*> (x .:? "awsAccountId")
<*> (x .:? "eventArn")
<*> (x .:? "entityArn")
<*> (x .:? "tags" .!= mempty)
<*> (x .:? "statusCode"))
instance Hashable AffectedEntity
instance NFData AffectedEntity
data DateTimeRange = DateTimeRange'
{ _dtrTo :: !(Maybe POSIX)
, _dtrFrom :: !(Maybe POSIX)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
dateTimeRange
:: DateTimeRange
dateTimeRange =
DateTimeRange'
{ _dtrTo = Nothing
, _dtrFrom = Nothing
}
dtrTo :: Lens' DateTimeRange (Maybe UTCTime)
dtrTo = lens _dtrTo (\ s a -> s{_dtrTo = a}) . mapping _Time;
dtrFrom :: Lens' DateTimeRange (Maybe UTCTime)
dtrFrom = lens _dtrFrom (\ s a -> s{_dtrFrom = a}) . mapping _Time;
instance Hashable DateTimeRange
instance NFData DateTimeRange
instance ToJSON DateTimeRange where
toJSON DateTimeRange'{..}
= object
(catMaybes
[("to" .=) <$> _dtrTo, ("from" .=) <$> _dtrFrom])
data EntityAggregate = EntityAggregate'
{ _eCount :: !(Maybe Int)
, _eEventARN :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
entityAggregate
:: EntityAggregate
entityAggregate =
EntityAggregate'
{ _eCount = Nothing
, _eEventARN = Nothing
}
eCount :: Lens' EntityAggregate (Maybe Int)
eCount = lens _eCount (\ s a -> s{_eCount = a});
eEventARN :: Lens' EntityAggregate (Maybe Text)
eEventARN = lens _eEventARN (\ s a -> s{_eEventARN = a});
instance FromJSON EntityAggregate where
parseJSON
= withObject "EntityAggregate"
(\ x ->
EntityAggregate' <$>
(x .:? "count") <*> (x .:? "eventArn"))
instance Hashable EntityAggregate
instance NFData EntityAggregate
data EntityFilter = EntityFilter'
{ _eStatusCodes :: !(Maybe (List1 EntityStatusCode))
, _eEntityARNs :: !(Maybe (List1 Text))
, _eEntityValues :: !(Maybe (List1 Text))
, _eTags :: !(Maybe [Map Text Text])
, _eLastUpdatedTimes :: !(Maybe (List1 DateTimeRange))
, _eEventARNs :: !(List1 Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
entityFilter
:: NonEmpty Text
-> EntityFilter
entityFilter pEventARNs_ =
EntityFilter'
{ _eStatusCodes = Nothing
, _eEntityARNs = Nothing
, _eEntityValues = Nothing
, _eTags = Nothing
, _eLastUpdatedTimes = Nothing
, _eEventARNs = _List1 # pEventARNs_
}
eStatusCodes :: Lens' EntityFilter (Maybe (NonEmpty EntityStatusCode))
eStatusCodes = lens _eStatusCodes (\ s a -> s{_eStatusCodes = a}) . mapping _List1;
eEntityARNs :: Lens' EntityFilter (Maybe (NonEmpty Text))
eEntityARNs = lens _eEntityARNs (\ s a -> s{_eEntityARNs = a}) . mapping _List1;
eEntityValues :: Lens' EntityFilter (Maybe (NonEmpty Text))
eEntityValues = lens _eEntityValues (\ s a -> s{_eEntityValues = a}) . mapping _List1;
eTags :: Lens' EntityFilter [HashMap Text Text]
eTags = lens _eTags (\ s a -> s{_eTags = a}) . _Default . _Coerce;
eLastUpdatedTimes :: Lens' EntityFilter (Maybe (NonEmpty DateTimeRange))
eLastUpdatedTimes = lens _eLastUpdatedTimes (\ s a -> s{_eLastUpdatedTimes = a}) . mapping _List1;
eEventARNs :: Lens' EntityFilter (NonEmpty Text)
eEventARNs = lens _eEventARNs (\ s a -> s{_eEventARNs = a}) . _List1;
instance Hashable EntityFilter
instance NFData EntityFilter
instance ToJSON EntityFilter where
toJSON EntityFilter'{..}
= object
(catMaybes
[("statusCodes" .=) <$> _eStatusCodes,
("entityArns" .=) <$> _eEntityARNs,
("entityValues" .=) <$> _eEntityValues,
("tags" .=) <$> _eTags,
("lastUpdatedTimes" .=) <$> _eLastUpdatedTimes,
Just ("eventArns" .= _eEventARNs)])
data Event = Event'
{ _eLastUpdatedTime :: !(Maybe POSIX)
, _eArn :: !(Maybe Text)
, _eService :: !(Maybe Text)
, _eStartTime :: !(Maybe POSIX)
, _eEventTypeCode :: !(Maybe Text)
, _eEventTypeCategory :: !(Maybe EventTypeCategory)
, _eAvailabilityZone :: !(Maybe Text)
, _eEndTime :: !(Maybe POSIX)
, _eRegion :: !(Maybe Text)
, _eStatusCode :: !(Maybe EventStatusCode)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
event
:: Event
event =
Event'
{ _eLastUpdatedTime = Nothing
, _eArn = Nothing
, _eService = Nothing
, _eStartTime = Nothing
, _eEventTypeCode = Nothing
, _eEventTypeCategory = Nothing
, _eAvailabilityZone = Nothing
, _eEndTime = Nothing
, _eRegion = Nothing
, _eStatusCode = Nothing
}
eLastUpdatedTime :: Lens' Event (Maybe UTCTime)
eLastUpdatedTime = lens _eLastUpdatedTime (\ s a -> s{_eLastUpdatedTime = a}) . mapping _Time;
eArn :: Lens' Event (Maybe Text)
eArn = lens _eArn (\ s a -> s{_eArn = a});
eService :: Lens' Event (Maybe Text)
eService = lens _eService (\ s a -> s{_eService = a});
eStartTime :: Lens' Event (Maybe UTCTime)
eStartTime = lens _eStartTime (\ s a -> s{_eStartTime = a}) . mapping _Time;
eEventTypeCode :: Lens' Event (Maybe Text)
eEventTypeCode = lens _eEventTypeCode (\ s a -> s{_eEventTypeCode = a});
eEventTypeCategory :: Lens' Event (Maybe EventTypeCategory)
eEventTypeCategory = lens _eEventTypeCategory (\ s a -> s{_eEventTypeCategory = a});
eAvailabilityZone :: Lens' Event (Maybe Text)
eAvailabilityZone = lens _eAvailabilityZone (\ s a -> s{_eAvailabilityZone = a});
eEndTime :: Lens' Event (Maybe UTCTime)
eEndTime = lens _eEndTime (\ s a -> s{_eEndTime = a}) . mapping _Time;
eRegion :: Lens' Event (Maybe Text)
eRegion = lens _eRegion (\ s a -> s{_eRegion = a});
eStatusCode :: Lens' Event (Maybe EventStatusCode)
eStatusCode = lens _eStatusCode (\ s a -> s{_eStatusCode = a});
instance FromJSON Event where
parseJSON
= withObject "Event"
(\ x ->
Event' <$>
(x .:? "lastUpdatedTime") <*> (x .:? "arn") <*>
(x .:? "service")
<*> (x .:? "startTime")
<*> (x .:? "eventTypeCode")
<*> (x .:? "eventTypeCategory")
<*> (x .:? "availabilityZone")
<*> (x .:? "endTime")
<*> (x .:? "region")
<*> (x .:? "statusCode"))
instance Hashable Event
instance NFData Event
data EventAggregate = EventAggregate'
{ _eaCount :: !(Maybe Int)
, _eaAggregateValue :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
eventAggregate
:: EventAggregate
eventAggregate =
EventAggregate'
{ _eaCount = Nothing
, _eaAggregateValue = Nothing
}
eaCount :: Lens' EventAggregate (Maybe Int)
eaCount = lens _eaCount (\ s a -> s{_eaCount = a});
eaAggregateValue :: Lens' EventAggregate (Maybe Text)
eaAggregateValue = lens _eaAggregateValue (\ s a -> s{_eaAggregateValue = a});
instance FromJSON EventAggregate where
parseJSON
= withObject "EventAggregate"
(\ x ->
EventAggregate' <$>
(x .:? "count") <*> (x .:? "aggregateValue"))
instance Hashable EventAggregate
instance NFData EventAggregate
newtype EventDescription = EventDescription'
{ _edLatestDescription :: Maybe Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
eventDescription
:: EventDescription
eventDescription =
EventDescription'
{ _edLatestDescription = Nothing
}
edLatestDescription :: Lens' EventDescription (Maybe Text)
edLatestDescription = lens _edLatestDescription (\ s a -> s{_edLatestDescription = a});
instance FromJSON EventDescription where
parseJSON
= withObject "EventDescription"
(\ x ->
EventDescription' <$> (x .:? "latestDescription"))
instance Hashable EventDescription
instance NFData EventDescription
data EventDetails = EventDetails'
{ _edEvent :: !(Maybe Event)
, _edEventDescription :: !(Maybe EventDescription)
, _edEventMetadata :: !(Maybe (Map Text Text))
} deriving (Eq,Read,Show,Data,Typeable,Generic)
eventDetails
:: EventDetails
eventDetails =
EventDetails'
{ _edEvent = Nothing
, _edEventDescription = Nothing
, _edEventMetadata = Nothing
}
edEvent :: Lens' EventDetails (Maybe Event)
edEvent = lens _edEvent (\ s a -> s{_edEvent = a});
edEventDescription :: Lens' EventDetails (Maybe EventDescription)
edEventDescription = lens _edEventDescription (\ s a -> s{_edEventDescription = a});
edEventMetadata :: Lens' EventDetails (HashMap Text Text)
edEventMetadata = lens _edEventMetadata (\ s a -> s{_edEventMetadata = a}) . _Default . _Map;
instance FromJSON EventDetails where
parseJSON
= withObject "EventDetails"
(\ x ->
EventDetails' <$>
(x .:? "event") <*> (x .:? "eventDescription") <*>
(x .:? "eventMetadata" .!= mempty))
instance Hashable EventDetails
instance NFData EventDetails
data EventDetailsErrorItem = EventDetailsErrorItem'
{ _edeiEventARN :: !(Maybe Text)
, _edeiErrorName :: !(Maybe Text)
, _edeiErrorMessage :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
eventDetailsErrorItem
:: EventDetailsErrorItem
eventDetailsErrorItem =
EventDetailsErrorItem'
{ _edeiEventARN = Nothing
, _edeiErrorName = Nothing
, _edeiErrorMessage = Nothing
}
edeiEventARN :: Lens' EventDetailsErrorItem (Maybe Text)
edeiEventARN = lens _edeiEventARN (\ s a -> s{_edeiEventARN = a});
edeiErrorName :: Lens' EventDetailsErrorItem (Maybe Text)
edeiErrorName = lens _edeiErrorName (\ s a -> s{_edeiErrorName = a});
edeiErrorMessage :: Lens' EventDetailsErrorItem (Maybe Text)
edeiErrorMessage = lens _edeiErrorMessage (\ s a -> s{_edeiErrorMessage = a});
instance FromJSON EventDetailsErrorItem where
parseJSON
= withObject "EventDetailsErrorItem"
(\ x ->
EventDetailsErrorItem' <$>
(x .:? "eventArn") <*> (x .:? "errorName") <*>
(x .:? "errorMessage"))
instance Hashable EventDetailsErrorItem
instance NFData EventDetailsErrorItem
data EventFilter = EventFilter'
{ _efEventARNs :: !(Maybe (List1 Text))
, _efEventTypeCategories :: !(Maybe (List1 EventTypeCategory))
, _efEventTypeCodes :: !(Maybe (List1 Text))
, _efRegions :: !(Maybe (List1 Text))
, _efEventStatusCodes :: !(Maybe (List1 EventStatusCode))
, _efEndTimes :: !(Maybe (List1 DateTimeRange))
, _efAvailabilityZones :: !(Maybe [Text])
, _efEntityARNs :: !(Maybe (List1 Text))
, _efEntityValues :: !(Maybe (List1 Text))
, _efStartTimes :: !(Maybe (List1 DateTimeRange))
, _efServices :: !(Maybe (List1 Text))
, _efTags :: !(Maybe [Map Text Text])
, _efLastUpdatedTimes :: !(Maybe (List1 DateTimeRange))
} deriving (Eq,Read,Show,Data,Typeable,Generic)
eventFilter
:: EventFilter
eventFilter =
EventFilter'
{ _efEventARNs = Nothing
, _efEventTypeCategories = Nothing
, _efEventTypeCodes = Nothing
, _efRegions = Nothing
, _efEventStatusCodes = Nothing
, _efEndTimes = Nothing
, _efAvailabilityZones = Nothing
, _efEntityARNs = Nothing
, _efEntityValues = Nothing
, _efStartTimes = Nothing
, _efServices = Nothing
, _efTags = Nothing
, _efLastUpdatedTimes = Nothing
}
efEventARNs :: Lens' EventFilter (Maybe (NonEmpty Text))
efEventARNs = lens _efEventARNs (\ s a -> s{_efEventARNs = a}) . mapping _List1;
efEventTypeCategories :: Lens' EventFilter (Maybe (NonEmpty EventTypeCategory))
efEventTypeCategories = lens _efEventTypeCategories (\ s a -> s{_efEventTypeCategories = a}) . mapping _List1;
efEventTypeCodes :: Lens' EventFilter (Maybe (NonEmpty Text))
efEventTypeCodes = lens _efEventTypeCodes (\ s a -> s{_efEventTypeCodes = a}) . mapping _List1;
efRegions :: Lens' EventFilter (Maybe (NonEmpty Text))
efRegions = lens _efRegions (\ s a -> s{_efRegions = a}) . mapping _List1;
efEventStatusCodes :: Lens' EventFilter (Maybe (NonEmpty EventStatusCode))
efEventStatusCodes = lens _efEventStatusCodes (\ s a -> s{_efEventStatusCodes = a}) . mapping _List1;
efEndTimes :: Lens' EventFilter (Maybe (NonEmpty DateTimeRange))
efEndTimes = lens _efEndTimes (\ s a -> s{_efEndTimes = a}) . mapping _List1;
efAvailabilityZones :: Lens' EventFilter [Text]
efAvailabilityZones = lens _efAvailabilityZones (\ s a -> s{_efAvailabilityZones = a}) . _Default . _Coerce;
efEntityARNs :: Lens' EventFilter (Maybe (NonEmpty Text))
efEntityARNs = lens _efEntityARNs (\ s a -> s{_efEntityARNs = a}) . mapping _List1;
efEntityValues :: Lens' EventFilter (Maybe (NonEmpty Text))
efEntityValues = lens _efEntityValues (\ s a -> s{_efEntityValues = a}) . mapping _List1;
efStartTimes :: Lens' EventFilter (Maybe (NonEmpty DateTimeRange))
efStartTimes = lens _efStartTimes (\ s a -> s{_efStartTimes = a}) . mapping _List1;
efServices :: Lens' EventFilter (Maybe (NonEmpty Text))
efServices = lens _efServices (\ s a -> s{_efServices = a}) . mapping _List1;
efTags :: Lens' EventFilter [HashMap Text Text]
efTags = lens _efTags (\ s a -> s{_efTags = a}) . _Default . _Coerce;
efLastUpdatedTimes :: Lens' EventFilter (Maybe (NonEmpty DateTimeRange))
efLastUpdatedTimes = lens _efLastUpdatedTimes (\ s a -> s{_efLastUpdatedTimes = a}) . mapping _List1;
instance Hashable EventFilter
instance NFData EventFilter
instance ToJSON EventFilter where
toJSON EventFilter'{..}
= object
(catMaybes
[("eventArns" .=) <$> _efEventARNs,
("eventTypeCategories" .=) <$>
_efEventTypeCategories,
("eventTypeCodes" .=) <$> _efEventTypeCodes,
("regions" .=) <$> _efRegions,
("eventStatusCodes" .=) <$> _efEventStatusCodes,
("endTimes" .=) <$> _efEndTimes,
("availabilityZones" .=) <$> _efAvailabilityZones,
("entityArns" .=) <$> _efEntityARNs,
("entityValues" .=) <$> _efEntityValues,
("startTimes" .=) <$> _efStartTimes,
("services" .=) <$> _efServices,
("tags" .=) <$> _efTags,
("lastUpdatedTimes" .=) <$> _efLastUpdatedTimes])
data EventType = EventType'
{ _etService :: !(Maybe Text)
, _etCategory :: !(Maybe EventTypeCategory)
, _etCode :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
eventType
:: EventType
eventType =
EventType'
{ _etService = Nothing
, _etCategory = Nothing
, _etCode = Nothing
}
etService :: Lens' EventType (Maybe Text)
etService = lens _etService (\ s a -> s{_etService = a});
etCategory :: Lens' EventType (Maybe EventTypeCategory)
etCategory = lens _etCategory (\ s a -> s{_etCategory = a});
etCode :: Lens' EventType (Maybe Text)
etCode = lens _etCode (\ s a -> s{_etCode = a});
instance FromJSON EventType where
parseJSON
= withObject "EventType"
(\ x ->
EventType' <$>
(x .:? "service") <*> (x .:? "category") <*>
(x .:? "code"))
instance Hashable EventType
instance NFData EventType
data EventTypeFilter = EventTypeFilter'
{ _etfEventTypeCategories :: !(Maybe (List1 EventTypeCategory))
, _etfEventTypeCodes :: !(Maybe (List1 Text))
, _etfServices :: !(Maybe (List1 Text))
} deriving (Eq,Read,Show,Data,Typeable,Generic)
eventTypeFilter
:: EventTypeFilter
eventTypeFilter =
EventTypeFilter'
{ _etfEventTypeCategories = Nothing
, _etfEventTypeCodes = Nothing
, _etfServices = Nothing
}
etfEventTypeCategories :: Lens' EventTypeFilter (Maybe (NonEmpty EventTypeCategory))
etfEventTypeCategories = lens _etfEventTypeCategories (\ s a -> s{_etfEventTypeCategories = a}) . mapping _List1;
etfEventTypeCodes :: Lens' EventTypeFilter (Maybe (NonEmpty Text))
etfEventTypeCodes = lens _etfEventTypeCodes (\ s a -> s{_etfEventTypeCodes = a}) . mapping _List1;
etfServices :: Lens' EventTypeFilter (Maybe (NonEmpty Text))
etfServices = lens _etfServices (\ s a -> s{_etfServices = a}) . mapping _List1;
instance Hashable EventTypeFilter
instance NFData EventTypeFilter
instance ToJSON EventTypeFilter where
toJSON EventTypeFilter'{..}
= object
(catMaybes
[("eventTypeCategories" .=) <$>
_etfEventTypeCategories,
("eventTypeCodes" .=) <$> _etfEventTypeCodes,
("services" .=) <$> _etfServices])