XRayClient.h

 
#pragma once
#include <aws/xray/XRay_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/xray/XRayServiceClientModel.h>
 
namespace Aws
{
namespace XRay
{
  class AWS_XRAY_API XRayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<XRayClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef XRayClientConfiguration ClientConfigurationType;
      typedef XRayEndpointProvider EndpointProviderType;
 
        XRayClient(const Aws::XRay::XRayClientConfiguration& clientConfiguration = Aws::XRay::XRayClientConfiguration(),
                   std::shared_ptr<XRayEndpointProviderBase> endpointProvider = nullptr);
 
        XRayClient(const Aws::Auth::AWSCredentials& credentials,
                   std::shared_ptr<XRayEndpointProviderBase> endpointProvider = nullptr,
                   const Aws::XRay::XRayClientConfiguration& clientConfiguration = Aws::XRay::XRayClientConfiguration());
 
        XRayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   std::shared_ptr<XRayEndpointProviderBase> endpointProvider = nullptr,
                   const Aws::XRay::XRayClientConfiguration& clientConfiguration = Aws::XRay::XRayClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        XRayClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        XRayClient(const Aws::Auth::AWSCredentials& credentials,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        XRayClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~XRayClient();
 
        virtual Model::BatchGetTracesOutcome BatchGetTraces(const Model::BatchGetTracesRequest& request) const;
 
        template<typename BatchGetTracesRequestT = Model::BatchGetTracesRequest>
        Model::BatchGetTracesOutcomeCallable BatchGetTracesCallable(const BatchGetTracesRequestT& request) const
        {
            return SubmitCallable(&XRayClient::BatchGetTraces, request);
        }
 
        template<typename BatchGetTracesRequestT = Model::BatchGetTracesRequest>
        void BatchGetTracesAsync(const BatchGetTracesRequestT& request, const BatchGetTracesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::BatchGetTraces, request, handler, context);
        }
 
        virtual Model::CancelTraceRetrievalOutcome CancelTraceRetrieval(const Model::CancelTraceRetrievalRequest& request) const;
 
        template<typename CancelTraceRetrievalRequestT = Model::CancelTraceRetrievalRequest>
        Model::CancelTraceRetrievalOutcomeCallable CancelTraceRetrievalCallable(const CancelTraceRetrievalRequestT& request) const
        {
            return SubmitCallable(&XRayClient::CancelTraceRetrieval, request);
        }
 
        template<typename CancelTraceRetrievalRequestT = Model::CancelTraceRetrievalRequest>
        void CancelTraceRetrievalAsync(const CancelTraceRetrievalRequestT& request, const CancelTraceRetrievalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::CancelTraceRetrieval, request, handler, context);
        }
 
        virtual Model::CreateGroupOutcome CreateGroup(const Model::CreateGroupRequest& request) const;
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        Model::CreateGroupOutcomeCallable CreateGroupCallable(const CreateGroupRequestT& request) const
        {
            return SubmitCallable(&XRayClient::CreateGroup, request);
        }
 
