ApplicationInsightsClient.h

 
#pragma once
#include <aws/application-insights/ApplicationInsightsPaginationBase.h>
#include <aws/application-insights/ApplicationInsightsServiceClientModel.h>
#include <aws/application-insights/ApplicationInsightsWaiter.h>
#include <aws/application-insights/ApplicationInsights_EXPORTS.h>
#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>
 
namespace Aws {
namespace ApplicationInsights {
class AWS_APPLICATIONINSIGHTS_API ApplicationInsightsClient : public Aws::Client::AWSJsonClient,
                                                              public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationInsightsClient>,
                                                              public ApplicationInsightsPaginationBase<ApplicationInsightsClient>,
                                                              public ApplicationInsightsWaiter<ApplicationInsightsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ApplicationInsightsClientConfiguration ClientConfigurationType;
  typedef ApplicationInsightsEndpointProvider EndpointProviderType;
 
  ApplicationInsightsClient(const Aws::ApplicationInsights::ApplicationInsightsClientConfiguration& clientConfiguration =
                                Aws::ApplicationInsights::ApplicationInsightsClientConfiguration(),
                            std::shared_ptr<ApplicationInsightsEndpointProviderBase> endpointProvider = nullptr);
 
  ApplicationInsightsClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<ApplicationInsightsEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::ApplicationInsights::ApplicationInsightsClientConfiguration& clientConfiguration =
                                Aws::ApplicationInsights::ApplicationInsightsClientConfiguration());
 
  ApplicationInsightsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<ApplicationInsightsEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::ApplicationInsights::ApplicationInsightsClientConfiguration& clientConfiguration =
                                Aws::ApplicationInsights::ApplicationInsightsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ApplicationInsightsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ApplicationInsightsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ApplicationInsightsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ApplicationInsightsClient();
 
  virtual Model::AddWorkloadOutcome AddWorkload(const Model::AddWorkloadRequest& request) const;
 
