ApplicationSignalsClient.h

 
#pragma once
#include <aws/application-signals/ApplicationSignalsPaginationBase.h>
#include <aws/application-signals/ApplicationSignalsServiceClientModel.h>
#include <aws/application-signals/ApplicationSignalsWaiter.h>
#include <aws/application-signals/ApplicationSignals_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 ApplicationSignals {
class AWS_APPLICATIONSIGNALS_API ApplicationSignalsClient : public Aws::Client::AWSJsonClient,
                                                            public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationSignalsClient>,
                                                            public ApplicationSignalsPaginationBase<ApplicationSignalsClient>,
                                                            public ApplicationSignalsWaiter<ApplicationSignalsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ApplicationSignalsClientConfiguration ClientConfigurationType;
  typedef ApplicationSignalsEndpointProvider EndpointProviderType;
 
  ApplicationSignalsClient(const Aws::ApplicationSignals::ApplicationSignalsClientConfiguration& clientConfiguration =
                               Aws::ApplicationSignals::ApplicationSignalsClientConfiguration(),
                           std::shared_ptr<ApplicationSignalsEndpointProviderBase> endpointProvider = nullptr);
 
  ApplicationSignalsClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<ApplicationSignalsEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ApplicationSignals::ApplicationSignalsClientConfiguration& clientConfiguration =
                               Aws::ApplicationSignals::ApplicationSignalsClientConfiguration());
 
  ApplicationSignalsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<ApplicationSignalsEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ApplicationSignals::ApplicationSignalsClientConfiguration& clientConfiguration =
                               Aws::ApplicationSignals::ApplicationSignalsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ApplicationSignalsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ApplicationSignalsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ApplicationSignalsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ApplicationSignalsClient();
 
  virtual Model::BatchDeleteInstrumentationConfigurationsOutcome BatchDeleteInstrumentationConfigurations(
      const Model::BatchDeleteInstrumentationConfigurationsRequest& request) const;
 
  template <typename BatchDeleteInstrumentationConfigurationsRequestT = Model::BatchDeleteInstrumentationConfigurationsRequest>
  Model::BatchDeleteInstrumentationConfigurationsOutcomeCallable BatchDeleteInstrumentationConfigurationsCallable(
      const BatchDeleteInstrumentationConfigurationsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::BatchDeleteInstrumentationConfigurations, request);
  }
 
  template <typename BatchDeleteInstrumentationConfigurationsRequestT = Model::BatchDeleteInstrumentationConfigurationsRequest>
  void BatchDeleteInstrumentationConfigurationsAsync(
      const BatchDeleteInstrumentationConfigurationsRequestT& request,
      const BatchDeleteInstrumentationConfigurationsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::BatchDeleteInstrumentationConfigurations, request, handler, context);
  }
 
  virtual Model::BatchGetServiceLevelObjectiveBudgetReportOutcome BatchGetServiceLevelObjectiveBudgetReport(
      const Model::BatchGetServiceLevelObjectiveBudgetReportRequest& request) const;
 
  template <typename BatchGetServiceLevelObjectiveBudgetReportRequestT = Model::BatchGetServiceLevelObjectiveBudgetReportRequest>
  Model::BatchGetServiceLevelObjectiveBudgetReportOutcomeCallable BatchGetServiceLevelObjectiveBudgetReportCallable(
      const BatchGetServiceLevelObjectiveBudgetReportRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::BatchGetServiceLevelObjectiveBudgetReport, request);
  }
 
  template <typename BatchGetServiceLevelObjectiveBudgetReportRequestT = Model::BatchGetServiceLevelObjectiveBudgetReportRequest>
  void BatchGetServiceLevelObjectiveBudgetReportAsync(
      const BatchGetServiceLevelObjectiveBudgetReportRequestT& request,
      const BatchGetServiceLevelObjectiveBudgetReportResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::BatchGetServiceLevelObjectiveBudgetReport, request, handler, context);
  }
 
  virtual Model::BatchUpdateExclusionWindowsOutcome BatchUpdateExclusionWindows(
      const Model::BatchUpdateExclusionWindowsRequest& request) const;
 
  template <typename BatchUpdateExclusionWindowsRequestT = Model::BatchUpdateExclusionWindowsRequest>
  Model::BatchUpdateExclusionWindowsOutcomeCallable BatchUpdateExclusionWindowsCallable(
      const BatchUpdateExclusionWindowsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::BatchUpdateExclusionWindows, request);
  }
 
  template <typename BatchUpdateExclusionWindowsRequestT = Model::BatchUpdateExclusionWindowsRequest>
  void BatchUpdateExclusionWindowsAsync(const BatchUpdateExclusionWindowsRequestT& request,
                                        const BatchUpdateExclusionWindowsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::BatchUpdateExclusionWindows, request, handler, context);
  }
 
  virtual Model::CreateInstrumentationConfigurationOutcome CreateInstrumentationConfiguration(
      const Model::CreateInstrumentationConfigurationRequest& request) const;
 
  template <typename CreateInstrumentationConfigurationRequestT = Model::CreateInstrumentationConfigurationRequest>
  Model::CreateInstrumentationConfigurationOutcomeCallable CreateInstrumentationConfigurationCallable(
      const CreateInstrumentationConfigurationRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::CreateInstrumentationConfiguration, request);
  }
 
  template <typename CreateInstrumentationConfigurationRequestT = Model::CreateInstrumentationConfigurationRequest>
  void CreateInstrumentationConfigurationAsync(const CreateInstrumentationConfigurationRequestT& request,
                                               const CreateInstrumentationConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::CreateInstrumentationConfiguration, request, handler, context);
  }
 
  virtual Model::CreateServiceLevelObjectiveOutcome CreateServiceLevelObjective(
      const Model::CreateServiceLevelObjectiveRequest& request) const;
 
  template <typename CreateServiceLevelObjectiveRequestT = Model::CreateServiceLevelObjectiveRequest>
  Model::CreateServiceLevelObjectiveOutcomeCallable CreateServiceLevelObjectiveCallable(
      const CreateServiceLevelObjectiveRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::CreateServiceLevelObjective, request);
  }
 
  template <typename CreateServiceLevelObjectiveRequestT = Model::CreateServiceLevelObjectiveRequest>
  void CreateServiceLevelObjectiveAsync(const CreateServiceLevelObjectiveRequestT& request,
                                        const CreateServiceLevelObjectiveResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::CreateServiceLevelObjective, request, handler, context);
  }
 
  virtual Model::DeleteGroupingConfigurationOutcome DeleteGroupingConfiguration(
      const Model::DeleteGroupingConfigurationRequest& request = {}) const;
 
  template <typename DeleteGroupingConfigurationRequestT = Model::DeleteGroupingConfigurationRequest>
  Model::DeleteGroupingConfigurationOutcomeCallable DeleteGroupingConfigurationCallable(
      const DeleteGroupingConfigurationRequestT& request = {}) const {
    return SubmitCallable(&ApplicationSignalsClient::DeleteGroupingConfiguration, request);
  }
 
  template <typename DeleteGroupingConfigurationRequestT = Model::DeleteGroupingConfigurationRequest>
  void DeleteGroupingConfigurationAsync(const DeleteGroupingConfigurationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const DeleteGroupingConfigurationRequestT& request = {}) const {
    return SubmitAsync(&ApplicationSignalsClient::DeleteGroupingConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteInstrumentationConfigurationOutcome DeleteInstrumentationConfiguration(
      const Model::DeleteInstrumentationConfigurationRequest& request) const;
 
  template <typename DeleteInstrumentationConfigurationRequestT = Model::DeleteInstrumentationConfigurationRequest>
  Model::DeleteInstrumentationConfigurationOutcomeCallable DeleteInstrumentationConfigurationCallable(
      const DeleteInstrumentationConfigurationRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::DeleteInstrumentationConfiguration, request);
  }
 
  template <typename DeleteInstrumentationConfigurationRequestT = Model::DeleteInstrumentationConfigurationRequest>
  void DeleteInstrumentationConfigurationAsync(const DeleteInstrumentationConfigurationRequestT& request,
                                               const DeleteInstrumentationConfigurationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::DeleteInstrumentationConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteServiceLevelObjectiveOutcome DeleteServiceLevelObjective(
      const Model::DeleteServiceLevelObjectiveRequest& request) const;
 
  template <typename DeleteServiceLevelObjectiveRequestT = Model::DeleteServiceLevelObjectiveRequest>
  Model::DeleteServiceLevelObjectiveOutcomeCallable DeleteServiceLevelObjectiveCallable(
      const DeleteServiceLevelObjectiveRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::DeleteServiceLevelObjective, request);
  }
 
  template <typename DeleteServiceLevelObjectiveRequestT = Model::DeleteServiceLevelObjectiveRequest>
  void DeleteServiceLevelObjectiveAsync(const DeleteServiceLevelObjectiveRequestT& request,
                                        const DeleteServiceLevelObjectiveResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::DeleteServiceLevelObjective, request, handler, context);
  }
 
  virtual Model::GetInstrumentationConfigurationOutcome GetInstrumentationConfiguration(
      const Model::GetInstrumentationConfigurationRequest& request) const;
 
  template <typename GetInstrumentationConfigurationRequestT = Model::GetInstrumentationConfigurationRequest>
  Model::GetInstrumentationConfigurationOutcomeCallable GetInstrumentationConfigurationCallable(
      const GetInstrumentationConfigurationRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::GetInstrumentationConfiguration, request);
  }
 
  template <typename GetInstrumentationConfigurationRequestT = Model::GetInstrumentationConfigurationRequest>
  void GetInstrumentationConfigurationAsync(const GetInstrumentationConfigurationRequestT& request,
                                            const GetInstrumentationConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::GetInstrumentationConfiguration, request, handler, context);
  }
 
  virtual Model::GetInstrumentationConfigurationStatusOutcome GetInstrumentationConfigurationStatus(
      const Model::GetInstrumentationConfigurationStatusRequest& request) const;
 
  template <typename GetInstrumentationConfigurationStatusRequestT = Model::GetInstrumentationConfigurationStatusRequest>
  Model::GetInstrumentationConfigurationStatusOutcomeCallable GetInstrumentationConfigurationStatusCallable(
      const GetInstrumentationConfigurationStatusRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::GetInstrumentationConfigurationStatus, request);
  }
 
  template <typename GetInstrumentationConfigurationStatusRequestT = Model::GetInstrumentationConfigurationStatusRequest>
  void GetInstrumentationConfigurationStatusAsync(const GetInstrumentationConfigurationStatusRequestT& request,
                                                  const GetInstrumentationConfigurationStatusResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::GetInstrumentationConfigurationStatus, request, handler, context);
  }
 
  virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const;
 
  template <typename GetServiceRequestT = Model::GetServiceRequest>
  Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::GetService, request);
  }
 
  template <typename GetServiceRequestT = Model::GetServiceRequest>
  void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::GetService, request, handler, context);
  }
 
  virtual Model::GetServiceLevelObjectiveOutcome GetServiceLevelObjective(const Model::GetServiceLevelObjectiveRequest& request) const;
 
  template <typename GetServiceLevelObjectiveRequestT = Model::GetServiceLevelObjectiveRequest>
  Model::GetServiceLevelObjectiveOutcomeCallable GetServiceLevelObjectiveCallable(const GetServiceLevelObjectiveRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::GetServiceLevelObjective, request);
  }
 
  template <typename GetServiceLevelObjectiveRequestT = Model::GetServiceLevelObjectiveRequest>
  void GetServiceLevelObjectiveAsync(const GetServiceLevelObjectiveRequestT& request,
                                     const GetServiceLevelObjectiveResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::GetServiceLevelObjective, request, handler, context);
  }
 
  virtual Model::ListAuditFindingsOutcome ListAuditFindings(const Model::ListAuditFindingsRequest& request) const;
 
  template <typename ListAuditFindingsRequestT = Model::ListAuditFindingsRequest>
  Model::ListAuditFindingsOutcomeCallable ListAuditFindingsCallable(const ListAuditFindingsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListAuditFindings, request);
  }
 
  template <typename ListAuditFindingsRequestT = Model::ListAuditFindingsRequest>
  void ListAuditFindingsAsync(const ListAuditFindingsRequestT& request, const ListAuditFindingsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListAuditFindings, request, handler, context);
  }
 
  virtual Model::ListEntityEventsOutcome ListEntityEvents(const Model::ListEntityEventsRequest& request) const;
 
  template <typename ListEntityEventsRequestT = Model::ListEntityEventsRequest>
  Model::ListEntityEventsOutcomeCallable ListEntityEventsCallable(const ListEntityEventsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListEntityEvents, request);
  }
 
  template <typename ListEntityEventsRequestT = Model::ListEntityEventsRequest>
  void ListEntityEventsAsync(const ListEntityEventsRequestT& request, const ListEntityEventsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListEntityEvents, request, handler, context);
  }
 
  virtual Model::ListGroupingAttributeDefinitionsOutcome ListGroupingAttributeDefinitions(
      const Model::ListGroupingAttributeDefinitionsRequest& request = {}) const;
 
  template <typename ListGroupingAttributeDefinitionsRequestT = Model::ListGroupingAttributeDefinitionsRequest>
  Model::ListGroupingAttributeDefinitionsOutcomeCallable ListGroupingAttributeDefinitionsCallable(
      const ListGroupingAttributeDefinitionsRequestT& request = {}) const {
    return SubmitCallable(&ApplicationSignalsClient::ListGroupingAttributeDefinitions, request);
  }
 
  template <typename ListGroupingAttributeDefinitionsRequestT = Model::ListGroupingAttributeDefinitionsRequest>
  void ListGroupingAttributeDefinitionsAsync(const ListGroupingAttributeDefinitionsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const ListGroupingAttributeDefinitionsRequestT& request = {}) const {
    return SubmitAsync(&ApplicationSignalsClient::ListGroupingAttributeDefinitions, request, handler, context);
  }
 
  virtual Model::ListInstrumentationConfigurationsOutcome ListInstrumentationConfigurations(
      const Model::ListInstrumentationConfigurationsRequest& request) const;
 
  template <typename ListInstrumentationConfigurationsRequestT = Model::ListInstrumentationConfigurationsRequest>
  Model::ListInstrumentationConfigurationsOutcomeCallable ListInstrumentationConfigurationsCallable(
      const ListInstrumentationConfigurationsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListInstrumentationConfigurations, request);
  }
 
  template <typename ListInstrumentationConfigurationsRequestT = Model::ListInstrumentationConfigurationsRequest>
  void ListInstrumentationConfigurationsAsync(const ListInstrumentationConfigurationsRequestT& request,
                                              const ListInstrumentationConfigurationsResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListInstrumentationConfigurations, request, handler, context);
  }
 
  virtual Model::ListServiceDependenciesOutcome ListServiceDependencies(const Model::ListServiceDependenciesRequest& request) const;
 
  template <typename ListServiceDependenciesRequestT = Model::ListServiceDependenciesRequest>
  Model::ListServiceDependenciesOutcomeCallable ListServiceDependenciesCallable(const ListServiceDependenciesRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListServiceDependencies, request);
  }
 
  template <typename ListServiceDependenciesRequestT = Model::ListServiceDependenciesRequest>
  void ListServiceDependenciesAsync(const ListServiceDependenciesRequestT& request,
                                    const ListServiceDependenciesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListServiceDependencies, request, handler, context);
  }
 
  virtual Model::ListServiceDependentsOutcome ListServiceDependents(const Model::ListServiceDependentsRequest& request) const;
 
  template <typename ListServiceDependentsRequestT = Model::ListServiceDependentsRequest>
  Model::ListServiceDependentsOutcomeCallable ListServiceDependentsCallable(const ListServiceDependentsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListServiceDependents, request);
  }
 
  template <typename ListServiceDependentsRequestT = Model::ListServiceDependentsRequest>
  void ListServiceDependentsAsync(const ListServiceDependentsRequestT& request, const ListServiceDependentsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListServiceDependents, request, handler, context);
  }
 
  virtual Model::ListServiceLevelObjectiveExclusionWindowsOutcome ListServiceLevelObjectiveExclusionWindows(
      const Model::ListServiceLevelObjectiveExclusionWindowsRequest& request) const;
 
  template <typename ListServiceLevelObjectiveExclusionWindowsRequestT = Model::ListServiceLevelObjectiveExclusionWindowsRequest>
  Model::ListServiceLevelObjectiveExclusionWindowsOutcomeCallable ListServiceLevelObjectiveExclusionWindowsCallable(
      const ListServiceLevelObjectiveExclusionWindowsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListServiceLevelObjectiveExclusionWindows, request);
  }
 
  template <typename ListServiceLevelObjectiveExclusionWindowsRequestT = Model::ListServiceLevelObjectiveExclusionWindowsRequest>
  void ListServiceLevelObjectiveExclusionWindowsAsync(
      const ListServiceLevelObjectiveExclusionWindowsRequestT& request,
      const ListServiceLevelObjectiveExclusionWindowsResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListServiceLevelObjectiveExclusionWindows, request, handler, context);
  }
 
  virtual Model::ListServiceLevelObjectivesOutcome ListServiceLevelObjectives(
      const Model::ListServiceLevelObjectivesRequest& request = {}) const;
 
  template <typename ListServiceLevelObjectivesRequestT = Model::ListServiceLevelObjectivesRequest>
  Model::ListServiceLevelObjectivesOutcomeCallable ListServiceLevelObjectivesCallable(
      const ListServiceLevelObjectivesRequestT& request = {}) const {
    return SubmitCallable(&ApplicationSignalsClient::ListServiceLevelObjectives, request);
  }
 
  template <typename ListServiceLevelObjectivesRequestT = Model::ListServiceLevelObjectivesRequest>
  void ListServiceLevelObjectivesAsync(const ListServiceLevelObjectivesResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListServiceLevelObjectivesRequestT& request = {}) const {
    return SubmitAsync(&ApplicationSignalsClient::ListServiceLevelObjectives, request, handler, context);
  }
 
  virtual Model::ListServiceOperationsOutcome ListServiceOperations(const Model::ListServiceOperationsRequest& request) const;
 
  template <typename ListServiceOperationsRequestT = Model::ListServiceOperationsRequest>
  Model::ListServiceOperationsOutcomeCallable ListServiceOperationsCallable(const ListServiceOperationsRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListServiceOperations, request);
  }
 
  template <typename ListServiceOperationsRequestT = Model::ListServiceOperationsRequest>
  void ListServiceOperationsAsync(const ListServiceOperationsRequestT& request, const ListServiceOperationsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListServiceOperations, request, handler, context);
  }
 
  virtual Model::ListServiceStatesOutcome ListServiceStates(const Model::ListServiceStatesRequest& request) const;
 
  template <typename ListServiceStatesRequestT = Model::ListServiceStatesRequest>
  Model::ListServiceStatesOutcomeCallable ListServiceStatesCallable(const ListServiceStatesRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListServiceStates, request);
  }
 
  template <typename ListServiceStatesRequestT = Model::ListServiceStatesRequest>
  void ListServiceStatesAsync(const ListServiceStatesRequestT& request, const ListServiceStatesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListServiceStates, request, handler, context);
  }
 
  virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request) const;
 
  template <typename ListServicesRequestT = Model::ListServicesRequest>
  Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ListServices, request);
  }
 
  template <typename ListServicesRequestT = Model::ListServicesRequest>
  void ListServicesAsync(const ListServicesRequestT& request, const ListServicesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ListServices, 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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PutGroupingConfigurationOutcome PutGroupingConfiguration(const Model::PutGroupingConfigurationRequest& request) const;
 
  template <typename PutGroupingConfigurationRequestT = Model::PutGroupingConfigurationRequest>
  Model::PutGroupingConfigurationOutcomeCallable PutGroupingConfigurationCallable(const PutGroupingConfigurationRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::PutGroupingConfiguration, request);
  }
 
  template <typename PutGroupingConfigurationRequestT = Model::PutGroupingConfigurationRequest>
  void PutGroupingConfigurationAsync(const PutGroupingConfigurationRequestT& request,
                                     const PutGroupingConfigurationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::PutGroupingConfiguration, request, handler, context);
  }
 
  virtual Model::ReportInstrumentationConfigurationStatusOutcome ReportInstrumentationConfigurationStatus(
      const Model::ReportInstrumentationConfigurationStatusRequest& request) const;
 
  template <typename ReportInstrumentationConfigurationStatusRequestT = Model::ReportInstrumentationConfigurationStatusRequest>
  Model::ReportInstrumentationConfigurationStatusOutcomeCallable ReportInstrumentationConfigurationStatusCallable(
      const ReportInstrumentationConfigurationStatusRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::ReportInstrumentationConfigurationStatus, request);
  }
 
  template <typename ReportInstrumentationConfigurationStatusRequestT = Model::ReportInstrumentationConfigurationStatusRequest>
  void ReportInstrumentationConfigurationStatusAsync(
      const ReportInstrumentationConfigurationStatusRequestT& request,
      const ReportInstrumentationConfigurationStatusResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::ReportInstrumentationConfigurationStatus, request, handler, context);
  }
 
  virtual Model::StartDiscoveryOutcome StartDiscovery(const Model::StartDiscoveryRequest& request = {}) const;
 
  template <typename StartDiscoveryRequestT = Model::StartDiscoveryRequest>
  Model::StartDiscoveryOutcomeCallable StartDiscoveryCallable(const StartDiscoveryRequestT& request = {}) const {
    return SubmitCallable(&ApplicationSignalsClient::StartDiscovery, request);
  }
 
  template <typename StartDiscoveryRequestT = Model::StartDiscoveryRequest>
  void StartDiscoveryAsync(const StartDiscoveryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const StartDiscoveryRequestT& request = {}) const {
    return SubmitAsync(&ApplicationSignalsClient::StartDiscovery, 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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::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(&ApplicationSignalsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateServiceLevelObjectiveOutcome UpdateServiceLevelObjective(
      const Model::UpdateServiceLevelObjectiveRequest& request) const;
 
  template <typename UpdateServiceLevelObjectiveRequestT = Model::UpdateServiceLevelObjectiveRequest>
  Model::UpdateServiceLevelObjectiveOutcomeCallable UpdateServiceLevelObjectiveCallable(
      const UpdateServiceLevelObjectiveRequestT& request) const {
    return SubmitCallable(&ApplicationSignalsClient::UpdateServiceLevelObjective, request);
  }
 
  template <typename UpdateServiceLevelObjectiveRequestT = Model::UpdateServiceLevelObjectiveRequest>
  void UpdateServiceLevelObjectiveAsync(const UpdateServiceLevelObjectiveRequestT& request,
                                        const UpdateServiceLevelObjectiveResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ApplicationSignalsClient::UpdateServiceLevelObjective, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ApplicationSignalsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ApplicationSignalsClient>;
  void init(const ApplicationSignalsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ApplicationSignalsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ApplicationSignalsClientConfiguration m_clientConfiguration;
  std::shared_ptr<ApplicationSignalsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ApplicationSignals
}  // namespace Aws