DevOpsGuruClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/devops-guru/DevOpsGuruPaginationBase.h>
#include <aws/devops-guru/DevOpsGuruServiceClientModel.h>
#include <aws/devops-guru/DevOpsGuruWaiter.h>
#include <aws/devops-guru/DevOpsGuru_EXPORTS.h>
 
namespace Aws {
namespace DevOpsGuru {
class AWS_DEVOPSGURU_API DevOpsGuruClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<DevOpsGuruClient>,
                                            public DevOpsGuruPaginationBase<DevOpsGuruClient>,
                                            public DevOpsGuruWaiter<DevOpsGuruClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DevOpsGuruClientConfiguration ClientConfigurationType;
  typedef DevOpsGuruEndpointProvider EndpointProviderType;
 
  DevOpsGuruClient(
      const Aws::DevOpsGuru::DevOpsGuruClientConfiguration& clientConfiguration = Aws::DevOpsGuru::DevOpsGuruClientConfiguration(),
      std::shared_ptr<DevOpsGuruEndpointProviderBase> endpointProvider = nullptr);
 
  DevOpsGuruClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DevOpsGuruEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DevOpsGuru::DevOpsGuruClientConfiguration& clientConfiguration = Aws::DevOpsGuru::DevOpsGuruClientConfiguration());
 
  DevOpsGuruClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<DevOpsGuruEndpointProviderBase> endpointProvider = nullptr,
      const Aws::DevOpsGuru::DevOpsGuruClientConfiguration& clientConfiguration = Aws::DevOpsGuru::DevOpsGuruClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DevOpsGuruClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DevOpsGuruClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DevOpsGuruClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DevOpsGuruClient();
 
  virtual Model::AddNotificationChannelOutcome AddNotificationChannel(const Model::AddNotificationChannelRequest& request) const;
 