  template <typename AddWorkloadRequestT = Model::AddWorkloadRequest>
  Model::AddWorkloadOutcomeCallable AddWorkloadCallable(const AddWorkloadRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::AddWorkload, request);
  }
 
  template <typename AddWorkloadRequestT = Model::AddWorkloadRequest>
  void AddWorkloadAsync(const AddWorkloadRequestT& request, const AddWorkloadResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::AddWorkload, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request = {}) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request = {}) const {
    return SubmitCallable(&ApplicationInsightsClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const CreateApplicationRequestT& request = {}) const {
    return SubmitAsync(&ApplicationInsightsClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateComponentOutcome CreateComponent(const Model::CreateComponentRequest& request) const;
 
  template <typename CreateComponentRequestT = Model::CreateComponentRequest>
  Model::CreateComponentOutcomeCallable CreateComponentCallable(const CreateComponentRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::CreateComponent, request);
  }
 
  template <typename CreateComponentRequestT = Model::CreateComponentRequest>
  void CreateComponentAsync(const CreateComponentRequestT& request, const CreateComponentResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::CreateComponent, request, handler, context);
  }
 
  virtual Model::CreateLogPatternOutcome CreateLogPattern(const Model::CreateLogPatternRequest& request) const;
 
  template <typename CreateLogPatternRequestT = Model::CreateLogPatternRequest>
  Model::CreateLogPatternOutcomeCallable CreateLogPatternCallable(const CreateLogPatternRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::CreateLogPattern, request);
  }
 
  template <typename CreateLogPatternRequestT = Model::CreateLogPatternRequest>
  void CreateLogPatternAsync(const CreateLogPatternRequestT& request, const CreateLogPatternResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::CreateLogPattern, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteComponentOutcome DeleteComponent(const Model::DeleteComponentRequest& request) const;
 
  template <typename DeleteComponentRequestT = Model::DeleteComponentRequest>
  Model::DeleteComponentOutcomeCallable DeleteComponentCallable(const DeleteComponentRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DeleteComponent, request);
  }
 
  template <typename DeleteComponentRequestT = Model::DeleteComponentRequest>
  void DeleteComponentAsync(const DeleteComponentRequestT& request, const DeleteComponentResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DeleteComponent, request, handler, context);
  }
 
  virtual Model::DeleteLogPatternOutcome DeleteLogPattern(const Model::DeleteLogPatternRequest& request) const;
 
  template <typename DeleteLogPatternRequestT = Model::DeleteLogPatternRequest>
  Model::DeleteLogPatternOutcomeCallable DeleteLogPatternCallable(const DeleteLogPatternRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DeleteLogPattern, request);
  }
 
  template <typename DeleteLogPatternRequestT = Model::DeleteLogPatternRequest>
  void DeleteLogPatternAsync(const DeleteLogPatternRequestT& request, const DeleteLogPatternResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DeleteLogPattern, request, handler, context);
  }
 
  virtual Model::DescribeApplicationOutcome DescribeApplication(const Model::DescribeApplicationRequest& request) const;
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  Model::DescribeApplicationOutcomeCallable DescribeApplicationCallable(const DescribeApplicationRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeApplication, request);
  }
 
  template <typename DescribeApplicationRequestT = Model::DescribeApplicationRequest>
  void DescribeApplicationAsync(const DescribeApplicationRequestT& request, const DescribeApplicationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeApplication, request, handler, context);
  }
 
  virtual Model::DescribeComponentOutcome DescribeComponent(const Model::DescribeComponentRequest& request) const;
 
  template <typename DescribeComponentRequestT = Model::DescribeComponentRequest>
  Model::DescribeComponentOutcomeCallable DescribeComponentCallable(const DescribeComponentRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeComponent, request);
  }
 
  template <typename DescribeComponentRequestT = Model::DescribeComponentRequest>
  void DescribeComponentAsync(const DescribeComponentRequestT& request, const DescribeComponentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeComponent, request, handler, context);
  }
 
  virtual Model::DescribeComponentConfigurationOutcome DescribeComponentConfiguration(
      const Model::DescribeComponentConfigurationRequest& request) const;
 
  template <typename DescribeComponentConfigurationRequestT = Model::DescribeComponentConfigurationRequest>
  Model::DescribeComponentConfigurationOutcomeCallable DescribeComponentConfigurationCallable(
      const DescribeComponentConfigurationRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeComponentConfiguration, request);
  }
 
  template <typename DescribeComponentConfigurationRequestT = Model::DescribeComponentConfigurationRequest>
  void DescribeComponentConfigurationAsync(const DescribeComponentConfigurationRequestT& request,
                                           const DescribeComponentConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeComponentConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeComponentConfigurationRecommendationOutcome DescribeComponentConfigurationRecommendation(
      const Model::DescribeComponentConfigurationRecommendationRequest& request) const;
 
  template <typename DescribeComponentConfigurationRecommendationRequestT = Model::DescribeComponentConfigurationRecommendationRequest>
  Model::DescribeComponentConfigurationRecommendationOutcomeCallable DescribeComponentConfigurationRecommendationCallable(
      const DescribeComponentConfigurationRecommendationRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeComponentConfigurationRecommendation, request);
  }
 
  template <typename DescribeComponentConfigurationRecommendationRequestT = Model::DescribeComponentConfigurationRecommendationRequest>
  void DescribeComponentConfigurationRecommendationAsync(
      const DescribeComponentConfigurationRecommendationRequestT& request,
      const DescribeComponentConfigurationRecommendationResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeComponentConfigurationRecommendation, request, handler, context);
  }
 
  virtual Model::DescribeLogPatternOutcome DescribeLogPattern(const Model::DescribeLogPatternRequest& request) const;
 
  template <typename DescribeLogPatternRequestT = Model::DescribeLogPatternRequest>
  Model::DescribeLogPatternOutcomeCallable DescribeLogPatternCallable(const DescribeLogPatternRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeLogPattern, request);
  }
 
  template <typename DescribeLogPatternRequestT = Model::DescribeLogPatternRequest>
  void DescribeLogPatternAsync(const DescribeLogPatternRequestT& request, const DescribeLogPatternResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeLogPattern, request, handler, context);
  }
 
  virtual Model::DescribeObservationOutcome DescribeObservation(const Model::DescribeObservationRequest& request) const;
 
  template <typename DescribeObservationRequestT = Model::DescribeObservationRequest>
  Model::DescribeObservationOutcomeCallable DescribeObservationCallable(const DescribeObservationRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeObservation, request);
  }
 
  template <typename DescribeObservationRequestT = Model::DescribeObservationRequest>
  void DescribeObservationAsync(const DescribeObservationRequestT& request, const DescribeObservationResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeObservation, request, handler, context);
  }
 
  virtual Model::DescribeProblemOutcome DescribeProblem(const Model::DescribeProblemRequest& request) const;
 
  template <typename DescribeProblemRequestT = Model::DescribeProblemRequest>
  Model::DescribeProblemOutcomeCallable DescribeProblemCallable(const DescribeProblemRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeProblem, request);
  }
 
  template <typename DescribeProblemRequestT = Model::DescribeProblemRequest>
  void DescribeProblemAsync(const DescribeProblemRequestT& request, const DescribeProblemResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeProblem, request, handler, context);
  }
 
  virtual Model::DescribeProblemObservationsOutcome DescribeProblemObservations(
      const Model::DescribeProblemObservationsRequest& request) const;
 
  template <typename DescribeProblemObservationsRequestT = Model::DescribeProblemObservationsRequest>
  Model::DescribeProblemObservationsOutcomeCallable DescribeProblemObservationsCallable(
      const DescribeProblemObservationsRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeProblemObservations, request);
  }
 
  template <typename DescribeProblemObservationsRequestT = Model::DescribeProblemObservationsRequest>
  void DescribeProblemObservationsAsync(const DescribeProblemObservationsRequestT& request,
                                        const DescribeProblemObservationsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeProblemObservations, request, handler, context);
  }
 
  virtual Model::DescribeWorkloadOutcome DescribeWorkload(const Model::DescribeWorkloadRequest& request) const;
 
  template <typename DescribeWorkloadRequestT = Model::DescribeWorkloadRequest>
  Model::DescribeWorkloadOutcomeCallable DescribeWorkloadCallable(const DescribeWorkloadRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::DescribeWorkload, request);
  }
 
  template <typename DescribeWorkloadRequestT = Model::DescribeWorkloadRequest>
  void DescribeWorkloadAsync(const DescribeWorkloadRequestT& request, const DescribeWorkloadResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::DescribeWorkload, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&ApplicationInsightsClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&ApplicationInsightsClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request) const;
 
  template <typename ListComponentsRequestT = Model::ListComponentsRequest>
  Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::ListComponents, request);
  }
 
  template <typename ListComponentsRequestT = Model::ListComponentsRequest>
  void ListComponentsAsync(const ListComponentsRequestT& request, const ListComponentsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::ListComponents, request, handler, context);
  }
 
  virtual Model::ListConfigurationHistoryOutcome ListConfigurationHistory(const Model::ListConfigurationHistoryRequest& request = {}) const;
 
  template <typename ListConfigurationHistoryRequestT = Model::ListConfigurationHistoryRequest>
  Model::ListConfigurationHistoryOutcomeCallable ListConfigurationHistoryCallable(
      const ListConfigurationHistoryRequestT& request = {}) const {
    return SubmitCallable(&ApplicationInsightsClient::ListConfigurationHistory, request);
  }
 
  template <typename ListConfigurationHistoryRequestT = Model::ListConfigurationHistoryRequest>
  void ListConfigurationHistoryAsync(const ListConfigurationHistoryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListConfigurationHistoryRequestT& request = {}) const {
    return SubmitAsync(&ApplicationInsightsClient::ListConfigurationHistory, request, handler, context);
  }
 
  virtual Model::ListLogPatternSetsOutcome ListLogPatternSets(const Model::ListLogPatternSetsRequest& request) const;
 
  template <typename ListLogPatternSetsRequestT = Model::ListLogPatternSetsRequest>
  Model::ListLogPatternSetsOutcomeCallable ListLogPatternSetsCallable(const ListLogPatternSetsRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::ListLogPatternSets, request);
  }
 
  template <typename ListLogPatternSetsRequestT = Model::ListLogPatternSetsRequest>
  void ListLogPatternSetsAsync(const ListLogPatternSetsRequestT& request, const ListLogPatternSetsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::ListLogPatternSets, request, handler, context);
  }
 
  virtual Model::ListLogPatternsOutcome ListLogPatterns(const Model::ListLogPatternsRequest& request) const;
 
  template <typename ListLogPatternsRequestT = Model::ListLogPatternsRequest>
  Model::ListLogPatternsOutcomeCallable ListLogPatternsCallable(const ListLogPatternsRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::ListLogPatterns, request);
  }
 
  template <typename ListLogPatternsRequestT = Model::ListLogPatternsRequest>
  void ListLogPatternsAsync(const ListLogPatternsRequestT& request, const ListLogPatternsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::ListLogPatterns, request, handler, context);
  }
 
  virtual Model::ListProblemsOutcome ListProblems(const Model::ListProblemsRequest& request = {}) const;
 
  template <typename ListProblemsRequestT = Model::ListProblemsRequest>
  Model::ListProblemsOutcomeCallable ListProblemsCallable(const ListProblemsRequestT& request = {}) const {
    return SubmitCallable(&ApplicationInsightsClient::ListProblems, request);
  }
 
  template <typename ListProblemsRequestT = Model::ListProblemsRequest>
  void ListProblemsAsync(const ListProblemsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProblemsRequestT& request = {}) const {
    return SubmitAsync(&ApplicationInsightsClient::ListProblems, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWorkloadsOutcome ListWorkloads(const Model::ListWorkloadsRequest& request) const;
 
  template <typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
  Model::ListWorkloadsOutcomeCallable ListWorkloadsCallable(const ListWorkloadsRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::ListWorkloads, request);
  }
 
  template <typename ListWorkloadsRequestT = Model::ListWorkloadsRequest>
  void ListWorkloadsAsync(const ListWorkloadsRequestT& request, const ListWorkloadsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::ListWorkloads, request, handler, context);
  }
 
  virtual Model::RemoveWorkloadOutcome RemoveWorkload(const Model::RemoveWorkloadRequest& request) const;
 
  template <typename RemoveWorkloadRequestT = Model::RemoveWorkloadRequest>
  Model::RemoveWorkloadOutcomeCallable RemoveWorkloadCallable(const RemoveWorkloadRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::RemoveWorkload, request);
  }
 
  template <typename RemoveWorkloadRequestT = Model::RemoveWorkloadRequest>
  void RemoveWorkloadAsync(const RemoveWorkloadRequestT& request, const RemoveWorkloadResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::RemoveWorkload, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateComponentOutcome UpdateComponent(const Model::UpdateComponentRequest& request) const;
 
  template <typename UpdateComponentRequestT = Model::UpdateComponentRequest>
  Model::UpdateComponentOutcomeCallable UpdateComponentCallable(const UpdateComponentRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::UpdateComponent, request);
  }
 
  template <typename UpdateComponentRequestT = Model::UpdateComponentRequest>
  void UpdateComponentAsync(const UpdateComponentRequestT& request, const UpdateComponentResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::UpdateComponent, request, handler, context);
  }
 
  virtual Model::UpdateComponentConfigurationOutcome UpdateComponentConfiguration(
      const Model::UpdateComponentConfigurationRequest& request) const;
 
  template <typename UpdateComponentConfigurationRequestT = Model::UpdateComponentConfigurationRequest>
  Model::UpdateComponentConfigurationOutcomeCallable UpdateComponentConfigurationCallable(
      const UpdateComponentConfigurationRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::UpdateComponentConfiguration, request);
  }
 
  template <typename UpdateComponentConfigurationRequestT = Model::UpdateComponentConfigurationRequest>
  void UpdateComponentConfigurationAsync(const UpdateComponentConfigurationRequestT& request,
                                         const UpdateComponentConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::UpdateComponentConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateLogPatternOutcome UpdateLogPattern(const Model::UpdateLogPatternRequest& request) const;
 
  template <typename UpdateLogPatternRequestT = Model::UpdateLogPatternRequest>
  Model::UpdateLogPatternOutcomeCallable UpdateLogPatternCallable(const UpdateLogPatternRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::UpdateLogPattern, request);
  }
 
  template <typename UpdateLogPatternRequestT = Model::UpdateLogPatternRequest>
  void UpdateLogPatternAsync(const UpdateLogPatternRequestT& request, const UpdateLogPatternResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::UpdateLogPattern, request, handler, context);
  }
 
  virtual Model::UpdateProblemOutcome UpdateProblem(const Model::UpdateProblemRequest& request) const;
 
  template <typename UpdateProblemRequestT = Model::UpdateProblemRequest>
  Model::UpdateProblemOutcomeCallable UpdateProblemCallable(const UpdateProblemRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::UpdateProblem, request);
  }
 
  template <typename UpdateProblemRequestT = Model::UpdateProblemRequest>
  void UpdateProblemAsync(const UpdateProblemRequestT& request, const UpdateProblemResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::UpdateProblem, request, handler, context);
  }
 
  virtual Model::UpdateWorkloadOutcome UpdateWorkload(const Model::UpdateWorkloadRequest& request) const;
 
  template <typename UpdateWorkloadRequestT = Model::UpdateWorkloadRequest>
  Model::UpdateWorkloadOutcomeCallable UpdateWorkloadCallable(const UpdateWorkloadRequestT& request) const {
    return SubmitCallable(&ApplicationInsightsClient::UpdateWorkload, request);
  }
 
  template <typename UpdateWorkloadRequestT = Model::UpdateWorkloadRequest>
  void UpdateWorkloadAsync(const UpdateWorkloadRequestT& request, const UpdateWorkloadResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationInsightsClient::UpdateWorkload, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ApplicationInsightsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ApplicationInsightsClient>;
  void init(const ApplicationInsightsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ApplicationInsightsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  ApplicationInsightsClientConfiguration m_clientConfiguration;
  std::shared_ptr<ApplicationInsightsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ApplicationInsights
}  // namespace Aws