CloudWatchEvidentlyClient.h

 
#pragma once
#include <aws/evidently/CloudWatchEvidently_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/evidently/CloudWatchEvidentlyServiceClientModel.h>
 
namespace Aws
{
namespace CloudWatchEvidently
{
  class AWS_CLOUDWATCHEVIDENTLY_API CloudWatchEvidentlyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchEvidentlyClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CloudWatchEvidentlyClientConfiguration ClientConfigurationType;
      typedef CloudWatchEvidentlyEndpointProvider EndpointProviderType;
 
        CloudWatchEvidentlyClient(const Aws::CloudWatchEvidently::CloudWatchEvidentlyClientConfiguration& clientConfiguration = Aws::CloudWatchEvidently::CloudWatchEvidentlyClientConfiguration(),
                                  std::shared_ptr<CloudWatchEvidentlyEndpointProviderBase> endpointProvider = nullptr);
 
        CloudWatchEvidentlyClient(const Aws::Auth::AWSCredentials& credentials,
                                  std::shared_ptr<CloudWatchEvidentlyEndpointProviderBase> endpointProvider = nullptr,
                                  const Aws::CloudWatchEvidently::CloudWatchEvidentlyClientConfiguration& clientConfiguration = Aws::CloudWatchEvidently::CloudWatchEvidentlyClientConfiguration());
 
        CloudWatchEvidentlyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                  std::shared_ptr<CloudWatchEvidentlyEndpointProviderBase> endpointProvider = nullptr,
                                  const Aws::CloudWatchEvidently::CloudWatchEvidentlyClientConfiguration& clientConfiguration = Aws::CloudWatchEvidently::CloudWatchEvidentlyClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CloudWatchEvidentlyClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CloudWatchEvidentlyClient(const Aws::Auth::AWSCredentials& credentials,
                                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CloudWatchEvidentlyClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CloudWatchEvidentlyClient();
 
        virtual Model::BatchEvaluateFeatureOutcome BatchEvaluateFeature(const Model::BatchEvaluateFeatureRequest& request) const;
 
        template<typename BatchEvaluateFeatureRequestT = Model::BatchEvaluateFeatureRequest>
        Model::BatchEvaluateFeatureOutcomeCallable BatchEvaluateFeatureCallable(const BatchEvaluateFeatureRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::BatchEvaluateFeature, request);
        }
 
        template<typename BatchEvaluateFeatureRequestT = Model::BatchEvaluateFeatureRequest>
        void BatchEvaluateFeatureAsync(const BatchEvaluateFeatureRequestT& request, const BatchEvaluateFeatureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::BatchEvaluateFeature, request, handler, context);
        }
 
        virtual Model::CreateExperimentOutcome CreateExperiment(const Model::CreateExperimentRequest& request) const;
 