  template <typename AddNotificationChannelRequestT = Model::AddNotificationChannelRequest>
  Model::AddNotificationChannelOutcomeCallable AddNotificationChannelCallable(const AddNotificationChannelRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::AddNotificationChannel, request);
  }
 
  template <typename AddNotificationChannelRequestT = Model::AddNotificationChannelRequest>
  void AddNotificationChannelAsync(const AddNotificationChannelRequestT& request,
                                   const AddNotificationChannelResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::AddNotificationChannel, request, handler, context);
  }
 
  virtual Model::DeleteInsightOutcome DeleteInsight(const Model::DeleteInsightRequest& request) const;
 
  template <typename DeleteInsightRequestT = Model::DeleteInsightRequest>
  Model::DeleteInsightOutcomeCallable DeleteInsightCallable(const DeleteInsightRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::DeleteInsight, request);
  }
 
  template <typename DeleteInsightRequestT = Model::DeleteInsightRequest>
  void DeleteInsightAsync(const DeleteInsightRequestT& request, const DeleteInsightResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::DeleteInsight, request, handler, context);
  }
 
  virtual Model::DescribeAccountHealthOutcome DescribeAccountHealth(const Model::DescribeAccountHealthRequest& request = {}) const;
 
  template <typename DescribeAccountHealthRequestT = Model::DescribeAccountHealthRequest>
  Model::DescribeAccountHealthOutcomeCallable DescribeAccountHealthCallable(const DescribeAccountHealthRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeAccountHealth, request);
  }
 
  template <typename DescribeAccountHealthRequestT = Model::DescribeAccountHealthRequest>
  void DescribeAccountHealthAsync(const DescribeAccountHealthResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeAccountHealthRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeAccountHealth, request, handler, context);
  }
 
  virtual Model::DescribeAccountOverviewOutcome DescribeAccountOverview(const Model::DescribeAccountOverviewRequest& request) const;
 
  template <typename DescribeAccountOverviewRequestT = Model::DescribeAccountOverviewRequest>
  Model::DescribeAccountOverviewOutcomeCallable DescribeAccountOverviewCallable(const DescribeAccountOverviewRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeAccountOverview, request);
  }
 
  template <typename DescribeAccountOverviewRequestT = Model::DescribeAccountOverviewRequest>
  void DescribeAccountOverviewAsync(const DescribeAccountOverviewRequestT& request,
                                    const DescribeAccountOverviewResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeAccountOverview, request, handler, context);
  }
 
  virtual Model::DescribeAnomalyOutcome DescribeAnomaly(const Model::DescribeAnomalyRequest& request) const;
 
  template <typename DescribeAnomalyRequestT = Model::DescribeAnomalyRequest>
  Model::DescribeAnomalyOutcomeCallable DescribeAnomalyCallable(const DescribeAnomalyRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeAnomaly, request);
  }
 
  template <typename DescribeAnomalyRequestT = Model::DescribeAnomalyRequest>
  void DescribeAnomalyAsync(const DescribeAnomalyRequestT& request, const DescribeAnomalyResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeAnomaly, request, handler, context);
  }
 
  virtual Model::DescribeEventSourcesConfigOutcome DescribeEventSourcesConfig(
      const Model::DescribeEventSourcesConfigRequest& request = {}) const;
 
  template <typename DescribeEventSourcesConfigRequestT = Model::DescribeEventSourcesConfigRequest>
  Model::DescribeEventSourcesConfigOutcomeCallable DescribeEventSourcesConfigCallable(
      const DescribeEventSourcesConfigRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeEventSourcesConfig, request);
  }
 
  template <typename DescribeEventSourcesConfigRequestT = Model::DescribeEventSourcesConfigRequest>
  void DescribeEventSourcesConfigAsync(const DescribeEventSourcesConfigResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeEventSourcesConfigRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeEventSourcesConfig, request, handler, context);
  }
 
  virtual Model::DescribeFeedbackOutcome DescribeFeedback(const Model::DescribeFeedbackRequest& request = {}) const;
 
  template <typename DescribeFeedbackRequestT = Model::DescribeFeedbackRequest>
  Model::DescribeFeedbackOutcomeCallable DescribeFeedbackCallable(const DescribeFeedbackRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeFeedback, request);
  }
 
  template <typename DescribeFeedbackRequestT = Model::DescribeFeedbackRequest>
  void DescribeFeedbackAsync(const DescribeFeedbackResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const DescribeFeedbackRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeFeedback, request, handler, context);
  }
 
  virtual Model::DescribeInsightOutcome DescribeInsight(const Model::DescribeInsightRequest& request) const;
 
  template <typename DescribeInsightRequestT = Model::DescribeInsightRequest>
  Model::DescribeInsightOutcomeCallable DescribeInsightCallable(const DescribeInsightRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeInsight, request);
  }
 
  template <typename DescribeInsightRequestT = Model::DescribeInsightRequest>
  void DescribeInsightAsync(const DescribeInsightRequestT& request, const DescribeInsightResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeInsight, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationHealthOutcome DescribeOrganizationHealth(
      const Model::DescribeOrganizationHealthRequest& request = {}) const;
 
  template <typename DescribeOrganizationHealthRequestT = Model::DescribeOrganizationHealthRequest>
  Model::DescribeOrganizationHealthOutcomeCallable DescribeOrganizationHealthCallable(
      const DescribeOrganizationHealthRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeOrganizationHealth, request);
  }
 
  template <typename DescribeOrganizationHealthRequestT = Model::DescribeOrganizationHealthRequest>
  void DescribeOrganizationHealthAsync(const DescribeOrganizationHealthResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeOrganizationHealthRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeOrganizationHealth, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationOverviewOutcome DescribeOrganizationOverview(
      const Model::DescribeOrganizationOverviewRequest& request) const;
 
  template <typename DescribeOrganizationOverviewRequestT = Model::DescribeOrganizationOverviewRequest>
  Model::DescribeOrganizationOverviewOutcomeCallable DescribeOrganizationOverviewCallable(
      const DescribeOrganizationOverviewRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeOrganizationOverview, request);
  }
 
  template <typename DescribeOrganizationOverviewRequestT = Model::DescribeOrganizationOverviewRequest>
  void DescribeOrganizationOverviewAsync(const DescribeOrganizationOverviewRequestT& request,
                                         const DescribeOrganizationOverviewResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeOrganizationOverview, request, handler, context);
  }
 
  virtual Model::DescribeOrganizationResourceCollectionHealthOutcome DescribeOrganizationResourceCollectionHealth(
      const Model::DescribeOrganizationResourceCollectionHealthRequest& request) const;
 
  template <typename DescribeOrganizationResourceCollectionHealthRequestT = Model::DescribeOrganizationResourceCollectionHealthRequest>
  Model::DescribeOrganizationResourceCollectionHealthOutcomeCallable DescribeOrganizationResourceCollectionHealthCallable(
      const DescribeOrganizationResourceCollectionHealthRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeOrganizationResourceCollectionHealth, request);
  }
 
  template <typename DescribeOrganizationResourceCollectionHealthRequestT = Model::DescribeOrganizationResourceCollectionHealthRequest>
  void DescribeOrganizationResourceCollectionHealthAsync(
      const DescribeOrganizationResourceCollectionHealthRequestT& request,
      const DescribeOrganizationResourceCollectionHealthResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeOrganizationResourceCollectionHealth, request, handler, context);
  }
 
  virtual Model::DescribeResourceCollectionHealthOutcome DescribeResourceCollectionHealth(
      const Model::DescribeResourceCollectionHealthRequest& request) const;
 
  template <typename DescribeResourceCollectionHealthRequestT = Model::DescribeResourceCollectionHealthRequest>
  Model::DescribeResourceCollectionHealthOutcomeCallable DescribeResourceCollectionHealthCallable(
      const DescribeResourceCollectionHealthRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeResourceCollectionHealth, request);
  }
 
  template <typename DescribeResourceCollectionHealthRequestT = Model::DescribeResourceCollectionHealthRequest>
  void DescribeResourceCollectionHealthAsync(const DescribeResourceCollectionHealthRequestT& request,
                                             const DescribeResourceCollectionHealthResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeResourceCollectionHealth, request, handler, context);
  }
 
  virtual Model::DescribeServiceIntegrationOutcome DescribeServiceIntegration(
      const Model::DescribeServiceIntegrationRequest& request = {}) const;
 
  template <typename DescribeServiceIntegrationRequestT = Model::DescribeServiceIntegrationRequest>
  Model::DescribeServiceIntegrationOutcomeCallable DescribeServiceIntegrationCallable(
      const DescribeServiceIntegrationRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::DescribeServiceIntegration, request);
  }
 
  template <typename DescribeServiceIntegrationRequestT = Model::DescribeServiceIntegrationRequest>
  void DescribeServiceIntegrationAsync(const DescribeServiceIntegrationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const DescribeServiceIntegrationRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::DescribeServiceIntegration, request, handler, context);
  }
 
  virtual Model::GetCostEstimationOutcome GetCostEstimation(const Model::GetCostEstimationRequest& request = {}) const;
 
  template <typename GetCostEstimationRequestT = Model::GetCostEstimationRequest>
  Model::GetCostEstimationOutcomeCallable GetCostEstimationCallable(const GetCostEstimationRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::GetCostEstimation, request);
  }
 
  template <typename GetCostEstimationRequestT = Model::GetCostEstimationRequest>
  void GetCostEstimationAsync(const GetCostEstimationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const GetCostEstimationRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::GetCostEstimation, request, handler, context);
  }
 
  virtual Model::GetResourceCollectionOutcome GetResourceCollection(const Model::GetResourceCollectionRequest& request) const;
 
  template <typename GetResourceCollectionRequestT = Model::GetResourceCollectionRequest>
  Model::GetResourceCollectionOutcomeCallable GetResourceCollectionCallable(const GetResourceCollectionRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::GetResourceCollection, request);
  }
 
  template <typename GetResourceCollectionRequestT = Model::GetResourceCollectionRequest>
  void GetResourceCollectionAsync(const GetResourceCollectionRequestT& request, const GetResourceCollectionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::GetResourceCollection, request, handler, context);
  }
 
  virtual Model::ListAnomaliesForInsightOutcome ListAnomaliesForInsight(const Model::ListAnomaliesForInsightRequest& request) const;
 
  template <typename ListAnomaliesForInsightRequestT = Model::ListAnomaliesForInsightRequest>
  Model::ListAnomaliesForInsightOutcomeCallable ListAnomaliesForInsightCallable(const ListAnomaliesForInsightRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::ListAnomaliesForInsight, request);
  }
 
  template <typename ListAnomaliesForInsightRequestT = Model::ListAnomaliesForInsightRequest>
  void ListAnomaliesForInsightAsync(const ListAnomaliesForInsightRequestT& request,
                                    const ListAnomaliesForInsightResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::ListAnomaliesForInsight, request, handler, context);
  }
 
  virtual Model::ListAnomalousLogGroupsOutcome ListAnomalousLogGroups(const Model::ListAnomalousLogGroupsRequest& request) const;
 
  template <typename ListAnomalousLogGroupsRequestT = Model::ListAnomalousLogGroupsRequest>
  Model::ListAnomalousLogGroupsOutcomeCallable ListAnomalousLogGroupsCallable(const ListAnomalousLogGroupsRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::ListAnomalousLogGroups, request);
  }
 
  template <typename ListAnomalousLogGroupsRequestT = Model::ListAnomalousLogGroupsRequest>
  void ListAnomalousLogGroupsAsync(const ListAnomalousLogGroupsRequestT& request,
                                   const ListAnomalousLogGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::ListAnomalousLogGroups, request, handler, context);
  }
 
  virtual Model::ListEventsOutcome ListEvents(const Model::ListEventsRequest& request) const;
 
  template <typename ListEventsRequestT = Model::ListEventsRequest>
  Model::ListEventsOutcomeCallable ListEventsCallable(const ListEventsRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::ListEvents, request);
  }
 
  template <typename ListEventsRequestT = Model::ListEventsRequest>
  void ListEventsAsync(const ListEventsRequestT& request, const ListEventsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::ListEvents, request, handler, context);
  }
 
  virtual Model::ListInsightsOutcome ListInsights(const Model::ListInsightsRequest& request) const;
 
  template <typename ListInsightsRequestT = Model::ListInsightsRequest>
  Model::ListInsightsOutcomeCallable ListInsightsCallable(const ListInsightsRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::ListInsights, request);
  }
 
  template <typename ListInsightsRequestT = Model::ListInsightsRequest>
  void ListInsightsAsync(const ListInsightsRequestT& request, const ListInsightsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::ListInsights, request, handler, context);
  }
 
  virtual Model::ListMonitoredResourcesOutcome ListMonitoredResources(const Model::ListMonitoredResourcesRequest& request = {}) const;
 
  template <typename ListMonitoredResourcesRequestT = Model::ListMonitoredResourcesRequest>
  Model::ListMonitoredResourcesOutcomeCallable ListMonitoredResourcesCallable(const ListMonitoredResourcesRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::ListMonitoredResources, request);
  }
 
  template <typename ListMonitoredResourcesRequestT = Model::ListMonitoredResourcesRequest>
  void ListMonitoredResourcesAsync(const ListMonitoredResourcesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListMonitoredResourcesRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::ListMonitoredResources, request, handler, context);
  }
 
  virtual Model::ListNotificationChannelsOutcome ListNotificationChannels(const Model::ListNotificationChannelsRequest& request = {}) const;
 
  template <typename ListNotificationChannelsRequestT = Model::ListNotificationChannelsRequest>
  Model::ListNotificationChannelsOutcomeCallable ListNotificationChannelsCallable(
      const ListNotificationChannelsRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::ListNotificationChannels, request);
  }
 
  template <typename ListNotificationChannelsRequestT = Model::ListNotificationChannelsRequest>
  void ListNotificationChannelsAsync(const ListNotificationChannelsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListNotificationChannelsRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::ListNotificationChannels, request, handler, context);
  }
 
  virtual Model::ListOrganizationInsightsOutcome ListOrganizationInsights(const Model::ListOrganizationInsightsRequest& request) const;
 
  template <typename ListOrganizationInsightsRequestT = Model::ListOrganizationInsightsRequest>
  Model::ListOrganizationInsightsOutcomeCallable ListOrganizationInsightsCallable(const ListOrganizationInsightsRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::ListOrganizationInsights, request);
  }
 
  template <typename ListOrganizationInsightsRequestT = Model::ListOrganizationInsightsRequest>
  void ListOrganizationInsightsAsync(const ListOrganizationInsightsRequestT& request,
                                     const ListOrganizationInsightsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::ListOrganizationInsights, request, handler, context);
  }
 
  virtual Model::ListRecommendationsOutcome ListRecommendations(const Model::ListRecommendationsRequest& request) const;
 
  template <typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
  Model::ListRecommendationsOutcomeCallable ListRecommendationsCallable(const ListRecommendationsRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::ListRecommendations, request);
  }
 
  template <typename ListRecommendationsRequestT = Model::ListRecommendationsRequest>
  void ListRecommendationsAsync(const ListRecommendationsRequestT& request, const ListRecommendationsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::ListRecommendations, request, handler, context);
  }
 
  virtual Model::PutFeedbackOutcome PutFeedback(const Model::PutFeedbackRequest& request = {}) const;
 
  template <typename PutFeedbackRequestT = Model::PutFeedbackRequest>
  Model::PutFeedbackOutcomeCallable PutFeedbackCallable(const PutFeedbackRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::PutFeedback, request);
  }
 
  template <typename PutFeedbackRequestT = Model::PutFeedbackRequest>
  void PutFeedbackAsync(const PutFeedbackResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const PutFeedbackRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::PutFeedback, request, handler, context);
  }
 
  virtual Model::RemoveNotificationChannelOutcome RemoveNotificationChannel(const Model::RemoveNotificationChannelRequest& request) const;
 
  template <typename RemoveNotificationChannelRequestT = Model::RemoveNotificationChannelRequest>
  Model::RemoveNotificationChannelOutcomeCallable RemoveNotificationChannelCallable(
      const RemoveNotificationChannelRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::RemoveNotificationChannel, request);
  }
 
  template <typename RemoveNotificationChannelRequestT = Model::RemoveNotificationChannelRequest>
  void RemoveNotificationChannelAsync(const RemoveNotificationChannelRequestT& request,
                                      const RemoveNotificationChannelResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::RemoveNotificationChannel, request, handler, context);
  }
 
  virtual Model::SearchInsightsOutcome SearchInsights(const Model::SearchInsightsRequest& request) const;
 
  template <typename SearchInsightsRequestT = Model::SearchInsightsRequest>
  Model::SearchInsightsOutcomeCallable SearchInsightsCallable(const SearchInsightsRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::SearchInsights, request);
  }
 
  template <typename SearchInsightsRequestT = Model::SearchInsightsRequest>
  void SearchInsightsAsync(const SearchInsightsRequestT& request, const SearchInsightsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::SearchInsights, request, handler, context);
  }
 
  virtual Model::SearchOrganizationInsightsOutcome SearchOrganizationInsights(
      const Model::SearchOrganizationInsightsRequest& request) const;
 
  template <typename SearchOrganizationInsightsRequestT = Model::SearchOrganizationInsightsRequest>
  Model::SearchOrganizationInsightsOutcomeCallable SearchOrganizationInsightsCallable(
      const SearchOrganizationInsightsRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::SearchOrganizationInsights, request);
  }
 
  template <typename SearchOrganizationInsightsRequestT = Model::SearchOrganizationInsightsRequest>
  void SearchOrganizationInsightsAsync(const SearchOrganizationInsightsRequestT& request,
                                       const SearchOrganizationInsightsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::SearchOrganizationInsights, request, handler, context);
  }
 
  virtual Model::StartCostEstimationOutcome StartCostEstimation(const Model::StartCostEstimationRequest& request) const;
 
  template <typename StartCostEstimationRequestT = Model::StartCostEstimationRequest>
  Model::StartCostEstimationOutcomeCallable StartCostEstimationCallable(const StartCostEstimationRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::StartCostEstimation, request);
  }
 
  template <typename StartCostEstimationRequestT = Model::StartCostEstimationRequest>
  void StartCostEstimationAsync(const StartCostEstimationRequestT& request, const StartCostEstimationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::StartCostEstimation, request, handler, context);
  }
 
  virtual Model::UpdateEventSourcesConfigOutcome UpdateEventSourcesConfig(const Model::UpdateEventSourcesConfigRequest& request = {}) const;
 
  template <typename UpdateEventSourcesConfigRequestT = Model::UpdateEventSourcesConfigRequest>
  Model::UpdateEventSourcesConfigOutcomeCallable UpdateEventSourcesConfigCallable(
      const UpdateEventSourcesConfigRequestT& request = {}) const {
    return SubmitCallable(&DevOpsGuruClient::UpdateEventSourcesConfig, request);
  }
 
  template <typename UpdateEventSourcesConfigRequestT = Model::UpdateEventSourcesConfigRequest>
  void UpdateEventSourcesConfigAsync(const UpdateEventSourcesConfigResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const UpdateEventSourcesConfigRequestT& request = {}) const {
    return SubmitAsync(&DevOpsGuruClient::UpdateEventSourcesConfig, request, handler, context);
  }
 
  virtual Model::UpdateResourceCollectionOutcome UpdateResourceCollection(const Model::UpdateResourceCollectionRequest& request) const;
 
  template <typename UpdateResourceCollectionRequestT = Model::UpdateResourceCollectionRequest>
  Model::UpdateResourceCollectionOutcomeCallable UpdateResourceCollectionCallable(const UpdateResourceCollectionRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::UpdateResourceCollection, request);
  }
 
  template <typename UpdateResourceCollectionRequestT = Model::UpdateResourceCollectionRequest>
  void UpdateResourceCollectionAsync(const UpdateResourceCollectionRequestT& request,
                                     const UpdateResourceCollectionResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::UpdateResourceCollection, request, handler, context);
  }
 
  virtual Model::UpdateServiceIntegrationOutcome UpdateServiceIntegration(const Model::UpdateServiceIntegrationRequest& request) const;
 
  template <typename UpdateServiceIntegrationRequestT = Model::UpdateServiceIntegrationRequest>
  Model::UpdateServiceIntegrationOutcomeCallable UpdateServiceIntegrationCallable(const UpdateServiceIntegrationRequestT& request) const {
    return SubmitCallable(&DevOpsGuruClient::UpdateServiceIntegration, request);
  }
 
  template <typename UpdateServiceIntegrationRequestT = Model::UpdateServiceIntegrationRequest>
  void UpdateServiceIntegrationAsync(const UpdateServiceIntegrationRequestT& request,
                                     const UpdateServiceIntegrationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DevOpsGuruClient::UpdateServiceIntegration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<DevOpsGuruEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DevOpsGuruClient>;
  void init(const DevOpsGuruClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, DevOpsGuruError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  DevOpsGuruClientConfiguration m_clientConfiguration;
  std::shared_ptr<DevOpsGuruEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace DevOpsGuru
}  // namespace Aws