ObservabilityAdminClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/observabilityadmin/ObservabilityAdminPaginationBase.h>
#include <aws/observabilityadmin/ObservabilityAdminServiceClientModel.h>
#include <aws/observabilityadmin/ObservabilityAdminWaiter.h>
#include <aws/observabilityadmin/ObservabilityAdmin_EXPORTS.h>
 
namespace Aws {
namespace ObservabilityAdmin {
class AWS_OBSERVABILITYADMIN_API ObservabilityAdminClient : public Aws::Client::AWSJsonClient,
                                                            public Aws::Client::ClientWithAsyncTemplateMethods<ObservabilityAdminClient>,
                                                            public ObservabilityAdminPaginationBase<ObservabilityAdminClient>,
                                                            public ObservabilityAdminWaiter<ObservabilityAdminClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef ObservabilityAdminClientConfiguration ClientConfigurationType;
  typedef ObservabilityAdminEndpointProvider EndpointProviderType;
 
  ObservabilityAdminClient(const Aws::ObservabilityAdmin::ObservabilityAdminClientConfiguration& clientConfiguration =
                               Aws::ObservabilityAdmin::ObservabilityAdminClientConfiguration(),
                           std::shared_ptr<ObservabilityAdminEndpointProviderBase> endpointProvider = nullptr);
 
  ObservabilityAdminClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<ObservabilityAdminEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ObservabilityAdmin::ObservabilityAdminClientConfiguration& clientConfiguration =
                               Aws::ObservabilityAdmin::ObservabilityAdminClientConfiguration());
 
  ObservabilityAdminClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<ObservabilityAdminEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::ObservabilityAdmin::ObservabilityAdminClientConfiguration& clientConfiguration =
                               Aws::ObservabilityAdmin::ObservabilityAdminClientConfiguration());
 
  /* Legacy constructors due deprecation */
  ObservabilityAdminClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ObservabilityAdminClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  ObservabilityAdminClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~ObservabilityAdminClient();
 
  virtual Model::CreateCentralizationRuleForOrganizationOutcome CreateCentralizationRuleForOrganization(
      const Model::CreateCentralizationRuleForOrganizationRequest& request) const;
 
  template <typename CreateCentralizationRuleForOrganizationRequestT = Model::CreateCentralizationRuleForOrganizationRequest>
  Model::CreateCentralizationRuleForOrganizationOutcomeCallable CreateCentralizationRuleForOrganizationCallable(
      const CreateCentralizationRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::CreateCentralizationRuleForOrganization, request);
  }
 
  template <typename CreateCentralizationRuleForOrganizationRequestT = Model::CreateCentralizationRuleForOrganizationRequest>
  void CreateCentralizationRuleForOrganizationAsync(const CreateCentralizationRuleForOrganizationRequestT& request,
                                                    const CreateCentralizationRuleForOrganizationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::CreateCentralizationRuleForOrganization, request, handler, context);
  }
 
  virtual Model::CreateDatasetIntegrationOutcome CreateDatasetIntegration(const Model::CreateDatasetIntegrationRequest& request) const;
 
  template <typename CreateDatasetIntegrationRequestT = Model::CreateDatasetIntegrationRequest>
  Model::CreateDatasetIntegrationOutcomeCallable CreateDatasetIntegrationCallable(const CreateDatasetIntegrationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::CreateDatasetIntegration, request);
  }
 
  template <typename CreateDatasetIntegrationRequestT = Model::CreateDatasetIntegrationRequest>
  void CreateDatasetIntegrationAsync(const CreateDatasetIntegrationRequestT& request,
                                     const CreateDatasetIntegrationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::CreateDatasetIntegration, request, handler, context);
  }
 
  virtual Model::CreateS3TableIntegrationOutcome CreateS3TableIntegration(const Model::CreateS3TableIntegrationRequest& request) const;
 
  template <typename CreateS3TableIntegrationRequestT = Model::CreateS3TableIntegrationRequest>
  Model::CreateS3TableIntegrationOutcomeCallable CreateS3TableIntegrationCallable(const CreateS3TableIntegrationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::CreateS3TableIntegration, request);
  }
 
  template <typename CreateS3TableIntegrationRequestT = Model::CreateS3TableIntegrationRequest>
  void CreateS3TableIntegrationAsync(const CreateS3TableIntegrationRequestT& request,
                                     const CreateS3TableIntegrationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::CreateS3TableIntegration, request, handler, context);
  }
 
  virtual Model::CreateTelemetryPipelineOutcome CreateTelemetryPipeline(const Model::CreateTelemetryPipelineRequest& request) const;
 
  template <typename CreateTelemetryPipelineRequestT = Model::CreateTelemetryPipelineRequest>
  Model::CreateTelemetryPipelineOutcomeCallable CreateTelemetryPipelineCallable(const CreateTelemetryPipelineRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::CreateTelemetryPipeline, request);
  }
 
  template <typename CreateTelemetryPipelineRequestT = Model::CreateTelemetryPipelineRequest>
  void CreateTelemetryPipelineAsync(const CreateTelemetryPipelineRequestT& request,
                                    const CreateTelemetryPipelineResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::CreateTelemetryPipeline, request, handler, context);
  }
 
  virtual Model::CreateTelemetryRuleOutcome CreateTelemetryRule(const Model::CreateTelemetryRuleRequest& request) const;
 
  template <typename CreateTelemetryRuleRequestT = Model::CreateTelemetryRuleRequest>
  Model::CreateTelemetryRuleOutcomeCallable CreateTelemetryRuleCallable(const CreateTelemetryRuleRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::CreateTelemetryRule, request);
  }
 
  template <typename CreateTelemetryRuleRequestT = Model::CreateTelemetryRuleRequest>
  void CreateTelemetryRuleAsync(const CreateTelemetryRuleRequestT& request, const CreateTelemetryRuleResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::CreateTelemetryRule, request, handler, context);
  }
 
  virtual Model::CreateTelemetryRuleForOrganizationOutcome CreateTelemetryRuleForOrganization(
      const Model::CreateTelemetryRuleForOrganizationRequest& request) const;
 
  template <typename CreateTelemetryRuleForOrganizationRequestT = Model::CreateTelemetryRuleForOrganizationRequest>
  Model::CreateTelemetryRuleForOrganizationOutcomeCallable CreateTelemetryRuleForOrganizationCallable(
      const CreateTelemetryRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::CreateTelemetryRuleForOrganization, request);
  }
 
  template <typename CreateTelemetryRuleForOrganizationRequestT = Model::CreateTelemetryRuleForOrganizationRequest>
  void CreateTelemetryRuleForOrganizationAsync(const CreateTelemetryRuleForOrganizationRequestT& request,
                                               const CreateTelemetryRuleForOrganizationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::CreateTelemetryRuleForOrganization, request, handler, context);
  }
 
  virtual Model::DeleteCentralizationRuleForOrganizationOutcome DeleteCentralizationRuleForOrganization(
      const Model::DeleteCentralizationRuleForOrganizationRequest& request) const;
 
  template <typename DeleteCentralizationRuleForOrganizationRequestT = Model::DeleteCentralizationRuleForOrganizationRequest>
  Model::DeleteCentralizationRuleForOrganizationOutcomeCallable DeleteCentralizationRuleForOrganizationCallable(
      const DeleteCentralizationRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::DeleteCentralizationRuleForOrganization, request);
  }
 
  template <typename DeleteCentralizationRuleForOrganizationRequestT = Model::DeleteCentralizationRuleForOrganizationRequest>
  void DeleteCentralizationRuleForOrganizationAsync(const DeleteCentralizationRuleForOrganizationRequestT& request,
                                                    const DeleteCentralizationRuleForOrganizationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::DeleteCentralizationRuleForOrganization, request, handler, context);
  }
 
  virtual Model::DeleteDatasetIntegrationOutcome DeleteDatasetIntegration(const Model::DeleteDatasetIntegrationRequest& request) const;
 
  template <typename DeleteDatasetIntegrationRequestT = Model::DeleteDatasetIntegrationRequest>
  Model::DeleteDatasetIntegrationOutcomeCallable DeleteDatasetIntegrationCallable(const DeleteDatasetIntegrationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::DeleteDatasetIntegration, request);
  }
 
  template <typename DeleteDatasetIntegrationRequestT = Model::DeleteDatasetIntegrationRequest>
  void DeleteDatasetIntegrationAsync(const DeleteDatasetIntegrationRequestT& request,
                                     const DeleteDatasetIntegrationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::DeleteDatasetIntegration, request, handler, context);
  }
 
  virtual Model::DeleteS3TableIntegrationOutcome DeleteS3TableIntegration(const Model::DeleteS3TableIntegrationRequest& request) const;
 
  template <typename DeleteS3TableIntegrationRequestT = Model::DeleteS3TableIntegrationRequest>
  Model::DeleteS3TableIntegrationOutcomeCallable DeleteS3TableIntegrationCallable(const DeleteS3TableIntegrationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::DeleteS3TableIntegration, request);
  }
 
  template <typename DeleteS3TableIntegrationRequestT = Model::DeleteS3TableIntegrationRequest>
  void DeleteS3TableIntegrationAsync(const DeleteS3TableIntegrationRequestT& request,
                                     const DeleteS3TableIntegrationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::DeleteS3TableIntegration, request, handler, context);
  }
 
  virtual Model::DeleteTelemetryPipelineOutcome DeleteTelemetryPipeline(const Model::DeleteTelemetryPipelineRequest& request) const;
 
  template <typename DeleteTelemetryPipelineRequestT = Model::DeleteTelemetryPipelineRequest>
  Model::DeleteTelemetryPipelineOutcomeCallable DeleteTelemetryPipelineCallable(const DeleteTelemetryPipelineRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::DeleteTelemetryPipeline, request);
  }
 
  template <typename DeleteTelemetryPipelineRequestT = Model::DeleteTelemetryPipelineRequest>
  void DeleteTelemetryPipelineAsync(const DeleteTelemetryPipelineRequestT& request,
                                    const DeleteTelemetryPipelineResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::DeleteTelemetryPipeline, request, handler, context);
  }
 
  virtual Model::DeleteTelemetryRuleOutcome DeleteTelemetryRule(const Model::DeleteTelemetryRuleRequest& request) const;
 
  template <typename DeleteTelemetryRuleRequestT = Model::DeleteTelemetryRuleRequest>
  Model::DeleteTelemetryRuleOutcomeCallable DeleteTelemetryRuleCallable(const DeleteTelemetryRuleRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::DeleteTelemetryRule, request);
  }
 
  template <typename DeleteTelemetryRuleRequestT = Model::DeleteTelemetryRuleRequest>
  void DeleteTelemetryRuleAsync(const DeleteTelemetryRuleRequestT& request, const DeleteTelemetryRuleResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::DeleteTelemetryRule, request, handler, context);
  }
 
  virtual Model::DeleteTelemetryRuleForOrganizationOutcome DeleteTelemetryRuleForOrganization(
      const Model::DeleteTelemetryRuleForOrganizationRequest& request) const;
 
  template <typename DeleteTelemetryRuleForOrganizationRequestT = Model::DeleteTelemetryRuleForOrganizationRequest>
  Model::DeleteTelemetryRuleForOrganizationOutcomeCallable DeleteTelemetryRuleForOrganizationCallable(
      const DeleteTelemetryRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::DeleteTelemetryRuleForOrganization, request);
  }
 
  template <typename DeleteTelemetryRuleForOrganizationRequestT = Model::DeleteTelemetryRuleForOrganizationRequest>
  void DeleteTelemetryRuleForOrganizationAsync(const DeleteTelemetryRuleForOrganizationRequestT& request,
                                               const DeleteTelemetryRuleForOrganizationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::DeleteTelemetryRuleForOrganization, request, handler, context);
  }
 
  virtual Model::GetCentralizationRuleForOrganizationOutcome GetCentralizationRuleForOrganization(
      const Model::GetCentralizationRuleForOrganizationRequest& request) const;
 
  template <typename GetCentralizationRuleForOrganizationRequestT = Model::GetCentralizationRuleForOrganizationRequest>
  Model::GetCentralizationRuleForOrganizationOutcomeCallable GetCentralizationRuleForOrganizationCallable(
      const GetCentralizationRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::GetCentralizationRuleForOrganization, request);
  }
 
  template <typename GetCentralizationRuleForOrganizationRequestT = Model::GetCentralizationRuleForOrganizationRequest>
  void GetCentralizationRuleForOrganizationAsync(const GetCentralizationRuleForOrganizationRequestT& request,
                                                 const GetCentralizationRuleForOrganizationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::GetCentralizationRuleForOrganization, request, handler, context);
  }
 
  virtual Model::GetDatasetIntegrationOutcome GetDatasetIntegration(const Model::GetDatasetIntegrationRequest& request) const;
 
  template <typename GetDatasetIntegrationRequestT = Model::GetDatasetIntegrationRequest>
  Model::GetDatasetIntegrationOutcomeCallable GetDatasetIntegrationCallable(const GetDatasetIntegrationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::GetDatasetIntegration, request);
  }
 
  template <typename GetDatasetIntegrationRequestT = Model::GetDatasetIntegrationRequest>
  void GetDatasetIntegrationAsync(const GetDatasetIntegrationRequestT& request, const GetDatasetIntegrationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::GetDatasetIntegration, request, handler, context);
  }
 
  virtual Model::GetS3TableIntegrationOutcome GetS3TableIntegration(const Model::GetS3TableIntegrationRequest& request) const;
 
  template <typename GetS3TableIntegrationRequestT = Model::GetS3TableIntegrationRequest>
  Model::GetS3TableIntegrationOutcomeCallable GetS3TableIntegrationCallable(const GetS3TableIntegrationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::GetS3TableIntegration, request);
  }
 
  template <typename GetS3TableIntegrationRequestT = Model::GetS3TableIntegrationRequest>
  void GetS3TableIntegrationAsync(const GetS3TableIntegrationRequestT& request, const GetS3TableIntegrationResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::GetS3TableIntegration, request, handler, context);
  }
 
  virtual Model::GetTelemetryEnrichmentStatusOutcome GetTelemetryEnrichmentStatus(
      const Model::GetTelemetryEnrichmentStatusRequest& request = {}) const;
 
  template <typename GetTelemetryEnrichmentStatusRequestT = Model::GetTelemetryEnrichmentStatusRequest>
  Model::GetTelemetryEnrichmentStatusOutcomeCallable GetTelemetryEnrichmentStatusCallable(
      const GetTelemetryEnrichmentStatusRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::GetTelemetryEnrichmentStatus, request);
  }
 
  template <typename GetTelemetryEnrichmentStatusRequestT = Model::GetTelemetryEnrichmentStatusRequest>
  void GetTelemetryEnrichmentStatusAsync(const GetTelemetryEnrichmentStatusResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetTelemetryEnrichmentStatusRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::GetTelemetryEnrichmentStatus, request, handler, context);
  }
 
  virtual Model::GetTelemetryEvaluationStatusOutcome GetTelemetryEvaluationStatus(
      const Model::GetTelemetryEvaluationStatusRequest& request = {}) const;
 
  template <typename GetTelemetryEvaluationStatusRequestT = Model::GetTelemetryEvaluationStatusRequest>
  Model::GetTelemetryEvaluationStatusOutcomeCallable GetTelemetryEvaluationStatusCallable(
      const GetTelemetryEvaluationStatusRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::GetTelemetryEvaluationStatus, request);
  }
 
  template <typename GetTelemetryEvaluationStatusRequestT = Model::GetTelemetryEvaluationStatusRequest>
  void GetTelemetryEvaluationStatusAsync(const GetTelemetryEvaluationStatusResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const GetTelemetryEvaluationStatusRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::GetTelemetryEvaluationStatus, request, handler, context);
  }
 
  virtual Model::GetTelemetryEvaluationStatusForOrganizationOutcome GetTelemetryEvaluationStatusForOrganization(
      const Model::GetTelemetryEvaluationStatusForOrganizationRequest& request = {}) const;
 
  template <typename GetTelemetryEvaluationStatusForOrganizationRequestT = Model::GetTelemetryEvaluationStatusForOrganizationRequest>
  Model::GetTelemetryEvaluationStatusForOrganizationOutcomeCallable GetTelemetryEvaluationStatusForOrganizationCallable(
      const GetTelemetryEvaluationStatusForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::GetTelemetryEvaluationStatusForOrganization, request);
  }
 
  template <typename GetTelemetryEvaluationStatusForOrganizationRequestT = Model::GetTelemetryEvaluationStatusForOrganizationRequest>
  void GetTelemetryEvaluationStatusForOrganizationAsync(const GetTelemetryEvaluationStatusForOrganizationResponseReceivedHandler& handler,
                                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                        const GetTelemetryEvaluationStatusForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::GetTelemetryEvaluationStatusForOrganization, request, handler, context);
  }
 
  virtual Model::GetTelemetryPipelineOutcome GetTelemetryPipeline(const Model::GetTelemetryPipelineRequest& request) const;
 
  template <typename GetTelemetryPipelineRequestT = Model::GetTelemetryPipelineRequest>
  Model::GetTelemetryPipelineOutcomeCallable GetTelemetryPipelineCallable(const GetTelemetryPipelineRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::GetTelemetryPipeline, request);
  }
 
  template <typename GetTelemetryPipelineRequestT = Model::GetTelemetryPipelineRequest>
  void GetTelemetryPipelineAsync(const GetTelemetryPipelineRequestT& request, const GetTelemetryPipelineResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::GetTelemetryPipeline, request, handler, context);
  }
 
  virtual Model::GetTelemetryRuleOutcome GetTelemetryRule(const Model::GetTelemetryRuleRequest& request) const;
 
  template <typename GetTelemetryRuleRequestT = Model::GetTelemetryRuleRequest>
  Model::GetTelemetryRuleOutcomeCallable GetTelemetryRuleCallable(const GetTelemetryRuleRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::GetTelemetryRule, request);
  }
 
  template <typename GetTelemetryRuleRequestT = Model::GetTelemetryRuleRequest>
  void GetTelemetryRuleAsync(const GetTelemetryRuleRequestT& request, const GetTelemetryRuleResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::GetTelemetryRule, request, handler, context);
  }
 
  virtual Model::GetTelemetryRuleForOrganizationOutcome GetTelemetryRuleForOrganization(
      const Model::GetTelemetryRuleForOrganizationRequest& request) const;
 
  template <typename GetTelemetryRuleForOrganizationRequestT = Model::GetTelemetryRuleForOrganizationRequest>
  Model::GetTelemetryRuleForOrganizationOutcomeCallable GetTelemetryRuleForOrganizationCallable(
      const GetTelemetryRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::GetTelemetryRuleForOrganization, request);
  }
 
  template <typename GetTelemetryRuleForOrganizationRequestT = Model::GetTelemetryRuleForOrganizationRequest>
  void GetTelemetryRuleForOrganizationAsync(const GetTelemetryRuleForOrganizationRequestT& request,
                                            const GetTelemetryRuleForOrganizationResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::GetTelemetryRuleForOrganization, request, handler, context);
  }
 
  virtual Model::ListCentralizationRulesForOrganizationOutcome ListCentralizationRulesForOrganization(
      const Model::ListCentralizationRulesForOrganizationRequest& request = {}) const;
 
  template <typename ListCentralizationRulesForOrganizationRequestT = Model::ListCentralizationRulesForOrganizationRequest>
  Model::ListCentralizationRulesForOrganizationOutcomeCallable ListCentralizationRulesForOrganizationCallable(
      const ListCentralizationRulesForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListCentralizationRulesForOrganization, request);
  }
 
  template <typename ListCentralizationRulesForOrganizationRequestT = Model::ListCentralizationRulesForOrganizationRequest>
  void ListCentralizationRulesForOrganizationAsync(const ListCentralizationRulesForOrganizationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const ListCentralizationRulesForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListCentralizationRulesForOrganization, request, handler, context);
  }
 
  virtual Model::ListDatasetIntegrationsOutcome ListDatasetIntegrations(const Model::ListDatasetIntegrationsRequest& request = {}) const;
 
  template <typename ListDatasetIntegrationsRequestT = Model::ListDatasetIntegrationsRequest>
  Model::ListDatasetIntegrationsOutcomeCallable ListDatasetIntegrationsCallable(const ListDatasetIntegrationsRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListDatasetIntegrations, request);
  }
 
  template <typename ListDatasetIntegrationsRequestT = Model::ListDatasetIntegrationsRequest>
  void ListDatasetIntegrationsAsync(const ListDatasetIntegrationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListDatasetIntegrationsRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListDatasetIntegrations, request, handler, context);
  }
 
  virtual Model::ListResourceTelemetryOutcome ListResourceTelemetry(const Model::ListResourceTelemetryRequest& request = {}) const;
 
  template <typename ListResourceTelemetryRequestT = Model::ListResourceTelemetryRequest>
  Model::ListResourceTelemetryOutcomeCallable ListResourceTelemetryCallable(const ListResourceTelemetryRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListResourceTelemetry, request);
  }
 
  template <typename ListResourceTelemetryRequestT = Model::ListResourceTelemetryRequest>
  void ListResourceTelemetryAsync(const ListResourceTelemetryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListResourceTelemetryRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListResourceTelemetry, request, handler, context);
  }
 
  virtual Model::ListResourceTelemetryForOrganizationOutcome ListResourceTelemetryForOrganization(
      const Model::ListResourceTelemetryForOrganizationRequest& request = {}) const;
 
  template <typename ListResourceTelemetryForOrganizationRequestT = Model::ListResourceTelemetryForOrganizationRequest>
  Model::ListResourceTelemetryForOrganizationOutcomeCallable ListResourceTelemetryForOrganizationCallable(
      const ListResourceTelemetryForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListResourceTelemetryForOrganization, request);
  }
 
  template <typename ListResourceTelemetryForOrganizationRequestT = Model::ListResourceTelemetryForOrganizationRequest>
  void ListResourceTelemetryForOrganizationAsync(const ListResourceTelemetryForOrganizationResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const ListResourceTelemetryForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListResourceTelemetryForOrganization, request, handler, context);
  }
 
  virtual Model::ListS3TableIntegrationsOutcome ListS3TableIntegrations(const Model::ListS3TableIntegrationsRequest& request = {}) const;
 
  template <typename ListS3TableIntegrationsRequestT = Model::ListS3TableIntegrationsRequest>
  Model::ListS3TableIntegrationsOutcomeCallable ListS3TableIntegrationsCallable(const ListS3TableIntegrationsRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListS3TableIntegrations, request);
  }
 
  template <typename ListS3TableIntegrationsRequestT = Model::ListS3TableIntegrationsRequest>
  void ListS3TableIntegrationsAsync(const ListS3TableIntegrationsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListS3TableIntegrationsRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListS3TableIntegrations, 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(&ObservabilityAdminClient::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(&ObservabilityAdminClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTelemetryPipelinesOutcome ListTelemetryPipelines(const Model::ListTelemetryPipelinesRequest& request = {}) const;
 
  template <typename ListTelemetryPipelinesRequestT = Model::ListTelemetryPipelinesRequest>
  Model::ListTelemetryPipelinesOutcomeCallable ListTelemetryPipelinesCallable(const ListTelemetryPipelinesRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListTelemetryPipelines, request);
  }
 
  template <typename ListTelemetryPipelinesRequestT = Model::ListTelemetryPipelinesRequest>
  void ListTelemetryPipelinesAsync(const ListTelemetryPipelinesResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListTelemetryPipelinesRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListTelemetryPipelines, request, handler, context);
  }
 
  virtual Model::ListTelemetryRulesOutcome ListTelemetryRules(const Model::ListTelemetryRulesRequest& request = {}) const;
 
  template <typename ListTelemetryRulesRequestT = Model::ListTelemetryRulesRequest>
  Model::ListTelemetryRulesOutcomeCallable ListTelemetryRulesCallable(const ListTelemetryRulesRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListTelemetryRules, request);
  }
 
  template <typename ListTelemetryRulesRequestT = Model::ListTelemetryRulesRequest>
  void ListTelemetryRulesAsync(const ListTelemetryRulesResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListTelemetryRulesRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListTelemetryRules, request, handler, context);
  }
 
  virtual Model::ListTelemetryRulesForOrganizationOutcome ListTelemetryRulesForOrganization(
      const Model::ListTelemetryRulesForOrganizationRequest& request = {}) const;
 
  template <typename ListTelemetryRulesForOrganizationRequestT = Model::ListTelemetryRulesForOrganizationRequest>
  Model::ListTelemetryRulesForOrganizationOutcomeCallable ListTelemetryRulesForOrganizationCallable(
      const ListTelemetryRulesForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::ListTelemetryRulesForOrganization, request);
  }
 
  template <typename ListTelemetryRulesForOrganizationRequestT = Model::ListTelemetryRulesForOrganizationRequest>
  void ListTelemetryRulesForOrganizationAsync(const ListTelemetryRulesForOrganizationResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                              const ListTelemetryRulesForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::ListTelemetryRulesForOrganization, request, handler, context);
  }
 
  virtual Model::StartTelemetryEnrichmentOutcome StartTelemetryEnrichment(const Model::StartTelemetryEnrichmentRequest& request = {}) const;
 
  template <typename StartTelemetryEnrichmentRequestT = Model::StartTelemetryEnrichmentRequest>
  Model::StartTelemetryEnrichmentOutcomeCallable StartTelemetryEnrichmentCallable(
      const StartTelemetryEnrichmentRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::StartTelemetryEnrichment, request);
  }
 
  template <typename StartTelemetryEnrichmentRequestT = Model::StartTelemetryEnrichmentRequest>
  void StartTelemetryEnrichmentAsync(const StartTelemetryEnrichmentResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const StartTelemetryEnrichmentRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::StartTelemetryEnrichment, request, handler, context);
  }
 
  virtual Model::StartTelemetryEvaluationOutcome StartTelemetryEvaluation(const Model::StartTelemetryEvaluationRequest& request = {}) const;
 
  template <typename StartTelemetryEvaluationRequestT = Model::StartTelemetryEvaluationRequest>
  Model::StartTelemetryEvaluationOutcomeCallable StartTelemetryEvaluationCallable(
      const StartTelemetryEvaluationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::StartTelemetryEvaluation, request);
  }
 
  template <typename StartTelemetryEvaluationRequestT = Model::StartTelemetryEvaluationRequest>
  void StartTelemetryEvaluationAsync(const StartTelemetryEvaluationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const StartTelemetryEvaluationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::StartTelemetryEvaluation, request, handler, context);
  }
 
  virtual Model::StartTelemetryEvaluationForOrganizationOutcome StartTelemetryEvaluationForOrganization(
      const Model::StartTelemetryEvaluationForOrganizationRequest& request = {}) const;
 
  template <typename StartTelemetryEvaluationForOrganizationRequestT = Model::StartTelemetryEvaluationForOrganizationRequest>
  Model::StartTelemetryEvaluationForOrganizationOutcomeCallable StartTelemetryEvaluationForOrganizationCallable(
      const StartTelemetryEvaluationForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::StartTelemetryEvaluationForOrganization, request);
  }
 
  template <typename StartTelemetryEvaluationForOrganizationRequestT = Model::StartTelemetryEvaluationForOrganizationRequest>
  void StartTelemetryEvaluationForOrganizationAsync(const StartTelemetryEvaluationForOrganizationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                    const StartTelemetryEvaluationForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::StartTelemetryEvaluationForOrganization, request, handler, context);
  }
 
  virtual Model::StopTelemetryEnrichmentOutcome StopTelemetryEnrichment(const Model::StopTelemetryEnrichmentRequest& request = {}) const;
 
  template <typename StopTelemetryEnrichmentRequestT = Model::StopTelemetryEnrichmentRequest>
  Model::StopTelemetryEnrichmentOutcomeCallable StopTelemetryEnrichmentCallable(const StopTelemetryEnrichmentRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::StopTelemetryEnrichment, request);
  }
 
  template <typename StopTelemetryEnrichmentRequestT = Model::StopTelemetryEnrichmentRequest>
  void StopTelemetryEnrichmentAsync(const StopTelemetryEnrichmentResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const StopTelemetryEnrichmentRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::StopTelemetryEnrichment, request, handler, context);
  }
 
  virtual Model::StopTelemetryEvaluationOutcome StopTelemetryEvaluation(const Model::StopTelemetryEvaluationRequest& request = {}) const;
 
  template <typename StopTelemetryEvaluationRequestT = Model::StopTelemetryEvaluationRequest>
  Model::StopTelemetryEvaluationOutcomeCallable StopTelemetryEvaluationCallable(const StopTelemetryEvaluationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::StopTelemetryEvaluation, request);
  }
 
  template <typename StopTelemetryEvaluationRequestT = Model::StopTelemetryEvaluationRequest>
  void StopTelemetryEvaluationAsync(const StopTelemetryEvaluationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const StopTelemetryEvaluationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::StopTelemetryEvaluation, request, handler, context);
  }
 
  virtual Model::StopTelemetryEvaluationForOrganizationOutcome StopTelemetryEvaluationForOrganization(
      const Model::StopTelemetryEvaluationForOrganizationRequest& request = {}) const;
 
  template <typename StopTelemetryEvaluationForOrganizationRequestT = Model::StopTelemetryEvaluationForOrganizationRequest>
  Model::StopTelemetryEvaluationForOrganizationOutcomeCallable StopTelemetryEvaluationForOrganizationCallable(
      const StopTelemetryEvaluationForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&ObservabilityAdminClient::StopTelemetryEvaluationForOrganization, request);
  }
 
  template <typename StopTelemetryEvaluationForOrganizationRequestT = Model::StopTelemetryEvaluationForOrganizationRequest>
  void StopTelemetryEvaluationForOrganizationAsync(const StopTelemetryEvaluationForOrganizationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                   const StopTelemetryEvaluationForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&ObservabilityAdminClient::StopTelemetryEvaluationForOrganization, 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(&ObservabilityAdminClient::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(&ObservabilityAdminClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestTelemetryPipelineOutcome TestTelemetryPipeline(const Model::TestTelemetryPipelineRequest& request) const;
 
  template <typename TestTelemetryPipelineRequestT = Model::TestTelemetryPipelineRequest>
  Model::TestTelemetryPipelineOutcomeCallable TestTelemetryPipelineCallable(const TestTelemetryPipelineRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::TestTelemetryPipeline, request);
  }
 
  template <typename TestTelemetryPipelineRequestT = Model::TestTelemetryPipelineRequest>
  void TestTelemetryPipelineAsync(const TestTelemetryPipelineRequestT& request, const TestTelemetryPipelineResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::TestTelemetryPipeline, 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(&ObservabilityAdminClient::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(&ObservabilityAdminClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateCentralizationRuleForOrganizationOutcome UpdateCentralizationRuleForOrganization(
      const Model::UpdateCentralizationRuleForOrganizationRequest& request) const;
 
  template <typename UpdateCentralizationRuleForOrganizationRequestT = Model::UpdateCentralizationRuleForOrganizationRequest>
  Model::UpdateCentralizationRuleForOrganizationOutcomeCallable UpdateCentralizationRuleForOrganizationCallable(
      const UpdateCentralizationRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::UpdateCentralizationRuleForOrganization, request);
  }
 
  template <typename UpdateCentralizationRuleForOrganizationRequestT = Model::UpdateCentralizationRuleForOrganizationRequest>
  void UpdateCentralizationRuleForOrganizationAsync(const UpdateCentralizationRuleForOrganizationRequestT& request,
                                                    const UpdateCentralizationRuleForOrganizationResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::UpdateCentralizationRuleForOrganization, request, handler, context);
  }
 
  virtual Model::UpdateDatasetIntegrationOutcome UpdateDatasetIntegration(const Model::UpdateDatasetIntegrationRequest& request) const;
 
  template <typename UpdateDatasetIntegrationRequestT = Model::UpdateDatasetIntegrationRequest>
  Model::UpdateDatasetIntegrationOutcomeCallable UpdateDatasetIntegrationCallable(const UpdateDatasetIntegrationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::UpdateDatasetIntegration, request);
  }
 
  template <typename UpdateDatasetIntegrationRequestT = Model::UpdateDatasetIntegrationRequest>
  void UpdateDatasetIntegrationAsync(const UpdateDatasetIntegrationRequestT& request,
                                     const UpdateDatasetIntegrationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::UpdateDatasetIntegration, request, handler, context);
  }
 
  virtual Model::UpdateTelemetryPipelineOutcome UpdateTelemetryPipeline(const Model::UpdateTelemetryPipelineRequest& request) const;
 
  template <typename UpdateTelemetryPipelineRequestT = Model::UpdateTelemetryPipelineRequest>
  Model::UpdateTelemetryPipelineOutcomeCallable UpdateTelemetryPipelineCallable(const UpdateTelemetryPipelineRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::UpdateTelemetryPipeline, request);
  }
 
  template <typename UpdateTelemetryPipelineRequestT = Model::UpdateTelemetryPipelineRequest>
  void UpdateTelemetryPipelineAsync(const UpdateTelemetryPipelineRequestT& request,
                                    const UpdateTelemetryPipelineResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::UpdateTelemetryPipeline, request, handler, context);
  }
 
  virtual Model::UpdateTelemetryRuleOutcome UpdateTelemetryRule(const Model::UpdateTelemetryRuleRequest& request) const;
 
  template <typename UpdateTelemetryRuleRequestT = Model::UpdateTelemetryRuleRequest>
  Model::UpdateTelemetryRuleOutcomeCallable UpdateTelemetryRuleCallable(const UpdateTelemetryRuleRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::UpdateTelemetryRule, request);
  }
 
  template <typename UpdateTelemetryRuleRequestT = Model::UpdateTelemetryRuleRequest>
  void UpdateTelemetryRuleAsync(const UpdateTelemetryRuleRequestT& request, const UpdateTelemetryRuleResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::UpdateTelemetryRule, request, handler, context);
  }
 
  virtual Model::UpdateTelemetryRuleForOrganizationOutcome UpdateTelemetryRuleForOrganization(
      const Model::UpdateTelemetryRuleForOrganizationRequest& request) const;
 
  template <typename UpdateTelemetryRuleForOrganizationRequestT = Model::UpdateTelemetryRuleForOrganizationRequest>
  Model::UpdateTelemetryRuleForOrganizationOutcomeCallable UpdateTelemetryRuleForOrganizationCallable(
      const UpdateTelemetryRuleForOrganizationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::UpdateTelemetryRuleForOrganization, request);
  }
 
  template <typename UpdateTelemetryRuleForOrganizationRequestT = Model::UpdateTelemetryRuleForOrganizationRequest>
  void UpdateTelemetryRuleForOrganizationAsync(const UpdateTelemetryRuleForOrganizationRequestT& request,
                                               const UpdateTelemetryRuleForOrganizationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::UpdateTelemetryRuleForOrganization, request, handler, context);
  }
 
  virtual Model::ValidateTelemetryPipelineConfigurationOutcome ValidateTelemetryPipelineConfiguration(
      const Model::ValidateTelemetryPipelineConfigurationRequest& request) const;
 
  template <typename ValidateTelemetryPipelineConfigurationRequestT = Model::ValidateTelemetryPipelineConfigurationRequest>
  Model::ValidateTelemetryPipelineConfigurationOutcomeCallable ValidateTelemetryPipelineConfigurationCallable(
      const ValidateTelemetryPipelineConfigurationRequestT& request) const {
    return SubmitCallable(&ObservabilityAdminClient::ValidateTelemetryPipelineConfiguration, request);
  }
 
  template <typename ValidateTelemetryPipelineConfigurationRequestT = Model::ValidateTelemetryPipelineConfigurationRequest>
  void ValidateTelemetryPipelineConfigurationAsync(const ValidateTelemetryPipelineConfigurationRequestT& request,
                                                   const ValidateTelemetryPipelineConfigurationResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&ObservabilityAdminClient::ValidateTelemetryPipelineConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<ObservabilityAdminEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<ObservabilityAdminClient>;
  void init(const ObservabilityAdminClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, ObservabilityAdminError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  ObservabilityAdminClientConfiguration m_clientConfiguration;
  std::shared_ptr<ObservabilityAdminEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace ObservabilityAdmin
}  // namespace Aws