        template<typename CreateExperimentRequestT = Model::CreateExperimentRequest>
        Model::CreateExperimentOutcomeCallable CreateExperimentCallable(const CreateExperimentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::CreateExperiment, request);
        }
 
        template<typename CreateExperimentRequestT = Model::CreateExperimentRequest>
        void CreateExperimentAsync(const CreateExperimentRequestT& request, const CreateExperimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::CreateExperiment, request, handler, context);
        }
 
        virtual Model::CreateFeatureOutcome CreateFeature(const Model::CreateFeatureRequest& request) const;
 
        template<typename CreateFeatureRequestT = Model::CreateFeatureRequest>
        Model::CreateFeatureOutcomeCallable CreateFeatureCallable(const CreateFeatureRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::CreateFeature, request);
        }
 
        template<typename CreateFeatureRequestT = Model::CreateFeatureRequest>
        void CreateFeatureAsync(const CreateFeatureRequestT& request, const CreateFeatureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::CreateFeature, request, handler, context);
        }
 
        virtual Model::CreateLaunchOutcome CreateLaunch(const Model::CreateLaunchRequest& request) const;
 
        template<typename CreateLaunchRequestT = Model::CreateLaunchRequest>
        Model::CreateLaunchOutcomeCallable CreateLaunchCallable(const CreateLaunchRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::CreateLaunch, request);
        }
 
        template<typename CreateLaunchRequestT = Model::CreateLaunchRequest>
        void CreateLaunchAsync(const CreateLaunchRequestT& request, const CreateLaunchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::CreateLaunch, request, handler, context);
        }
 
        virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::CreateProject, request);
        }
 
        template<typename CreateProjectRequestT = Model::CreateProjectRequest>
        void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::CreateProject, request, handler, context);
        }
 
        virtual Model::CreateSegmentOutcome CreateSegment(const Model::CreateSegmentRequest& request) const;
 
        template<typename CreateSegmentRequestT = Model::CreateSegmentRequest>
        Model::CreateSegmentOutcomeCallable CreateSegmentCallable(const CreateSegmentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::CreateSegment, request);
        }
 
        template<typename CreateSegmentRequestT = Model::CreateSegmentRequest>
        void CreateSegmentAsync(const CreateSegmentRequestT& request, const CreateSegmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::CreateSegment, request, handler, context);
        }
 
        virtual Model::DeleteExperimentOutcome DeleteExperiment(const Model::DeleteExperimentRequest& request) const;
 
        template<typename DeleteExperimentRequestT = Model::DeleteExperimentRequest>
        Model::DeleteExperimentOutcomeCallable DeleteExperimentCallable(const DeleteExperimentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::DeleteExperiment, request);
        }
 
        template<typename DeleteExperimentRequestT = Model::DeleteExperimentRequest>
        void DeleteExperimentAsync(const DeleteExperimentRequestT& request, const DeleteExperimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::DeleteExperiment, request, handler, context);
        }
 
        virtual Model::DeleteFeatureOutcome DeleteFeature(const Model::DeleteFeatureRequest& request) const;
 
        template<typename DeleteFeatureRequestT = Model::DeleteFeatureRequest>
        Model::DeleteFeatureOutcomeCallable DeleteFeatureCallable(const DeleteFeatureRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::DeleteFeature, request);
        }
 
        template<typename DeleteFeatureRequestT = Model::DeleteFeatureRequest>
        void DeleteFeatureAsync(const DeleteFeatureRequestT& request, const DeleteFeatureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::DeleteFeature, request, handler, context);
        }
 
        virtual Model::DeleteLaunchOutcome DeleteLaunch(const Model::DeleteLaunchRequest& request) const;
 
        template<typename DeleteLaunchRequestT = Model::DeleteLaunchRequest>
        Model::DeleteLaunchOutcomeCallable DeleteLaunchCallable(const DeleteLaunchRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::DeleteLaunch, request);
        }
 
        template<typename DeleteLaunchRequestT = Model::DeleteLaunchRequest>
        void DeleteLaunchAsync(const DeleteLaunchRequestT& request, const DeleteLaunchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::DeleteLaunch, request, handler, context);
        }
 
        virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::DeleteProject, request);
        }
 
        template<typename DeleteProjectRequestT = Model::DeleteProjectRequest>
        void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::DeleteProject, request, handler, context);
        }
 
        virtual Model::DeleteSegmentOutcome DeleteSegment(const Model::DeleteSegmentRequest& request) const;
 
        template<typename DeleteSegmentRequestT = Model::DeleteSegmentRequest>
        Model::DeleteSegmentOutcomeCallable DeleteSegmentCallable(const DeleteSegmentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::DeleteSegment, request);
        }
 
        template<typename DeleteSegmentRequestT = Model::DeleteSegmentRequest>
        void DeleteSegmentAsync(const DeleteSegmentRequestT& request, const DeleteSegmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::DeleteSegment, request, handler, context);
        }
 
        virtual Model::EvaluateFeatureOutcome EvaluateFeature(const Model::EvaluateFeatureRequest& request) const;
 
        template<typename EvaluateFeatureRequestT = Model::EvaluateFeatureRequest>
        Model::EvaluateFeatureOutcomeCallable EvaluateFeatureCallable(const EvaluateFeatureRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::EvaluateFeature, request);
        }
 
        template<typename EvaluateFeatureRequestT = Model::EvaluateFeatureRequest>
        void EvaluateFeatureAsync(const EvaluateFeatureRequestT& request, const EvaluateFeatureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::EvaluateFeature, request, handler, context);
        }
 
        virtual Model::GetExperimentOutcome GetExperiment(const Model::GetExperimentRequest& request) const;
 
        template<typename GetExperimentRequestT = Model::GetExperimentRequest>
        Model::GetExperimentOutcomeCallable GetExperimentCallable(const GetExperimentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::GetExperiment, request);
        }
 
        template<typename GetExperimentRequestT = Model::GetExperimentRequest>
        void GetExperimentAsync(const GetExperimentRequestT& request, const GetExperimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::GetExperiment, request, handler, context);
        }
 
        virtual Model::GetExperimentResultsOutcome GetExperimentResults(const Model::GetExperimentResultsRequest& request) const;
 
        template<typename GetExperimentResultsRequestT = Model::GetExperimentResultsRequest>
        Model::GetExperimentResultsOutcomeCallable GetExperimentResultsCallable(const GetExperimentResultsRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::GetExperimentResults, request);
        }
 
        template<typename GetExperimentResultsRequestT = Model::GetExperimentResultsRequest>
        void GetExperimentResultsAsync(const GetExperimentResultsRequestT& request, const GetExperimentResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::GetExperimentResults, request, handler, context);
        }
 
        virtual Model::GetFeatureOutcome GetFeature(const Model::GetFeatureRequest& request) const;
 
        template<typename GetFeatureRequestT = Model::GetFeatureRequest>
        Model::GetFeatureOutcomeCallable GetFeatureCallable(const GetFeatureRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::GetFeature, request);
        }
 
        template<typename GetFeatureRequestT = Model::GetFeatureRequest>
        void GetFeatureAsync(const GetFeatureRequestT& request, const GetFeatureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::GetFeature, request, handler, context);
        }
 
        virtual Model::GetLaunchOutcome GetLaunch(const Model::GetLaunchRequest& request) const;
 
        template<typename GetLaunchRequestT = Model::GetLaunchRequest>
        Model::GetLaunchOutcomeCallable GetLaunchCallable(const GetLaunchRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::GetLaunch, request);
        }
 
        template<typename GetLaunchRequestT = Model::GetLaunchRequest>
        void GetLaunchAsync(const GetLaunchRequestT& request, const GetLaunchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::GetLaunch, request, handler, context);
        }
 
        virtual Model::GetProjectOutcome GetProject(const Model::GetProjectRequest& request) const;
 
        template<typename GetProjectRequestT = Model::GetProjectRequest>
        Model::GetProjectOutcomeCallable GetProjectCallable(const GetProjectRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::GetProject, request);
        }
 
        template<typename GetProjectRequestT = Model::GetProjectRequest>
        void GetProjectAsync(const GetProjectRequestT& request, const GetProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::GetProject, request, handler, context);
        }
 
        virtual Model::GetSegmentOutcome GetSegment(const Model::GetSegmentRequest& request) const;
 
        template<typename GetSegmentRequestT = Model::GetSegmentRequest>
        Model::GetSegmentOutcomeCallable GetSegmentCallable(const GetSegmentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::GetSegment, request);
        }
 
        template<typename GetSegmentRequestT = Model::GetSegmentRequest>
        void GetSegmentAsync(const GetSegmentRequestT& request, const GetSegmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::GetSegment, request, handler, context);
        }
 
        virtual Model::ListExperimentsOutcome ListExperiments(const Model::ListExperimentsRequest& request) const;
 
        template<typename ListExperimentsRequestT = Model::ListExperimentsRequest>
        Model::ListExperimentsOutcomeCallable ListExperimentsCallable(const ListExperimentsRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::ListExperiments, request);
        }
 
        template<typename ListExperimentsRequestT = Model::ListExperimentsRequest>
        void ListExperimentsAsync(const ListExperimentsRequestT& request, const ListExperimentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::ListExperiments, request, handler, context);
        }
 
        virtual Model::ListFeaturesOutcome ListFeatures(const Model::ListFeaturesRequest& request) const;
 
        template<typename ListFeaturesRequestT = Model::ListFeaturesRequest>
        Model::ListFeaturesOutcomeCallable ListFeaturesCallable(const ListFeaturesRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::ListFeatures, request);
        }
 
        template<typename ListFeaturesRequestT = Model::ListFeaturesRequest>
        void ListFeaturesAsync(const ListFeaturesRequestT& request, const ListFeaturesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::ListFeatures, request, handler, context);
        }
 
        virtual Model::ListLaunchesOutcome ListLaunches(const Model::ListLaunchesRequest& request) const;
 
        template<typename ListLaunchesRequestT = Model::ListLaunchesRequest>
        Model::ListLaunchesOutcomeCallable ListLaunchesCallable(const ListLaunchesRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::ListLaunches, request);
        }
 
        template<typename ListLaunchesRequestT = Model::ListLaunchesRequest>
        void ListLaunchesAsync(const ListLaunchesRequestT& request, const ListLaunchesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::ListLaunches, request, handler, context);
        }
 
        virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request = {}) const;
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::ListProjects, request);
        }
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        void ListProjectsAsync(const ListProjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListProjectsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::ListProjects, request, handler, context);
        }
 
        virtual Model::ListSegmentReferencesOutcome ListSegmentReferences(const Model::ListSegmentReferencesRequest& request) const;
 
        template<typename ListSegmentReferencesRequestT = Model::ListSegmentReferencesRequest>
        Model::ListSegmentReferencesOutcomeCallable ListSegmentReferencesCallable(const ListSegmentReferencesRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::ListSegmentReferences, request);
        }
 
        template<typename ListSegmentReferencesRequestT = Model::ListSegmentReferencesRequest>
        void ListSegmentReferencesAsync(const ListSegmentReferencesRequestT& request, const ListSegmentReferencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::ListSegmentReferences, request, handler, context);
        }
 
        virtual Model::ListSegmentsOutcome ListSegments(const Model::ListSegmentsRequest& request = {}) const;
 
        template<typename ListSegmentsRequestT = Model::ListSegmentsRequest>
        Model::ListSegmentsOutcomeCallable ListSegmentsCallable(const ListSegmentsRequestT& request = {}) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::ListSegments, request);
        }
 
        template<typename ListSegmentsRequestT = Model::ListSegmentsRequest>
        void ListSegmentsAsync(const ListSegmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSegmentsRequestT& request = {}) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::ListSegments, 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(&CloudWatchEvidentlyClient::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(&CloudWatchEvidentlyClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutProjectEventsOutcome PutProjectEvents(const Model::PutProjectEventsRequest& request) const;
 
        template<typename PutProjectEventsRequestT = Model::PutProjectEventsRequest>
        Model::PutProjectEventsOutcomeCallable PutProjectEventsCallable(const PutProjectEventsRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::PutProjectEvents, request);
        }
 
        template<typename PutProjectEventsRequestT = Model::PutProjectEventsRequest>
        void PutProjectEventsAsync(const PutProjectEventsRequestT& request, const PutProjectEventsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::PutProjectEvents, request, handler, context);
        }
 
        virtual Model::StartExperimentOutcome StartExperiment(const Model::StartExperimentRequest& request) const;
 
        template<typename StartExperimentRequestT = Model::StartExperimentRequest>
        Model::StartExperimentOutcomeCallable StartExperimentCallable(const StartExperimentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::StartExperiment, request);
        }
 
        template<typename StartExperimentRequestT = Model::StartExperimentRequest>
        void StartExperimentAsync(const StartExperimentRequestT& request, const StartExperimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::StartExperiment, request, handler, context);
        }
 
        virtual Model::StartLaunchOutcome StartLaunch(const Model::StartLaunchRequest& request) const;
 
        template<typename StartLaunchRequestT = Model::StartLaunchRequest>
        Model::StartLaunchOutcomeCallable StartLaunchCallable(const StartLaunchRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::StartLaunch, request);
        }
 
        template<typename StartLaunchRequestT = Model::StartLaunchRequest>
        void StartLaunchAsync(const StartLaunchRequestT& request, const StartLaunchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::StartLaunch, request, handler, context);
        }
 
        virtual Model::StopExperimentOutcome StopExperiment(const Model::StopExperimentRequest& request) const;
 
        template<typename StopExperimentRequestT = Model::StopExperimentRequest>
        Model::StopExperimentOutcomeCallable StopExperimentCallable(const StopExperimentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::StopExperiment, request);
        }
 
        template<typename StopExperimentRequestT = Model::StopExperimentRequest>
        void StopExperimentAsync(const StopExperimentRequestT& request, const StopExperimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::StopExperiment, request, handler, context);
        }
 
        virtual Model::StopLaunchOutcome StopLaunch(const Model::StopLaunchRequest& request) const;
 
        template<typename StopLaunchRequestT = Model::StopLaunchRequest>
        Model::StopLaunchOutcomeCallable StopLaunchCallable(const StopLaunchRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::StopLaunch, request);
        }
 
        template<typename StopLaunchRequestT = Model::StopLaunchRequest>
        void StopLaunchAsync(const StopLaunchRequestT& request, const StopLaunchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::StopLaunch, 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(&CloudWatchEvidentlyClient::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(&CloudWatchEvidentlyClient::TagResource, request, handler, context);
        }
 
        virtual Model::TestSegmentPatternOutcome TestSegmentPattern(const Model::TestSegmentPatternRequest& request) const;
 
        template<typename TestSegmentPatternRequestT = Model::TestSegmentPatternRequest>
        Model::TestSegmentPatternOutcomeCallable TestSegmentPatternCallable(const TestSegmentPatternRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::TestSegmentPattern, request);
        }
 
        template<typename TestSegmentPatternRequestT = Model::TestSegmentPatternRequest>
        void TestSegmentPatternAsync(const TestSegmentPatternRequestT& request, const TestSegmentPatternResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::TestSegmentPattern, 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(&CloudWatchEvidentlyClient::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(&CloudWatchEvidentlyClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateExperimentOutcome UpdateExperiment(const Model::UpdateExperimentRequest& request) const;
 
        template<typename UpdateExperimentRequestT = Model::UpdateExperimentRequest>
        Model::UpdateExperimentOutcomeCallable UpdateExperimentCallable(const UpdateExperimentRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::UpdateExperiment, request);
        }
 
        template<typename UpdateExperimentRequestT = Model::UpdateExperimentRequest>
        void UpdateExperimentAsync(const UpdateExperimentRequestT& request, const UpdateExperimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::UpdateExperiment, request, handler, context);
        }
 
        virtual Model::UpdateFeatureOutcome UpdateFeature(const Model::UpdateFeatureRequest& request) const;
 
        template<typename UpdateFeatureRequestT = Model::UpdateFeatureRequest>
        Model::UpdateFeatureOutcomeCallable UpdateFeatureCallable(const UpdateFeatureRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::UpdateFeature, request);
        }
 
        template<typename UpdateFeatureRequestT = Model::UpdateFeatureRequest>
        void UpdateFeatureAsync(const UpdateFeatureRequestT& request, const UpdateFeatureResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::UpdateFeature, request, handler, context);
        }
 
        virtual Model::UpdateLaunchOutcome UpdateLaunch(const Model::UpdateLaunchRequest& request) const;
 
        template<typename UpdateLaunchRequestT = Model::UpdateLaunchRequest>
        Model::UpdateLaunchOutcomeCallable UpdateLaunchCallable(const UpdateLaunchRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::UpdateLaunch, request);
        }
 
        template<typename UpdateLaunchRequestT = Model::UpdateLaunchRequest>
        void UpdateLaunchAsync(const UpdateLaunchRequestT& request, const UpdateLaunchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::UpdateLaunch, request, handler, context);
        }
 
        virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::UpdateProject, request);
        }
 
        template<typename UpdateProjectRequestT = Model::UpdateProjectRequest>
        void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::UpdateProject, request, handler, context);
        }
 
        virtual Model::UpdateProjectDataDeliveryOutcome UpdateProjectDataDelivery(const Model::UpdateProjectDataDeliveryRequest& request) const;
 
        template<typename UpdateProjectDataDeliveryRequestT = Model::UpdateProjectDataDeliveryRequest>
        Model::UpdateProjectDataDeliveryOutcomeCallable UpdateProjectDataDeliveryCallable(const UpdateProjectDataDeliveryRequestT& request) const
        {
            return SubmitCallable(&CloudWatchEvidentlyClient::UpdateProjectDataDelivery, request);
        }
 
        template<typename UpdateProjectDataDeliveryRequestT = Model::UpdateProjectDataDeliveryRequest>
        void UpdateProjectDataDeliveryAsync(const UpdateProjectDataDeliveryRequestT& request, const UpdateProjectDataDeliveryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CloudWatchEvidentlyClient::UpdateProjectDataDelivery, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CloudWatchEvidentlyEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudWatchEvidentlyClient>;
      void init(const CloudWatchEvidentlyClientConfiguration& clientConfiguration);
 
      CloudWatchEvidentlyClientConfiguration m_clientConfiguration;
      std::shared_ptr<CloudWatchEvidentlyEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CloudWatchEvidently
} // namespace Aws