{-# 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])
, _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
, _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;
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 .:? "ReferenceDataSourceDescriptions" .!= mempty)
<*> (x .:? "InputDescriptions" .!= mempty)
<*> (x .:? "ApplicationCode")
<*> (x .:? "CreateTimestamp")
<*> (x .:? "LastUpdateTimestamp")
<*> (x .: "ApplicationName")
<*> (x .: "ApplicationARN")
<*> (x .: "ApplicationStatus")
<*> (x .: "ApplicationVersionId"))
instance Hashable ApplicationDetail
instance NFData ApplicationDetail
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
instance NFData ApplicationSummary
data ApplicationUpdate = ApplicationUpdate'
{ _auReferenceDataSourceUpdates :: !(Maybe [ReferenceDataSourceUpdate])
, _auInputUpdates :: !(Maybe [InputUpdate])
, _auOutputUpdates :: !(Maybe [OutputUpdate])
, _auApplicationCodeUpdate :: !(Maybe Text)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
applicationUpdate
:: ApplicationUpdate
applicationUpdate =
ApplicationUpdate'
{ _auReferenceDataSourceUpdates = Nothing
, _auInputUpdates = 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;
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
instance NFData ApplicationUpdate
instance ToJSON ApplicationUpdate where
toJSON ApplicationUpdate'{..}
= object
(catMaybes
[("ReferenceDataSourceUpdates" .=) <$>
_auReferenceDataSourceUpdates,
("InputUpdates" .=) <$> _auInputUpdates,
("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
instance NFData CSVMappingParameters
instance ToJSON CSVMappingParameters where
toJSON CSVMappingParameters'{..}
= object
(catMaybes
[Just
("RecordRowDelimiter" .= _cmpRecordRowDelimiter),
Just
("RecordColumnDelimiter" .=
_cmpRecordColumnDelimiter)])
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
instance NFData DestinationSchema
instance ToJSON DestinationSchema where
toJSON DestinationSchema'{..}
= object
(catMaybes
[("RecordFormatType" .=) <$> _dsRecordFormatType])
data Input = Input'
{ _iInputParallelism :: !(Maybe InputParallelism)
, _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
, _iKinesisStreamsInput = Nothing
, _iKinesisFirehoseInput = Nothing
, _iNamePrefix = pNamePrefix_
, _iInputSchema = pInputSchema_
}
iInputParallelism :: Lens' Input (Maybe InputParallelism)
iInputParallelism = lens _iInputParallelism (\ s a -> s{_iInputParallelism = 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
instance NFData Input
instance ToJSON Input where
toJSON Input'{..}
= object
(catMaybes
[("InputParallelism" .=) <$> _iInputParallelism,
("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
instance NFData InputConfiguration
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)
} 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
}
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});
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"))
instance Hashable InputDescription
instance NFData InputDescription
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
instance NFData InputParallelism
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
instance NFData InputParallelismUpdate
instance ToJSON InputParallelismUpdate where
toJSON InputParallelismUpdate'{..}
= object
(catMaybes [("CountUpdate" .=) <$> _ipuCountUpdate])
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
instance NFData InputSchemaUpdate
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
instance NFData InputStartingPositionConfiguration
instance ToJSON InputStartingPositionConfiguration
where
toJSON InputStartingPositionConfiguration'{..}
= object
(catMaybes
[("InputStartingPosition" .=) <$>
_ispcInputStartingPosition])
data InputUpdate = InputUpdate'
{ _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'
{ _iuKinesisStreamsInputUpdate = Nothing
, _iuInputParallelismUpdate = Nothing
, _iuNamePrefixUpdate = Nothing
, _iuInputSchemaUpdate = Nothing
, _iuKinesisFirehoseInputUpdate = Nothing
, _iuInputId = pInputId_
}
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
instance NFData InputUpdate
instance ToJSON InputUpdate where
toJSON InputUpdate'{..}
= object
(catMaybes
[("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
instance NFData JSONMappingParameters
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
instance NFData KinesisFirehoseInput
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
instance NFData KinesisFirehoseInputDescription
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
instance NFData KinesisFirehoseInputUpdate
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
instance NFData KinesisFirehoseOutput
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
instance NFData KinesisFirehoseOutputDescription
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
instance NFData KinesisFirehoseOutputUpdate
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
instance NFData KinesisStreamsInput
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
instance NFData KinesisStreamsInputDescription
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
instance NFData KinesisStreamsInputUpdate
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
instance NFData KinesisStreamsOutput
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
instance NFData KinesisStreamsOutputDescription
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
instance NFData KinesisStreamsOutputUpdate
instance ToJSON KinesisStreamsOutputUpdate where
toJSON KinesisStreamsOutputUpdate'{..}
= object
(catMaybes
[("RoleARNUpdate" .=) <$> _ksouRoleARNUpdate,
("ResourceARNUpdate" .=) <$> _ksouResourceARNUpdate])
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
instance NFData MappingParameters
instance ToJSON MappingParameters where
toJSON MappingParameters'{..}
= object
(catMaybes
[("CSVMappingParameters" .=) <$>
_mpCSVMappingParameters,
("JSONMappingParameters" .=) <$>
_mpJSONMappingParameters])
data Output = Output'
{ _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'
{ _oKinesisStreamsOutput = Nothing
, _oKinesisFirehoseOutput = Nothing
, _oName = pName_
, _oDestinationSchema = pDestinationSchema_
}
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
instance NFData Output
instance ToJSON Output where
toJSON Output'{..}
= object
(catMaybes
[("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)
} deriving (Eq,Read,Show,Data,Typeable,Generic)
outputDescription
:: OutputDescription
outputDescription =
OutputDescription'
{ _odOutputId = Nothing
, _odDestinationSchema = Nothing
, _odKinesisFirehoseOutputDescription = Nothing
, _odKinesisStreamsOutputDescription = Nothing
, _odName = 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});
instance FromJSON OutputDescription where
parseJSON
= withObject "OutputDescription"
(\ x ->
OutputDescription' <$>
(x .:? "OutputId") <*> (x .:? "DestinationSchema")
<*> (x .:? "KinesisFirehoseOutputDescription")
<*> (x .:? "KinesisStreamsOutputDescription")
<*> (x .:? "Name"))
instance Hashable OutputDescription
instance NFData OutputDescription
data OutputUpdate = OutputUpdate'
{ _ouKinesisStreamsOutputUpdate :: !(Maybe KinesisStreamsOutputUpdate)
, _ouDestinationSchemaUpdate :: !(Maybe DestinationSchema)
, _ouKinesisFirehoseOutputUpdate :: !(Maybe KinesisFirehoseOutputUpdate)
, _ouNameUpdate :: !(Maybe Text)
, _ouOutputId :: !Text
} deriving (Eq,Read,Show,Data,Typeable,Generic)
outputUpdate
:: Text
-> OutputUpdate
outputUpdate pOutputId_ =
OutputUpdate'
{ _ouKinesisStreamsOutputUpdate = Nothing
, _ouDestinationSchemaUpdate = Nothing
, _ouKinesisFirehoseOutputUpdate = Nothing
, _ouNameUpdate = 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});
ouOutputId :: Lens' OutputUpdate Text
ouOutputId = lens _ouOutputId (\ s a -> s{_ouOutputId = a});
instance Hashable OutputUpdate
instance NFData OutputUpdate
instance ToJSON OutputUpdate where
toJSON OutputUpdate'{..}
= object
(catMaybes
[("KinesisStreamsOutputUpdate" .=) <$>
_ouKinesisStreamsOutputUpdate,
("DestinationSchemaUpdate" .=) <$>
_ouDestinationSchemaUpdate,
("KinesisFirehoseOutputUpdate" .=) <$>
_ouKinesisFirehoseOutputUpdate,
("NameUpdate" .=) <$> _ouNameUpdate,
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
instance NFData RecordColumn
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
instance NFData RecordFormat
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
instance NFData ReferenceDataSource
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
instance NFData ReferenceDataSourceDescription
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
instance NFData ReferenceDataSourceUpdate
instance ToJSON ReferenceDataSourceUpdate where
toJSON ReferenceDataSourceUpdate'{..}
= object
(catMaybes
[("TableNameUpdate" .=) <$> _rdsuTableNameUpdate,
("S3ReferenceDataSourceUpdate" .=) <$>
_rdsuS3ReferenceDataSourceUpdate,
("ReferenceSchemaUpdate" .=) <$>
_rdsuReferenceSchemaUpdate,
Just ("ReferenceId" .= _rdsuReferenceId)])
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
instance NFData S3ReferenceDataSource
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
instance NFData S3ReferenceDataSourceDescription
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
instance NFData S3ReferenceDataSourceUpdate
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
instance NFData SourceSchema
instance ToJSON SourceSchema where
toJSON SourceSchema'{..}
= object
(catMaybes
[("RecordEncoding" .=) <$> _ssRecordEncoding,
Just ("RecordFormat" .= _ssRecordFormat),
Just ("RecordColumns" .= _ssRecordColumns)])