{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module Network.AWS.Firehose.Types.Product where
import Network.AWS.Firehose.Types.Sum
import Network.AWS.Lens
import Network.AWS.Prelude
data BufferingHints = BufferingHints'
{ _bhSizeInMBs :: !(Maybe Nat)
, _bhIntervalInSeconds :: !(Maybe Nat)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
bufferingHints
:: BufferingHints
bufferingHints =
BufferingHints'
{ _bhSizeInMBs = Nothing
, _bhIntervalInSeconds = Nothing
}
bhSizeInMBs :: Lens' BufferingHints (Maybe Natural)
bhSizeInMBs = lens _bhSizeInMBs (\ s a -> s{_bhSizeInMBs = a}) . mapping _Nat;
bhIntervalInSeconds :: Lens' BufferingHints (Maybe Natural)
bhIntervalInSeconds = lens _bhIntervalInSeconds (\ s a -> s{_bhIntervalInSeconds = a}) . mapping _Nat;
instance FromJSON BufferingHints where
parseJSON
= withObject "BufferingHints"
(\ x ->
BufferingHints' <$>
(x .:? "SizeInMBs") <*> (x .:? "IntervalInSeconds"))
instance Hashable BufferingHints
instance NFData BufferingHints
instance ToJSON BufferingHints where
toJSON BufferingHints'{..}
= object
(catMaybes
[("SizeInMBs" .=) <$> _bhSizeInMBs,
("IntervalInSeconds" .=) <$> _bhIntervalInSeconds])
data CloudWatchLoggingOptions = CloudWatchLoggingOptions'
{ _cwloEnabled :: !(Maybe Bool)
, _cwloLogGroupName :: !(Maybe Text)
, _cwloLogStreamName :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
cloudWatchLoggingOptions
:: CloudWatchLoggingOptions
cloudWatchLoggingOptions =
CloudWatchLoggingOptions'
{ _cwloEnabled = Nothing
, _cwloLogGroupName = Nothing
, _cwloLogStreamName = Nothing
}
cwloEnabled :: Lens' CloudWatchLoggingOptions (Maybe Bool)
cwloEnabled = lens _cwloEnabled (\ s a -> s{_cwloEnabled = a});
cwloLogGroupName :: Lens' CloudWatchLoggingOptions (Maybe Text)
cwloLogGroupName = lens _cwloLogGroupName (\ s a -> s{_cwloLogGroupName = a});
cwloLogStreamName :: Lens' CloudWatchLoggingOptions (Maybe Text)
cwloLogStreamName = lens _cwloLogStreamName (\ s a -> s{_cwloLogStreamName = a});
instance FromJSON CloudWatchLoggingOptions where
parseJSON
= withObject "CloudWatchLoggingOptions"
(\ x ->
CloudWatchLoggingOptions' <$>
(x .:? "Enabled") <*> (x .:? "LogGroupName") <*>
(x .:? "LogStreamName"))
instance Hashable CloudWatchLoggingOptions
instance NFData CloudWatchLoggingOptions
instance ToJSON CloudWatchLoggingOptions where
toJSON CloudWatchLoggingOptions'{..}
= object
(catMaybes
[("Enabled" .=) <$> _cwloEnabled,
("LogGroupName" .=) <$> _cwloLogGroupName,
("LogStreamName" .=) <$> _cwloLogStreamName])
data CopyCommand = CopyCommand'
{ _ccCopyOptions :: !(Maybe Text)
, _ccDataTableColumns :: !(Maybe Text)
, _ccDataTableName :: !Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
copyCommand
:: Text
-> CopyCommand
copyCommand pDataTableName_ =
CopyCommand'
{ _ccCopyOptions = Nothing
, _ccDataTableColumns = Nothing
, _ccDataTableName = pDataTableName_
}
ccCopyOptions :: Lens' CopyCommand (Maybe Text)
ccCopyOptions = lens _ccCopyOptions (\ s a -> s{_ccCopyOptions = a});
ccDataTableColumns :: Lens' CopyCommand (Maybe Text)
ccDataTableColumns = lens _ccDataTableColumns (\ s a -> s{_ccDataTableColumns = a});
ccDataTableName :: Lens' CopyCommand Text
ccDataTableName = lens _ccDataTableName (\ s a -> s{_ccDataTableName = a});
instance FromJSON CopyCommand where
parseJSON
= withObject "CopyCommand"
(\ x ->
CopyCommand' <$>
(x .:? "CopyOptions") <*> (x .:? "DataTableColumns")
<*> (x .: "DataTableName"))
instance Hashable CopyCommand
instance NFData CopyCommand
instance ToJSON CopyCommand where
toJSON CopyCommand'{..}
= object
(catMaybes
[("CopyOptions" .=) <$> _ccCopyOptions,
("DataTableColumns" .=) <$> _ccDataTableColumns,
Just ("DataTableName" .= _ccDataTableName)])
data DeliveryStreamDescription = DeliveryStreamDescription'
{ _dsdCreateTimestamp :: !(Maybe POSIX)
, _dsdLastUpdateTimestamp :: !(Maybe POSIX)
, _dsdDeliveryStreamName :: !Text
, _dsdDeliveryStreamARN :: !Text
, _dsdDeliveryStreamStatus :: !DeliveryStreamStatus
, _dsdVersionId :: !Text
, _dsdDestinations :: ![DestinationDescription]
, _dsdHasMoreDestinations :: !Bool
} deriving (Eq,Read,Show,Data,Typeable,Generic)
deliveryStreamDescription
:: Text
-> Text
-> DeliveryStreamStatus
-> Text
-> Bool
-> DeliveryStreamDescription
deliveryStreamDescription pDeliveryStreamName_ pDeliveryStreamARN_ pDeliveryStreamStatus_ pVersionId_ pHasMoreDestinations_ =
DeliveryStreamDescription'
{ _dsdCreateTimestamp = Nothing
, _dsdLastUpdateTimestamp = Nothing
, _dsdDeliveryStreamName = pDeliveryStreamName_
, _dsdDeliveryStreamARN = pDeliveryStreamARN_
, _dsdDeliveryStreamStatus = pDeliveryStreamStatus_
, _dsdVersionId = pVersionId_
, _dsdDestinations = mempty
, _dsdHasMoreDestinations = pHasMoreDestinations_
}
dsdCreateTimestamp :: Lens' DeliveryStreamDescription (Maybe UTCTime)
dsdCreateTimestamp = lens _dsdCreateTimestamp (\ s a -> s{_dsdCreateTimestamp = a}) . mapping _Time;
dsdLastUpdateTimestamp :: Lens' DeliveryStreamDescription (Maybe UTCTime)
dsdLastUpdateTimestamp = lens _dsdLastUpdateTimestamp (\ s a -> s{_dsdLastUpdateTimestamp = a}) . mapping _Time;
dsdDeliveryStreamName :: Lens' DeliveryStreamDescription Text
dsdDeliveryStreamName = lens _dsdDeliveryStreamName (\ s a -> s{_dsdDeliveryStreamName = a});
dsdDeliveryStreamARN :: Lens' DeliveryStreamDescription Text
dsdDeliveryStreamARN = lens _dsdDeliveryStreamARN (\ s a -> s{_dsdDeliveryStreamARN = a});
dsdDeliveryStreamStatus :: Lens' DeliveryStreamDescription DeliveryStreamStatus
dsdDeliveryStreamStatus = lens _dsdDeliveryStreamStatus (\ s a -> s{_dsdDeliveryStreamStatus = a});
dsdVersionId :: Lens' DeliveryStreamDescription Text
dsdVersionId = lens _dsdVersionId (\ s a -> s{_dsdVersionId = a});
dsdDestinations :: Lens' DeliveryStreamDescription [DestinationDescription]
dsdDestinations = lens _dsdDestinations (\ s a -> s{_dsdDestinations = a}) . _Coerce;
dsdHasMoreDestinations :: Lens' DeliveryStreamDescription Bool
dsdHasMoreDestinations = lens _dsdHasMoreDestinations (\ s a -> s{_dsdHasMoreDestinations = a});
instance FromJSON DeliveryStreamDescription where
parseJSON
= withObject "DeliveryStreamDescription"
(\ x ->
DeliveryStreamDescription' <$>
(x .:? "CreateTimestamp") <*>
(x .:? "LastUpdateTimestamp")
<*> (x .: "DeliveryStreamName")
<*> (x .: "DeliveryStreamARN")
<*> (x .: "DeliveryStreamStatus")
<*> (x .: "VersionId")
<*> (x .:? "Destinations" .!= mempty)
<*> (x .: "HasMoreDestinations"))
instance Hashable DeliveryStreamDescription
instance NFData DeliveryStreamDescription
data DestinationDescription = DestinationDescription'
{ _ddS3DestinationDescription :: !(Maybe S3DestinationDescription)
, _ddElasticsearchDestinationDescription :: !(Maybe ElasticsearchDestinationDescription)
, _ddRedshiftDestinationDescription :: !(Maybe RedshiftDestinationDescription)
, _ddDestinationId :: !Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
destinationDescription
:: Text
-> DestinationDescription
destinationDescription pDestinationId_ =
DestinationDescription'
{ _ddS3DestinationDescription = Nothing
, _ddElasticsearchDestinationDescription = Nothing
, _ddRedshiftDestinationDescription = Nothing
, _ddDestinationId = pDestinationId_
}
ddS3DestinationDescription :: Lens' DestinationDescription (Maybe S3DestinationDescription)
ddS3DestinationDescription = lens _ddS3DestinationDescription (\ s a -> s{_ddS3DestinationDescription = a});
ddElasticsearchDestinationDescription :: Lens' DestinationDescription (Maybe ElasticsearchDestinationDescription)
ddElasticsearchDestinationDescription = lens _ddElasticsearchDestinationDescription (\ s a -> s{_ddElasticsearchDestinationDescription = a});
ddRedshiftDestinationDescription :: Lens' DestinationDescription (Maybe RedshiftDestinationDescription)
ddRedshiftDestinationDescription = lens _ddRedshiftDestinationDescription (\ s a -> s{_ddRedshiftDestinationDescription = a});
ddDestinationId :: Lens' DestinationDescription Text
ddDestinationId = lens _ddDestinationId (\ s a -> s{_ddDestinationId = a});
instance FromJSON DestinationDescription where
parseJSON
= withObject "DestinationDescription"
(\ x ->
DestinationDescription' <$>
(x .:? "S3DestinationDescription") <*>
(x .:? "ElasticsearchDestinationDescription")
<*> (x .:? "RedshiftDestinationDescription")
<*> (x .: "DestinationId"))
instance Hashable DestinationDescription
instance NFData DestinationDescription
data ElasticsearchBufferingHints = ElasticsearchBufferingHints'
{ _ebhSizeInMBs :: !(Maybe Nat)
, _ebhIntervalInSeconds :: !(Maybe Nat)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
elasticsearchBufferingHints
:: ElasticsearchBufferingHints
elasticsearchBufferingHints =
ElasticsearchBufferingHints'
{ _ebhSizeInMBs = Nothing
, _ebhIntervalInSeconds = Nothing
}
ebhSizeInMBs :: Lens' ElasticsearchBufferingHints (Maybe Natural)
ebhSizeInMBs = lens _ebhSizeInMBs (\ s a -> s{_ebhSizeInMBs = a}) . mapping _Nat;
ebhIntervalInSeconds :: Lens' ElasticsearchBufferingHints (Maybe Natural)
ebhIntervalInSeconds = lens _ebhIntervalInSeconds (\ s a -> s{_ebhIntervalInSeconds = a}) . mapping _Nat;
instance FromJSON ElasticsearchBufferingHints where
parseJSON
= withObject "ElasticsearchBufferingHints"
(\ x ->
ElasticsearchBufferingHints' <$>
(x .:? "SizeInMBs") <*> (x .:? "IntervalInSeconds"))
instance Hashable ElasticsearchBufferingHints
instance NFData ElasticsearchBufferingHints
instance ToJSON ElasticsearchBufferingHints where
toJSON ElasticsearchBufferingHints'{..}
= object
(catMaybes
[("SizeInMBs" .=) <$> _ebhSizeInMBs,
("IntervalInSeconds" .=) <$> _ebhIntervalInSeconds])
data ElasticsearchDestinationConfiguration = ElasticsearchDestinationConfiguration'
{ _edcIndexRotationPeriod :: !(Maybe ElasticsearchIndexRotationPeriod)
, _edcS3BackupMode :: !(Maybe ElasticsearchS3BackupMode)
, _edcCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _edcBufferingHints :: !(Maybe ElasticsearchBufferingHints)
, _edcRetryOptions :: !(Maybe ElasticsearchRetryOptions)
, _edcRoleARN :: !Text
, _edcDomainARN :: !Text
, _edcIndexName :: !Text
, _edcTypeName :: !Text
, _edcS3Configuration :: !S3DestinationConfiguration
} deriving (Eq,Read,Show,Data,Typeable,Generic)
elasticsearchDestinationConfiguration
:: Text
-> Text
-> Text
-> Text
-> S3DestinationConfiguration
-> ElasticsearchDestinationConfiguration
elasticsearchDestinationConfiguration pRoleARN_ pDomainARN_ pIndexName_ pTypeName_ pS3Configuration_ =
ElasticsearchDestinationConfiguration'
{ _edcIndexRotationPeriod = Nothing
, _edcS3BackupMode = Nothing
, _edcCloudWatchLoggingOptions = Nothing
, _edcBufferingHints = Nothing
, _edcRetryOptions = Nothing
, _edcRoleARN = pRoleARN_
, _edcDomainARN = pDomainARN_
, _edcIndexName = pIndexName_
, _edcTypeName = pTypeName_
, _edcS3Configuration = pS3Configuration_
}
edcIndexRotationPeriod :: Lens' ElasticsearchDestinationConfiguration (Maybe ElasticsearchIndexRotationPeriod)
edcIndexRotationPeriod = lens _edcIndexRotationPeriod (\ s a -> s{_edcIndexRotationPeriod = a});
edcS3BackupMode :: Lens' ElasticsearchDestinationConfiguration (Maybe ElasticsearchS3BackupMode)
edcS3BackupMode = lens _edcS3BackupMode (\ s a -> s{_edcS3BackupMode = a});
edcCloudWatchLoggingOptions :: Lens' ElasticsearchDestinationConfiguration (Maybe CloudWatchLoggingOptions)
edcCloudWatchLoggingOptions = lens _edcCloudWatchLoggingOptions (\ s a -> s{_edcCloudWatchLoggingOptions = a});
edcBufferingHints :: Lens' ElasticsearchDestinationConfiguration (Maybe ElasticsearchBufferingHints)
edcBufferingHints = lens _edcBufferingHints (\ s a -> s{_edcBufferingHints = a});
edcRetryOptions :: Lens' ElasticsearchDestinationConfiguration (Maybe ElasticsearchRetryOptions)
edcRetryOptions = lens _edcRetryOptions (\ s a -> s{_edcRetryOptions = a});
edcRoleARN :: Lens' ElasticsearchDestinationConfiguration Text
edcRoleARN = lens _edcRoleARN (\ s a -> s{_edcRoleARN = a});
edcDomainARN :: Lens' ElasticsearchDestinationConfiguration Text
edcDomainARN = lens _edcDomainARN (\ s a -> s{_edcDomainARN = a});
edcIndexName :: Lens' ElasticsearchDestinationConfiguration Text
edcIndexName = lens _edcIndexName (\ s a -> s{_edcIndexName = a});
edcTypeName :: Lens' ElasticsearchDestinationConfiguration Text
edcTypeName = lens _edcTypeName (\ s a -> s{_edcTypeName = a});
edcS3Configuration :: Lens' ElasticsearchDestinationConfiguration S3DestinationConfiguration
edcS3Configuration = lens _edcS3Configuration (\ s a -> s{_edcS3Configuration = a});
instance Hashable
ElasticsearchDestinationConfiguration
instance NFData ElasticsearchDestinationConfiguration
instance ToJSON ElasticsearchDestinationConfiguration
where
toJSON ElasticsearchDestinationConfiguration'{..}
= object
(catMaybes
[("IndexRotationPeriod" .=) <$>
_edcIndexRotationPeriod,
("S3BackupMode" .=) <$> _edcS3BackupMode,
("CloudWatchLoggingOptions" .=) <$>
_edcCloudWatchLoggingOptions,
("BufferingHints" .=) <$> _edcBufferingHints,
("RetryOptions" .=) <$> _edcRetryOptions,
Just ("RoleARN" .= _edcRoleARN),
Just ("DomainARN" .= _edcDomainARN),
Just ("IndexName" .= _edcIndexName),
Just ("TypeName" .= _edcTypeName),
Just ("S3Configuration" .= _edcS3Configuration)])
data ElasticsearchDestinationDescription = ElasticsearchDestinationDescription'
{ _eddIndexRotationPeriod :: !(Maybe ElasticsearchIndexRotationPeriod)
, _eddTypeName :: !(Maybe Text)
, _eddS3BackupMode :: !(Maybe ElasticsearchS3BackupMode)
, _eddDomainARN :: !(Maybe Text)
, _eddCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _eddS3DestinationDescription :: !(Maybe S3DestinationDescription)
, _eddBufferingHints :: !(Maybe ElasticsearchBufferingHints)
, _eddRetryOptions :: !(Maybe ElasticsearchRetryOptions)
, _eddRoleARN :: !(Maybe Text)
, _eddIndexName :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
elasticsearchDestinationDescription
:: ElasticsearchDestinationDescription
elasticsearchDestinationDescription =
ElasticsearchDestinationDescription'
{ _eddIndexRotationPeriod = Nothing
, _eddTypeName = Nothing
, _eddS3BackupMode = Nothing
, _eddDomainARN = Nothing
, _eddCloudWatchLoggingOptions = Nothing
, _eddS3DestinationDescription = Nothing
, _eddBufferingHints = Nothing
, _eddRetryOptions = Nothing
, _eddRoleARN = Nothing
, _eddIndexName = Nothing
}
eddIndexRotationPeriod :: Lens' ElasticsearchDestinationDescription (Maybe ElasticsearchIndexRotationPeriod)
eddIndexRotationPeriod = lens _eddIndexRotationPeriod (\ s a -> s{_eddIndexRotationPeriod = a});
eddTypeName :: Lens' ElasticsearchDestinationDescription (Maybe Text)
eddTypeName = lens _eddTypeName (\ s a -> s{_eddTypeName = a});
eddS3BackupMode :: Lens' ElasticsearchDestinationDescription (Maybe ElasticsearchS3BackupMode)
eddS3BackupMode = lens _eddS3BackupMode (\ s a -> s{_eddS3BackupMode = a});
eddDomainARN :: Lens' ElasticsearchDestinationDescription (Maybe Text)
eddDomainARN = lens _eddDomainARN (\ s a -> s{_eddDomainARN = a});
eddCloudWatchLoggingOptions :: Lens' ElasticsearchDestinationDescription (Maybe CloudWatchLoggingOptions)
eddCloudWatchLoggingOptions = lens _eddCloudWatchLoggingOptions (\ s a -> s{_eddCloudWatchLoggingOptions = a});
eddS3DestinationDescription :: Lens' ElasticsearchDestinationDescription (Maybe S3DestinationDescription)
eddS3DestinationDescription = lens _eddS3DestinationDescription (\ s a -> s{_eddS3DestinationDescription = a});
eddBufferingHints :: Lens' ElasticsearchDestinationDescription (Maybe ElasticsearchBufferingHints)
eddBufferingHints = lens _eddBufferingHints (\ s a -> s{_eddBufferingHints = a});
eddRetryOptions :: Lens' ElasticsearchDestinationDescription (Maybe ElasticsearchRetryOptions)
eddRetryOptions = lens _eddRetryOptions (\ s a -> s{_eddRetryOptions = a});
eddRoleARN :: Lens' ElasticsearchDestinationDescription (Maybe Text)
eddRoleARN = lens _eddRoleARN (\ s a -> s{_eddRoleARN = a});
eddIndexName :: Lens' ElasticsearchDestinationDescription (Maybe Text)
eddIndexName = lens _eddIndexName (\ s a -> s{_eddIndexName = a});
instance FromJSON ElasticsearchDestinationDescription
where
parseJSON
= withObject "ElasticsearchDestinationDescription"
(\ x ->
ElasticsearchDestinationDescription' <$>
(x .:? "IndexRotationPeriod") <*> (x .:? "TypeName")
<*> (x .:? "S3BackupMode")
<*> (x .:? "DomainARN")
<*> (x .:? "CloudWatchLoggingOptions")
<*> (x .:? "S3DestinationDescription")
<*> (x .:? "BufferingHints")
<*> (x .:? "RetryOptions")
<*> (x .:? "RoleARN")
<*> (x .:? "IndexName"))
instance Hashable ElasticsearchDestinationDescription
instance NFData ElasticsearchDestinationDescription
data ElasticsearchDestinationUpdate = ElasticsearchDestinationUpdate'
{ _eduIndexRotationPeriod :: !(Maybe ElasticsearchIndexRotationPeriod)
, _eduTypeName :: !(Maybe Text)
, _eduDomainARN :: !(Maybe Text)
, _eduCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _eduS3Update :: !(Maybe S3DestinationUpdate)
, _eduBufferingHints :: !(Maybe ElasticsearchBufferingHints)
, _eduRetryOptions :: !(Maybe ElasticsearchRetryOptions)
, _eduRoleARN :: !(Maybe Text)
, _eduIndexName :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
elasticsearchDestinationUpdate
:: ElasticsearchDestinationUpdate
elasticsearchDestinationUpdate =
ElasticsearchDestinationUpdate'
{ _eduIndexRotationPeriod = Nothing
, _eduTypeName = Nothing
, _eduDomainARN = Nothing
, _eduCloudWatchLoggingOptions = Nothing
, _eduS3Update = Nothing
, _eduBufferingHints = Nothing
, _eduRetryOptions = Nothing
, _eduRoleARN = Nothing
, _eduIndexName = Nothing
}
eduIndexRotationPeriod :: Lens' ElasticsearchDestinationUpdate (Maybe ElasticsearchIndexRotationPeriod)
eduIndexRotationPeriod = lens _eduIndexRotationPeriod (\ s a -> s{_eduIndexRotationPeriod = a});
eduTypeName :: Lens' ElasticsearchDestinationUpdate (Maybe Text)
eduTypeName = lens _eduTypeName (\ s a -> s{_eduTypeName = a});
eduDomainARN :: Lens' ElasticsearchDestinationUpdate (Maybe Text)
eduDomainARN = lens _eduDomainARN (\ s a -> s{_eduDomainARN = a});
eduCloudWatchLoggingOptions :: Lens' ElasticsearchDestinationUpdate (Maybe CloudWatchLoggingOptions)
eduCloudWatchLoggingOptions = lens _eduCloudWatchLoggingOptions (\ s a -> s{_eduCloudWatchLoggingOptions = a});
eduS3Update :: Lens' ElasticsearchDestinationUpdate (Maybe S3DestinationUpdate)
eduS3Update = lens _eduS3Update (\ s a -> s{_eduS3Update = a});
eduBufferingHints :: Lens' ElasticsearchDestinationUpdate (Maybe ElasticsearchBufferingHints)
eduBufferingHints = lens _eduBufferingHints (\ s a -> s{_eduBufferingHints = a});
eduRetryOptions :: Lens' ElasticsearchDestinationUpdate (Maybe ElasticsearchRetryOptions)
eduRetryOptions = lens _eduRetryOptions (\ s a -> s{_eduRetryOptions = a});
eduRoleARN :: Lens' ElasticsearchDestinationUpdate (Maybe Text)
eduRoleARN = lens _eduRoleARN (\ s a -> s{_eduRoleARN = a});
eduIndexName :: Lens' ElasticsearchDestinationUpdate (Maybe Text)
eduIndexName = lens _eduIndexName (\ s a -> s{_eduIndexName = a});
instance Hashable ElasticsearchDestinationUpdate
instance NFData ElasticsearchDestinationUpdate
instance ToJSON ElasticsearchDestinationUpdate where
toJSON ElasticsearchDestinationUpdate'{..}
= object
(catMaybes
[("IndexRotationPeriod" .=) <$>
_eduIndexRotationPeriod,
("TypeName" .=) <$> _eduTypeName,
("DomainARN" .=) <$> _eduDomainARN,
("CloudWatchLoggingOptions" .=) <$>
_eduCloudWatchLoggingOptions,
("S3Update" .=) <$> _eduS3Update,
("BufferingHints" .=) <$> _eduBufferingHints,
("RetryOptions" .=) <$> _eduRetryOptions,
("RoleARN" .=) <$> _eduRoleARN,
("IndexName" .=) <$> _eduIndexName])
newtype ElasticsearchRetryOptions = ElasticsearchRetryOptions'
{ _eroDurationInSeconds :: Maybe Nat
} deriving (Eq,Read,Show,Data,Typeable,Generic)
elasticsearchRetryOptions
:: ElasticsearchRetryOptions
elasticsearchRetryOptions =
ElasticsearchRetryOptions'
{ _eroDurationInSeconds = Nothing
}
eroDurationInSeconds :: Lens' ElasticsearchRetryOptions (Maybe Natural)
eroDurationInSeconds = lens _eroDurationInSeconds (\ s a -> s{_eroDurationInSeconds = a}) . mapping _Nat;
instance FromJSON ElasticsearchRetryOptions where
parseJSON
= withObject "ElasticsearchRetryOptions"
(\ x ->
ElasticsearchRetryOptions' <$>
(x .:? "DurationInSeconds"))
instance Hashable ElasticsearchRetryOptions
instance NFData ElasticsearchRetryOptions
instance ToJSON ElasticsearchRetryOptions where
toJSON ElasticsearchRetryOptions'{..}
= object
(catMaybes
[("DurationInSeconds" .=) <$> _eroDurationInSeconds])
data EncryptionConfiguration = EncryptionConfiguration'
{ _ecNoEncryptionConfig :: !(Maybe NoEncryptionConfig)
, _ecKMSEncryptionConfig :: !(Maybe KMSEncryptionConfig)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
encryptionConfiguration
:: EncryptionConfiguration
encryptionConfiguration =
EncryptionConfiguration'
{ _ecNoEncryptionConfig = Nothing
, _ecKMSEncryptionConfig = Nothing
}
ecNoEncryptionConfig :: Lens' EncryptionConfiguration (Maybe NoEncryptionConfig)
ecNoEncryptionConfig = lens _ecNoEncryptionConfig (\ s a -> s{_ecNoEncryptionConfig = a});
ecKMSEncryptionConfig :: Lens' EncryptionConfiguration (Maybe KMSEncryptionConfig)
ecKMSEncryptionConfig = lens _ecKMSEncryptionConfig (\ s a -> s{_ecKMSEncryptionConfig = a});
instance FromJSON EncryptionConfiguration where
parseJSON
= withObject "EncryptionConfiguration"
(\ x ->
EncryptionConfiguration' <$>
(x .:? "NoEncryptionConfig") <*>
(x .:? "KMSEncryptionConfig"))
instance Hashable EncryptionConfiguration
instance NFData EncryptionConfiguration
instance ToJSON EncryptionConfiguration where
toJSON EncryptionConfiguration'{..}
= object
(catMaybes
[("NoEncryptionConfig" .=) <$> _ecNoEncryptionConfig,
("KMSEncryptionConfig" .=) <$>
_ecKMSEncryptionConfig])
newtype KMSEncryptionConfig = KMSEncryptionConfig'
{ _kecAWSKMSKeyARN :: Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
kmsEncryptionConfig
:: Text
-> KMSEncryptionConfig
kmsEncryptionConfig pAWSKMSKeyARN_ =
KMSEncryptionConfig'
{ _kecAWSKMSKeyARN = pAWSKMSKeyARN_
}
kecAWSKMSKeyARN :: Lens' KMSEncryptionConfig Text
kecAWSKMSKeyARN = lens _kecAWSKMSKeyARN (\ s a -> s{_kecAWSKMSKeyARN = a});
instance FromJSON KMSEncryptionConfig where
parseJSON
= withObject "KMSEncryptionConfig"
(\ x ->
KMSEncryptionConfig' <$> (x .: "AWSKMSKeyARN"))
instance Hashable KMSEncryptionConfig
instance NFData KMSEncryptionConfig
instance ToJSON KMSEncryptionConfig where
toJSON KMSEncryptionConfig'{..}
= object
(catMaybes
[Just ("AWSKMSKeyARN" .= _kecAWSKMSKeyARN)])
data PutRecordBatchResponseEntry = PutRecordBatchResponseEntry'
{ _prbreRecordId :: !(Maybe Text)
, _prbreErrorCode :: !(Maybe Text)
, _prbreErrorMessage :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
putRecordBatchResponseEntry
:: PutRecordBatchResponseEntry
putRecordBatchResponseEntry =
PutRecordBatchResponseEntry'
{ _prbreRecordId = Nothing
, _prbreErrorCode = Nothing
, _prbreErrorMessage = Nothing
}
prbreRecordId :: Lens' PutRecordBatchResponseEntry (Maybe Text)
prbreRecordId = lens _prbreRecordId (\ s a -> s{_prbreRecordId = a});
prbreErrorCode :: Lens' PutRecordBatchResponseEntry (Maybe Text)
prbreErrorCode = lens _prbreErrorCode (\ s a -> s{_prbreErrorCode = a});
prbreErrorMessage :: Lens' PutRecordBatchResponseEntry (Maybe Text)
prbreErrorMessage = lens _prbreErrorMessage (\ s a -> s{_prbreErrorMessage = a});
instance FromJSON PutRecordBatchResponseEntry where
parseJSON
= withObject "PutRecordBatchResponseEntry"
(\ x ->
PutRecordBatchResponseEntry' <$>
(x .:? "RecordId") <*> (x .:? "ErrorCode") <*>
(x .:? "ErrorMessage"))
instance Hashable PutRecordBatchResponseEntry
instance NFData PutRecordBatchResponseEntry
newtype Record = Record'
{ _rData :: Base64
} deriving (Eq,Read,Show,Data,Typeable,Generic)
record
:: ByteString
-> Record
record pData_ =
Record'
{ _rData = _Base64 # pData_
}
rData :: Lens' Record ByteString
rData = lens _rData (\ s a -> s{_rData = a}) . _Base64;
instance Hashable Record
instance NFData Record
instance ToJSON Record where
toJSON Record'{..}
= object (catMaybes [Just ("Data" .= _rData)])
data RedshiftDestinationConfiguration = RedshiftDestinationConfiguration'
{ _rdcCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _rdcRetryOptions :: !(Maybe RedshiftRetryOptions)
, _rdcRoleARN :: !Text
, _rdcClusterJDBCURL :: !Text
, _rdcCopyCommand :: !CopyCommand
, _rdcUsername :: !(Sensitive Text)
, _rdcPassword :: !(Sensitive Text)
, _rdcS3Configuration :: !S3DestinationConfiguration
} deriving (Eq,Read,Show,Data,Typeable,Generic)
redshiftDestinationConfiguration
:: Text
-> Text
-> CopyCommand
-> Text
-> Text
-> S3DestinationConfiguration
-> RedshiftDestinationConfiguration
redshiftDestinationConfiguration pRoleARN_ pClusterJDBCURL_ pCopyCommand_ pUsername_ pPassword_ pS3Configuration_ =
RedshiftDestinationConfiguration'
{ _rdcCloudWatchLoggingOptions = Nothing
, _rdcRetryOptions = Nothing
, _rdcRoleARN = pRoleARN_
, _rdcClusterJDBCURL = pClusterJDBCURL_
, _rdcCopyCommand = pCopyCommand_
, _rdcUsername = _Sensitive # pUsername_
, _rdcPassword = _Sensitive # pPassword_
, _rdcS3Configuration = pS3Configuration_
}
rdcCloudWatchLoggingOptions :: Lens' RedshiftDestinationConfiguration (Maybe CloudWatchLoggingOptions)
rdcCloudWatchLoggingOptions = lens _rdcCloudWatchLoggingOptions (\ s a -> s{_rdcCloudWatchLoggingOptions = a});
rdcRetryOptions :: Lens' RedshiftDestinationConfiguration (Maybe RedshiftRetryOptions)
rdcRetryOptions = lens _rdcRetryOptions (\ s a -> s{_rdcRetryOptions = a});
rdcRoleARN :: Lens' RedshiftDestinationConfiguration Text
rdcRoleARN = lens _rdcRoleARN (\ s a -> s{_rdcRoleARN = a});
rdcClusterJDBCURL :: Lens' RedshiftDestinationConfiguration Text
rdcClusterJDBCURL = lens _rdcClusterJDBCURL (\ s a -> s{_rdcClusterJDBCURL = a});
rdcCopyCommand :: Lens' RedshiftDestinationConfiguration CopyCommand
rdcCopyCommand = lens _rdcCopyCommand (\ s a -> s{_rdcCopyCommand = a});
rdcUsername :: Lens' RedshiftDestinationConfiguration Text
rdcUsername = lens _rdcUsername (\ s a -> s{_rdcUsername = a}) . _Sensitive;
rdcPassword :: Lens' RedshiftDestinationConfiguration Text
rdcPassword = lens _rdcPassword (\ s a -> s{_rdcPassword = a}) . _Sensitive;
rdcS3Configuration :: Lens' RedshiftDestinationConfiguration S3DestinationConfiguration
rdcS3Configuration = lens _rdcS3Configuration (\ s a -> s{_rdcS3Configuration = a});
instance Hashable RedshiftDestinationConfiguration
instance NFData RedshiftDestinationConfiguration
instance ToJSON RedshiftDestinationConfiguration
where
toJSON RedshiftDestinationConfiguration'{..}
= object
(catMaybes
[("CloudWatchLoggingOptions" .=) <$>
_rdcCloudWatchLoggingOptions,
("RetryOptions" .=) <$> _rdcRetryOptions,
Just ("RoleARN" .= _rdcRoleARN),
Just ("ClusterJDBCURL" .= _rdcClusterJDBCURL),
Just ("CopyCommand" .= _rdcCopyCommand),
Just ("Username" .= _rdcUsername),
Just ("Password" .= _rdcPassword),
Just ("S3Configuration" .= _rdcS3Configuration)])
data RedshiftDestinationDescription = RedshiftDestinationDescription'
{ _rddCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _rddRetryOptions :: !(Maybe RedshiftRetryOptions)
, _rddRoleARN :: !Text
, _rddClusterJDBCURL :: !Text
, _rddCopyCommand :: !CopyCommand
, _rddUsername :: !(Sensitive Text)
, _rddS3DestinationDescription :: !S3DestinationDescription
} deriving (Eq,Read,Show,Data,Typeable,Generic)
redshiftDestinationDescription
:: Text
-> Text
-> CopyCommand
-> Text
-> S3DestinationDescription
-> RedshiftDestinationDescription
redshiftDestinationDescription pRoleARN_ pClusterJDBCURL_ pCopyCommand_ pUsername_ pS3DestinationDescription_ =
RedshiftDestinationDescription'
{ _rddCloudWatchLoggingOptions = Nothing
, _rddRetryOptions = Nothing
, _rddRoleARN = pRoleARN_
, _rddClusterJDBCURL = pClusterJDBCURL_
, _rddCopyCommand = pCopyCommand_
, _rddUsername = _Sensitive # pUsername_
, _rddS3DestinationDescription = pS3DestinationDescription_
}
rddCloudWatchLoggingOptions :: Lens' RedshiftDestinationDescription (Maybe CloudWatchLoggingOptions)
rddCloudWatchLoggingOptions = lens _rddCloudWatchLoggingOptions (\ s a -> s{_rddCloudWatchLoggingOptions = a});
rddRetryOptions :: Lens' RedshiftDestinationDescription (Maybe RedshiftRetryOptions)
rddRetryOptions = lens _rddRetryOptions (\ s a -> s{_rddRetryOptions = a});
rddRoleARN :: Lens' RedshiftDestinationDescription Text
rddRoleARN = lens _rddRoleARN (\ s a -> s{_rddRoleARN = a});
rddClusterJDBCURL :: Lens' RedshiftDestinationDescription Text
rddClusterJDBCURL = lens _rddClusterJDBCURL (\ s a -> s{_rddClusterJDBCURL = a});
rddCopyCommand :: Lens' RedshiftDestinationDescription CopyCommand
rddCopyCommand = lens _rddCopyCommand (\ s a -> s{_rddCopyCommand = a});
rddUsername :: Lens' RedshiftDestinationDescription Text
rddUsername = lens _rddUsername (\ s a -> s{_rddUsername = a}) . _Sensitive;
rddS3DestinationDescription :: Lens' RedshiftDestinationDescription S3DestinationDescription
rddS3DestinationDescription = lens _rddS3DestinationDescription (\ s a -> s{_rddS3DestinationDescription = a});
instance FromJSON RedshiftDestinationDescription
where
parseJSON
= withObject "RedshiftDestinationDescription"
(\ x ->
RedshiftDestinationDescription' <$>
(x .:? "CloudWatchLoggingOptions") <*>
(x .:? "RetryOptions")
<*> (x .: "RoleARN")
<*> (x .: "ClusterJDBCURL")
<*> (x .: "CopyCommand")
<*> (x .: "Username")
<*> (x .: "S3DestinationDescription"))
instance Hashable RedshiftDestinationDescription
instance NFData RedshiftDestinationDescription
data RedshiftDestinationUpdate = RedshiftDestinationUpdate'
{ _rduCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _rduUsername :: !(Maybe (Sensitive Text))
, _rduS3Update :: !(Maybe S3DestinationUpdate)
, _rduPassword :: !(Maybe (Sensitive Text))
, _rduCopyCommand :: !(Maybe CopyCommand)
, _rduRetryOptions :: !(Maybe RedshiftRetryOptions)
, _rduClusterJDBCURL :: !(Maybe Text)
, _rduRoleARN :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
redshiftDestinationUpdate
:: RedshiftDestinationUpdate
redshiftDestinationUpdate =
RedshiftDestinationUpdate'
{ _rduCloudWatchLoggingOptions = Nothing
, _rduUsername = Nothing
, _rduS3Update = Nothing
, _rduPassword = Nothing
, _rduCopyCommand = Nothing
, _rduRetryOptions = Nothing
, _rduClusterJDBCURL = Nothing
, _rduRoleARN = Nothing
}
rduCloudWatchLoggingOptions :: Lens' RedshiftDestinationUpdate (Maybe CloudWatchLoggingOptions)
rduCloudWatchLoggingOptions = lens _rduCloudWatchLoggingOptions (\ s a -> s{_rduCloudWatchLoggingOptions = a});
rduUsername :: Lens' RedshiftDestinationUpdate (Maybe Text)
rduUsername = lens _rduUsername (\ s a -> s{_rduUsername = a}) . mapping _Sensitive;
rduS3Update :: Lens' RedshiftDestinationUpdate (Maybe S3DestinationUpdate)
rduS3Update = lens _rduS3Update (\ s a -> s{_rduS3Update = a});
rduPassword :: Lens' RedshiftDestinationUpdate (Maybe Text)
rduPassword = lens _rduPassword (\ s a -> s{_rduPassword = a}) . mapping _Sensitive;
rduCopyCommand :: Lens' RedshiftDestinationUpdate (Maybe CopyCommand)
rduCopyCommand = lens _rduCopyCommand (\ s a -> s{_rduCopyCommand = a});
rduRetryOptions :: Lens' RedshiftDestinationUpdate (Maybe RedshiftRetryOptions)
rduRetryOptions = lens _rduRetryOptions (\ s a -> s{_rduRetryOptions = a});
rduClusterJDBCURL :: Lens' RedshiftDestinationUpdate (Maybe Text)
rduClusterJDBCURL = lens _rduClusterJDBCURL (\ s a -> s{_rduClusterJDBCURL = a});
rduRoleARN :: Lens' RedshiftDestinationUpdate (Maybe Text)
rduRoleARN = lens _rduRoleARN (\ s a -> s{_rduRoleARN = a});
instance Hashable RedshiftDestinationUpdate
instance NFData RedshiftDestinationUpdate
instance ToJSON RedshiftDestinationUpdate where
toJSON RedshiftDestinationUpdate'{..}
= object
(catMaybes
[("CloudWatchLoggingOptions" .=) <$>
_rduCloudWatchLoggingOptions,
("Username" .=) <$> _rduUsername,
("S3Update" .=) <$> _rduS3Update,
("Password" .=) <$> _rduPassword,
("CopyCommand" .=) <$> _rduCopyCommand,
("RetryOptions" .=) <$> _rduRetryOptions,
("ClusterJDBCURL" .=) <$> _rduClusterJDBCURL,
("RoleARN" .=) <$> _rduRoleARN])
newtype RedshiftRetryOptions = RedshiftRetryOptions'
{ _rroDurationInSeconds :: Maybe Nat
} deriving (Eq,Read,Show,Data,Typeable,Generic)
redshiftRetryOptions
:: RedshiftRetryOptions
redshiftRetryOptions =
RedshiftRetryOptions'
{ _rroDurationInSeconds = Nothing
}
rroDurationInSeconds :: Lens' RedshiftRetryOptions (Maybe Natural)
rroDurationInSeconds = lens _rroDurationInSeconds (\ s a -> s{_rroDurationInSeconds = a}) . mapping _Nat;
instance FromJSON RedshiftRetryOptions where
parseJSON
= withObject "RedshiftRetryOptions"
(\ x ->
RedshiftRetryOptions' <$>
(x .:? "DurationInSeconds"))
instance Hashable RedshiftRetryOptions
instance NFData RedshiftRetryOptions
instance ToJSON RedshiftRetryOptions where
toJSON RedshiftRetryOptions'{..}
= object
(catMaybes
[("DurationInSeconds" .=) <$> _rroDurationInSeconds])
data S3DestinationConfiguration = S3DestinationConfiguration'
{ _sdcPrefix :: !(Maybe Text)
, _sdcCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _sdcEncryptionConfiguration :: !(Maybe EncryptionConfiguration)
, _sdcCompressionFormat :: !(Maybe CompressionFormat)
, _sdcBufferingHints :: !(Maybe BufferingHints)
, _sdcRoleARN :: !Text
, _sdcBucketARN :: !Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
s3DestinationConfiguration
:: Text
-> Text
-> S3DestinationConfiguration
s3DestinationConfiguration pRoleARN_ pBucketARN_ =
S3DestinationConfiguration'
{ _sdcPrefix = Nothing
, _sdcCloudWatchLoggingOptions = Nothing
, _sdcEncryptionConfiguration = Nothing
, _sdcCompressionFormat = Nothing
, _sdcBufferingHints = Nothing
, _sdcRoleARN = pRoleARN_
, _sdcBucketARN = pBucketARN_
}
sdcPrefix :: Lens' S3DestinationConfiguration (Maybe Text)
sdcPrefix = lens _sdcPrefix (\ s a -> s{_sdcPrefix = a});
sdcCloudWatchLoggingOptions :: Lens' S3DestinationConfiguration (Maybe CloudWatchLoggingOptions)
sdcCloudWatchLoggingOptions = lens _sdcCloudWatchLoggingOptions (\ s a -> s{_sdcCloudWatchLoggingOptions = a});
sdcEncryptionConfiguration :: Lens' S3DestinationConfiguration (Maybe EncryptionConfiguration)
sdcEncryptionConfiguration = lens _sdcEncryptionConfiguration (\ s a -> s{_sdcEncryptionConfiguration = a});
sdcCompressionFormat :: Lens' S3DestinationConfiguration (Maybe CompressionFormat)
sdcCompressionFormat = lens _sdcCompressionFormat (\ s a -> s{_sdcCompressionFormat = a});
sdcBufferingHints :: Lens' S3DestinationConfiguration (Maybe BufferingHints)
sdcBufferingHints = lens _sdcBufferingHints (\ s a -> s{_sdcBufferingHints = a});
sdcRoleARN :: Lens' S3DestinationConfiguration Text
sdcRoleARN = lens _sdcRoleARN (\ s a -> s{_sdcRoleARN = a});
sdcBucketARN :: Lens' S3DestinationConfiguration Text
sdcBucketARN = lens _sdcBucketARN (\ s a -> s{_sdcBucketARN = a});
instance Hashable S3DestinationConfiguration
instance NFData S3DestinationConfiguration
instance ToJSON S3DestinationConfiguration where
toJSON S3DestinationConfiguration'{..}
= object
(catMaybes
[("Prefix" .=) <$> _sdcPrefix,
("CloudWatchLoggingOptions" .=) <$>
_sdcCloudWatchLoggingOptions,
("EncryptionConfiguration" .=) <$>
_sdcEncryptionConfiguration,
("CompressionFormat" .=) <$> _sdcCompressionFormat,
("BufferingHints" .=) <$> _sdcBufferingHints,
Just ("RoleARN" .= _sdcRoleARN),
Just ("BucketARN" .= _sdcBucketARN)])
data S3DestinationDescription = S3DestinationDescription'
{ _sddPrefix :: !(Maybe Text)
, _sddCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _sddRoleARN :: !Text
, _sddBucketARN :: !Text
, _sddBufferingHints :: !BufferingHints
, _sddCompressionFormat :: !CompressionFormat
, _sddEncryptionConfiguration :: !EncryptionConfiguration
} deriving (Eq,Read,Show,Data,Typeable,Generic)
s3DestinationDescription
:: Text
-> Text
-> BufferingHints
-> CompressionFormat
-> EncryptionConfiguration
-> S3DestinationDescription
s3DestinationDescription pRoleARN_ pBucketARN_ pBufferingHints_ pCompressionFormat_ pEncryptionConfiguration_ =
S3DestinationDescription'
{ _sddPrefix = Nothing
, _sddCloudWatchLoggingOptions = Nothing
, _sddRoleARN = pRoleARN_
, _sddBucketARN = pBucketARN_
, _sddBufferingHints = pBufferingHints_
, _sddCompressionFormat = pCompressionFormat_
, _sddEncryptionConfiguration = pEncryptionConfiguration_
}
sddPrefix :: Lens' S3DestinationDescription (Maybe Text)
sddPrefix = lens _sddPrefix (\ s a -> s{_sddPrefix = a});
sddCloudWatchLoggingOptions :: Lens' S3DestinationDescription (Maybe CloudWatchLoggingOptions)
sddCloudWatchLoggingOptions = lens _sddCloudWatchLoggingOptions (\ s a -> s{_sddCloudWatchLoggingOptions = a});
sddRoleARN :: Lens' S3DestinationDescription Text
sddRoleARN = lens _sddRoleARN (\ s a -> s{_sddRoleARN = a});
sddBucketARN :: Lens' S3DestinationDescription Text
sddBucketARN = lens _sddBucketARN (\ s a -> s{_sddBucketARN = a});
sddBufferingHints :: Lens' S3DestinationDescription BufferingHints
sddBufferingHints = lens _sddBufferingHints (\ s a -> s{_sddBufferingHints = a});
sddCompressionFormat :: Lens' S3DestinationDescription CompressionFormat
sddCompressionFormat = lens _sddCompressionFormat (\ s a -> s{_sddCompressionFormat = a});
sddEncryptionConfiguration :: Lens' S3DestinationDescription EncryptionConfiguration
sddEncryptionConfiguration = lens _sddEncryptionConfiguration (\ s a -> s{_sddEncryptionConfiguration = a});
instance FromJSON S3DestinationDescription where
parseJSON
= withObject "S3DestinationDescription"
(\ x ->
S3DestinationDescription' <$>
(x .:? "Prefix") <*>
(x .:? "CloudWatchLoggingOptions")
<*> (x .: "RoleARN")
<*> (x .: "BucketARN")
<*> (x .: "BufferingHints")
<*> (x .: "CompressionFormat")
<*> (x .: "EncryptionConfiguration"))
instance Hashable S3DestinationDescription
instance NFData S3DestinationDescription
data S3DestinationUpdate = S3DestinationUpdate'
{ _sduPrefix :: !(Maybe Text)
, _sduCloudWatchLoggingOptions :: !(Maybe CloudWatchLoggingOptions)
, _sduEncryptionConfiguration :: !(Maybe EncryptionConfiguration)
, _sduCompressionFormat :: !(Maybe CompressionFormat)
, _sduBufferingHints :: !(Maybe BufferingHints)
, _sduBucketARN :: !(Maybe Text)
, _sduRoleARN :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
s3DestinationUpdate
:: S3DestinationUpdate
s3DestinationUpdate =
S3DestinationUpdate'
{ _sduPrefix = Nothing
, _sduCloudWatchLoggingOptions = Nothing
, _sduEncryptionConfiguration = Nothing
, _sduCompressionFormat = Nothing
, _sduBufferingHints = Nothing
, _sduBucketARN = Nothing
, _sduRoleARN = Nothing
}
sduPrefix :: Lens' S3DestinationUpdate (Maybe Text)
sduPrefix = lens _sduPrefix (\ s a -> s{_sduPrefix = a});
sduCloudWatchLoggingOptions :: Lens' S3DestinationUpdate (Maybe CloudWatchLoggingOptions)
sduCloudWatchLoggingOptions = lens _sduCloudWatchLoggingOptions (\ s a -> s{_sduCloudWatchLoggingOptions = a});
sduEncryptionConfiguration :: Lens' S3DestinationUpdate (Maybe EncryptionConfiguration)
sduEncryptionConfiguration = lens _sduEncryptionConfiguration (\ s a -> s{_sduEncryptionConfiguration = a});
sduCompressionFormat :: Lens' S3DestinationUpdate (Maybe CompressionFormat)
sduCompressionFormat = lens _sduCompressionFormat (\ s a -> s{_sduCompressionFormat = a});
sduBufferingHints :: Lens' S3DestinationUpdate (Maybe BufferingHints)
sduBufferingHints = lens _sduBufferingHints (\ s a -> s{_sduBufferingHints = a});
sduBucketARN :: Lens' S3DestinationUpdate (Maybe Text)
sduBucketARN = lens _sduBucketARN (\ s a -> s{_sduBucketARN = a});
sduRoleARN :: Lens' S3DestinationUpdate (Maybe Text)
sduRoleARN = lens _sduRoleARN (\ s a -> s{_sduRoleARN = a});
instance Hashable S3DestinationUpdate
instance NFData S3DestinationUpdate
instance ToJSON S3DestinationUpdate where
toJSON S3DestinationUpdate'{..}
= object
(catMaybes
[("Prefix" .=) <$> _sduPrefix,
("CloudWatchLoggingOptions" .=) <$>
_sduCloudWatchLoggingOptions,
("EncryptionConfiguration" .=) <$>
_sduEncryptionConfiguration,
("CompressionFormat" .=) <$> _sduCompressionFormat,
("BufferingHints" .=) <$> _sduBufferingHints,
("BucketARN" .=) <$> _sduBucketARN,
("RoleARN" .=) <$> _sduRoleARN])