PrometheusServiceClient.h

 
#pragma once
#include <aws/amp/PrometheusServicePaginationBase.h>
#include <aws/amp/PrometheusServiceServiceClientModel.h>
#include <aws/amp/PrometheusServiceWaiter.h>
#include <aws/amp/PrometheusService_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 PrometheusService {
class AWS_PROMETHEUSSERVICE_API PrometheusServiceClient : public Aws::Client::AWSJsonClient,
                                                          public Aws::Client::ClientWithAsyncTemplateMethods<PrometheusServiceClient>,
                                                          public PrometheusServicePaginationBase<PrometheusServiceClient>,
                                                          public PrometheusServiceWaiter<PrometheusServiceClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef PrometheusServiceClientConfiguration ClientConfigurationType;
  typedef PrometheusServiceEndpointProvider EndpointProviderType;
 
  PrometheusServiceClient(const Aws::PrometheusService::PrometheusServiceClientConfiguration& clientConfiguration =
                              Aws::PrometheusService::PrometheusServiceClientConfiguration(),
                          std::shared_ptr<PrometheusServiceEndpointProviderBase> endpointProvider = nullptr);
 
  PrometheusServiceClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<PrometheusServiceEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::PrometheusService::PrometheusServiceClientConfiguration& clientConfiguration =
                              Aws::PrometheusService::PrometheusServiceClientConfiguration());
 
  PrometheusServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<PrometheusServiceEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::PrometheusService::PrometheusServiceClientConfiguration& clientConfiguration =
                              Aws::PrometheusService::PrometheusServiceClientConfiguration());
 
  /* Legacy constructors due deprecation */
  PrometheusServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PrometheusServiceClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  PrometheusServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~PrometheusServiceClient();
 
  virtual Model::CreateAlertManagerDefinitionOutcome CreateAlertManagerDefinition(
      const Model::CreateAlertManagerDefinitionRequest& request) const;
 
  template <typename CreateAlertManagerDefinitionRequestT = Model::CreateAlertManagerDefinitionRequest>
  Model::CreateAlertManagerDefinitionOutcomeCallable CreateAlertManagerDefinitionCallable(
      const CreateAlertManagerDefinitionRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::CreateAlertManagerDefinition, request);
  }
 
  template <typename CreateAlertManagerDefinitionRequestT = Model::CreateAlertManagerDefinitionRequest>
  void CreateAlertManagerDefinitionAsync(const CreateAlertManagerDefinitionRequestT& request,
                                         const CreateAlertManagerDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::CreateAlertManagerDefinition, request, handler, context);
  }
 
  virtual Model::CreateAnomalyDetectorOutcome CreateAnomalyDetector(const Model::CreateAnomalyDetectorRequest& request) const;
 
  template <typename CreateAnomalyDetectorRequestT = Model::CreateAnomalyDetectorRequest>
  Model::CreateAnomalyDetectorOutcomeCallable CreateAnomalyDetectorCallable(const CreateAnomalyDetectorRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::CreateAnomalyDetector, request);
  }
 
  template <typename CreateAnomalyDetectorRequestT = Model::CreateAnomalyDetectorRequest>
  void CreateAnomalyDetectorAsync(const CreateAnomalyDetectorRequestT& request, const CreateAnomalyDetectorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::CreateAnomalyDetector, request, handler, context);
  }
 
  virtual Model::CreateLoggingConfigurationOutcome CreateLoggingConfiguration(
      const Model::CreateLoggingConfigurationRequest& request) const;
 
  template <typename CreateLoggingConfigurationRequestT = Model::CreateLoggingConfigurationRequest>
  Model::CreateLoggingConfigurationOutcomeCallable CreateLoggingConfigurationCallable(
      const CreateLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::CreateLoggingConfiguration, request);
  }
 
  template <typename CreateLoggingConfigurationRequestT = Model::CreateLoggingConfigurationRequest>
  void CreateLoggingConfigurationAsync(const CreateLoggingConfigurationRequestT& request,
                                       const CreateLoggingConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::CreateLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::CreateQueryLoggingConfigurationOutcome CreateQueryLoggingConfiguration(
      const Model::CreateQueryLoggingConfigurationRequest& request) const;
 
  template <typename CreateQueryLoggingConfigurationRequestT = Model::CreateQueryLoggingConfigurationRequest>
  Model::CreateQueryLoggingConfigurationOutcomeCallable CreateQueryLoggingConfigurationCallable(
      const CreateQueryLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::CreateQueryLoggingConfiguration, request);
  }
 
  template <typename CreateQueryLoggingConfigurationRequestT = Model::CreateQueryLoggingConfigurationRequest>
  void CreateQueryLoggingConfigurationAsync(const CreateQueryLoggingConfigurationRequestT& request,
                                            const CreateQueryLoggingConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::CreateQueryLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::CreateRuleGroupsNamespaceOutcome CreateRuleGroupsNamespace(const Model::CreateRuleGroupsNamespaceRequest& request) const;
 
  template <typename CreateRuleGroupsNamespaceRequestT = Model::CreateRuleGroupsNamespaceRequest>
  Model::CreateRuleGroupsNamespaceOutcomeCallable CreateRuleGroupsNamespaceCallable(
      const CreateRuleGroupsNamespaceRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::CreateRuleGroupsNamespace, request);
  }
 
  template <typename CreateRuleGroupsNamespaceRequestT = Model::CreateRuleGroupsNamespaceRequest>
  void CreateRuleGroupsNamespaceAsync(const CreateRuleGroupsNamespaceRequestT& request,
                                      const CreateRuleGroupsNamespaceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::CreateRuleGroupsNamespace, request, handler, context);
  }
 
  virtual Model::CreateScraperOutcome CreateScraper(const Model::CreateScraperRequest& request) const;
 
  template <typename CreateScraperRequestT = Model::CreateScraperRequest>
  Model::CreateScraperOutcomeCallable CreateScraperCallable(const CreateScraperRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::CreateScraper, request);
  }
 
  template <typename CreateScraperRequestT = Model::CreateScraperRequest>
  void CreateScraperAsync(const CreateScraperRequestT& request, const CreateScraperResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::CreateScraper, request, handler, context);
  }
 
  virtual Model::CreateWorkspaceOutcome CreateWorkspace(const Model::CreateWorkspaceRequest& request = {}) const;
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  Model::CreateWorkspaceOutcomeCallable CreateWorkspaceCallable(const CreateWorkspaceRequestT& request = {}) const {
    return SubmitCallable(&PrometheusServiceClient::CreateWorkspace, request);
  }
 
  template <typename CreateWorkspaceRequestT = Model::CreateWorkspaceRequest>
  void CreateWorkspaceAsync(const CreateWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const CreateWorkspaceRequestT& request = {}) const {
    return SubmitAsync(&PrometheusServiceClient::CreateWorkspace, request, handler, context);
  }
 
  virtual Model::DeleteAlertManagerDefinitionOutcome DeleteAlertManagerDefinition(
      const Model::DeleteAlertManagerDefinitionRequest& request) const;
 
  template <typename DeleteAlertManagerDefinitionRequestT = Model::DeleteAlertManagerDefinitionRequest>
  Model::DeleteAlertManagerDefinitionOutcomeCallable DeleteAlertManagerDefinitionCallable(
      const DeleteAlertManagerDefinitionRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteAlertManagerDefinition, request);
  }
 
  template <typename DeleteAlertManagerDefinitionRequestT = Model::DeleteAlertManagerDefinitionRequest>
  void DeleteAlertManagerDefinitionAsync(const DeleteAlertManagerDefinitionRequestT& request,
                                         const DeleteAlertManagerDefinitionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteAlertManagerDefinition, request, handler, context);
  }
 
  virtual Model::DeleteAnomalyDetectorOutcome DeleteAnomalyDetector(const Model::DeleteAnomalyDetectorRequest& request) const;
 
  template <typename DeleteAnomalyDetectorRequestT = Model::DeleteAnomalyDetectorRequest>
  Model::DeleteAnomalyDetectorOutcomeCallable DeleteAnomalyDetectorCallable(const DeleteAnomalyDetectorRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteAnomalyDetector, request);
  }
 
  template <typename DeleteAnomalyDetectorRequestT = Model::DeleteAnomalyDetectorRequest>
  void DeleteAnomalyDetectorAsync(const DeleteAnomalyDetectorRequestT& request, const DeleteAnomalyDetectorResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteAnomalyDetector, request, handler, context);
  }
 
  virtual Model::DeleteLoggingConfigurationOutcome DeleteLoggingConfiguration(
      const Model::DeleteLoggingConfigurationRequest& request) const;
 
  template <typename DeleteLoggingConfigurationRequestT = Model::DeleteLoggingConfigurationRequest>
  Model::DeleteLoggingConfigurationOutcomeCallable DeleteLoggingConfigurationCallable(
      const DeleteLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteLoggingConfiguration, request);
  }
 
  template <typename DeleteLoggingConfigurationRequestT = Model::DeleteLoggingConfigurationRequest>
  void DeleteLoggingConfigurationAsync(const DeleteLoggingConfigurationRequestT& request,
                                       const DeleteLoggingConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteQueryLoggingConfigurationOutcome DeleteQueryLoggingConfiguration(
      const Model::DeleteQueryLoggingConfigurationRequest& request) const;
 
  template <typename DeleteQueryLoggingConfigurationRequestT = Model::DeleteQueryLoggingConfigurationRequest>
  Model::DeleteQueryLoggingConfigurationOutcomeCallable DeleteQueryLoggingConfigurationCallable(
      const DeleteQueryLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteQueryLoggingConfiguration, request);
  }
 
  template <typename DeleteQueryLoggingConfigurationRequestT = Model::DeleteQueryLoggingConfigurationRequest>
  void DeleteQueryLoggingConfigurationAsync(const DeleteQueryLoggingConfigurationRequestT& request,
                                            const DeleteQueryLoggingConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteQueryLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteRuleGroupsNamespaceOutcome DeleteRuleGroupsNamespace(const Model::DeleteRuleGroupsNamespaceRequest& request) const;
 
  template <typename DeleteRuleGroupsNamespaceRequestT = Model::DeleteRuleGroupsNamespaceRequest>
  Model::DeleteRuleGroupsNamespaceOutcomeCallable DeleteRuleGroupsNamespaceCallable(
      const DeleteRuleGroupsNamespaceRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteRuleGroupsNamespace, request);
  }
 
  template <typename DeleteRuleGroupsNamespaceRequestT = Model::DeleteRuleGroupsNamespaceRequest>
  void DeleteRuleGroupsNamespaceAsync(const DeleteRuleGroupsNamespaceRequestT& request,
                                      const DeleteRuleGroupsNamespaceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteRuleGroupsNamespace, request, handler, context);
  }
 
  virtual Model::DeleteScraperOutcome DeleteScraper(const Model::DeleteScraperRequest& request) const;
 
  template <typename DeleteScraperRequestT = Model::DeleteScraperRequest>
  Model::DeleteScraperOutcomeCallable DeleteScraperCallable(const DeleteScraperRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteScraper, request);
  }
 
  template <typename DeleteScraperRequestT = Model::DeleteScraperRequest>
  void DeleteScraperAsync(const DeleteScraperRequestT& request, const DeleteScraperResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteScraper, request, handler, context);
  }
 
  virtual Model::DeleteScraperLoggingConfigurationOutcome DeleteScraperLoggingConfiguration(
      const Model::DeleteScraperLoggingConfigurationRequest& request) const;
 
  template <typename DeleteScraperLoggingConfigurationRequestT = Model::DeleteScraperLoggingConfigurationRequest>
  Model::DeleteScraperLoggingConfigurationOutcomeCallable DeleteScraperLoggingConfigurationCallable(
      const DeleteScraperLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteScraperLoggingConfiguration, request);
  }
 
  template <typename DeleteScraperLoggingConfigurationRequestT = Model::DeleteScraperLoggingConfigurationRequest>
  void DeleteScraperLoggingConfigurationAsync(const DeleteScraperLoggingConfigurationRequestT& request,
                                              const DeleteScraperLoggingConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteScraperLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteWorkspaceOutcome DeleteWorkspace(const Model::DeleteWorkspaceRequest& request) const;
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  Model::DeleteWorkspaceOutcomeCallable DeleteWorkspaceCallable(const DeleteWorkspaceRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DeleteWorkspace, request);
  }
 
  template <typename DeleteWorkspaceRequestT = Model::DeleteWorkspaceRequest>
  void DeleteWorkspaceAsync(const DeleteWorkspaceRequestT& request, const DeleteWorkspaceResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DeleteWorkspace, request, handler, context);
  }
 
  virtual Model::DescribeAlertManagerDefinitionOutcome DescribeAlertManagerDefinition(
      const Model::DescribeAlertManagerDefinitionRequest& request) const;
 
  template <typename DescribeAlertManagerDefinitionRequestT = Model::DescribeAlertManagerDefinitionRequest>
  Model::DescribeAlertManagerDefinitionOutcomeCallable DescribeAlertManagerDefinitionCallable(
      const DescribeAlertManagerDefinitionRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeAlertManagerDefinition, request);
  }
 
  template <typename DescribeAlertManagerDefinitionRequestT = Model::DescribeAlertManagerDefinitionRequest>
  void DescribeAlertManagerDefinitionAsync(const DescribeAlertManagerDefinitionRequestT& request,
                                           const DescribeAlertManagerDefinitionResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeAlertManagerDefinition, request, handler, context);
  }
 
  virtual Model::DescribeAnomalyDetectorOutcome DescribeAnomalyDetector(const Model::DescribeAnomalyDetectorRequest& request) const;
 
  template <typename DescribeAnomalyDetectorRequestT = Model::DescribeAnomalyDetectorRequest>
  Model::DescribeAnomalyDetectorOutcomeCallable DescribeAnomalyDetectorCallable(const DescribeAnomalyDetectorRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeAnomalyDetector, request);
  }
 
  template <typename DescribeAnomalyDetectorRequestT = Model::DescribeAnomalyDetectorRequest>
  void DescribeAnomalyDetectorAsync(const DescribeAnomalyDetectorRequestT& request,
                                    const DescribeAnomalyDetectorResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeAnomalyDetector, request, handler, context);
  }
 
  virtual Model::DescribeLoggingConfigurationOutcome DescribeLoggingConfiguration(
      const Model::DescribeLoggingConfigurationRequest& request) const;
 
  template <typename DescribeLoggingConfigurationRequestT = Model::DescribeLoggingConfigurationRequest>
  Model::DescribeLoggingConfigurationOutcomeCallable DescribeLoggingConfigurationCallable(
      const DescribeLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeLoggingConfiguration, request);
  }
 
  template <typename DescribeLoggingConfigurationRequestT = Model::DescribeLoggingConfigurationRequest>
  void DescribeLoggingConfigurationAsync(const DescribeLoggingConfigurationRequestT& request,
                                         const DescribeLoggingConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeQueryLoggingConfigurationOutcome DescribeQueryLoggingConfiguration(
      const Model::DescribeQueryLoggingConfigurationRequest& request) const;
 
  template <typename DescribeQueryLoggingConfigurationRequestT = Model::DescribeQueryLoggingConfigurationRequest>
  Model::DescribeQueryLoggingConfigurationOutcomeCallable DescribeQueryLoggingConfigurationCallable(
      const DescribeQueryLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeQueryLoggingConfiguration, request);
  }
 
  template <typename DescribeQueryLoggingConfigurationRequestT = Model::DescribeQueryLoggingConfigurationRequest>
  void DescribeQueryLoggingConfigurationAsync(const DescribeQueryLoggingConfigurationRequestT& request,
                                              const DescribeQueryLoggingConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeQueryLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeResourcePolicyOutcome DescribeResourcePolicy(const Model::DescribeResourcePolicyRequest& request) const;
 
  template <typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
  Model::DescribeResourcePolicyOutcomeCallable DescribeResourcePolicyCallable(const DescribeResourcePolicyRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeResourcePolicy, request);
  }
 
  template <typename DescribeResourcePolicyRequestT = Model::DescribeResourcePolicyRequest>
  void DescribeResourcePolicyAsync(const DescribeResourcePolicyRequestT& request,
                                   const DescribeResourcePolicyResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeResourcePolicy, request, handler, context);
  }
 
  virtual Model::DescribeRuleGroupsNamespaceOutcome DescribeRuleGroupsNamespace(
      const Model::DescribeRuleGroupsNamespaceRequest& request) const;
 
  template <typename DescribeRuleGroupsNamespaceRequestT = Model::DescribeRuleGroupsNamespaceRequest>
  Model::DescribeRuleGroupsNamespaceOutcomeCallable DescribeRuleGroupsNamespaceCallable(
      const DescribeRuleGroupsNamespaceRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeRuleGroupsNamespace, request);
  }
 
  template <typename DescribeRuleGroupsNamespaceRequestT = Model::DescribeRuleGroupsNamespaceRequest>
  void DescribeRuleGroupsNamespaceAsync(const DescribeRuleGroupsNamespaceRequestT& request,
                                        const DescribeRuleGroupsNamespaceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeRuleGroupsNamespace, request, handler, context);
  }
 
  virtual Model::DescribeScraperOutcome DescribeScraper(const Model::DescribeScraperRequest& request) const;
 
  template <typename DescribeScraperRequestT = Model::DescribeScraperRequest>
  Model::DescribeScraperOutcomeCallable DescribeScraperCallable(const DescribeScraperRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeScraper, request);
  }
 
  template <typename DescribeScraperRequestT = Model::DescribeScraperRequest>
  void DescribeScraperAsync(const DescribeScraperRequestT& request, const DescribeScraperResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeScraper, request, handler, context);
  }
 
  virtual Model::DescribeScraperLoggingConfigurationOutcome DescribeScraperLoggingConfiguration(
      const Model::DescribeScraperLoggingConfigurationRequest& request) const;
 
  template <typename DescribeScraperLoggingConfigurationRequestT = Model::DescribeScraperLoggingConfigurationRequest>
  Model::DescribeScraperLoggingConfigurationOutcomeCallable DescribeScraperLoggingConfigurationCallable(
      const DescribeScraperLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeScraperLoggingConfiguration, request);
  }
 
  template <typename DescribeScraperLoggingConfigurationRequestT = Model::DescribeScraperLoggingConfigurationRequest>
  void DescribeScraperLoggingConfigurationAsync(const DescribeScraperLoggingConfigurationRequestT& request,
                                                const DescribeScraperLoggingConfigurationResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeScraperLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::DescribeWorkspaceOutcome DescribeWorkspace(const Model::DescribeWorkspaceRequest& request) const;
 
  template <typename DescribeWorkspaceRequestT = Model::DescribeWorkspaceRequest>
  Model::DescribeWorkspaceOutcomeCallable DescribeWorkspaceCallable(const DescribeWorkspaceRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeWorkspace, request);
  }
 
  template <typename DescribeWorkspaceRequestT = Model::DescribeWorkspaceRequest>
  void DescribeWorkspaceAsync(const DescribeWorkspaceRequestT& request, const DescribeWorkspaceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeWorkspace, request, handler, context);
  }
 
  virtual Model::DescribeWorkspaceConfigurationOutcome DescribeWorkspaceConfiguration(
      const Model::DescribeWorkspaceConfigurationRequest& request) const;
 
  template <typename DescribeWorkspaceConfigurationRequestT = Model::DescribeWorkspaceConfigurationRequest>
  Model::DescribeWorkspaceConfigurationOutcomeCallable DescribeWorkspaceConfigurationCallable(
      const DescribeWorkspaceConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::DescribeWorkspaceConfiguration, request);
  }
 
  template <typename DescribeWorkspaceConfigurationRequestT = Model::DescribeWorkspaceConfigurationRequest>
  void DescribeWorkspaceConfigurationAsync(const DescribeWorkspaceConfigurationRequestT& request,
                                           const DescribeWorkspaceConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::DescribeWorkspaceConfiguration, request, handler, context);
  }
 
  virtual Model::GetDefaultScraperConfigurationOutcome GetDefaultScraperConfiguration(
      const Model::GetDefaultScraperConfigurationRequest& request = {}) const;
 
  template <typename GetDefaultScraperConfigurationRequestT = Model::GetDefaultScraperConfigurationRequest>
  Model::GetDefaultScraperConfigurationOutcomeCallable GetDefaultScraperConfigurationCallable(
      const GetDefaultScraperConfigurationRequestT& request = {}) const {
    return SubmitCallable(&PrometheusServiceClient::GetDefaultScraperConfiguration, request);
  }
 
  template <typename GetDefaultScraperConfigurationRequestT = Model::GetDefaultScraperConfigurationRequest>
  void GetDefaultScraperConfigurationAsync(const GetDefaultScraperConfigurationResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                           const GetDefaultScraperConfigurationRequestT& request = {}) const {
    return SubmitAsync(&PrometheusServiceClient::GetDefaultScraperConfiguration, request, handler, context);
  }
 
  virtual Model::ListAnomalyDetectorsOutcome ListAnomalyDetectors(const Model::ListAnomalyDetectorsRequest& request) const;
 
  template <typename ListAnomalyDetectorsRequestT = Model::ListAnomalyDetectorsRequest>
  Model::ListAnomalyDetectorsOutcomeCallable ListAnomalyDetectorsCallable(const ListAnomalyDetectorsRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::ListAnomalyDetectors, request);
  }
 
  template <typename ListAnomalyDetectorsRequestT = Model::ListAnomalyDetectorsRequest>
  void ListAnomalyDetectorsAsync(const ListAnomalyDetectorsRequestT& request, const ListAnomalyDetectorsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::ListAnomalyDetectors, request, handler, context);
  }
 
  virtual Model::ListRuleGroupsNamespacesOutcome ListRuleGroupsNamespaces(const Model::ListRuleGroupsNamespacesRequest& request) const;
 
  template <typename ListRuleGroupsNamespacesRequestT = Model::ListRuleGroupsNamespacesRequest>
  Model::ListRuleGroupsNamespacesOutcomeCallable ListRuleGroupsNamespacesCallable(const ListRuleGroupsNamespacesRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::ListRuleGroupsNamespaces, request);
  }
 
  template <typename ListRuleGroupsNamespacesRequestT = Model::ListRuleGroupsNamespacesRequest>
  void ListRuleGroupsNamespacesAsync(const ListRuleGroupsNamespacesRequestT& request,
                                     const ListRuleGroupsNamespacesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::ListRuleGroupsNamespaces, request, handler, context);
  }
 
  virtual Model::ListScrapersOutcome ListScrapers(const Model::ListScrapersRequest& request = {}) const;
 
  template <typename ListScrapersRequestT = Model::ListScrapersRequest>
  Model::ListScrapersOutcomeCallable ListScrapersCallable(const ListScrapersRequestT& request = {}) const {
    return SubmitCallable(&PrometheusServiceClient::ListScrapers, request);
  }
 
  template <typename ListScrapersRequestT = Model::ListScrapersRequest>
  void ListScrapersAsync(const ListScrapersResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListScrapersRequestT& request = {}) const {
    return SubmitAsync(&PrometheusServiceClient::ListScrapers, 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(&PrometheusServiceClient::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(&PrometheusServiceClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListWorkspacesOutcome ListWorkspaces(const Model::ListWorkspacesRequest& request = {}) const;
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  Model::ListWorkspacesOutcomeCallable ListWorkspacesCallable(const ListWorkspacesRequestT& request = {}) const {
    return SubmitCallable(&PrometheusServiceClient::ListWorkspaces, request);
  }
 
  template <typename ListWorkspacesRequestT = Model::ListWorkspacesRequest>
  void ListWorkspacesAsync(const ListWorkspacesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const ListWorkspacesRequestT& request = {}) const {
    return SubmitAsync(&PrometheusServiceClient::ListWorkspaces, request, handler, context);
  }
 
  virtual Model::PutAlertManagerDefinitionOutcome PutAlertManagerDefinition(const Model::PutAlertManagerDefinitionRequest& request) const;
 
  template <typename PutAlertManagerDefinitionRequestT = Model::PutAlertManagerDefinitionRequest>
  Model::PutAlertManagerDefinitionOutcomeCallable PutAlertManagerDefinitionCallable(
      const PutAlertManagerDefinitionRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::PutAlertManagerDefinition, request);
  }
 
  template <typename PutAlertManagerDefinitionRequestT = Model::PutAlertManagerDefinitionRequest>
  void PutAlertManagerDefinitionAsync(const PutAlertManagerDefinitionRequestT& request,
                                      const PutAlertManagerDefinitionResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::PutAlertManagerDefinition, request, handler, context);
  }
 
  virtual Model::PutAnomalyDetectorOutcome PutAnomalyDetector(const Model::PutAnomalyDetectorRequest& request) const;
 
  template <typename PutAnomalyDetectorRequestT = Model::PutAnomalyDetectorRequest>
  Model::PutAnomalyDetectorOutcomeCallable PutAnomalyDetectorCallable(const PutAnomalyDetectorRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::PutAnomalyDetector, request);
  }
 
  template <typename PutAnomalyDetectorRequestT = Model::PutAnomalyDetectorRequest>
  void PutAnomalyDetectorAsync(const PutAnomalyDetectorRequestT& request, const PutAnomalyDetectorResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::PutAnomalyDetector, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::PutRuleGroupsNamespaceOutcome PutRuleGroupsNamespace(const Model::PutRuleGroupsNamespaceRequest& request) const;
 
  template <typename PutRuleGroupsNamespaceRequestT = Model::PutRuleGroupsNamespaceRequest>
  Model::PutRuleGroupsNamespaceOutcomeCallable PutRuleGroupsNamespaceCallable(const PutRuleGroupsNamespaceRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::PutRuleGroupsNamespace, request);
  }
 
  template <typename PutRuleGroupsNamespaceRequestT = Model::PutRuleGroupsNamespaceRequest>
  void PutRuleGroupsNamespaceAsync(const PutRuleGroupsNamespaceRequestT& request,
                                   const PutRuleGroupsNamespaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::PutRuleGroupsNamespace, 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(&PrometheusServiceClient::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(&PrometheusServiceClient::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(&PrometheusServiceClient::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(&PrometheusServiceClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateLoggingConfigurationOutcome UpdateLoggingConfiguration(
      const Model::UpdateLoggingConfigurationRequest& request) const;
 
  template <typename UpdateLoggingConfigurationRequestT = Model::UpdateLoggingConfigurationRequest>
  Model::UpdateLoggingConfigurationOutcomeCallable UpdateLoggingConfigurationCallable(
      const UpdateLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::UpdateLoggingConfiguration, request);
  }
 
  template <typename UpdateLoggingConfigurationRequestT = Model::UpdateLoggingConfigurationRequest>
  void UpdateLoggingConfigurationAsync(const UpdateLoggingConfigurationRequestT& request,
                                       const UpdateLoggingConfigurationResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::UpdateLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateQueryLoggingConfigurationOutcome UpdateQueryLoggingConfiguration(
      const Model::UpdateQueryLoggingConfigurationRequest& request) const;
 
  template <typename UpdateQueryLoggingConfigurationRequestT = Model::UpdateQueryLoggingConfigurationRequest>
  Model::UpdateQueryLoggingConfigurationOutcomeCallable UpdateQueryLoggingConfigurationCallable(
      const UpdateQueryLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::UpdateQueryLoggingConfiguration, request);
  }
 
  template <typename UpdateQueryLoggingConfigurationRequestT = Model::UpdateQueryLoggingConfigurationRequest>
  void UpdateQueryLoggingConfigurationAsync(const UpdateQueryLoggingConfigurationRequestT& request,
                                            const UpdateQueryLoggingConfigurationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::UpdateQueryLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateScraperOutcome UpdateScraper(const Model::UpdateScraperRequest& request) const;
 
  template <typename UpdateScraperRequestT = Model::UpdateScraperRequest>
  Model::UpdateScraperOutcomeCallable UpdateScraperCallable(const UpdateScraperRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::UpdateScraper, request);
  }
 
  template <typename UpdateScraperRequestT = Model::UpdateScraperRequest>
  void UpdateScraperAsync(const UpdateScraperRequestT& request, const UpdateScraperResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::UpdateScraper, request, handler, context);
  }
 
  virtual Model::UpdateScraperLoggingConfigurationOutcome UpdateScraperLoggingConfiguration(
      const Model::UpdateScraperLoggingConfigurationRequest& request) const;
 
  template <typename UpdateScraperLoggingConfigurationRequestT = Model::UpdateScraperLoggingConfigurationRequest>
  Model::UpdateScraperLoggingConfigurationOutcomeCallable UpdateScraperLoggingConfigurationCallable(
      const UpdateScraperLoggingConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::UpdateScraperLoggingConfiguration, request);
  }
 
  template <typename UpdateScraperLoggingConfigurationRequestT = Model::UpdateScraperLoggingConfigurationRequest>
  void UpdateScraperLoggingConfigurationAsync(const UpdateScraperLoggingConfigurationRequestT& request,
                                              const UpdateScraperLoggingConfigurationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::UpdateScraperLoggingConfiguration, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceAliasOutcome UpdateWorkspaceAlias(const Model::UpdateWorkspaceAliasRequest& request) const;
 
  template <typename UpdateWorkspaceAliasRequestT = Model::UpdateWorkspaceAliasRequest>
  Model::UpdateWorkspaceAliasOutcomeCallable UpdateWorkspaceAliasCallable(const UpdateWorkspaceAliasRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::UpdateWorkspaceAlias, request);
  }
 
  template <typename UpdateWorkspaceAliasRequestT = Model::UpdateWorkspaceAliasRequest>
  void UpdateWorkspaceAliasAsync(const UpdateWorkspaceAliasRequestT& request, const UpdateWorkspaceAliasResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::UpdateWorkspaceAlias, request, handler, context);
  }
 
  virtual Model::UpdateWorkspaceConfigurationOutcome UpdateWorkspaceConfiguration(
      const Model::UpdateWorkspaceConfigurationRequest& request) const;
 
  template <typename UpdateWorkspaceConfigurationRequestT = Model::UpdateWorkspaceConfigurationRequest>
  Model::UpdateWorkspaceConfigurationOutcomeCallable UpdateWorkspaceConfigurationCallable(
      const UpdateWorkspaceConfigurationRequestT& request) const {
    return SubmitCallable(&PrometheusServiceClient::UpdateWorkspaceConfiguration, request);
  }
 
  template <typename UpdateWorkspaceConfigurationRequestT = Model::UpdateWorkspaceConfigurationRequest>
  void UpdateWorkspaceConfigurationAsync(const UpdateWorkspaceConfigurationRequestT& request,
                                         const UpdateWorkspaceConfigurationResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&PrometheusServiceClient::UpdateWorkspaceConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<PrometheusServiceEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<PrometheusServiceClient>;
  void init(const PrometheusServiceClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, PrometheusServiceError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  PrometheusServiceClientConfiguration m_clientConfiguration;
  std::shared_ptr<PrometheusServiceEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace PrometheusService
}  // namespace Aws