UpdateEventSourceMappingResult.h

 
#pragma once
#include <aws/core/http/HttpResponse.h>
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/lambda/Lambda_EXPORTS.h>
#include <aws/lambda/model/AmazonManagedKafkaEventSourceConfig.h>
#include <aws/lambda/model/DestinationConfig.h>
#include <aws/lambda/model/DocumentDBEventSourceConfig.h>
#include <aws/lambda/model/EventSourceMappingLoggingConfig.h>
#include <aws/lambda/model/EventSourceMappingMetricsConfig.h>
#include <aws/lambda/model/EventSourcePosition.h>
#include <aws/lambda/model/FilterCriteria.h>
#include <aws/lambda/model/FilterCriteriaError.h>
#include <aws/lambda/model/FunctionResponseType.h>
#include <aws/lambda/model/ProvisionedPollerConfig.h>
#include <aws/lambda/model/ScalingConfig.h>
#include <aws/lambda/model/SelfManagedEventSource.h>
#include <aws/lambda/model/SelfManagedKafkaEventSourceConfig.h>
#include <aws/lambda/model/SourceAccessConfiguration.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace Lambda {
namespace Model {
class UpdateEventSourceMappingResult {
 public:
  AWS_LAMBDA_API UpdateEventSourceMappingResult() = default;
  AWS_LAMBDA_API UpdateEventSourceMappingResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_LAMBDA_API UpdateEventSourceMappingResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetUUID() const { return m_uUID; }
  template <typename UUIDT = Aws::String>
  void SetUUID(UUIDT&& value) {
    m_uUIDHasBeenSet = true;
    m_uUID = std::forward<UUIDT>(value);
  }
  template <typename UUIDT = Aws::String>
  UpdateEventSourceMappingResult& WithUUID(UUIDT&& value) {
    SetUUID(std::forward<UUIDT>(value));
    return *this;
  }
 
 
  inline EventSourcePosition GetStartingPosition() const { return m_startingPosition; }
  inline void SetStartingPosition(EventSourcePosition value) {
    m_startingPositionHasBeenSet = true;
    m_startingPosition = value;
  }
  inline UpdateEventSourceMappingResult& WithStartingPosition(EventSourcePosition value) {
    SetStartingPosition(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStartingPositionTimestamp() const { return m_startingPositionTimestamp; }
  template <typename StartingPositionTimestampT = Aws::Utils::DateTime>
  void SetStartingPositionTimestamp(StartingPositionTimestampT&& value) {
    m_startingPositionTimestampHasBeenSet = true;
    m_startingPositionTimestamp = std::forward<StartingPositionTimestampT>(value);
  }
  template <typename StartingPositionTimestampT = Aws::Utils::DateTime>
  UpdateEventSourceMappingResult& WithStartingPositionTimestamp(StartingPositionTimestampT&& value) {
    SetStartingPositionTimestamp(std::forward<StartingPositionTimestampT>(value));
    return *this;
  }
 
 
  inline int GetBatchSize() const { return m_batchSize; }
  inline void SetBatchSize(int value) {
    m_batchSizeHasBeenSet = true;
    m_batchSize = value;
  }
  inline UpdateEventSourceMappingResult& WithBatchSize(int value) {
    SetBatchSize(value);
    return *this;
  }
 
 
  inline int GetMaximumBatchingWindowInSeconds() const { return m_maximumBatchingWindowInSeconds; }
  inline void SetMaximumBatchingWindowInSeconds(int value) {
    m_maximumBatchingWindowInSecondsHasBeenSet = true;
    m_maximumBatchingWindowInSeconds = value;
  }
  inline UpdateEventSourceMappingResult& WithMaximumBatchingWindowInSeconds(int value) {
    SetMaximumBatchingWindowInSeconds(value);
    return *this;
  }
 
 
  inline int GetParallelizationFactor() const { return m_parallelizationFactor; }
  inline void SetParallelizationFactor(int value) {
    m_parallelizationFactorHasBeenSet = true;
    m_parallelizationFactor = value;
  }
  inline UpdateEventSourceMappingResult& WithParallelizationFactor(int value) {
    SetParallelizationFactor(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEventSourceArn() const { return m_eventSourceArn; }
  template <typename EventSourceArnT = Aws::String>
  void SetEventSourceArn(EventSourceArnT&& value) {
    m_eventSourceArnHasBeenSet = true;
    m_eventSourceArn = std::forward<EventSourceArnT>(value);
  }
  template <typename EventSourceArnT = Aws::String>
  UpdateEventSourceMappingResult& WithEventSourceArn(EventSourceArnT&& value) {
    SetEventSourceArn(std::forward<EventSourceArnT>(value));
    return *this;
  }
 
 
  inline const FilterCriteria& GetFilterCriteria() const { return m_filterCriteria; }
  template <typename FilterCriteriaT = FilterCriteria>
  void SetFilterCriteria(FilterCriteriaT&& value) {
    m_filterCriteriaHasBeenSet = true;
    m_filterCriteria = std::forward<FilterCriteriaT>(value);
  }
  template <typename FilterCriteriaT = FilterCriteria>
  UpdateEventSourceMappingResult& WithFilterCriteria(FilterCriteriaT&& value) {
    SetFilterCriteria(std::forward<FilterCriteriaT>(value));
    return *this;
  }
 
 
  inline const FilterCriteriaError& GetFilterCriteriaError() const { return m_filterCriteriaError; }
  template <typename FilterCriteriaErrorT = FilterCriteriaError>
  void SetFilterCriteriaError(FilterCriteriaErrorT&& value) {
    m_filterCriteriaErrorHasBeenSet = true;
    m_filterCriteriaError = std::forward<FilterCriteriaErrorT>(value);
  }
  template <typename FilterCriteriaErrorT = FilterCriteriaError>
  UpdateEventSourceMappingResult& WithFilterCriteriaError(FilterCriteriaErrorT&& value) {
    SetFilterCriteriaError(std::forward<FilterCriteriaErrorT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKMSKeyArn() const { return m_kMSKeyArn; }
  template <typename KMSKeyArnT = Aws::String>
  void SetKMSKeyArn(KMSKeyArnT&& value) {
    m_kMSKeyArnHasBeenSet = true;
    m_kMSKeyArn = std::forward<KMSKeyArnT>(value);
  }
  template <typename KMSKeyArnT = Aws::String>
  UpdateEventSourceMappingResult& WithKMSKeyArn(KMSKeyArnT&& value) {
    SetKMSKeyArn(std::forward<KMSKeyArnT>(value));
    return *this;
  }
 
 
  inline const EventSourceMappingMetricsConfig& GetMetricsConfig() const { return m_metricsConfig; }
  template <typename MetricsConfigT = EventSourceMappingMetricsConfig>
  void SetMetricsConfig(MetricsConfigT&& value) {
    m_metricsConfigHasBeenSet = true;
    m_metricsConfig = std::forward<MetricsConfigT>(value);
  }
  template <typename MetricsConfigT = EventSourceMappingMetricsConfig>
  UpdateEventSourceMappingResult& WithMetricsConfig(MetricsConfigT&& value) {
    SetMetricsConfig(std::forward<MetricsConfigT>(value));
    return *this;
  }
 
 
  inline const EventSourceMappingLoggingConfig& GetLoggingConfig() const { return m_loggingConfig; }
  template <typename LoggingConfigT = EventSourceMappingLoggingConfig>
  void SetLoggingConfig(LoggingConfigT&& value) {
    m_loggingConfigHasBeenSet = true;
    m_loggingConfig = std::forward<LoggingConfigT>(value);
  }
  template <typename LoggingConfigT = EventSourceMappingLoggingConfig>
  UpdateEventSourceMappingResult& WithLoggingConfig(LoggingConfigT&& value) {
    SetLoggingConfig(std::forward<LoggingConfigT>(value));
    return *this;
  }
 
 
  inline const ScalingConfig& GetScalingConfig() const { return m_scalingConfig; }
  template <typename ScalingConfigT = ScalingConfig>
  void SetScalingConfig(ScalingConfigT&& value) {
    m_scalingConfigHasBeenSet = true;
    m_scalingConfig = std::forward<ScalingConfigT>(value);
  }
  template <typename ScalingConfigT = ScalingConfig>
  UpdateEventSourceMappingResult& WithScalingConfig(ScalingConfigT&& value) {
    SetScalingConfig(std::forward<ScalingConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFunctionArn() const { return m_functionArn; }
  template <typename FunctionArnT = Aws::String>
  void SetFunctionArn(FunctionArnT&& value) {
    m_functionArnHasBeenSet = true;
    m_functionArn = std::forward<FunctionArnT>(value);
  }
  template <typename FunctionArnT = Aws::String>
  UpdateEventSourceMappingResult& WithFunctionArn(FunctionArnT&& value) {
    SetFunctionArn(std::forward<FunctionArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastModified() const { return m_lastModified; }
  template <typename LastModifiedT = Aws::Utils::DateTime>
  void SetLastModified(LastModifiedT&& value) {
    m_lastModifiedHasBeenSet = true;
    m_lastModified = std::forward<LastModifiedT>(value);
  }
  template <typename LastModifiedT = Aws::Utils::DateTime>
  UpdateEventSourceMappingResult& WithLastModified(LastModifiedT&& value) {
    SetLastModified(std::forward<LastModifiedT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLastProcessingResult() const { return m_lastProcessingResult; }
  template <typename LastProcessingResultT = Aws::String>
  void SetLastProcessingResult(LastProcessingResultT&& value) {
    m_lastProcessingResultHasBeenSet = true;
    m_lastProcessingResult = std::forward<LastProcessingResultT>(value);
  }
  template <typename LastProcessingResultT = Aws::String>
  UpdateEventSourceMappingResult& WithLastProcessingResult(LastProcessingResultT&& value) {
    SetLastProcessingResult(std::forward<LastProcessingResultT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetState() const { return m_state; }
  template <typename StateT = Aws::String>
  void SetState(StateT&& value) {
    m_stateHasBeenSet = true;
    m_state = std::forward<StateT>(value);
  }
  template <typename StateT = Aws::String>
  UpdateEventSourceMappingResult& WithState(StateT&& value) {
    SetState(std::forward<StateT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStateTransitionReason() const { return m_stateTransitionReason; }
  template <typename StateTransitionReasonT = Aws::String>
  void SetStateTransitionReason(StateTransitionReasonT&& value) {
    m_stateTransitionReasonHasBeenSet = true;
    m_stateTransitionReason = std::forward<StateTransitionReasonT>(value);
  }
  template <typename StateTransitionReasonT = Aws::String>
  UpdateEventSourceMappingResult& WithStateTransitionReason(StateTransitionReasonT&& value) {
    SetStateTransitionReason(std::forward<StateTransitionReasonT>(value));
    return *this;
  }
 
 
  inline const DestinationConfig& GetDestinationConfig() const { return m_destinationConfig; }
  template <typename DestinationConfigT = DestinationConfig>
  void SetDestinationConfig(DestinationConfigT&& value) {
    m_destinationConfigHasBeenSet = true;
    m_destinationConfig = std::forward<DestinationConfigT>(value);
  }
  template <typename DestinationConfigT = DestinationConfig>
  UpdateEventSourceMappingResult& WithDestinationConfig(DestinationConfigT&& value) {
    SetDestinationConfig(std::forward<DestinationConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetTopics() const { return m_topics; }
  template <typename TopicsT = Aws::Vector<Aws::String>>
  void SetTopics(TopicsT&& value) {
    m_topicsHasBeenSet = true;
    m_topics = std::forward<TopicsT>(value);
  }
  template <typename TopicsT = Aws::Vector<Aws::String>>
  UpdateEventSourceMappingResult& WithTopics(TopicsT&& value) {
    SetTopics(std::forward<TopicsT>(value));
    return *this;
  }
  template <typename TopicsT = Aws::String>
  UpdateEventSourceMappingResult& AddTopics(TopicsT&& value) {
    m_topicsHasBeenSet = true;
    m_topics.emplace_back(std::forward<TopicsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetQueues() const { return m_queues; }
  template <typename QueuesT = Aws::Vector<Aws::String>>
  void SetQueues(QueuesT&& value) {
    m_queuesHasBeenSet = true;
    m_queues = std::forward<QueuesT>(value);
  }
  template <typename QueuesT = Aws::Vector<Aws::String>>
  UpdateEventSourceMappingResult& WithQueues(QueuesT&& value) {
    SetQueues(std::forward<QueuesT>(value));
    return *this;
  }
  template <typename QueuesT = Aws::String>
  UpdateEventSourceMappingResult& AddQueues(QueuesT&& value) {
    m_queuesHasBeenSet = true;
    m_queues.emplace_back(std::forward<QueuesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SourceAccessConfiguration>& GetSourceAccessConfigurations() const { return m_sourceAccessConfigurations; }
  template <typename SourceAccessConfigurationsT = Aws::Vector<SourceAccessConfiguration>>
  void SetSourceAccessConfigurations(SourceAccessConfigurationsT&& value) {
    m_sourceAccessConfigurationsHasBeenSet = true;
    m_sourceAccessConfigurations = std::forward<SourceAccessConfigurationsT>(value);
  }
  template <typename SourceAccessConfigurationsT = Aws::Vector<SourceAccessConfiguration>>
  UpdateEventSourceMappingResult& WithSourceAccessConfigurations(SourceAccessConfigurationsT&& value) {
    SetSourceAccessConfigurations(std::forward<SourceAccessConfigurationsT>(value));
    return *this;
  }
  template <typename SourceAccessConfigurationsT = SourceAccessConfiguration>
  UpdateEventSourceMappingResult& AddSourceAccessConfigurations(SourceAccessConfigurationsT&& value) {
    m_sourceAccessConfigurationsHasBeenSet = true;
    m_sourceAccessConfigurations.emplace_back(std::forward<SourceAccessConfigurationsT>(value));
    return *this;
  }
 
 
  inline const SelfManagedEventSource& GetSelfManagedEventSource() const { return m_selfManagedEventSource; }
  template <typename SelfManagedEventSourceT = SelfManagedEventSource>
  void SetSelfManagedEventSource(SelfManagedEventSourceT&& value) {
    m_selfManagedEventSourceHasBeenSet = true;
    m_selfManagedEventSource = std::forward<SelfManagedEventSourceT>(value);
  }
  template <typename SelfManagedEventSourceT = SelfManagedEventSource>
  UpdateEventSourceMappingResult& WithSelfManagedEventSource(SelfManagedEventSourceT&& value) {
    SetSelfManagedEventSource(std::forward<SelfManagedEventSourceT>(value));
    return *this;
  }
 
 
  inline int GetMaximumRecordAgeInSeconds() const { return m_maximumRecordAgeInSeconds; }
  inline void SetMaximumRecordAgeInSeconds(int value) {
    m_maximumRecordAgeInSecondsHasBeenSet = true;
    m_maximumRecordAgeInSeconds = value;
  }
  inline UpdateEventSourceMappingResult& WithMaximumRecordAgeInSeconds(int value) {
    SetMaximumRecordAgeInSeconds(value);
    return *this;
  }
 
 
  inline bool GetBisectBatchOnFunctionError() const { return m_bisectBatchOnFunctionError; }
  inline void SetBisectBatchOnFunctionError(bool value) {
    m_bisectBatchOnFunctionErrorHasBeenSet = true;
    m_bisectBatchOnFunctionError = value;
  }
  inline UpdateEventSourceMappingResult& WithBisectBatchOnFunctionError(bool value) {
    SetBisectBatchOnFunctionError(value);
    return *this;
  }
 
 
  inline int GetMaximumRetryAttempts() const { return m_maximumRetryAttempts; }
  inline void SetMaximumRetryAttempts(int value) {
    m_maximumRetryAttemptsHasBeenSet = true;
    m_maximumRetryAttempts = value;
  }
  inline UpdateEventSourceMappingResult& WithMaximumRetryAttempts(int value) {
    SetMaximumRetryAttempts(value);
    return *this;
  }
 
 
  inline int GetTumblingWindowInSeconds() const { return m_tumblingWindowInSeconds; }
  inline void SetTumblingWindowInSeconds(int value) {
    m_tumblingWindowInSecondsHasBeenSet = true;
    m_tumblingWindowInSeconds = value;
  }
  inline UpdateEventSourceMappingResult& WithTumblingWindowInSeconds(int value) {
    SetTumblingWindowInSeconds(value);
    return *this;
  }
 
 
  inline const Aws::Vector<FunctionResponseType>& GetFunctionResponseTypes() const { return m_functionResponseTypes; }
  template <typename FunctionResponseTypesT = Aws::Vector<FunctionResponseType>>
  void SetFunctionResponseTypes(FunctionResponseTypesT&& value) {
    m_functionResponseTypesHasBeenSet = true;
    m_functionResponseTypes = std::forward<FunctionResponseTypesT>(value);
  }
  template <typename FunctionResponseTypesT = Aws::Vector<FunctionResponseType>>
  UpdateEventSourceMappingResult& WithFunctionResponseTypes(FunctionResponseTypesT&& value) {
    SetFunctionResponseTypes(std::forward<FunctionResponseTypesT>(value));
    return *this;
  }
  inline UpdateEventSourceMappingResult& AddFunctionResponseTypes(FunctionResponseType value) {
    m_functionResponseTypesHasBeenSet = true;
    m_functionResponseTypes.push_back(value);
    return *this;
  }
 
 
  inline const AmazonManagedKafkaEventSourceConfig& GetAmazonManagedKafkaEventSourceConfig() const {
    return m_amazonManagedKafkaEventSourceConfig;
  }
  template <typename AmazonManagedKafkaEventSourceConfigT = AmazonManagedKafkaEventSourceConfig>
  void SetAmazonManagedKafkaEventSourceConfig(AmazonManagedKafkaEventSourceConfigT&& value) {
    m_amazonManagedKafkaEventSourceConfigHasBeenSet = true;
    m_amazonManagedKafkaEventSourceConfig = std::forward<AmazonManagedKafkaEventSourceConfigT>(value);
  }
  template <typename AmazonManagedKafkaEventSourceConfigT = AmazonManagedKafkaEventSourceConfig>
  UpdateEventSourceMappingResult& WithAmazonManagedKafkaEventSourceConfig(AmazonManagedKafkaEventSourceConfigT&& value) {
    SetAmazonManagedKafkaEventSourceConfig(std::forward<AmazonManagedKafkaEventSourceConfigT>(value));
    return *this;
  }
 
 
  inline const SelfManagedKafkaEventSourceConfig& GetSelfManagedKafkaEventSourceConfig() const {
    return m_selfManagedKafkaEventSourceConfig;
  }
  template <typename SelfManagedKafkaEventSourceConfigT = SelfManagedKafkaEventSourceConfig>
  void SetSelfManagedKafkaEventSourceConfig(SelfManagedKafkaEventSourceConfigT&& value) {
    m_selfManagedKafkaEventSourceConfigHasBeenSet = true;
    m_selfManagedKafkaEventSourceConfig = std::forward<SelfManagedKafkaEventSourceConfigT>(value);
  }
  template <typename SelfManagedKafkaEventSourceConfigT = SelfManagedKafkaEventSourceConfig>
  UpdateEventSourceMappingResult& WithSelfManagedKafkaEventSourceConfig(SelfManagedKafkaEventSourceConfigT&& value) {
    SetSelfManagedKafkaEventSourceConfig(std::forward<SelfManagedKafkaEventSourceConfigT>(value));
    return *this;
  }
 
 
  inline const DocumentDBEventSourceConfig& GetDocumentDBEventSourceConfig() const { return m_documentDBEventSourceConfig; }
  template <typename DocumentDBEventSourceConfigT = DocumentDBEventSourceConfig>
  void SetDocumentDBEventSourceConfig(DocumentDBEventSourceConfigT&& value) {
    m_documentDBEventSourceConfigHasBeenSet = true;
    m_documentDBEventSourceConfig = std::forward<DocumentDBEventSourceConfigT>(value);
  }
  template <typename DocumentDBEventSourceConfigT = DocumentDBEventSourceConfig>
  UpdateEventSourceMappingResult& WithDocumentDBEventSourceConfig(DocumentDBEventSourceConfigT&& value) {
    SetDocumentDBEventSourceConfig(std::forward<DocumentDBEventSourceConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEventSourceMappingArn() const { return m_eventSourceMappingArn; }
  template <typename EventSourceMappingArnT = Aws::String>
  void SetEventSourceMappingArn(EventSourceMappingArnT&& value) {
    m_eventSourceMappingArnHasBeenSet = true;
    m_eventSourceMappingArn = std::forward<EventSourceMappingArnT>(value);
  }
  template <typename EventSourceMappingArnT = Aws::String>
  UpdateEventSourceMappingResult& WithEventSourceMappingArn(EventSourceMappingArnT&& value) {
    SetEventSourceMappingArn(std::forward<EventSourceMappingArnT>(value));
    return *this;
  }
 
 
  inline const ProvisionedPollerConfig& GetProvisionedPollerConfig() const { return m_provisionedPollerConfig; }
  template <typename ProvisionedPollerConfigT = ProvisionedPollerConfig>
  void SetProvisionedPollerConfig(ProvisionedPollerConfigT&& value) {
    m_provisionedPollerConfigHasBeenSet = true;
    m_provisionedPollerConfig = std::forward<ProvisionedPollerConfigT>(value);
  }
  template <typename ProvisionedPollerConfigT = ProvisionedPollerConfig>
  UpdateEventSourceMappingResult& WithProvisionedPollerConfig(ProvisionedPollerConfigT&& value) {
    SetProvisionedPollerConfig(std::forward<ProvisionedPollerConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  UpdateEventSourceMappingResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
  inline Aws::Http::HttpResponseCode GetHttpResponseCode() const { return m_HttpResponseCode; }
 
 private:
  Aws::String m_uUID;
 
  EventSourcePosition m_startingPosition{EventSourcePosition::NOT_SET};
 
  Aws::Utils::DateTime m_startingPositionTimestamp{};
 
  int m_batchSize{0};
 
  int m_maximumBatchingWindowInSeconds{0};
 
  int m_parallelizationFactor{0};
 
  Aws::String m_eventSourceArn;
 
  FilterCriteria m_filterCriteria;
 
  FilterCriteriaError m_filterCriteriaError;
 
  Aws::String m_kMSKeyArn;
 
  EventSourceMappingMetricsConfig m_metricsConfig;
 
  EventSourceMappingLoggingConfig m_loggingConfig;
 
  ScalingConfig m_scalingConfig;
 
  Aws::String m_functionArn;
 
  Aws::Utils::DateTime m_lastModified{};
 
  Aws::String m_lastProcessingResult;
 
  Aws::String m_state;
 
  Aws::String m_stateTransitionReason;
 
  DestinationConfig m_destinationConfig;
 
  Aws::Vector<Aws::String> m_topics;
 
  Aws::Vector<Aws::String> m_queues;
 
  Aws::Vector<SourceAccessConfiguration> m_sourceAccessConfigurations;
 
  SelfManagedEventSource m_selfManagedEventSource;
 
  int m_maximumRecordAgeInSeconds{0};
 
  bool m_bisectBatchOnFunctionError{false};
 
  int m_maximumRetryAttempts{0};
 
  int m_tumblingWindowInSeconds{0};
 
  Aws::Vector<FunctionResponseType> m_functionResponseTypes;
 
  AmazonManagedKafkaEventSourceConfig m_amazonManagedKafkaEventSourceConfig;
 
  SelfManagedKafkaEventSourceConfig m_selfManagedKafkaEventSourceConfig;
 
  DocumentDBEventSourceConfig m_documentDBEventSourceConfig;
 
  Aws::String m_eventSourceMappingArn;
 
  ProvisionedPollerConfig m_provisionedPollerConfig;
 
  Aws::String m_requestId;
  Aws::Http::HttpResponseCode m_HttpResponseCode;
  bool m_uUIDHasBeenSet = false;
  bool m_startingPositionHasBeenSet = false;
  bool m_startingPositionTimestampHasBeenSet = false;
  bool m_batchSizeHasBeenSet = false;
  bool m_maximumBatchingWindowInSecondsHasBeenSet = false;
  bool m_parallelizationFactorHasBeenSet = false;
  bool m_eventSourceArnHasBeenSet = false;
  bool m_filterCriteriaHasBeenSet = false;
  bool m_filterCriteriaErrorHasBeenSet = false;
  bool m_kMSKeyArnHasBeenSet = false;
  bool m_metricsConfigHasBeenSet = false;
  bool m_loggingConfigHasBeenSet = false;
  bool m_scalingConfigHasBeenSet = false;
  bool m_functionArnHasBeenSet = false;
  bool m_lastModifiedHasBeenSet = false;
  bool m_lastProcessingResultHasBeenSet = false;
  bool m_stateHasBeenSet = false;
  bool m_stateTransitionReasonHasBeenSet = false;
  bool m_destinationConfigHasBeenSet = false;
  bool m_topicsHasBeenSet = false;
  bool m_queuesHasBeenSet = false;
  bool m_sourceAccessConfigurationsHasBeenSet = false;
  bool m_selfManagedEventSourceHasBeenSet = false;
  bool m_maximumRecordAgeInSecondsHasBeenSet = false;
  bool m_bisectBatchOnFunctionErrorHasBeenSet = false;
  bool m_maximumRetryAttemptsHasBeenSet = false;
  bool m_tumblingWindowInSecondsHasBeenSet = false;
  bool m_functionResponseTypesHasBeenSet = false;
  bool m_amazonManagedKafkaEventSourceConfigHasBeenSet = false;
  bool m_selfManagedKafkaEventSourceConfigHasBeenSet = false;
  bool m_documentDBEventSourceConfigHasBeenSet = false;
  bool m_eventSourceMappingArnHasBeenSet = false;
  bool m_provisionedPollerConfigHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lambda
}  // namespace Aws