        template<typename CreateGroupRequestT = Model::CreateGroupRequest>
        void CreateGroupAsync(const CreateGroupRequestT& request, const CreateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::CreateGroup, request, handler, context);
        }
 
        virtual Model::CreateSamplingRuleOutcome CreateSamplingRule(const Model::CreateSamplingRuleRequest& request) const;
 
        template<typename CreateSamplingRuleRequestT = Model::CreateSamplingRuleRequest>
        Model::CreateSamplingRuleOutcomeCallable CreateSamplingRuleCallable(const CreateSamplingRuleRequestT& request) const
        {
            return SubmitCallable(&XRayClient::CreateSamplingRule, request);
        }
 
        template<typename CreateSamplingRuleRequestT = Model::CreateSamplingRuleRequest>
        void CreateSamplingRuleAsync(const CreateSamplingRuleRequestT& request, const CreateSamplingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::CreateSamplingRule, request, handler, context);
        }
 
        virtual Model::DeleteGroupOutcome DeleteGroup(const Model::DeleteGroupRequest& request = {}) const;
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        Model::DeleteGroupOutcomeCallable DeleteGroupCallable(const DeleteGroupRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::DeleteGroup, request);
        }
 
        template<typename DeleteGroupRequestT = Model::DeleteGroupRequest>
        void DeleteGroupAsync(const DeleteGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteGroupRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::DeleteGroup, 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(&XRayClient::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(&XRayClient::DeleteResourcePolicy, request, handler, context);
        }
 
        virtual Model::DeleteSamplingRuleOutcome DeleteSamplingRule(const Model::DeleteSamplingRuleRequest& request = {}) const;
 
        template<typename DeleteSamplingRuleRequestT = Model::DeleteSamplingRuleRequest>
        Model::DeleteSamplingRuleOutcomeCallable DeleteSamplingRuleCallable(const DeleteSamplingRuleRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::DeleteSamplingRule, request);
        }
 
        template<typename DeleteSamplingRuleRequestT = Model::DeleteSamplingRuleRequest>
        void DeleteSamplingRuleAsync(const DeleteSamplingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteSamplingRuleRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::DeleteSamplingRule, request, handler, context);
        }
 
        virtual Model::GetEncryptionConfigOutcome GetEncryptionConfig(const Model::GetEncryptionConfigRequest& request = {}) const;
 
        template<typename GetEncryptionConfigRequestT = Model::GetEncryptionConfigRequest>
        Model::GetEncryptionConfigOutcomeCallable GetEncryptionConfigCallable(const GetEncryptionConfigRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::GetEncryptionConfig, request);
        }
 
        template<typename GetEncryptionConfigRequestT = Model::GetEncryptionConfigRequest>
        void GetEncryptionConfigAsync(const GetEncryptionConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetEncryptionConfigRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::GetEncryptionConfig, request, handler, context);
        }
 
        virtual Model::GetGroupOutcome GetGroup(const Model::GetGroupRequest& request = {}) const;
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        Model::GetGroupOutcomeCallable GetGroupCallable(const GetGroupRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::GetGroup, request);
        }
 
        template<typename GetGroupRequestT = Model::GetGroupRequest>
        void GetGroupAsync(const GetGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGroupRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::GetGroup, request, handler, context);
        }
 
        virtual Model::GetGroupsOutcome GetGroups(const Model::GetGroupsRequest& request = {}) const;
 
        template<typename GetGroupsRequestT = Model::GetGroupsRequest>
        Model::GetGroupsOutcomeCallable GetGroupsCallable(const GetGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::GetGroups, request);
        }
 
        template<typename GetGroupsRequestT = Model::GetGroupsRequest>
        void GetGroupsAsync(const GetGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::GetGroups, request, handler, context);
        }
 
        virtual Model::GetIndexingRulesOutcome GetIndexingRules(const Model::GetIndexingRulesRequest& request = {}) const;
 
        template<typename GetIndexingRulesRequestT = Model::GetIndexingRulesRequest>
        Model::GetIndexingRulesOutcomeCallable GetIndexingRulesCallable(const GetIndexingRulesRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::GetIndexingRules, request);
        }
 
        template<typename GetIndexingRulesRequestT = Model::GetIndexingRulesRequest>
        void GetIndexingRulesAsync(const GetIndexingRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetIndexingRulesRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::GetIndexingRules, request, handler, context);
        }
 
        virtual Model::GetInsightOutcome GetInsight(const Model::GetInsightRequest& request) const;
 
        template<typename GetInsightRequestT = Model::GetInsightRequest>
        Model::GetInsightOutcomeCallable GetInsightCallable(const GetInsightRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetInsight, request);
        }
 
        template<typename GetInsightRequestT = Model::GetInsightRequest>
        void GetInsightAsync(const GetInsightRequestT& request, const GetInsightResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetInsight, request, handler, context);
        }
 
        virtual Model::GetInsightEventsOutcome GetInsightEvents(const Model::GetInsightEventsRequest& request) const;
 
        template<typename GetInsightEventsRequestT = Model::GetInsightEventsRequest>
        Model::GetInsightEventsOutcomeCallable GetInsightEventsCallable(const GetInsightEventsRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetInsightEvents, request);
        }
 
        template<typename GetInsightEventsRequestT = Model::GetInsightEventsRequest>
        void GetInsightEventsAsync(const GetInsightEventsRequestT& request, const GetInsightEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetInsightEvents, request, handler, context);
        }
 
        virtual Model::GetInsightImpactGraphOutcome GetInsightImpactGraph(const Model::GetInsightImpactGraphRequest& request) const;
 
        template<typename GetInsightImpactGraphRequestT = Model::GetInsightImpactGraphRequest>
        Model::GetInsightImpactGraphOutcomeCallable GetInsightImpactGraphCallable(const GetInsightImpactGraphRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetInsightImpactGraph, request);
        }
 
        template<typename GetInsightImpactGraphRequestT = Model::GetInsightImpactGraphRequest>
        void GetInsightImpactGraphAsync(const GetInsightImpactGraphRequestT& request, const GetInsightImpactGraphResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetInsightImpactGraph, request, handler, context);
        }
 
        virtual Model::GetInsightSummariesOutcome GetInsightSummaries(const Model::GetInsightSummariesRequest& request) const;
 
        template<typename GetInsightSummariesRequestT = Model::GetInsightSummariesRequest>
        Model::GetInsightSummariesOutcomeCallable GetInsightSummariesCallable(const GetInsightSummariesRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetInsightSummaries, request);
        }
 
        template<typename GetInsightSummariesRequestT = Model::GetInsightSummariesRequest>
        void GetInsightSummariesAsync(const GetInsightSummariesRequestT& request, const GetInsightSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetInsightSummaries, request, handler, context);
        }
 
        virtual Model::GetRetrievedTracesGraphOutcome GetRetrievedTracesGraph(const Model::GetRetrievedTracesGraphRequest& request) const;
 
        template<typename GetRetrievedTracesGraphRequestT = Model::GetRetrievedTracesGraphRequest>
        Model::GetRetrievedTracesGraphOutcomeCallable GetRetrievedTracesGraphCallable(const GetRetrievedTracesGraphRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetRetrievedTracesGraph, request);
        }
 
        template<typename GetRetrievedTracesGraphRequestT = Model::GetRetrievedTracesGraphRequest>
        void GetRetrievedTracesGraphAsync(const GetRetrievedTracesGraphRequestT& request, const GetRetrievedTracesGraphResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetRetrievedTracesGraph, request, handler, context);
        }
 
        virtual Model::GetSamplingRulesOutcome GetSamplingRules(const Model::GetSamplingRulesRequest& request = {}) const;
 
        template<typename GetSamplingRulesRequestT = Model::GetSamplingRulesRequest>
        Model::GetSamplingRulesOutcomeCallable GetSamplingRulesCallable(const GetSamplingRulesRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::GetSamplingRules, request);
        }
 
        template<typename GetSamplingRulesRequestT = Model::GetSamplingRulesRequest>
        void GetSamplingRulesAsync(const GetSamplingRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSamplingRulesRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::GetSamplingRules, request, handler, context);
        }
 
        virtual Model::GetSamplingStatisticSummariesOutcome GetSamplingStatisticSummaries(const Model::GetSamplingStatisticSummariesRequest& request = {}) const;
 
        template<typename GetSamplingStatisticSummariesRequestT = Model::GetSamplingStatisticSummariesRequest>
        Model::GetSamplingStatisticSummariesOutcomeCallable GetSamplingStatisticSummariesCallable(const GetSamplingStatisticSummariesRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::GetSamplingStatisticSummaries, request);
        }
 
        template<typename GetSamplingStatisticSummariesRequestT = Model::GetSamplingStatisticSummariesRequest>
        void GetSamplingStatisticSummariesAsync(const GetSamplingStatisticSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetSamplingStatisticSummariesRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::GetSamplingStatisticSummaries, request, handler, context);
        }
 
        virtual Model::GetSamplingTargetsOutcome GetSamplingTargets(const Model::GetSamplingTargetsRequest& request) const;
 
        template<typename GetSamplingTargetsRequestT = Model::GetSamplingTargetsRequest>
        Model::GetSamplingTargetsOutcomeCallable GetSamplingTargetsCallable(const GetSamplingTargetsRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetSamplingTargets, request);
        }
 
        template<typename GetSamplingTargetsRequestT = Model::GetSamplingTargetsRequest>
        void GetSamplingTargetsAsync(const GetSamplingTargetsRequestT& request, const GetSamplingTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetSamplingTargets, request, handler, context);
        }
 
        virtual Model::GetServiceGraphOutcome GetServiceGraph(const Model::GetServiceGraphRequest& request) const;
 
        template<typename GetServiceGraphRequestT = Model::GetServiceGraphRequest>
        Model::GetServiceGraphOutcomeCallable GetServiceGraphCallable(const GetServiceGraphRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetServiceGraph, request);
        }
 
        template<typename GetServiceGraphRequestT = Model::GetServiceGraphRequest>
        void GetServiceGraphAsync(const GetServiceGraphRequestT& request, const GetServiceGraphResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetServiceGraph, request, handler, context);
        }
 
        virtual Model::GetTimeSeriesServiceStatisticsOutcome GetTimeSeriesServiceStatistics(const Model::GetTimeSeriesServiceStatisticsRequest& request) const;
 
        template<typename GetTimeSeriesServiceStatisticsRequestT = Model::GetTimeSeriesServiceStatisticsRequest>
        Model::GetTimeSeriesServiceStatisticsOutcomeCallable GetTimeSeriesServiceStatisticsCallable(const GetTimeSeriesServiceStatisticsRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetTimeSeriesServiceStatistics, request);
        }
 
        template<typename GetTimeSeriesServiceStatisticsRequestT = Model::GetTimeSeriesServiceStatisticsRequest>
        void GetTimeSeriesServiceStatisticsAsync(const GetTimeSeriesServiceStatisticsRequestT& request, const GetTimeSeriesServiceStatisticsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetTimeSeriesServiceStatistics, request, handler, context);
        }
 
        virtual Model::GetTraceGraphOutcome GetTraceGraph(const Model::GetTraceGraphRequest& request) const;
 
        template<typename GetTraceGraphRequestT = Model::GetTraceGraphRequest>
        Model::GetTraceGraphOutcomeCallable GetTraceGraphCallable(const GetTraceGraphRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetTraceGraph, request);
        }
 
        template<typename GetTraceGraphRequestT = Model::GetTraceGraphRequest>
        void GetTraceGraphAsync(const GetTraceGraphRequestT& request, const GetTraceGraphResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetTraceGraph, request, handler, context);
        }
 
        virtual Model::GetTraceSegmentDestinationOutcome GetTraceSegmentDestination(const Model::GetTraceSegmentDestinationRequest& request = {}) const;
 
        template<typename GetTraceSegmentDestinationRequestT = Model::GetTraceSegmentDestinationRequest>
        Model::GetTraceSegmentDestinationOutcomeCallable GetTraceSegmentDestinationCallable(const GetTraceSegmentDestinationRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::GetTraceSegmentDestination, request);
        }
 
        template<typename GetTraceSegmentDestinationRequestT = Model::GetTraceSegmentDestinationRequest>
        void GetTraceSegmentDestinationAsync(const GetTraceSegmentDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetTraceSegmentDestinationRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::GetTraceSegmentDestination, request, handler, context);
        }
 
        virtual Model::GetTraceSummariesOutcome GetTraceSummaries(const Model::GetTraceSummariesRequest& request) const;
 
        template<typename GetTraceSummariesRequestT = Model::GetTraceSummariesRequest>
        Model::GetTraceSummariesOutcomeCallable GetTraceSummariesCallable(const GetTraceSummariesRequestT& request) const
        {
            return SubmitCallable(&XRayClient::GetTraceSummaries, request);
        }
 
        template<typename GetTraceSummariesRequestT = Model::GetTraceSummariesRequest>
        void GetTraceSummariesAsync(const GetTraceSummariesRequestT& request, const GetTraceSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::GetTraceSummaries, request, handler, context);
        }
 
        virtual Model::ListResourcePoliciesOutcome ListResourcePolicies(const Model::ListResourcePoliciesRequest& request = {}) const;
 
        template<typename ListResourcePoliciesRequestT = Model::ListResourcePoliciesRequest>
        Model::ListResourcePoliciesOutcomeCallable ListResourcePoliciesCallable(const ListResourcePoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::ListResourcePolicies, request);
        }
 
        template<typename ListResourcePoliciesRequestT = Model::ListResourcePoliciesRequest>
        void ListResourcePoliciesAsync(const ListResourcePoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourcePoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::ListResourcePolicies, request, handler, context);
        }
 
        virtual Model::ListRetrievedTracesOutcome ListRetrievedTraces(const Model::ListRetrievedTracesRequest& request) const;
 
        template<typename ListRetrievedTracesRequestT = Model::ListRetrievedTracesRequest>
        Model::ListRetrievedTracesOutcomeCallable ListRetrievedTracesCallable(const ListRetrievedTracesRequestT& request) const
        {
            return SubmitCallable(&XRayClient::ListRetrievedTraces, request);
        }
 
        template<typename ListRetrievedTracesRequestT = Model::ListRetrievedTracesRequest>
        void ListRetrievedTracesAsync(const ListRetrievedTracesRequestT& request, const ListRetrievedTracesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::ListRetrievedTraces, 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(&XRayClient::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(&XRayClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutEncryptionConfigOutcome PutEncryptionConfig(const Model::PutEncryptionConfigRequest& request) const;
 
        template<typename PutEncryptionConfigRequestT = Model::PutEncryptionConfigRequest>
        Model::PutEncryptionConfigOutcomeCallable PutEncryptionConfigCallable(const PutEncryptionConfigRequestT& request) const
        {
            return SubmitCallable(&XRayClient::PutEncryptionConfig, request);
        }
 
        template<typename PutEncryptionConfigRequestT = Model::PutEncryptionConfigRequest>
        void PutEncryptionConfigAsync(const PutEncryptionConfigRequestT& request, const PutEncryptionConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::PutEncryptionConfig, 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(&XRayClient::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(&XRayClient::PutResourcePolicy, request, handler, context);
        }
 
        virtual Model::PutTelemetryRecordsOutcome PutTelemetryRecords(const Model::PutTelemetryRecordsRequest& request) const;
 
        template<typename PutTelemetryRecordsRequestT = Model::PutTelemetryRecordsRequest>
        Model::PutTelemetryRecordsOutcomeCallable PutTelemetryRecordsCallable(const PutTelemetryRecordsRequestT& request) const
        {
            return SubmitCallable(&XRayClient::PutTelemetryRecords, request);
        }
 
        template<typename PutTelemetryRecordsRequestT = Model::PutTelemetryRecordsRequest>
        void PutTelemetryRecordsAsync(const PutTelemetryRecordsRequestT& request, const PutTelemetryRecordsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::PutTelemetryRecords, request, handler, context);
        }
 
        virtual Model::PutTraceSegmentsOutcome PutTraceSegments(const Model::PutTraceSegmentsRequest& request) const;
 
        template<typename PutTraceSegmentsRequestT = Model::PutTraceSegmentsRequest>
        Model::PutTraceSegmentsOutcomeCallable PutTraceSegmentsCallable(const PutTraceSegmentsRequestT& request) const
        {
            return SubmitCallable(&XRayClient::PutTraceSegments, request);
        }
 
        template<typename PutTraceSegmentsRequestT = Model::PutTraceSegmentsRequest>
        void PutTraceSegmentsAsync(const PutTraceSegmentsRequestT& request, const PutTraceSegmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::PutTraceSegments, request, handler, context);
        }
 
        virtual Model::StartTraceRetrievalOutcome StartTraceRetrieval(const Model::StartTraceRetrievalRequest& request) const;
 
        template<typename StartTraceRetrievalRequestT = Model::StartTraceRetrievalRequest>
        Model::StartTraceRetrievalOutcomeCallable StartTraceRetrievalCallable(const StartTraceRetrievalRequestT& request) const
        {
            return SubmitCallable(&XRayClient::StartTraceRetrieval, request);
        }
 
        template<typename StartTraceRetrievalRequestT = Model::StartTraceRetrievalRequest>
        void StartTraceRetrievalAsync(const StartTraceRetrievalRequestT& request, const StartTraceRetrievalResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::StartTraceRetrieval, 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(&XRayClient::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(&XRayClient::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(&XRayClient::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(&XRayClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateGroupOutcome UpdateGroup(const Model::UpdateGroupRequest& request = {}) const;
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        Model::UpdateGroupOutcomeCallable UpdateGroupCallable(const UpdateGroupRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::UpdateGroup, request);
        }
 
        template<typename UpdateGroupRequestT = Model::UpdateGroupRequest>
        void UpdateGroupAsync(const UpdateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateGroupRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::UpdateGroup, request, handler, context);
        }
 
        virtual Model::UpdateIndexingRuleOutcome UpdateIndexingRule(const Model::UpdateIndexingRuleRequest& request) const;
 
        template<typename UpdateIndexingRuleRequestT = Model::UpdateIndexingRuleRequest>
        Model::UpdateIndexingRuleOutcomeCallable UpdateIndexingRuleCallable(const UpdateIndexingRuleRequestT& request) const
        {
            return SubmitCallable(&XRayClient::UpdateIndexingRule, request);
        }
 
        template<typename UpdateIndexingRuleRequestT = Model::UpdateIndexingRuleRequest>
        void UpdateIndexingRuleAsync(const UpdateIndexingRuleRequestT& request, const UpdateIndexingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::UpdateIndexingRule, request, handler, context);
        }
 
        virtual Model::UpdateSamplingRuleOutcome UpdateSamplingRule(const Model::UpdateSamplingRuleRequest& request) const;
 
        template<typename UpdateSamplingRuleRequestT = Model::UpdateSamplingRuleRequest>
        Model::UpdateSamplingRuleOutcomeCallable UpdateSamplingRuleCallable(const UpdateSamplingRuleRequestT& request) const
        {
            return SubmitCallable(&XRayClient::UpdateSamplingRule, request);
        }
 
        template<typename UpdateSamplingRuleRequestT = Model::UpdateSamplingRuleRequest>
        void UpdateSamplingRuleAsync(const UpdateSamplingRuleRequestT& request, const UpdateSamplingRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&XRayClient::UpdateSamplingRule, request, handler, context);
        }
 
        virtual Model::UpdateTraceSegmentDestinationOutcome UpdateTraceSegmentDestination(const Model::UpdateTraceSegmentDestinationRequest& request = {}) const;
 
        template<typename UpdateTraceSegmentDestinationRequestT = Model::UpdateTraceSegmentDestinationRequest>
        Model::UpdateTraceSegmentDestinationOutcomeCallable UpdateTraceSegmentDestinationCallable(const UpdateTraceSegmentDestinationRequestT& request = {}) const
        {
            return SubmitCallable(&XRayClient::UpdateTraceSegmentDestination, request);
        }
 
        template<typename UpdateTraceSegmentDestinationRequestT = Model::UpdateTraceSegmentDestinationRequest>
        void UpdateTraceSegmentDestinationAsync(const UpdateTraceSegmentDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateTraceSegmentDestinationRequestT& request = {}) const
        {
            return SubmitAsync(&XRayClient::UpdateTraceSegmentDestination, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<XRayEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<XRayClient>;
      void init(const XRayClientConfiguration& clientConfiguration);
 
      XRayClientConfiguration m_clientConfiguration;
      std::shared_ptr<XRayEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace XRay
} // namespace Aws