XRayClient.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/xray/XRayPaginationBase.h>
#include <aws/xray/XRayServiceClientModel.h>
#include <aws/xray/XRayWaiter.h>
#include <aws/xray/XRay_EXPORTS.h>
 
namespace Aws {
namespace XRay {
class AWS_XRAY_API XRayClient : public Aws::Client::AWSJsonClient,
                                public Aws::Client::ClientWithAsyncTemplateMethods<XRayClient>,
                                public XRayPaginationBase<XRayClient>,
                                public XRayWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<XRayEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<XRayClient>;
  void init(const XRayClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, XRayError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  XRayClientConfiguration m_clientConfiguration;
  std::shared_ptr<XRayEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace XRay
}  // namespace Aws