ObservabilityAdminClient.h

 
#pragma once
#include <aws/observabilityadmin/ObservabilityAdmin_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/observabilityadmin/ObservabilityAdminServiceClientModel.h>
 
namespace Aws
{
namespace ObservabilityAdmin
{
  class AWS_OBSERVABILITYADMIN_API ObservabilityAdminClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ObservabilityAdminEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ObservabilityAdminClient>;
      void init(const ObservabilityAdminClientConfiguration& clientConfiguration);
 
      ObservabilityAdminClientConfiguration m_clientConfiguration;
      std::shared_ptr<ObservabilityAdminEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ObservabilityAdmin
} // namespace Aws