{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module Network.AWS.KinesisAnalytics.Types.Product where
import Network.AWS.KinesisAnalytics.Types.Sum
import Network.AWS.Lens
import Network.AWS.Prelude
data ApplicationDetail = ApplicationDetail'
{ _adApplicationDescription :: !(Maybe Text)
, _adOutputDescriptions :: !(Maybe [OutputDescription])
, _adCloudWatchLoggingOptionDescriptions :: !(Maybe [CloudWatchLoggingOptionDescription])
, _adReferenceDataSourceDescriptions :: !(Maybe [ReferenceDataSourceDescription])
, _adInputDescriptions :: !(Maybe [InputDescription])
, _adApplicationCode :: !(Maybe Text)
, _adCreateTimestamp :: !(Maybe POSIX)
, _adLastUpdateTimestamp :: !(Maybe POSIX)
, _adApplicationName :: !Text
, _adApplicationARN :: !Text
, _adApplicationStatus :: !ApplicationStatus
, _adApplicationVersionId :: !Nat
} deriving (Eq, Read, Show, Data, Typeable, Generic)
applicationDetail
:: Text
-> Text
-> ApplicationStatus
-> Natural
-> ApplicationDetail
applicationDetail pApplicationName_ pApplicationARN_ pApplicationStatus_ pApplicationVersionId_ =
ApplicationDetail'
{ _adApplicationDescription = Nothing
, _adOutputDescriptions = Nothing
, _adCloudWatchLoggingOptionDescriptions = Nothing
, _adReferenceDataSourceDescriptions = Nothing
, _adInputDescriptions = Nothing
, _adApplicationCode = Nothing
, _adCreateTimestamp = Nothing
, _adLastUpdateTimestamp = Nothing
, _adApplicationName = pApplicationName_
, _adApplicationARN = pApplicationARN_
, _adApplicationStatus = pApplicationStatus_
, _adApplicationVersionId = _Nat # pApplicationVersionId_
}
adApplicationDescription :: Lens' ApplicationDetail (Maybe Text)
adApplicationDescription = lens _adApplicationDescription (\ s a -> s{_adApplicationDescription = a})
adOutputDescriptions :: Lens' ApplicationDetail [OutputDescription]
adOutputDescriptions = lens _adOutputDescriptions (\ s a -> s{_adOutputDescriptions = a}) . _Default . _Coerce
adCloudWatchLoggingOptionDescriptions :: Lens' ApplicationDetail [CloudWatchLoggingOptionDescription]
adCloudWatchLoggingOptionDescriptions = lens _adCloudWatchLoggingOptionDescriptions (\ s a -> s{_adCloudWatchLoggingOptionDescriptions = a}) . _Default . _Coerce
adReferenceDataSourceDescriptions :: Lens' ApplicationDetail [ReferenceDataSourceDescription]
adReferenceDataSourceDescriptions = lens _adReferenceDataSourceDescriptions (\ s a -> s{_adReferenceDataSourceDescriptions = a}) . _Default . _Coerce
adInputDescriptions :: Lens' ApplicationDetail [InputDescription]
adInputDescriptions = lens _adInputDescriptions (\ s a -> s{_adInputDescriptions = a}) . _Default . _Coerce
adApplicationCode :: Lens' ApplicationDetail (Maybe Text)
adApplicationCode = lens _adApplicationCode (\ s a -> s{_adApplicationCode = a})
adCreateTimestamp :: Lens' ApplicationDetail (Maybe UTCTime)
adCreateTimestamp = lens _adCreateTimestamp (\ s a -> s{_adCreateTimestamp = a}) . mapping _Time
adLastUpdateTimestamp :: Lens' ApplicationDetail (Maybe UTCTime)
adLastUpdateTimestamp = lens _adLastUpdateTimestamp (\ s a -> s{_adLastUpdateTimestamp = a}) . mapping _Time
adApplicationName :: Lens' ApplicationDetail Text
adApplicationName = lens _adApplicationName (\ s a -> s{_adApplicationName = a})
adApplicationARN :: Lens' ApplicationDetail Text
adApplicationARN = lens _adApplicationARN (\ s a -> s{_adApplicationARN = a})
adApplicationStatus :: Lens' ApplicationDetail ApplicationStatus
adApplicationStatus = lens _adApplicationStatus (\ s a -> s{_adApplicationStatus = a})
adApplicationVersionId :: Lens' ApplicationDetail Natural
adApplicationVersionId = lens _adApplicationVersionId (\ s a -> s{_adApplicationVersionId = a}) . _Nat
instance FromJSON ApplicationDetail where
parseJSON
= withObject "ApplicationDetail"
(\ x ->
ApplicationDetail' <$>
(x .:? "ApplicationDescription") <*>
(x .:? "OutputDescriptions" .!= mempty)
<*>
(x .:? "CloudWatchLoggingOptionDescriptions" .!=
mempty)
<*>
(x .:? "ReferenceDataSourceDescriptions" .!= mempty)
<*> (x .:? "InputDescriptions" .!= mempty)
<*> (x .:? "ApplicationCode")
<*> (x .:? "CreateTimestamp")
<*> (x .:? "LastUpdateTimestamp")
<*> (x .: "ApplicationName")
<*> (x .: "ApplicationARN")
<*> (x .: "ApplicationStatus")
<*> (x .: "ApplicationVersionId"))
instance Hashable ApplicationDetail where
instance NFData ApplicationDetail where
data ApplicationSummary = ApplicationSummary'
{ _asApplicationName :: !Text
, _asApplicationARN :: !Text
, _asApplicationStatus :: !ApplicationStatus
} deriving (Eq, Read, Show, Data, Typeable, Generic)
applicationSummary
:: Text
-> Text
-> ApplicationStatus
-> ApplicationSummary
applicationSummary pApplicationName_ pApplicationARN_ pApplicationStatus_ =
ApplicationSummary'
{ _asApplicationName = pApplicationName_
, _asApplicationARN = pApplicationARN_
, _asApplicationStatus = pApplicationStatus_
}
asApplicationName :: Lens' ApplicationSummary Text
asApplicationName = lens _asApplicationName (\ s a -> s{_asApplicationName = a})
asApplicationARN :: Lens' ApplicationSummary Text
asApplicationARN = lens _asApplicationARN (\ s a -> s{_asApplicationARN = a})
asApplicationStatus :: Lens' ApplicationSummary ApplicationStatus
asApplicationStatus = lens _asApplicationStatus (\ s a -> s{_asApplicationStatus = a})
instance FromJSON ApplicationSummary where
parseJSON
= withObject "ApplicationSummary"
(\ x ->
ApplicationSummary' <$>
(x .: "ApplicationName") <*> (x .: "ApplicationARN")
<*> (x .: "ApplicationStatus"))
instance Hashable ApplicationSummary where
instance NFData ApplicationSummary where
data ApplicationUpdate = ApplicationUpdate'
{ _auReferenceDataSourceUpdates :: !(Maybe [ReferenceDataSourceUpdate])
, _auInputUpdates :: !(Maybe [InputUpdate])
, _auCloudWatchLoggingOptionUpdates :: !(Maybe [CloudWatchLoggingOptionUpdate])
, _auOutputUpdates :: !(Maybe [OutputUpdate])
, _auApplicationCodeUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
applicationUpdate
:: ApplicationUpdate
applicationUpdate =
ApplicationUpdate'
{ _auReferenceDataSourceUpdates = Nothing
, _auInputUpdates = Nothing
, _auCloudWatchLoggingOptionUpdates = Nothing
, _auOutputUpdates = Nothing
, _auApplicationCodeUpdate = Nothing
}
auReferenceDataSourceUpdates :: Lens' ApplicationUpdate [ReferenceDataSourceUpdate]
auReferenceDataSourceUpdates = lens _auReferenceDataSourceUpdates (\ s a -> s{_auReferenceDataSourceUpdates = a}) . _Default . _Coerce
auInputUpdates :: Lens' ApplicationUpdate [InputUpdate]
auInputUpdates = lens _auInputUpdates (\ s a -> s{_auInputUpdates = a}) . _Default . _Coerce
auCloudWatchLoggingOptionUpdates :: Lens' ApplicationUpdate [CloudWatchLoggingOptionUpdate]
auCloudWatchLoggingOptionUpdates = lens _auCloudWatchLoggingOptionUpdates (\ s a -> s{_auCloudWatchLoggingOptionUpdates = a}) . _Default . _Coerce
auOutputUpdates :: Lens' ApplicationUpdate [OutputUpdate]
auOutputUpdates = lens _auOutputUpdates (\ s a -> s{_auOutputUpdates = a}) . _Default . _Coerce
auApplicationCodeUpdate :: Lens' ApplicationUpdate (Maybe Text)
auApplicationCodeUpdate = lens _auApplicationCodeUpdate (\ s a -> s{_auApplicationCodeUpdate = a})
instance Hashable ApplicationUpdate where
instance NFData ApplicationUpdate where
instance ToJSON ApplicationUpdate where
toJSON ApplicationUpdate'{..}
= object
(catMaybes
[("ReferenceDataSourceUpdates" .=) <$>
_auReferenceDataSourceUpdates,
("InputUpdates" .=) <$> _auInputUpdates,
("CloudWatchLoggingOptionUpdates" .=) <$>
_auCloudWatchLoggingOptionUpdates,
("OutputUpdates" .=) <$> _auOutputUpdates,
("ApplicationCodeUpdate" .=) <$>
_auApplicationCodeUpdate])
data CSVMappingParameters = CSVMappingParameters'
{ _cmpRecordRowDelimiter :: !Text
, _cmpRecordColumnDelimiter :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
csvMappingParameters
:: Text
-> Text
-> CSVMappingParameters
csvMappingParameters pRecordRowDelimiter_ pRecordColumnDelimiter_ =
CSVMappingParameters'
{ _cmpRecordRowDelimiter = pRecordRowDelimiter_
, _cmpRecordColumnDelimiter = pRecordColumnDelimiter_
}
cmpRecordRowDelimiter :: Lens' CSVMappingParameters Text
cmpRecordRowDelimiter = lens _cmpRecordRowDelimiter (\ s a -> s{_cmpRecordRowDelimiter = a})
cmpRecordColumnDelimiter :: Lens' CSVMappingParameters Text
cmpRecordColumnDelimiter = lens _cmpRecordColumnDelimiter (\ s a -> s{_cmpRecordColumnDelimiter = a})
instance FromJSON CSVMappingParameters where
parseJSON
= withObject "CSVMappingParameters"
(\ x ->
CSVMappingParameters' <$>
(x .: "RecordRowDelimiter") <*>
(x .: "RecordColumnDelimiter"))
instance Hashable CSVMappingParameters where
instance NFData CSVMappingParameters where
instance ToJSON CSVMappingParameters where
toJSON CSVMappingParameters'{..}
= object
(catMaybes
[Just
("RecordRowDelimiter" .= _cmpRecordRowDelimiter),
Just
("RecordColumnDelimiter" .=
_cmpRecordColumnDelimiter)])
data CloudWatchLoggingOption = CloudWatchLoggingOption'
{ _cwloLogStreamARN :: !Text
, _cwloRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
cloudWatchLoggingOption
:: Text
-> Text
-> CloudWatchLoggingOption
cloudWatchLoggingOption pLogStreamARN_ pRoleARN_ =
CloudWatchLoggingOption'
{_cwloLogStreamARN = pLogStreamARN_, _cwloRoleARN = pRoleARN_}
cwloLogStreamARN :: Lens' CloudWatchLoggingOption Text
cwloLogStreamARN = lens _cwloLogStreamARN (\ s a -> s{_cwloLogStreamARN = a})
cwloRoleARN :: Lens' CloudWatchLoggingOption Text
cwloRoleARN = lens _cwloRoleARN (\ s a -> s{_cwloRoleARN = a})
instance Hashable CloudWatchLoggingOption where
instance NFData CloudWatchLoggingOption where
instance ToJSON CloudWatchLoggingOption where
toJSON CloudWatchLoggingOption'{..}
= object
(catMaybes
[Just ("LogStreamARN" .= _cwloLogStreamARN),
Just ("RoleARN" .= _cwloRoleARN)])
data CloudWatchLoggingOptionDescription = CloudWatchLoggingOptionDescription'
{ _cwlodCloudWatchLoggingOptionId :: !(Maybe Text)
, _cwlodLogStreamARN :: !Text
, _cwlodRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
cloudWatchLoggingOptionDescription
:: Text
-> Text
-> CloudWatchLoggingOptionDescription
cloudWatchLoggingOptionDescription pLogStreamARN_ pRoleARN_ =
CloudWatchLoggingOptionDescription'
{ _cwlodCloudWatchLoggingOptionId = Nothing
, _cwlodLogStreamARN = pLogStreamARN_
, _cwlodRoleARN = pRoleARN_
}
cwlodCloudWatchLoggingOptionId :: Lens' CloudWatchLoggingOptionDescription (Maybe Text)
cwlodCloudWatchLoggingOptionId = lens _cwlodCloudWatchLoggingOptionId (\ s a -> s{_cwlodCloudWatchLoggingOptionId = a})
cwlodLogStreamARN :: Lens' CloudWatchLoggingOptionDescription Text
cwlodLogStreamARN = lens _cwlodLogStreamARN (\ s a -> s{_cwlodLogStreamARN = a})
cwlodRoleARN :: Lens' CloudWatchLoggingOptionDescription Text
cwlodRoleARN = lens _cwlodRoleARN (\ s a -> s{_cwlodRoleARN = a})
instance FromJSON CloudWatchLoggingOptionDescription
where
parseJSON
= withObject "CloudWatchLoggingOptionDescription"
(\ x ->
CloudWatchLoggingOptionDescription' <$>
(x .:? "CloudWatchLoggingOptionId") <*>
(x .: "LogStreamARN")
<*> (x .: "RoleARN"))
instance Hashable CloudWatchLoggingOptionDescription
where
instance NFData CloudWatchLoggingOptionDescription
where
data CloudWatchLoggingOptionUpdate = CloudWatchLoggingOptionUpdate'
{ _cwlouRoleARNUpdate :: !(Maybe Text)
, _cwlouLogStreamARNUpdate :: !(Maybe Text)
, _cwlouCloudWatchLoggingOptionId :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
cloudWatchLoggingOptionUpdate
:: Text
-> CloudWatchLoggingOptionUpdate
cloudWatchLoggingOptionUpdate pCloudWatchLoggingOptionId_ =
CloudWatchLoggingOptionUpdate'
{ _cwlouRoleARNUpdate = Nothing
, _cwlouLogStreamARNUpdate = Nothing
, _cwlouCloudWatchLoggingOptionId = pCloudWatchLoggingOptionId_
}
cwlouRoleARNUpdate :: Lens' CloudWatchLoggingOptionUpdate (Maybe Text)
cwlouRoleARNUpdate = lens _cwlouRoleARNUpdate (\ s a -> s{_cwlouRoleARNUpdate = a})
cwlouLogStreamARNUpdate :: Lens' CloudWatchLoggingOptionUpdate (Maybe Text)
cwlouLogStreamARNUpdate = lens _cwlouLogStreamARNUpdate (\ s a -> s{_cwlouLogStreamARNUpdate = a})
cwlouCloudWatchLoggingOptionId :: Lens' CloudWatchLoggingOptionUpdate Text
cwlouCloudWatchLoggingOptionId = lens _cwlouCloudWatchLoggingOptionId (\ s a -> s{_cwlouCloudWatchLoggingOptionId = a})
instance Hashable CloudWatchLoggingOptionUpdate where
instance NFData CloudWatchLoggingOptionUpdate where
instance ToJSON CloudWatchLoggingOptionUpdate where
toJSON CloudWatchLoggingOptionUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _cwlouRoleARNUpdate,
("LogStreamARNUpdate" .=) <$>
_cwlouLogStreamARNUpdate,
Just
("CloudWatchLoggingOptionId" .=
_cwlouCloudWatchLoggingOptionId)])
newtype DestinationSchema = DestinationSchema'
{ _dsRecordFormatType :: Maybe RecordFormatType
} deriving (Eq, Read, Show, Data, Typeable, Generic)
destinationSchema
:: DestinationSchema
destinationSchema = DestinationSchema' {_dsRecordFormatType = Nothing}
dsRecordFormatType :: Lens' DestinationSchema (Maybe RecordFormatType)
dsRecordFormatType = lens _dsRecordFormatType (\ s a -> s{_dsRecordFormatType = a})
instance FromJSON DestinationSchema where
parseJSON
= withObject "DestinationSchema"
(\ x ->
DestinationSchema' <$> (x .:? "RecordFormatType"))
instance Hashable DestinationSchema where
instance NFData DestinationSchema where
instance ToJSON DestinationSchema where
toJSON DestinationSchema'{..}
= object
(catMaybes
[("RecordFormatType" .=) <$> _dsRecordFormatType])
data Input = Input'
{ _iInputParallelism :: !(Maybe InputParallelism)
, _iInputProcessingConfiguration :: !(Maybe InputProcessingConfiguration)
, _iKinesisStreamsInput :: !(Maybe KinesisStreamsInput)
, _iKinesisFirehoseInput :: !(Maybe KinesisFirehoseInput)
, _iNamePrefix :: !Text
, _iInputSchema :: !SourceSchema
} deriving (Eq, Read, Show, Data, Typeable, Generic)
input
:: Text
-> SourceSchema
-> Input
input pNamePrefix_ pInputSchema_ =
Input'
{ _iInputParallelism = Nothing
, _iInputProcessingConfiguration = Nothing
, _iKinesisStreamsInput = Nothing
, _iKinesisFirehoseInput = Nothing
, _iNamePrefix = pNamePrefix_
, _iInputSchema = pInputSchema_
}
iInputParallelism :: Lens' Input (Maybe InputParallelism)
iInputParallelism = lens _iInputParallelism (\ s a -> s{_iInputParallelism = a})
iInputProcessingConfiguration :: Lens' Input (Maybe InputProcessingConfiguration)
iInputProcessingConfiguration = lens _iInputProcessingConfiguration (\ s a -> s{_iInputProcessingConfiguration = a})
iKinesisStreamsInput :: Lens' Input (Maybe KinesisStreamsInput)
iKinesisStreamsInput = lens _iKinesisStreamsInput (\ s a -> s{_iKinesisStreamsInput = a})
iKinesisFirehoseInput :: Lens' Input (Maybe KinesisFirehoseInput)
iKinesisFirehoseInput = lens _iKinesisFirehoseInput (\ s a -> s{_iKinesisFirehoseInput = a})
iNamePrefix :: Lens' Input Text
iNamePrefix = lens _iNamePrefix (\ s a -> s{_iNamePrefix = a})
iInputSchema :: Lens' Input SourceSchema
iInputSchema = lens _iInputSchema (\ s a -> s{_iInputSchema = a})
instance Hashable Input where
instance NFData Input where
instance ToJSON Input where
toJSON Input'{..}
= object
(catMaybes
[("InputParallelism" .=) <$> _iInputParallelism,
("InputProcessingConfiguration" .=) <$>
_iInputProcessingConfiguration,
("KinesisStreamsInput" .=) <$> _iKinesisStreamsInput,
("KinesisFirehoseInput" .=) <$>
_iKinesisFirehoseInput,
Just ("NamePrefix" .= _iNamePrefix),
Just ("InputSchema" .= _iInputSchema)])
data InputConfiguration = InputConfiguration'
{ _icId :: !Text
, _icInputStartingPositionConfiguration :: !InputStartingPositionConfiguration
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputConfiguration
:: Text
-> InputStartingPositionConfiguration
-> InputConfiguration
inputConfiguration pId_ pInputStartingPositionConfiguration_ =
InputConfiguration'
{ _icId = pId_
, _icInputStartingPositionConfiguration =
pInputStartingPositionConfiguration_
}
icId :: Lens' InputConfiguration Text
icId = lens _icId (\ s a -> s{_icId = a})
icInputStartingPositionConfiguration :: Lens' InputConfiguration InputStartingPositionConfiguration
icInputStartingPositionConfiguration = lens _icInputStartingPositionConfiguration (\ s a -> s{_icInputStartingPositionConfiguration = a})
instance Hashable InputConfiguration where
instance NFData InputConfiguration where
instance ToJSON InputConfiguration where
toJSON InputConfiguration'{..}
= object
(catMaybes
[Just ("Id" .= _icId),
Just
("InputStartingPositionConfiguration" .=
_icInputStartingPositionConfiguration)])
data InputDescription = InputDescription'
{ _idInputStartingPositionConfiguration :: !(Maybe InputStartingPositionConfiguration)
, _idInputParallelism :: !(Maybe InputParallelism)
, _idInputId :: !(Maybe Text)
, _idInAppStreamNames :: !(Maybe [Text])
, _idKinesisFirehoseInputDescription :: !(Maybe KinesisFirehoseInputDescription)
, _idInputSchema :: !(Maybe SourceSchema)
, _idKinesisStreamsInputDescription :: !(Maybe KinesisStreamsInputDescription)
, _idNamePrefix :: !(Maybe Text)
, _idInputProcessingConfigurationDescription :: !(Maybe InputProcessingConfigurationDescription)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputDescription
:: InputDescription
inputDescription =
InputDescription'
{ _idInputStartingPositionConfiguration = Nothing
, _idInputParallelism = Nothing
, _idInputId = Nothing
, _idInAppStreamNames = Nothing
, _idKinesisFirehoseInputDescription = Nothing
, _idInputSchema = Nothing
, _idKinesisStreamsInputDescription = Nothing
, _idNamePrefix = Nothing
, _idInputProcessingConfigurationDescription = Nothing
}
idInputStartingPositionConfiguration :: Lens' InputDescription (Maybe InputStartingPositionConfiguration)
idInputStartingPositionConfiguration = lens _idInputStartingPositionConfiguration (\ s a -> s{_idInputStartingPositionConfiguration = a})
idInputParallelism :: Lens' InputDescription (Maybe InputParallelism)
idInputParallelism = lens _idInputParallelism (\ s a -> s{_idInputParallelism = a})
idInputId :: Lens' InputDescription (Maybe Text)
idInputId = lens _idInputId (\ s a -> s{_idInputId = a})
idInAppStreamNames :: Lens' InputDescription [Text]
idInAppStreamNames = lens _idInAppStreamNames (\ s a -> s{_idInAppStreamNames = a}) . _Default . _Coerce
idKinesisFirehoseInputDescription :: Lens' InputDescription (Maybe KinesisFirehoseInputDescription)
idKinesisFirehoseInputDescription = lens _idKinesisFirehoseInputDescription (\ s a -> s{_idKinesisFirehoseInputDescription = a})
idInputSchema :: Lens' InputDescription (Maybe SourceSchema)
idInputSchema = lens _idInputSchema (\ s a -> s{_idInputSchema = a})
idKinesisStreamsInputDescription :: Lens' InputDescription (Maybe KinesisStreamsInputDescription)
idKinesisStreamsInputDescription = lens _idKinesisStreamsInputDescription (\ s a -> s{_idKinesisStreamsInputDescription = a})
idNamePrefix :: Lens' InputDescription (Maybe Text)
idNamePrefix = lens _idNamePrefix (\ s a -> s{_idNamePrefix = a})
idInputProcessingConfigurationDescription :: Lens' InputDescription (Maybe InputProcessingConfigurationDescription)
idInputProcessingConfigurationDescription = lens _idInputProcessingConfigurationDescription (\ s a -> s{_idInputProcessingConfigurationDescription = a})
instance FromJSON InputDescription where
parseJSON
= withObject "InputDescription"
(\ x ->
InputDescription' <$>
(x .:? "InputStartingPositionConfiguration") <*>
(x .:? "InputParallelism")
<*> (x .:? "InputId")
<*> (x .:? "InAppStreamNames" .!= mempty)
<*> (x .:? "KinesisFirehoseInputDescription")
<*> (x .:? "InputSchema")
<*> (x .:? "KinesisStreamsInputDescription")
<*> (x .:? "NamePrefix")
<*>
(x .:? "InputProcessingConfigurationDescription"))
instance Hashable InputDescription where
instance NFData InputDescription where
data InputLambdaProcessor = InputLambdaProcessor'
{ _ilpResourceARN :: !Text
, _ilpRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputLambdaProcessor
:: Text
-> Text
-> InputLambdaProcessor
inputLambdaProcessor pResourceARN_ pRoleARN_ =
InputLambdaProcessor'
{_ilpResourceARN = pResourceARN_, _ilpRoleARN = pRoleARN_}
ilpResourceARN :: Lens' InputLambdaProcessor Text
ilpResourceARN = lens _ilpResourceARN (\ s a -> s{_ilpResourceARN = a})
ilpRoleARN :: Lens' InputLambdaProcessor Text
ilpRoleARN = lens _ilpRoleARN (\ s a -> s{_ilpRoleARN = a})
instance Hashable InputLambdaProcessor where
instance NFData InputLambdaProcessor where
instance ToJSON InputLambdaProcessor where
toJSON InputLambdaProcessor'{..}
= object
(catMaybes
[Just ("ResourceARN" .= _ilpResourceARN),
Just ("RoleARN" .= _ilpRoleARN)])
data InputLambdaProcessorDescription = InputLambdaProcessorDescription'
{ _ilpdResourceARN :: !(Maybe Text)
, _ilpdRoleARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputLambdaProcessorDescription
:: InputLambdaProcessorDescription
inputLambdaProcessorDescription =
InputLambdaProcessorDescription'
{_ilpdResourceARN = Nothing, _ilpdRoleARN = Nothing}
ilpdResourceARN :: Lens' InputLambdaProcessorDescription (Maybe Text)
ilpdResourceARN = lens _ilpdResourceARN (\ s a -> s{_ilpdResourceARN = a})
ilpdRoleARN :: Lens' InputLambdaProcessorDescription (Maybe Text)
ilpdRoleARN = lens _ilpdRoleARN (\ s a -> s{_ilpdRoleARN = a})
instance FromJSON InputLambdaProcessorDescription
where
parseJSON
= withObject "InputLambdaProcessorDescription"
(\ x ->
InputLambdaProcessorDescription' <$>
(x .:? "ResourceARN") <*> (x .:? "RoleARN"))
instance Hashable InputLambdaProcessorDescription
where
instance NFData InputLambdaProcessorDescription where
data InputLambdaProcessorUpdate = InputLambdaProcessorUpdate'
{ _ilpuRoleARNUpdate :: !(Maybe Text)
, _ilpuResourceARNUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputLambdaProcessorUpdate
:: InputLambdaProcessorUpdate
inputLambdaProcessorUpdate =
InputLambdaProcessorUpdate'
{_ilpuRoleARNUpdate = Nothing, _ilpuResourceARNUpdate = Nothing}
ilpuRoleARNUpdate :: Lens' InputLambdaProcessorUpdate (Maybe Text)
ilpuRoleARNUpdate = lens _ilpuRoleARNUpdate (\ s a -> s{_ilpuRoleARNUpdate = a})
ilpuResourceARNUpdate :: Lens' InputLambdaProcessorUpdate (Maybe Text)
ilpuResourceARNUpdate = lens _ilpuResourceARNUpdate (\ s a -> s{_ilpuResourceARNUpdate = a})
instance Hashable InputLambdaProcessorUpdate where
instance NFData InputLambdaProcessorUpdate where
instance ToJSON InputLambdaProcessorUpdate where
toJSON InputLambdaProcessorUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _ilpuRoleARNUpdate,
("ResourceARNUpdate" .=) <$> _ilpuResourceARNUpdate])
newtype InputParallelism = InputParallelism'
{ _ipCount :: Maybe Nat
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputParallelism
:: InputParallelism
inputParallelism = InputParallelism' {_ipCount = Nothing}
ipCount :: Lens' InputParallelism (Maybe Natural)
ipCount = lens _ipCount (\ s a -> s{_ipCount = a}) . mapping _Nat
instance FromJSON InputParallelism where
parseJSON
= withObject "InputParallelism"
(\ x -> InputParallelism' <$> (x .:? "Count"))
instance Hashable InputParallelism where
instance NFData InputParallelism where
instance ToJSON InputParallelism where
toJSON InputParallelism'{..}
= object (catMaybes [("Count" .=) <$> _ipCount])
newtype InputParallelismUpdate = InputParallelismUpdate'
{ _ipuCountUpdate :: Maybe Nat
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputParallelismUpdate
:: InputParallelismUpdate
inputParallelismUpdate = InputParallelismUpdate' {_ipuCountUpdate = Nothing}
ipuCountUpdate :: Lens' InputParallelismUpdate (Maybe Natural)
ipuCountUpdate = lens _ipuCountUpdate (\ s a -> s{_ipuCountUpdate = a}) . mapping _Nat
instance Hashable InputParallelismUpdate where
instance NFData InputParallelismUpdate where
instance ToJSON InputParallelismUpdate where
toJSON InputParallelismUpdate'{..}
= object
(catMaybes [("CountUpdate" .=) <$> _ipuCountUpdate])
newtype InputProcessingConfiguration = InputProcessingConfiguration'
{ _ipcInputLambdaProcessor :: InputLambdaProcessor
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputProcessingConfiguration
:: InputLambdaProcessor
-> InputProcessingConfiguration
inputProcessingConfiguration pInputLambdaProcessor_ =
InputProcessingConfiguration'
{_ipcInputLambdaProcessor = pInputLambdaProcessor_}
ipcInputLambdaProcessor :: Lens' InputProcessingConfiguration InputLambdaProcessor
ipcInputLambdaProcessor = lens _ipcInputLambdaProcessor (\ s a -> s{_ipcInputLambdaProcessor = a})
instance Hashable InputProcessingConfiguration where
instance NFData InputProcessingConfiguration where
instance ToJSON InputProcessingConfiguration where
toJSON InputProcessingConfiguration'{..}
= object
(catMaybes
[Just
("InputLambdaProcessor" .=
_ipcInputLambdaProcessor)])
newtype InputProcessingConfigurationDescription = InputProcessingConfigurationDescription'
{ _ipcdInputLambdaProcessorDescription :: Maybe InputLambdaProcessorDescription
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputProcessingConfigurationDescription
:: InputProcessingConfigurationDescription
inputProcessingConfigurationDescription =
InputProcessingConfigurationDescription'
{_ipcdInputLambdaProcessorDescription = Nothing}
ipcdInputLambdaProcessorDescription :: Lens' InputProcessingConfigurationDescription (Maybe InputLambdaProcessorDescription)
ipcdInputLambdaProcessorDescription = lens _ipcdInputLambdaProcessorDescription (\ s a -> s{_ipcdInputLambdaProcessorDescription = a})
instance FromJSON
InputProcessingConfigurationDescription
where
parseJSON
= withObject
"InputProcessingConfigurationDescription"
(\ x ->
InputProcessingConfigurationDescription' <$>
(x .:? "InputLambdaProcessorDescription"))
instance Hashable
InputProcessingConfigurationDescription
where
instance NFData
InputProcessingConfigurationDescription
where
newtype InputProcessingConfigurationUpdate = InputProcessingConfigurationUpdate'
{ _ipcuInputLambdaProcessorUpdate :: InputLambdaProcessorUpdate
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputProcessingConfigurationUpdate
:: InputLambdaProcessorUpdate
-> InputProcessingConfigurationUpdate
inputProcessingConfigurationUpdate pInputLambdaProcessorUpdate_ =
InputProcessingConfigurationUpdate'
{_ipcuInputLambdaProcessorUpdate = pInputLambdaProcessorUpdate_}
ipcuInputLambdaProcessorUpdate :: Lens' InputProcessingConfigurationUpdate InputLambdaProcessorUpdate
ipcuInputLambdaProcessorUpdate = lens _ipcuInputLambdaProcessorUpdate (\ s a -> s{_ipcuInputLambdaProcessorUpdate = a})
instance Hashable InputProcessingConfigurationUpdate
where
instance NFData InputProcessingConfigurationUpdate
where
instance ToJSON InputProcessingConfigurationUpdate
where
toJSON InputProcessingConfigurationUpdate'{..}
= object
(catMaybes
[Just
("InputLambdaProcessorUpdate" .=
_ipcuInputLambdaProcessorUpdate)])
data InputSchemaUpdate = InputSchemaUpdate'
{ _isuRecordFormatUpdate :: !(Maybe RecordFormat)
, _isuRecordEncodingUpdate :: !(Maybe Text)
, _isuRecordColumnUpdates :: !(Maybe (List1 RecordColumn))
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputSchemaUpdate
:: InputSchemaUpdate
inputSchemaUpdate =
InputSchemaUpdate'
{ _isuRecordFormatUpdate = Nothing
, _isuRecordEncodingUpdate = Nothing
, _isuRecordColumnUpdates = Nothing
}
isuRecordFormatUpdate :: Lens' InputSchemaUpdate (Maybe RecordFormat)
isuRecordFormatUpdate = lens _isuRecordFormatUpdate (\ s a -> s{_isuRecordFormatUpdate = a})
isuRecordEncodingUpdate :: Lens' InputSchemaUpdate (Maybe Text)
isuRecordEncodingUpdate = lens _isuRecordEncodingUpdate (\ s a -> s{_isuRecordEncodingUpdate = a})
isuRecordColumnUpdates :: Lens' InputSchemaUpdate (Maybe (NonEmpty RecordColumn))
isuRecordColumnUpdates = lens _isuRecordColumnUpdates (\ s a -> s{_isuRecordColumnUpdates = a}) . mapping _List1
instance Hashable InputSchemaUpdate where
instance NFData InputSchemaUpdate where
instance ToJSON InputSchemaUpdate where
toJSON InputSchemaUpdate'{..}
= object
(catMaybes
[("RecordFormatUpdate" .=) <$>
_isuRecordFormatUpdate,
("RecordEncodingUpdate" .=) <$>
_isuRecordEncodingUpdate,
("RecordColumnUpdates" .=) <$>
_isuRecordColumnUpdates])
newtype InputStartingPositionConfiguration = InputStartingPositionConfiguration'
{ _ispcInputStartingPosition :: Maybe InputStartingPosition
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputStartingPositionConfiguration
:: InputStartingPositionConfiguration
inputStartingPositionConfiguration =
InputStartingPositionConfiguration' {_ispcInputStartingPosition = Nothing}
ispcInputStartingPosition :: Lens' InputStartingPositionConfiguration (Maybe InputStartingPosition)
ispcInputStartingPosition = lens _ispcInputStartingPosition (\ s a -> s{_ispcInputStartingPosition = a})
instance FromJSON InputStartingPositionConfiguration
where
parseJSON
= withObject "InputStartingPositionConfiguration"
(\ x ->
InputStartingPositionConfiguration' <$>
(x .:? "InputStartingPosition"))
instance Hashable InputStartingPositionConfiguration
where
instance NFData InputStartingPositionConfiguration
where
instance ToJSON InputStartingPositionConfiguration
where
toJSON InputStartingPositionConfiguration'{..}
= object
(catMaybes
[("InputStartingPosition" .=) <$>
_ispcInputStartingPosition])
data InputUpdate = InputUpdate'
{ _iuInputProcessingConfigurationUpdate :: !(Maybe InputProcessingConfigurationUpdate)
, _iuKinesisStreamsInputUpdate :: !(Maybe KinesisStreamsInputUpdate)
, _iuInputParallelismUpdate :: !(Maybe InputParallelismUpdate)
, _iuNamePrefixUpdate :: !(Maybe Text)
, _iuInputSchemaUpdate :: !(Maybe InputSchemaUpdate)
, _iuKinesisFirehoseInputUpdate :: !(Maybe KinesisFirehoseInputUpdate)
, _iuInputId :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputUpdate
:: Text
-> InputUpdate
inputUpdate pInputId_ =
InputUpdate'
{ _iuInputProcessingConfigurationUpdate = Nothing
, _iuKinesisStreamsInputUpdate = Nothing
, _iuInputParallelismUpdate = Nothing
, _iuNamePrefixUpdate = Nothing
, _iuInputSchemaUpdate = Nothing
, _iuKinesisFirehoseInputUpdate = Nothing
, _iuInputId = pInputId_
}
iuInputProcessingConfigurationUpdate :: Lens' InputUpdate (Maybe InputProcessingConfigurationUpdate)
iuInputProcessingConfigurationUpdate = lens _iuInputProcessingConfigurationUpdate (\ s a -> s{_iuInputProcessingConfigurationUpdate = a})
iuKinesisStreamsInputUpdate :: Lens' InputUpdate (Maybe KinesisStreamsInputUpdate)
iuKinesisStreamsInputUpdate = lens _iuKinesisStreamsInputUpdate (\ s a -> s{_iuKinesisStreamsInputUpdate = a})
iuInputParallelismUpdate :: Lens' InputUpdate (Maybe InputParallelismUpdate)
iuInputParallelismUpdate = lens _iuInputParallelismUpdate (\ s a -> s{_iuInputParallelismUpdate = a})
iuNamePrefixUpdate :: Lens' InputUpdate (Maybe Text)
iuNamePrefixUpdate = lens _iuNamePrefixUpdate (\ s a -> s{_iuNamePrefixUpdate = a})
iuInputSchemaUpdate :: Lens' InputUpdate (Maybe InputSchemaUpdate)
iuInputSchemaUpdate = lens _iuInputSchemaUpdate (\ s a -> s{_iuInputSchemaUpdate = a})
iuKinesisFirehoseInputUpdate :: Lens' InputUpdate (Maybe KinesisFirehoseInputUpdate)
iuKinesisFirehoseInputUpdate = lens _iuKinesisFirehoseInputUpdate (\ s a -> s{_iuKinesisFirehoseInputUpdate = a})
iuInputId :: Lens' InputUpdate Text
iuInputId = lens _iuInputId (\ s a -> s{_iuInputId = a})
instance Hashable InputUpdate where
instance NFData InputUpdate where
instance ToJSON InputUpdate where
toJSON InputUpdate'{..}
= object
(catMaybes
[("InputProcessingConfigurationUpdate" .=) <$>
_iuInputProcessingConfigurationUpdate,
("KinesisStreamsInputUpdate" .=) <$>
_iuKinesisStreamsInputUpdate,
("InputParallelismUpdate" .=) <$>
_iuInputParallelismUpdate,
("NamePrefixUpdate" .=) <$> _iuNamePrefixUpdate,
("InputSchemaUpdate" .=) <$> _iuInputSchemaUpdate,
("KinesisFirehoseInputUpdate" .=) <$>
_iuKinesisFirehoseInputUpdate,
Just ("InputId" .= _iuInputId)])
newtype JSONMappingParameters = JSONMappingParameters'
{ _jmpRecordRowPath :: Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
jsonMappingParameters
:: Text
-> JSONMappingParameters
jsonMappingParameters pRecordRowPath_ =
JSONMappingParameters' {_jmpRecordRowPath = pRecordRowPath_}
jmpRecordRowPath :: Lens' JSONMappingParameters Text
jmpRecordRowPath = lens _jmpRecordRowPath (\ s a -> s{_jmpRecordRowPath = a})
instance FromJSON JSONMappingParameters where
parseJSON
= withObject "JSONMappingParameters"
(\ x ->
JSONMappingParameters' <$> (x .: "RecordRowPath"))
instance Hashable JSONMappingParameters where
instance NFData JSONMappingParameters where
instance ToJSON JSONMappingParameters where
toJSON JSONMappingParameters'{..}
= object
(catMaybes
[Just ("RecordRowPath" .= _jmpRecordRowPath)])
data KinesisFirehoseInput = KinesisFirehoseInput'
{ _kfiResourceARN :: !Text
, _kfiRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisFirehoseInput
:: Text
-> Text
-> KinesisFirehoseInput
kinesisFirehoseInput pResourceARN_ pRoleARN_ =
KinesisFirehoseInput'
{_kfiResourceARN = pResourceARN_, _kfiRoleARN = pRoleARN_}
kfiResourceARN :: Lens' KinesisFirehoseInput Text
kfiResourceARN = lens _kfiResourceARN (\ s a -> s{_kfiResourceARN = a})
kfiRoleARN :: Lens' KinesisFirehoseInput Text
kfiRoleARN = lens _kfiRoleARN (\ s a -> s{_kfiRoleARN = a})
instance Hashable KinesisFirehoseInput where
instance NFData KinesisFirehoseInput where
instance ToJSON KinesisFirehoseInput where
toJSON KinesisFirehoseInput'{..}
= object
(catMaybes
[Just ("ResourceARN" .= _kfiResourceARN),
Just ("RoleARN" .= _kfiRoleARN)])
data KinesisFirehoseInputDescription = KinesisFirehoseInputDescription'
{ _kfidResourceARN :: !(Maybe Text)
, _kfidRoleARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisFirehoseInputDescription
:: KinesisFirehoseInputDescription
kinesisFirehoseInputDescription =
KinesisFirehoseInputDescription'
{_kfidResourceARN = Nothing, _kfidRoleARN = Nothing}
kfidResourceARN :: Lens' KinesisFirehoseInputDescription (Maybe Text)
kfidResourceARN = lens _kfidResourceARN (\ s a -> s{_kfidResourceARN = a})
kfidRoleARN :: Lens' KinesisFirehoseInputDescription (Maybe Text)
kfidRoleARN = lens _kfidRoleARN (\ s a -> s{_kfidRoleARN = a})
instance FromJSON KinesisFirehoseInputDescription
where
parseJSON
= withObject "KinesisFirehoseInputDescription"
(\ x ->
KinesisFirehoseInputDescription' <$>
(x .:? "ResourceARN") <*> (x .:? "RoleARN"))
instance Hashable KinesisFirehoseInputDescription
where
instance NFData KinesisFirehoseInputDescription where
data KinesisFirehoseInputUpdate = KinesisFirehoseInputUpdate'
{ _kfiuRoleARNUpdate :: !(Maybe Text)
, _kfiuResourceARNUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisFirehoseInputUpdate
:: KinesisFirehoseInputUpdate
kinesisFirehoseInputUpdate =
KinesisFirehoseInputUpdate'
{_kfiuRoleARNUpdate = Nothing, _kfiuResourceARNUpdate = Nothing}
kfiuRoleARNUpdate :: Lens' KinesisFirehoseInputUpdate (Maybe Text)
kfiuRoleARNUpdate = lens _kfiuRoleARNUpdate (\ s a -> s{_kfiuRoleARNUpdate = a})
kfiuResourceARNUpdate :: Lens' KinesisFirehoseInputUpdate (Maybe Text)
kfiuResourceARNUpdate = lens _kfiuResourceARNUpdate (\ s a -> s{_kfiuResourceARNUpdate = a})
instance Hashable KinesisFirehoseInputUpdate where
instance NFData KinesisFirehoseInputUpdate where
instance ToJSON KinesisFirehoseInputUpdate where
toJSON KinesisFirehoseInputUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _kfiuRoleARNUpdate,
("ResourceARNUpdate" .=) <$> _kfiuResourceARNUpdate])
data KinesisFirehoseOutput = KinesisFirehoseOutput'
{ _kfoResourceARN :: !Text
, _kfoRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisFirehoseOutput
:: Text
-> Text
-> KinesisFirehoseOutput
kinesisFirehoseOutput pResourceARN_ pRoleARN_ =
KinesisFirehoseOutput'
{_kfoResourceARN = pResourceARN_, _kfoRoleARN = pRoleARN_}
kfoResourceARN :: Lens' KinesisFirehoseOutput Text
kfoResourceARN = lens _kfoResourceARN (\ s a -> s{_kfoResourceARN = a})
kfoRoleARN :: Lens' KinesisFirehoseOutput Text
kfoRoleARN = lens _kfoRoleARN (\ s a -> s{_kfoRoleARN = a})
instance Hashable KinesisFirehoseOutput where
instance NFData KinesisFirehoseOutput where
instance ToJSON KinesisFirehoseOutput where
toJSON KinesisFirehoseOutput'{..}
= object
(catMaybes
[Just ("ResourceARN" .= _kfoResourceARN),
Just ("RoleARN" .= _kfoRoleARN)])
data KinesisFirehoseOutputDescription = KinesisFirehoseOutputDescription'
{ _kfodResourceARN :: !(Maybe Text)
, _kfodRoleARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisFirehoseOutputDescription
:: KinesisFirehoseOutputDescription
kinesisFirehoseOutputDescription =
KinesisFirehoseOutputDescription'
{_kfodResourceARN = Nothing, _kfodRoleARN = Nothing}
kfodResourceARN :: Lens' KinesisFirehoseOutputDescription (Maybe Text)
kfodResourceARN = lens _kfodResourceARN (\ s a -> s{_kfodResourceARN = a})
kfodRoleARN :: Lens' KinesisFirehoseOutputDescription (Maybe Text)
kfodRoleARN = lens _kfodRoleARN (\ s a -> s{_kfodRoleARN = a})
instance FromJSON KinesisFirehoseOutputDescription
where
parseJSON
= withObject "KinesisFirehoseOutputDescription"
(\ x ->
KinesisFirehoseOutputDescription' <$>
(x .:? "ResourceARN") <*> (x .:? "RoleARN"))
instance Hashable KinesisFirehoseOutputDescription
where
instance NFData KinesisFirehoseOutputDescription
where
data KinesisFirehoseOutputUpdate = KinesisFirehoseOutputUpdate'
{ _kfouRoleARNUpdate :: !(Maybe Text)
, _kfouResourceARNUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisFirehoseOutputUpdate
:: KinesisFirehoseOutputUpdate
kinesisFirehoseOutputUpdate =
KinesisFirehoseOutputUpdate'
{_kfouRoleARNUpdate = Nothing, _kfouResourceARNUpdate = Nothing}
kfouRoleARNUpdate :: Lens' KinesisFirehoseOutputUpdate (Maybe Text)
kfouRoleARNUpdate = lens _kfouRoleARNUpdate (\ s a -> s{_kfouRoleARNUpdate = a})
kfouResourceARNUpdate :: Lens' KinesisFirehoseOutputUpdate (Maybe Text)
kfouResourceARNUpdate = lens _kfouResourceARNUpdate (\ s a -> s{_kfouResourceARNUpdate = a})
instance Hashable KinesisFirehoseOutputUpdate where
instance NFData KinesisFirehoseOutputUpdate where
instance ToJSON KinesisFirehoseOutputUpdate where
toJSON KinesisFirehoseOutputUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _kfouRoleARNUpdate,
("ResourceARNUpdate" .=) <$> _kfouResourceARNUpdate])
data KinesisStreamsInput = KinesisStreamsInput'
{ _ksiResourceARN :: !Text
, _ksiRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisStreamsInput
:: Text
-> Text
-> KinesisStreamsInput
kinesisStreamsInput pResourceARN_ pRoleARN_ =
KinesisStreamsInput'
{_ksiResourceARN = pResourceARN_, _ksiRoleARN = pRoleARN_}
ksiResourceARN :: Lens' KinesisStreamsInput Text
ksiResourceARN = lens _ksiResourceARN (\ s a -> s{_ksiResourceARN = a})
ksiRoleARN :: Lens' KinesisStreamsInput Text
ksiRoleARN = lens _ksiRoleARN (\ s a -> s{_ksiRoleARN = a})
instance Hashable KinesisStreamsInput where
instance NFData KinesisStreamsInput where
instance ToJSON KinesisStreamsInput where
toJSON KinesisStreamsInput'{..}
= object
(catMaybes
[Just ("ResourceARN" .= _ksiResourceARN),
Just ("RoleARN" .= _ksiRoleARN)])
data KinesisStreamsInputDescription = KinesisStreamsInputDescription'
{ _ksidResourceARN :: !(Maybe Text)
, _ksidRoleARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisStreamsInputDescription
:: KinesisStreamsInputDescription
kinesisStreamsInputDescription =
KinesisStreamsInputDescription'
{_ksidResourceARN = Nothing, _ksidRoleARN = Nothing}
ksidResourceARN :: Lens' KinesisStreamsInputDescription (Maybe Text)
ksidResourceARN = lens _ksidResourceARN (\ s a -> s{_ksidResourceARN = a})
ksidRoleARN :: Lens' KinesisStreamsInputDescription (Maybe Text)
ksidRoleARN = lens _ksidRoleARN (\ s a -> s{_ksidRoleARN = a})
instance FromJSON KinesisStreamsInputDescription
where
parseJSON
= withObject "KinesisStreamsInputDescription"
(\ x ->
KinesisStreamsInputDescription' <$>
(x .:? "ResourceARN") <*> (x .:? "RoleARN"))
instance Hashable KinesisStreamsInputDescription
where
instance NFData KinesisStreamsInputDescription where
data KinesisStreamsInputUpdate = KinesisStreamsInputUpdate'
{ _ksiuRoleARNUpdate :: !(Maybe Text)
, _ksiuResourceARNUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisStreamsInputUpdate
:: KinesisStreamsInputUpdate
kinesisStreamsInputUpdate =
KinesisStreamsInputUpdate'
{_ksiuRoleARNUpdate = Nothing, _ksiuResourceARNUpdate = Nothing}
ksiuRoleARNUpdate :: Lens' KinesisStreamsInputUpdate (Maybe Text)
ksiuRoleARNUpdate = lens _ksiuRoleARNUpdate (\ s a -> s{_ksiuRoleARNUpdate = a})
ksiuResourceARNUpdate :: Lens' KinesisStreamsInputUpdate (Maybe Text)
ksiuResourceARNUpdate = lens _ksiuResourceARNUpdate (\ s a -> s{_ksiuResourceARNUpdate = a})
instance Hashable KinesisStreamsInputUpdate where
instance NFData KinesisStreamsInputUpdate where
instance ToJSON KinesisStreamsInputUpdate where
toJSON KinesisStreamsInputUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _ksiuRoleARNUpdate,
("ResourceARNUpdate" .=) <$> _ksiuResourceARNUpdate])
data KinesisStreamsOutput = KinesisStreamsOutput'
{ _ksoResourceARN :: !Text
, _ksoRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisStreamsOutput
:: Text
-> Text
-> KinesisStreamsOutput
kinesisStreamsOutput pResourceARN_ pRoleARN_ =
KinesisStreamsOutput'
{_ksoResourceARN = pResourceARN_, _ksoRoleARN = pRoleARN_}
ksoResourceARN :: Lens' KinesisStreamsOutput Text
ksoResourceARN = lens _ksoResourceARN (\ s a -> s{_ksoResourceARN = a})
ksoRoleARN :: Lens' KinesisStreamsOutput Text
ksoRoleARN = lens _ksoRoleARN (\ s a -> s{_ksoRoleARN = a})
instance Hashable KinesisStreamsOutput where
instance NFData KinesisStreamsOutput where
instance ToJSON KinesisStreamsOutput where
toJSON KinesisStreamsOutput'{..}
= object
(catMaybes
[Just ("ResourceARN" .= _ksoResourceARN),
Just ("RoleARN" .= _ksoRoleARN)])
data KinesisStreamsOutputDescription = KinesisStreamsOutputDescription'
{ _ksodResourceARN :: !(Maybe Text)
, _ksodRoleARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisStreamsOutputDescription
:: KinesisStreamsOutputDescription
kinesisStreamsOutputDescription =
KinesisStreamsOutputDescription'
{_ksodResourceARN = Nothing, _ksodRoleARN = Nothing}
ksodResourceARN :: Lens' KinesisStreamsOutputDescription (Maybe Text)
ksodResourceARN = lens _ksodResourceARN (\ s a -> s{_ksodResourceARN = a})
ksodRoleARN :: Lens' KinesisStreamsOutputDescription (Maybe Text)
ksodRoleARN = lens _ksodRoleARN (\ s a -> s{_ksodRoleARN = a})
instance FromJSON KinesisStreamsOutputDescription
where
parseJSON
= withObject "KinesisStreamsOutputDescription"
(\ x ->
KinesisStreamsOutputDescription' <$>
(x .:? "ResourceARN") <*> (x .:? "RoleARN"))
instance Hashable KinesisStreamsOutputDescription
where
instance NFData KinesisStreamsOutputDescription where
data KinesisStreamsOutputUpdate = KinesisStreamsOutputUpdate'
{ _ksouRoleARNUpdate :: !(Maybe Text)
, _ksouResourceARNUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
kinesisStreamsOutputUpdate
:: KinesisStreamsOutputUpdate
kinesisStreamsOutputUpdate =
KinesisStreamsOutputUpdate'
{_ksouRoleARNUpdate = Nothing, _ksouResourceARNUpdate = Nothing}
ksouRoleARNUpdate :: Lens' KinesisStreamsOutputUpdate (Maybe Text)
ksouRoleARNUpdate = lens _ksouRoleARNUpdate (\ s a -> s{_ksouRoleARNUpdate = a})
ksouResourceARNUpdate :: Lens' KinesisStreamsOutputUpdate (Maybe Text)
ksouResourceARNUpdate = lens _ksouResourceARNUpdate (\ s a -> s{_ksouResourceARNUpdate = a})
instance Hashable KinesisStreamsOutputUpdate where
instance NFData KinesisStreamsOutputUpdate where
instance ToJSON KinesisStreamsOutputUpdate where
toJSON KinesisStreamsOutputUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _ksouRoleARNUpdate,
("ResourceARNUpdate" .=) <$> _ksouResourceARNUpdate])
data LambdaOutput = LambdaOutput'
{ _loResourceARN :: !Text
, _loRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
lambdaOutput
:: Text
-> Text
-> LambdaOutput
lambdaOutput pResourceARN_ pRoleARN_ =
LambdaOutput' {_loResourceARN = pResourceARN_, _loRoleARN = pRoleARN_}
loResourceARN :: Lens' LambdaOutput Text
loResourceARN = lens _loResourceARN (\ s a -> s{_loResourceARN = a})
loRoleARN :: Lens' LambdaOutput Text
loRoleARN = lens _loRoleARN (\ s a -> s{_loRoleARN = a})
instance Hashable LambdaOutput where
instance NFData LambdaOutput where
instance ToJSON LambdaOutput where
toJSON LambdaOutput'{..}
= object
(catMaybes
[Just ("ResourceARN" .= _loResourceARN),
Just ("RoleARN" .= _loRoleARN)])
data LambdaOutputDescription = LambdaOutputDescription'
{ _lodResourceARN :: !(Maybe Text)
, _lodRoleARN :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
lambdaOutputDescription
:: LambdaOutputDescription
lambdaOutputDescription =
LambdaOutputDescription' {_lodResourceARN = Nothing, _lodRoleARN = Nothing}
lodResourceARN :: Lens' LambdaOutputDescription (Maybe Text)
lodResourceARN = lens _lodResourceARN (\ s a -> s{_lodResourceARN = a})
lodRoleARN :: Lens' LambdaOutputDescription (Maybe Text)
lodRoleARN = lens _lodRoleARN (\ s a -> s{_lodRoleARN = a})
instance FromJSON LambdaOutputDescription where
parseJSON
= withObject "LambdaOutputDescription"
(\ x ->
LambdaOutputDescription' <$>
(x .:? "ResourceARN") <*> (x .:? "RoleARN"))
instance Hashable LambdaOutputDescription where
instance NFData LambdaOutputDescription where
data LambdaOutputUpdate = LambdaOutputUpdate'
{ _louRoleARNUpdate :: !(Maybe Text)
, _louResourceARNUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
lambdaOutputUpdate
:: LambdaOutputUpdate
lambdaOutputUpdate =
LambdaOutputUpdate'
{_louRoleARNUpdate = Nothing, _louResourceARNUpdate = Nothing}
louRoleARNUpdate :: Lens' LambdaOutputUpdate (Maybe Text)
louRoleARNUpdate = lens _louRoleARNUpdate (\ s a -> s{_louRoleARNUpdate = a})
louResourceARNUpdate :: Lens' LambdaOutputUpdate (Maybe Text)
louResourceARNUpdate = lens _louResourceARNUpdate (\ s a -> s{_louResourceARNUpdate = a})
instance Hashable LambdaOutputUpdate where
instance NFData LambdaOutputUpdate where
instance ToJSON LambdaOutputUpdate where
toJSON LambdaOutputUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _louRoleARNUpdate,
("ResourceARNUpdate" .=) <$> _louResourceARNUpdate])
data MappingParameters = MappingParameters'
{ _mpCSVMappingParameters :: !(Maybe CSVMappingParameters)
, _mpJSONMappingParameters :: !(Maybe JSONMappingParameters)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
mappingParameters
:: MappingParameters
mappingParameters =
MappingParameters'
{_mpCSVMappingParameters = Nothing, _mpJSONMappingParameters = Nothing}
mpCSVMappingParameters :: Lens' MappingParameters (Maybe CSVMappingParameters)
mpCSVMappingParameters = lens _mpCSVMappingParameters (\ s a -> s{_mpCSVMappingParameters = a})
mpJSONMappingParameters :: Lens' MappingParameters (Maybe JSONMappingParameters)
mpJSONMappingParameters = lens _mpJSONMappingParameters (\ s a -> s{_mpJSONMappingParameters = a})
instance FromJSON MappingParameters where
parseJSON
= withObject "MappingParameters"
(\ x ->
MappingParameters' <$>
(x .:? "CSVMappingParameters") <*>
(x .:? "JSONMappingParameters"))
instance Hashable MappingParameters where
instance NFData MappingParameters where
instance ToJSON MappingParameters where
toJSON MappingParameters'{..}
= object
(catMaybes
[("CSVMappingParameters" .=) <$>
_mpCSVMappingParameters,
("JSONMappingParameters" .=) <$>
_mpJSONMappingParameters])
data Output = Output'
{ _oLambdaOutput :: !(Maybe LambdaOutput)
, _oKinesisStreamsOutput :: !(Maybe KinesisStreamsOutput)
, _oKinesisFirehoseOutput :: !(Maybe KinesisFirehoseOutput)
, _oName :: !Text
, _oDestinationSchema :: !DestinationSchema
} deriving (Eq, Read, Show, Data, Typeable, Generic)
output
:: Text
-> DestinationSchema
-> Output
output pName_ pDestinationSchema_ =
Output'
{ _oLambdaOutput = Nothing
, _oKinesisStreamsOutput = Nothing
, _oKinesisFirehoseOutput = Nothing
, _oName = pName_
, _oDestinationSchema = pDestinationSchema_
}
oLambdaOutput :: Lens' Output (Maybe LambdaOutput)
oLambdaOutput = lens _oLambdaOutput (\ s a -> s{_oLambdaOutput = a})
oKinesisStreamsOutput :: Lens' Output (Maybe KinesisStreamsOutput)
oKinesisStreamsOutput = lens _oKinesisStreamsOutput (\ s a -> s{_oKinesisStreamsOutput = a})
oKinesisFirehoseOutput :: Lens' Output (Maybe KinesisFirehoseOutput)
oKinesisFirehoseOutput = lens _oKinesisFirehoseOutput (\ s a -> s{_oKinesisFirehoseOutput = a})
oName :: Lens' Output Text
oName = lens _oName (\ s a -> s{_oName = a})
oDestinationSchema :: Lens' Output DestinationSchema
oDestinationSchema = lens _oDestinationSchema (\ s a -> s{_oDestinationSchema = a})
instance Hashable Output where
instance NFData Output where
instance ToJSON Output where
toJSON Output'{..}
= object
(catMaybes
[("LambdaOutput" .=) <$> _oLambdaOutput,
("KinesisStreamsOutput" .=) <$>
_oKinesisStreamsOutput,
("KinesisFirehoseOutput" .=) <$>
_oKinesisFirehoseOutput,
Just ("Name" .= _oName),
Just ("DestinationSchema" .= _oDestinationSchema)])
data OutputDescription = OutputDescription'
{ _odOutputId :: !(Maybe Text)
, _odDestinationSchema :: !(Maybe DestinationSchema)
, _odKinesisFirehoseOutputDescription :: !(Maybe KinesisFirehoseOutputDescription)
, _odKinesisStreamsOutputDescription :: !(Maybe KinesisStreamsOutputDescription)
, _odName :: !(Maybe Text)
, _odLambdaOutputDescription :: !(Maybe LambdaOutputDescription)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputDescription
:: OutputDescription
outputDescription =
OutputDescription'
{ _odOutputId = Nothing
, _odDestinationSchema = Nothing
, _odKinesisFirehoseOutputDescription = Nothing
, _odKinesisStreamsOutputDescription = Nothing
, _odName = Nothing
, _odLambdaOutputDescription = Nothing
}
odOutputId :: Lens' OutputDescription (Maybe Text)
odOutputId = lens _odOutputId (\ s a -> s{_odOutputId = a})
odDestinationSchema :: Lens' OutputDescription (Maybe DestinationSchema)
odDestinationSchema = lens _odDestinationSchema (\ s a -> s{_odDestinationSchema = a})
odKinesisFirehoseOutputDescription :: Lens' OutputDescription (Maybe KinesisFirehoseOutputDescription)
odKinesisFirehoseOutputDescription = lens _odKinesisFirehoseOutputDescription (\ s a -> s{_odKinesisFirehoseOutputDescription = a})
odKinesisStreamsOutputDescription :: Lens' OutputDescription (Maybe KinesisStreamsOutputDescription)
odKinesisStreamsOutputDescription = lens _odKinesisStreamsOutputDescription (\ s a -> s{_odKinesisStreamsOutputDescription = a})
odName :: Lens' OutputDescription (Maybe Text)
odName = lens _odName (\ s a -> s{_odName = a})
odLambdaOutputDescription :: Lens' OutputDescription (Maybe LambdaOutputDescription)
odLambdaOutputDescription = lens _odLambdaOutputDescription (\ s a -> s{_odLambdaOutputDescription = a})
instance FromJSON OutputDescription where
parseJSON
= withObject "OutputDescription"
(\ x ->
OutputDescription' <$>
(x .:? "OutputId") <*> (x .:? "DestinationSchema")
<*> (x .:? "KinesisFirehoseOutputDescription")
<*> (x .:? "KinesisStreamsOutputDescription")
<*> (x .:? "Name")
<*> (x .:? "LambdaOutputDescription"))
instance Hashable OutputDescription where
instance NFData OutputDescription where
data OutputUpdate = OutputUpdate'
{ _ouKinesisStreamsOutputUpdate :: !(Maybe KinesisStreamsOutputUpdate)
, _ouDestinationSchemaUpdate :: !(Maybe DestinationSchema)
, _ouKinesisFirehoseOutputUpdate :: !(Maybe KinesisFirehoseOutputUpdate)
, _ouNameUpdate :: !(Maybe Text)
, _ouLambdaOutputUpdate :: !(Maybe LambdaOutputUpdate)
, _ouOutputId :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputUpdate
:: Text
-> OutputUpdate
outputUpdate pOutputId_ =
OutputUpdate'
{ _ouKinesisStreamsOutputUpdate = Nothing
, _ouDestinationSchemaUpdate = Nothing
, _ouKinesisFirehoseOutputUpdate = Nothing
, _ouNameUpdate = Nothing
, _ouLambdaOutputUpdate = Nothing
, _ouOutputId = pOutputId_
}
ouKinesisStreamsOutputUpdate :: Lens' OutputUpdate (Maybe KinesisStreamsOutputUpdate)
ouKinesisStreamsOutputUpdate = lens _ouKinesisStreamsOutputUpdate (\ s a -> s{_ouKinesisStreamsOutputUpdate = a})
ouDestinationSchemaUpdate :: Lens' OutputUpdate (Maybe DestinationSchema)
ouDestinationSchemaUpdate = lens _ouDestinationSchemaUpdate (\ s a -> s{_ouDestinationSchemaUpdate = a})
ouKinesisFirehoseOutputUpdate :: Lens' OutputUpdate (Maybe KinesisFirehoseOutputUpdate)
ouKinesisFirehoseOutputUpdate = lens _ouKinesisFirehoseOutputUpdate (\ s a -> s{_ouKinesisFirehoseOutputUpdate = a})
ouNameUpdate :: Lens' OutputUpdate (Maybe Text)
ouNameUpdate = lens _ouNameUpdate (\ s a -> s{_ouNameUpdate = a})
ouLambdaOutputUpdate :: Lens' OutputUpdate (Maybe LambdaOutputUpdate)
ouLambdaOutputUpdate = lens _ouLambdaOutputUpdate (\ s a -> s{_ouLambdaOutputUpdate = a})
ouOutputId :: Lens' OutputUpdate Text
ouOutputId = lens _ouOutputId (\ s a -> s{_ouOutputId = a})
instance Hashable OutputUpdate where
instance NFData OutputUpdate where
instance ToJSON OutputUpdate where
toJSON OutputUpdate'{..}
= object
(catMaybes
[("KinesisStreamsOutputUpdate" .=) <$>
_ouKinesisStreamsOutputUpdate,
("DestinationSchemaUpdate" .=) <$>
_ouDestinationSchemaUpdate,
("KinesisFirehoseOutputUpdate" .=) <$>
_ouKinesisFirehoseOutputUpdate,
("NameUpdate" .=) <$> _ouNameUpdate,
("LambdaOutputUpdate" .=) <$> _ouLambdaOutputUpdate,
Just ("OutputId" .= _ouOutputId)])
data RecordColumn = RecordColumn'
{ _rcMapping :: !(Maybe Text)
, _rcName :: !Text
, _rcSqlType :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
recordColumn
:: Text
-> Text
-> RecordColumn
recordColumn pName_ pSqlType_ =
RecordColumn' {_rcMapping = Nothing, _rcName = pName_, _rcSqlType = pSqlType_}
rcMapping :: Lens' RecordColumn (Maybe Text)
rcMapping = lens _rcMapping (\ s a -> s{_rcMapping = a})
rcName :: Lens' RecordColumn Text
rcName = lens _rcName (\ s a -> s{_rcName = a})
rcSqlType :: Lens' RecordColumn Text
rcSqlType = lens _rcSqlType (\ s a -> s{_rcSqlType = a})
instance FromJSON RecordColumn where
parseJSON
= withObject "RecordColumn"
(\ x ->
RecordColumn' <$>
(x .:? "Mapping") <*> (x .: "Name") <*>
(x .: "SqlType"))
instance Hashable RecordColumn where
instance NFData RecordColumn where
instance ToJSON RecordColumn where
toJSON RecordColumn'{..}
= object
(catMaybes
[("Mapping" .=) <$> _rcMapping,
Just ("Name" .= _rcName),
Just ("SqlType" .= _rcSqlType)])
data RecordFormat = RecordFormat'
{ _rfMappingParameters :: !(Maybe MappingParameters)
, _rfRecordFormatType :: !RecordFormatType
} deriving (Eq, Read, Show, Data, Typeable, Generic)
recordFormat
:: RecordFormatType
-> RecordFormat
recordFormat pRecordFormatType_ =
RecordFormat'
{_rfMappingParameters = Nothing, _rfRecordFormatType = pRecordFormatType_}
rfMappingParameters :: Lens' RecordFormat (Maybe MappingParameters)
rfMappingParameters = lens _rfMappingParameters (\ s a -> s{_rfMappingParameters = a})
rfRecordFormatType :: Lens' RecordFormat RecordFormatType
rfRecordFormatType = lens _rfRecordFormatType (\ s a -> s{_rfRecordFormatType = a})
instance FromJSON RecordFormat where
parseJSON
= withObject "RecordFormat"
(\ x ->
RecordFormat' <$>
(x .:? "MappingParameters") <*>
(x .: "RecordFormatType"))
instance Hashable RecordFormat where
instance NFData RecordFormat where
instance ToJSON RecordFormat where
toJSON RecordFormat'{..}
= object
(catMaybes
[("MappingParameters" .=) <$> _rfMappingParameters,
Just ("RecordFormatType" .= _rfRecordFormatType)])
data ReferenceDataSource = ReferenceDataSource'
{ _rdsS3ReferenceDataSource :: !(Maybe S3ReferenceDataSource)
, _rdsTableName :: !Text
, _rdsReferenceSchema :: !SourceSchema
} deriving (Eq, Read, Show, Data, Typeable, Generic)
referenceDataSource
:: Text
-> SourceSchema
-> ReferenceDataSource
referenceDataSource pTableName_ pReferenceSchema_ =
ReferenceDataSource'
{ _rdsS3ReferenceDataSource = Nothing
, _rdsTableName = pTableName_
, _rdsReferenceSchema = pReferenceSchema_
}
rdsS3ReferenceDataSource :: Lens' ReferenceDataSource (Maybe S3ReferenceDataSource)
rdsS3ReferenceDataSource = lens _rdsS3ReferenceDataSource (\ s a -> s{_rdsS3ReferenceDataSource = a})
rdsTableName :: Lens' ReferenceDataSource Text
rdsTableName = lens _rdsTableName (\ s a -> s{_rdsTableName = a})
rdsReferenceSchema :: Lens' ReferenceDataSource SourceSchema
rdsReferenceSchema = lens _rdsReferenceSchema (\ s a -> s{_rdsReferenceSchema = a})
instance Hashable ReferenceDataSource where
instance NFData ReferenceDataSource where
instance ToJSON ReferenceDataSource where
toJSON ReferenceDataSource'{..}
= object
(catMaybes
[("S3ReferenceDataSource" .=) <$>
_rdsS3ReferenceDataSource,
Just ("TableName" .= _rdsTableName),
Just ("ReferenceSchema" .= _rdsReferenceSchema)])
data ReferenceDataSourceDescription = ReferenceDataSourceDescription'
{ _rdsdReferenceSchema :: !(Maybe SourceSchema)
, _rdsdReferenceId :: !Text
, _rdsdTableName :: !Text
, _rdsdS3ReferenceDataSourceDescription :: !S3ReferenceDataSourceDescription
} deriving (Eq, Read, Show, Data, Typeable, Generic)
referenceDataSourceDescription
:: Text
-> Text
-> S3ReferenceDataSourceDescription
-> ReferenceDataSourceDescription
referenceDataSourceDescription pReferenceId_ pTableName_ pS3ReferenceDataSourceDescription_ =
ReferenceDataSourceDescription'
{ _rdsdReferenceSchema = Nothing
, _rdsdReferenceId = pReferenceId_
, _rdsdTableName = pTableName_
, _rdsdS3ReferenceDataSourceDescription = pS3ReferenceDataSourceDescription_
}
rdsdReferenceSchema :: Lens' ReferenceDataSourceDescription (Maybe SourceSchema)
rdsdReferenceSchema = lens _rdsdReferenceSchema (\ s a -> s{_rdsdReferenceSchema = a})
rdsdReferenceId :: Lens' ReferenceDataSourceDescription Text
rdsdReferenceId = lens _rdsdReferenceId (\ s a -> s{_rdsdReferenceId = a})
rdsdTableName :: Lens' ReferenceDataSourceDescription Text
rdsdTableName = lens _rdsdTableName (\ s a -> s{_rdsdTableName = a})
rdsdS3ReferenceDataSourceDescription :: Lens' ReferenceDataSourceDescription S3ReferenceDataSourceDescription
rdsdS3ReferenceDataSourceDescription = lens _rdsdS3ReferenceDataSourceDescription (\ s a -> s{_rdsdS3ReferenceDataSourceDescription = a})
instance FromJSON ReferenceDataSourceDescription
where
parseJSON
= withObject "ReferenceDataSourceDescription"
(\ x ->
ReferenceDataSourceDescription' <$>
(x .:? "ReferenceSchema") <*> (x .: "ReferenceId")
<*> (x .: "TableName")
<*> (x .: "S3ReferenceDataSourceDescription"))
instance Hashable ReferenceDataSourceDescription
where
instance NFData ReferenceDataSourceDescription where
data ReferenceDataSourceUpdate = ReferenceDataSourceUpdate'
{ _rdsuTableNameUpdate :: !(Maybe Text)
, _rdsuS3ReferenceDataSourceUpdate :: !(Maybe S3ReferenceDataSourceUpdate)
, _rdsuReferenceSchemaUpdate :: !(Maybe SourceSchema)
, _rdsuReferenceId :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
referenceDataSourceUpdate
:: Text
-> ReferenceDataSourceUpdate
referenceDataSourceUpdate pReferenceId_ =
ReferenceDataSourceUpdate'
{ _rdsuTableNameUpdate = Nothing
, _rdsuS3ReferenceDataSourceUpdate = Nothing
, _rdsuReferenceSchemaUpdate = Nothing
, _rdsuReferenceId = pReferenceId_
}
rdsuTableNameUpdate :: Lens' ReferenceDataSourceUpdate (Maybe Text)
rdsuTableNameUpdate = lens _rdsuTableNameUpdate (\ s a -> s{_rdsuTableNameUpdate = a})
rdsuS3ReferenceDataSourceUpdate :: Lens' ReferenceDataSourceUpdate (Maybe S3ReferenceDataSourceUpdate)
rdsuS3ReferenceDataSourceUpdate = lens _rdsuS3ReferenceDataSourceUpdate (\ s a -> s{_rdsuS3ReferenceDataSourceUpdate = a})
rdsuReferenceSchemaUpdate :: Lens' ReferenceDataSourceUpdate (Maybe SourceSchema)
rdsuReferenceSchemaUpdate = lens _rdsuReferenceSchemaUpdate (\ s a -> s{_rdsuReferenceSchemaUpdate = a})
rdsuReferenceId :: Lens' ReferenceDataSourceUpdate Text
rdsuReferenceId = lens _rdsuReferenceId (\ s a -> s{_rdsuReferenceId = a})
instance Hashable ReferenceDataSourceUpdate where
instance NFData ReferenceDataSourceUpdate where
instance ToJSON ReferenceDataSourceUpdate where
toJSON ReferenceDataSourceUpdate'{..}
= object
(catMaybes
[("TableNameUpdate" .=) <$> _rdsuTableNameUpdate,
("S3ReferenceDataSourceUpdate" .=) <$>
_rdsuS3ReferenceDataSourceUpdate,
("ReferenceSchemaUpdate" .=) <$>
_rdsuReferenceSchemaUpdate,
Just ("ReferenceId" .= _rdsuReferenceId)])
data S3Configuration = S3Configuration'
{ _scRoleARN :: !Text
, _scBucketARN :: !Text
, _scFileKey :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
s3Configuration
:: Text
-> Text
-> Text
-> S3Configuration
s3Configuration pRoleARN_ pBucketARN_ pFileKey_ =
S3Configuration'
{_scRoleARN = pRoleARN_, _scBucketARN = pBucketARN_, _scFileKey = pFileKey_}
scRoleARN :: Lens' S3Configuration Text
scRoleARN = lens _scRoleARN (\ s a -> s{_scRoleARN = a})
scBucketARN :: Lens' S3Configuration Text
scBucketARN = lens _scBucketARN (\ s a -> s{_scBucketARN = a})
scFileKey :: Lens' S3Configuration Text
scFileKey = lens _scFileKey (\ s a -> s{_scFileKey = a})
instance Hashable S3Configuration where
instance NFData S3Configuration where
instance ToJSON S3Configuration where
toJSON S3Configuration'{..}
= object
(catMaybes
[Just ("RoleARN" .= _scRoleARN),
Just ("BucketARN" .= _scBucketARN),
Just ("FileKey" .= _scFileKey)])
data S3ReferenceDataSource = S3ReferenceDataSource'
{ _srdsBucketARN :: !Text
, _srdsFileKey :: !Text
, _srdsReferenceRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
s3ReferenceDataSource
:: Text
-> Text
-> Text
-> S3ReferenceDataSource
s3ReferenceDataSource pBucketARN_ pFileKey_ pReferenceRoleARN_ =
S3ReferenceDataSource'
{ _srdsBucketARN = pBucketARN_
, _srdsFileKey = pFileKey_
, _srdsReferenceRoleARN = pReferenceRoleARN_
}
srdsBucketARN :: Lens' S3ReferenceDataSource Text
srdsBucketARN = lens _srdsBucketARN (\ s a -> s{_srdsBucketARN = a})
srdsFileKey :: Lens' S3ReferenceDataSource Text
srdsFileKey = lens _srdsFileKey (\ s a -> s{_srdsFileKey = a})
srdsReferenceRoleARN :: Lens' S3ReferenceDataSource Text
srdsReferenceRoleARN = lens _srdsReferenceRoleARN (\ s a -> s{_srdsReferenceRoleARN = a})
instance Hashable S3ReferenceDataSource where
instance NFData S3ReferenceDataSource where
instance ToJSON S3ReferenceDataSource where
toJSON S3ReferenceDataSource'{..}
= object
(catMaybes
[Just ("BucketARN" .= _srdsBucketARN),
Just ("FileKey" .= _srdsFileKey),
Just ("ReferenceRoleARN" .= _srdsReferenceRoleARN)])
data S3ReferenceDataSourceDescription = S3ReferenceDataSourceDescription'
{ _srdsdBucketARN :: !Text
, _srdsdFileKey :: !Text
, _srdsdReferenceRoleARN :: !Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
s3ReferenceDataSourceDescription
:: Text
-> Text
-> Text
-> S3ReferenceDataSourceDescription
s3ReferenceDataSourceDescription pBucketARN_ pFileKey_ pReferenceRoleARN_ =
S3ReferenceDataSourceDescription'
{ _srdsdBucketARN = pBucketARN_
, _srdsdFileKey = pFileKey_
, _srdsdReferenceRoleARN = pReferenceRoleARN_
}
srdsdBucketARN :: Lens' S3ReferenceDataSourceDescription Text
srdsdBucketARN = lens _srdsdBucketARN (\ s a -> s{_srdsdBucketARN = a})
srdsdFileKey :: Lens' S3ReferenceDataSourceDescription Text
srdsdFileKey = lens _srdsdFileKey (\ s a -> s{_srdsdFileKey = a})
srdsdReferenceRoleARN :: Lens' S3ReferenceDataSourceDescription Text
srdsdReferenceRoleARN = lens _srdsdReferenceRoleARN (\ s a -> s{_srdsdReferenceRoleARN = a})
instance FromJSON S3ReferenceDataSourceDescription
where
parseJSON
= withObject "S3ReferenceDataSourceDescription"
(\ x ->
S3ReferenceDataSourceDescription' <$>
(x .: "BucketARN") <*> (x .: "FileKey") <*>
(x .: "ReferenceRoleARN"))
instance Hashable S3ReferenceDataSourceDescription
where
instance NFData S3ReferenceDataSourceDescription
where
data S3ReferenceDataSourceUpdate = S3ReferenceDataSourceUpdate'
{ _srdsuBucketARNUpdate :: !(Maybe Text)
, _srdsuFileKeyUpdate :: !(Maybe Text)
, _srdsuReferenceRoleARNUpdate :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
s3ReferenceDataSourceUpdate
:: S3ReferenceDataSourceUpdate
s3ReferenceDataSourceUpdate =
S3ReferenceDataSourceUpdate'
{ _srdsuBucketARNUpdate = Nothing
, _srdsuFileKeyUpdate = Nothing
, _srdsuReferenceRoleARNUpdate = Nothing
}
srdsuBucketARNUpdate :: Lens' S3ReferenceDataSourceUpdate (Maybe Text)
srdsuBucketARNUpdate = lens _srdsuBucketARNUpdate (\ s a -> s{_srdsuBucketARNUpdate = a})
srdsuFileKeyUpdate :: Lens' S3ReferenceDataSourceUpdate (Maybe Text)
srdsuFileKeyUpdate = lens _srdsuFileKeyUpdate (\ s a -> s{_srdsuFileKeyUpdate = a})
srdsuReferenceRoleARNUpdate :: Lens' S3ReferenceDataSourceUpdate (Maybe Text)
srdsuReferenceRoleARNUpdate = lens _srdsuReferenceRoleARNUpdate (\ s a -> s{_srdsuReferenceRoleARNUpdate = a})
instance Hashable S3ReferenceDataSourceUpdate where
instance NFData S3ReferenceDataSourceUpdate where
instance ToJSON S3ReferenceDataSourceUpdate where
toJSON S3ReferenceDataSourceUpdate'{..}
= object
(catMaybes
[("BucketARNUpdate" .=) <$> _srdsuBucketARNUpdate,
("FileKeyUpdate" .=) <$> _srdsuFileKeyUpdate,
("ReferenceRoleARNUpdate" .=) <$>
_srdsuReferenceRoleARNUpdate])
data SourceSchema = SourceSchema'
{ _ssRecordEncoding :: !(Maybe Text)
, _ssRecordFormat :: !RecordFormat
, _ssRecordColumns :: !(List1 RecordColumn)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
sourceSchema
:: RecordFormat
-> NonEmpty RecordColumn
-> SourceSchema
sourceSchema pRecordFormat_ pRecordColumns_ =
SourceSchema'
{ _ssRecordEncoding = Nothing
, _ssRecordFormat = pRecordFormat_
, _ssRecordColumns = _List1 # pRecordColumns_
}
ssRecordEncoding :: Lens' SourceSchema (Maybe Text)
ssRecordEncoding = lens _ssRecordEncoding (\ s a -> s{_ssRecordEncoding = a})
ssRecordFormat :: Lens' SourceSchema RecordFormat
ssRecordFormat = lens _ssRecordFormat (\ s a -> s{_ssRecordFormat = a})
ssRecordColumns :: Lens' SourceSchema (NonEmpty RecordColumn)
ssRecordColumns = lens _ssRecordColumns (\ s a -> s{_ssRecordColumns = a}) . _List1
instance FromJSON SourceSchema where
parseJSON
= withObject "SourceSchema"
(\ x ->
SourceSchema' <$>
(x .:? "RecordEncoding") <*> (x .: "RecordFormat")
<*> (x .: "RecordColumns"))
instance Hashable SourceSchema where
instance NFData SourceSchema where
instance ToJSON SourceSchema where
toJSON SourceSchema'{..}
= object
(catMaybes
[("RecordEncoding" .=) <$> _ssRecordEncoding,
Just ("RecordFormat" .= _ssRecordFormat),
Just ("RecordColumns" .= _ssRecordColumns)])