CodePipelineClient.h

 
#pragma once
#include <aws/codepipeline/CodePipeline_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/codepipeline/CodePipelineServiceClientModel.h>
 
namespace Aws
{
namespace CodePipeline
{
  class AWS_CODEPIPELINE_API CodePipelineClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CodePipelineClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CodePipelineClientConfiguration ClientConfigurationType;
      typedef CodePipelineEndpointProvider EndpointProviderType;
 
        CodePipelineClient(const Aws::CodePipeline::CodePipelineClientConfiguration& clientConfiguration = Aws::CodePipeline::CodePipelineClientConfiguration(),
                           std::shared_ptr<CodePipelineEndpointProviderBase> endpointProvider = nullptr);
 
        CodePipelineClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<CodePipelineEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::CodePipeline::CodePipelineClientConfiguration& clientConfiguration = Aws::CodePipeline::CodePipelineClientConfiguration());
 
        CodePipelineClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<CodePipelineEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::CodePipeline::CodePipelineClientConfiguration& clientConfiguration = Aws::CodePipeline::CodePipelineClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CodePipelineClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodePipelineClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodePipelineClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CodePipelineClient();
 
        virtual Model::AcknowledgeJobOutcome AcknowledgeJob(const Model::AcknowledgeJobRequest& request) const;
 
        template<typename AcknowledgeJobRequestT = Model::AcknowledgeJobRequest>
        Model::AcknowledgeJobOutcomeCallable AcknowledgeJobCallable(const AcknowledgeJobRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::AcknowledgeJob, request);
        }
 
        template<typename AcknowledgeJobRequestT = Model::AcknowledgeJobRequest>
        void AcknowledgeJobAsync(const AcknowledgeJobRequestT& request, const AcknowledgeJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::AcknowledgeJob, request, handler, context);
        }
 
        virtual Model::AcknowledgeThirdPartyJobOutcome AcknowledgeThirdPartyJob(const Model::AcknowledgeThirdPartyJobRequest& request) const;
 
        template<typename AcknowledgeThirdPartyJobRequestT = Model::AcknowledgeThirdPartyJobRequest>
        Model::AcknowledgeThirdPartyJobOutcomeCallable AcknowledgeThirdPartyJobCallable(const AcknowledgeThirdPartyJobRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::AcknowledgeThirdPartyJob, request);
        }
 
        template<typename AcknowledgeThirdPartyJobRequestT = Model::AcknowledgeThirdPartyJobRequest>
        void AcknowledgeThirdPartyJobAsync(const AcknowledgeThirdPartyJobRequestT& request, const AcknowledgeThirdPartyJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::AcknowledgeThirdPartyJob, request, handler, context);
        }
 
        virtual Model::CreateCustomActionTypeOutcome CreateCustomActionType(const Model::CreateCustomActionTypeRequest& request) const;
 
        template<typename CreateCustomActionTypeRequestT = Model::CreateCustomActionTypeRequest>
        Model::CreateCustomActionTypeOutcomeCallable CreateCustomActionTypeCallable(const CreateCustomActionTypeRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::CreateCustomActionType, request);
        }
 
        template<typename CreateCustomActionTypeRequestT = Model::CreateCustomActionTypeRequest>
        void CreateCustomActionTypeAsync(const CreateCustomActionTypeRequestT& request, const CreateCustomActionTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::CreateCustomActionType, request, handler, context);
        }
 
        virtual Model::CreatePipelineOutcome CreatePipeline(const Model::CreatePipelineRequest& request) const;
 
        template<typename CreatePipelineRequestT = Model::CreatePipelineRequest>
        Model::CreatePipelineOutcomeCallable CreatePipelineCallable(const CreatePipelineRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::CreatePipeline, request);
        }
 
        template<typename CreatePipelineRequestT = Model::CreatePipelineRequest>
        void CreatePipelineAsync(const CreatePipelineRequestT& request, const CreatePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::CreatePipeline, request, handler, context);
        }
 
        virtual Model::DeleteCustomActionTypeOutcome DeleteCustomActionType(const Model::DeleteCustomActionTypeRequest& request) const;
 
        template<typename DeleteCustomActionTypeRequestT = Model::DeleteCustomActionTypeRequest>
        Model::DeleteCustomActionTypeOutcomeCallable DeleteCustomActionTypeCallable(const DeleteCustomActionTypeRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::DeleteCustomActionType, request);
        }
 
        template<typename DeleteCustomActionTypeRequestT = Model::DeleteCustomActionTypeRequest>
        void DeleteCustomActionTypeAsync(const DeleteCustomActionTypeRequestT& request, const DeleteCustomActionTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::DeleteCustomActionType, request, handler, context);
        }
 
        virtual Model::DeletePipelineOutcome DeletePipeline(const Model::DeletePipelineRequest& request) const;
 
        template<typename DeletePipelineRequestT = Model::DeletePipelineRequest>
        Model::DeletePipelineOutcomeCallable DeletePipelineCallable(const DeletePipelineRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::DeletePipeline, request);
        }
 
        template<typename DeletePipelineRequestT = Model::DeletePipelineRequest>
        void DeletePipelineAsync(const DeletePipelineRequestT& request, const DeletePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::DeletePipeline, request, handler, context);
        }
 
        virtual Model::DeleteWebhookOutcome DeleteWebhook(const Model::DeleteWebhookRequest& request) const;
 
        template<typename DeleteWebhookRequestT = Model::DeleteWebhookRequest>
        Model::DeleteWebhookOutcomeCallable DeleteWebhookCallable(const DeleteWebhookRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::DeleteWebhook, request);
        }
 
        template<typename DeleteWebhookRequestT = Model::DeleteWebhookRequest>
        void DeleteWebhookAsync(const DeleteWebhookRequestT& request, const DeleteWebhookResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::DeleteWebhook, request, handler, context);
        }
 
        virtual Model::DeregisterWebhookWithThirdPartyOutcome DeregisterWebhookWithThirdParty(const Model::DeregisterWebhookWithThirdPartyRequest& request = {}) const;
 
        template<typename DeregisterWebhookWithThirdPartyRequestT = Model::DeregisterWebhookWithThirdPartyRequest>
        Model::DeregisterWebhookWithThirdPartyOutcomeCallable DeregisterWebhookWithThirdPartyCallable(const DeregisterWebhookWithThirdPartyRequestT& request = {}) const
        {
            return SubmitCallable(&CodePipelineClient::DeregisterWebhookWithThirdParty, request);
        }
 
        template<typename DeregisterWebhookWithThirdPartyRequestT = Model::DeregisterWebhookWithThirdPartyRequest>
        void DeregisterWebhookWithThirdPartyAsync(const DeregisterWebhookWithThirdPartyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeregisterWebhookWithThirdPartyRequestT& request = {}) const
        {
            return SubmitAsync(&CodePipelineClient::DeregisterWebhookWithThirdParty, request, handler, context);
        }
 
        virtual Model::DisableStageTransitionOutcome DisableStageTransition(const Model::DisableStageTransitionRequest& request) const;
 
        template<typename DisableStageTransitionRequestT = Model::DisableStageTransitionRequest>
        Model::DisableStageTransitionOutcomeCallable DisableStageTransitionCallable(const DisableStageTransitionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::DisableStageTransition, request);
        }
 
        template<typename DisableStageTransitionRequestT = Model::DisableStageTransitionRequest>
        void DisableStageTransitionAsync(const DisableStageTransitionRequestT& request, const DisableStageTransitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::DisableStageTransition, request, handler, context);
        }
 
        virtual Model::EnableStageTransitionOutcome EnableStageTransition(const Model::EnableStageTransitionRequest& request) const;
 
        template<typename EnableStageTransitionRequestT = Model::EnableStageTransitionRequest>
        Model::EnableStageTransitionOutcomeCallable EnableStageTransitionCallable(const EnableStageTransitionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::EnableStageTransition, request);
        }
 
        template<typename EnableStageTransitionRequestT = Model::EnableStageTransitionRequest>
        void EnableStageTransitionAsync(const EnableStageTransitionRequestT& request, const EnableStageTransitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::EnableStageTransition, request, handler, context);
        }
 
        virtual Model::GetActionTypeOutcome GetActionType(const Model::GetActionTypeRequest& request) const;
 
        template<typename GetActionTypeRequestT = Model::GetActionTypeRequest>
        Model::GetActionTypeOutcomeCallable GetActionTypeCallable(const GetActionTypeRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::GetActionType, request);
        }
 
        template<typename GetActionTypeRequestT = Model::GetActionTypeRequest>
        void GetActionTypeAsync(const GetActionTypeRequestT& request, const GetActionTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::GetActionType, request, handler, context);
        }
 
        virtual Model::GetJobDetailsOutcome GetJobDetails(const Model::GetJobDetailsRequest& request) const;
 
        template<typename GetJobDetailsRequestT = Model::GetJobDetailsRequest>
        Model::GetJobDetailsOutcomeCallable GetJobDetailsCallable(const GetJobDetailsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::GetJobDetails, request);
        }
 
        template<typename GetJobDetailsRequestT = Model::GetJobDetailsRequest>
        void GetJobDetailsAsync(const GetJobDetailsRequestT& request, const GetJobDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::GetJobDetails, request, handler, context);
        }
 
        virtual Model::GetPipelineOutcome GetPipeline(const Model::GetPipelineRequest& request) const;
 
        template<typename GetPipelineRequestT = Model::GetPipelineRequest>
        Model::GetPipelineOutcomeCallable GetPipelineCallable(const GetPipelineRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::GetPipeline, request);
        }
 
        template<typename GetPipelineRequestT = Model::GetPipelineRequest>
        void GetPipelineAsync(const GetPipelineRequestT& request, const GetPipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::GetPipeline, request, handler, context);
        }
 
        virtual Model::GetPipelineExecutionOutcome GetPipelineExecution(const Model::GetPipelineExecutionRequest& request) const;
 
        template<typename GetPipelineExecutionRequestT = Model::GetPipelineExecutionRequest>
        Model::GetPipelineExecutionOutcomeCallable GetPipelineExecutionCallable(const GetPipelineExecutionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::GetPipelineExecution, request);
        }
 
        template<typename GetPipelineExecutionRequestT = Model::GetPipelineExecutionRequest>
        void GetPipelineExecutionAsync(const GetPipelineExecutionRequestT& request, const GetPipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::GetPipelineExecution, request, handler, context);
        }
 
        virtual Model::GetPipelineStateOutcome GetPipelineState(const Model::GetPipelineStateRequest& request) const;
 
        template<typename GetPipelineStateRequestT = Model::GetPipelineStateRequest>
        Model::GetPipelineStateOutcomeCallable GetPipelineStateCallable(const GetPipelineStateRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::GetPipelineState, request);
        }
 
        template<typename GetPipelineStateRequestT = Model::GetPipelineStateRequest>
        void GetPipelineStateAsync(const GetPipelineStateRequestT& request, const GetPipelineStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::GetPipelineState, request, handler, context);
        }
 
        virtual Model::GetThirdPartyJobDetailsOutcome GetThirdPartyJobDetails(const Model::GetThirdPartyJobDetailsRequest& request) const;
 
        template<typename GetThirdPartyJobDetailsRequestT = Model::GetThirdPartyJobDetailsRequest>
        Model::GetThirdPartyJobDetailsOutcomeCallable GetThirdPartyJobDetailsCallable(const GetThirdPartyJobDetailsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::GetThirdPartyJobDetails, request);
        }
 
        template<typename GetThirdPartyJobDetailsRequestT = Model::GetThirdPartyJobDetailsRequest>
        void GetThirdPartyJobDetailsAsync(const GetThirdPartyJobDetailsRequestT& request, const GetThirdPartyJobDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::GetThirdPartyJobDetails, request, handler, context);
        }
 
        virtual Model::ListActionExecutionsOutcome ListActionExecutions(const Model::ListActionExecutionsRequest& request) const;
 
        template<typename ListActionExecutionsRequestT = Model::ListActionExecutionsRequest>
        Model::ListActionExecutionsOutcomeCallable ListActionExecutionsCallable(const ListActionExecutionsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::ListActionExecutions, request);
        }
 
        template<typename ListActionExecutionsRequestT = Model::ListActionExecutionsRequest>
        void ListActionExecutionsAsync(const ListActionExecutionsRequestT& request, const ListActionExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::ListActionExecutions, request, handler, context);
        }
 
        virtual Model::ListActionTypesOutcome ListActionTypes(const Model::ListActionTypesRequest& request = {}) const;
 
        template<typename ListActionTypesRequestT = Model::ListActionTypesRequest>
        Model::ListActionTypesOutcomeCallable ListActionTypesCallable(const ListActionTypesRequestT& request = {}) const
        {
            return SubmitCallable(&CodePipelineClient::ListActionTypes, request);
        }
 
        template<typename ListActionTypesRequestT = Model::ListActionTypesRequest>
        void ListActionTypesAsync(const ListActionTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListActionTypesRequestT& request = {}) const
        {
            return SubmitAsync(&CodePipelineClient::ListActionTypes, request, handler, context);
        }
 
        virtual Model::ListDeployActionExecutionTargetsOutcome ListDeployActionExecutionTargets(const Model::ListDeployActionExecutionTargetsRequest& request) const;
 
        template<typename ListDeployActionExecutionTargetsRequestT = Model::ListDeployActionExecutionTargetsRequest>
        Model::ListDeployActionExecutionTargetsOutcomeCallable ListDeployActionExecutionTargetsCallable(const ListDeployActionExecutionTargetsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::ListDeployActionExecutionTargets, request);
        }
 
        template<typename ListDeployActionExecutionTargetsRequestT = Model::ListDeployActionExecutionTargetsRequest>
        void ListDeployActionExecutionTargetsAsync(const ListDeployActionExecutionTargetsRequestT& request, const ListDeployActionExecutionTargetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::ListDeployActionExecutionTargets, request, handler, context);
        }
 
        virtual Model::ListPipelineExecutionsOutcome ListPipelineExecutions(const Model::ListPipelineExecutionsRequest& request) const;
 
        template<typename ListPipelineExecutionsRequestT = Model::ListPipelineExecutionsRequest>
        Model::ListPipelineExecutionsOutcomeCallable ListPipelineExecutionsCallable(const ListPipelineExecutionsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::ListPipelineExecutions, request);
        }
 
        template<typename ListPipelineExecutionsRequestT = Model::ListPipelineExecutionsRequest>
        void ListPipelineExecutionsAsync(const ListPipelineExecutionsRequestT& request, const ListPipelineExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::ListPipelineExecutions, request, handler, context);
        }
 
        virtual Model::ListPipelinesOutcome ListPipelines(const Model::ListPipelinesRequest& request = {}) const;
 
        template<typename ListPipelinesRequestT = Model::ListPipelinesRequest>
        Model::ListPipelinesOutcomeCallable ListPipelinesCallable(const ListPipelinesRequestT& request = {}) const
        {
            return SubmitCallable(&CodePipelineClient::ListPipelines, request);
        }
 
        template<typename ListPipelinesRequestT = Model::ListPipelinesRequest>
        void ListPipelinesAsync(const ListPipelinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPipelinesRequestT& request = {}) const
        {
            return SubmitAsync(&CodePipelineClient::ListPipelines, request, handler, context);
        }
 
        virtual Model::ListRuleExecutionsOutcome ListRuleExecutions(const Model::ListRuleExecutionsRequest& request) const;
 
        template<typename ListRuleExecutionsRequestT = Model::ListRuleExecutionsRequest>
        Model::ListRuleExecutionsOutcomeCallable ListRuleExecutionsCallable(const ListRuleExecutionsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::ListRuleExecutions, request);
        }
 
        template<typename ListRuleExecutionsRequestT = Model::ListRuleExecutionsRequest>
        void ListRuleExecutionsAsync(const ListRuleExecutionsRequestT& request, const ListRuleExecutionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::ListRuleExecutions, request, handler, context);
        }
 
        virtual Model::ListRuleTypesOutcome ListRuleTypes(const Model::ListRuleTypesRequest& request = {}) const;
 
        template<typename ListRuleTypesRequestT = Model::ListRuleTypesRequest>
        Model::ListRuleTypesOutcomeCallable ListRuleTypesCallable(const ListRuleTypesRequestT& request = {}) const
        {
            return SubmitCallable(&CodePipelineClient::ListRuleTypes, request);
        }
 
        template<typename ListRuleTypesRequestT = Model::ListRuleTypesRequest>
        void ListRuleTypesAsync(const ListRuleTypesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRuleTypesRequestT& request = {}) const
        {
            return SubmitAsync(&CodePipelineClient::ListRuleTypes, 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(&CodePipelineClient::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(&CodePipelineClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWebhooksOutcome ListWebhooks(const Model::ListWebhooksRequest& request = {}) const;
 
        template<typename ListWebhooksRequestT = Model::ListWebhooksRequest>
        Model::ListWebhooksOutcomeCallable ListWebhooksCallable(const ListWebhooksRequestT& request = {}) const
        {
            return SubmitCallable(&CodePipelineClient::ListWebhooks, request);
        }
 
        template<typename ListWebhooksRequestT = Model::ListWebhooksRequest>
        void ListWebhooksAsync(const ListWebhooksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWebhooksRequestT& request = {}) const
        {
            return SubmitAsync(&CodePipelineClient::ListWebhooks, request, handler, context);
        }
 
        virtual Model::OverrideStageConditionOutcome OverrideStageCondition(const Model::OverrideStageConditionRequest& request) const;
 
        template<typename OverrideStageConditionRequestT = Model::OverrideStageConditionRequest>
        Model::OverrideStageConditionOutcomeCallable OverrideStageConditionCallable(const OverrideStageConditionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::OverrideStageCondition, request);
        }
 
        template<typename OverrideStageConditionRequestT = Model::OverrideStageConditionRequest>
        void OverrideStageConditionAsync(const OverrideStageConditionRequestT& request, const OverrideStageConditionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::OverrideStageCondition, request, handler, context);
        }
 
        virtual Model::PollForJobsOutcome PollForJobs(const Model::PollForJobsRequest& request) const;
 
        template<typename PollForJobsRequestT = Model::PollForJobsRequest>
        Model::PollForJobsOutcomeCallable PollForJobsCallable(const PollForJobsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PollForJobs, request);
        }
 
        template<typename PollForJobsRequestT = Model::PollForJobsRequest>
        void PollForJobsAsync(const PollForJobsRequestT& request, const PollForJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PollForJobs, request, handler, context);
        }
 
        virtual Model::PollForThirdPartyJobsOutcome PollForThirdPartyJobs(const Model::PollForThirdPartyJobsRequest& request) const;
 
        template<typename PollForThirdPartyJobsRequestT = Model::PollForThirdPartyJobsRequest>
        Model::PollForThirdPartyJobsOutcomeCallable PollForThirdPartyJobsCallable(const PollForThirdPartyJobsRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PollForThirdPartyJobs, request);
        }
 
        template<typename PollForThirdPartyJobsRequestT = Model::PollForThirdPartyJobsRequest>
        void PollForThirdPartyJobsAsync(const PollForThirdPartyJobsRequestT& request, const PollForThirdPartyJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PollForThirdPartyJobs, request, handler, context);
        }
 
        virtual Model::PutActionRevisionOutcome PutActionRevision(const Model::PutActionRevisionRequest& request) const;
 
        template<typename PutActionRevisionRequestT = Model::PutActionRevisionRequest>
        Model::PutActionRevisionOutcomeCallable PutActionRevisionCallable(const PutActionRevisionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PutActionRevision, request);
        }
 
        template<typename PutActionRevisionRequestT = Model::PutActionRevisionRequest>
        void PutActionRevisionAsync(const PutActionRevisionRequestT& request, const PutActionRevisionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PutActionRevision, request, handler, context);
        }
 
        virtual Model::PutApprovalResultOutcome PutApprovalResult(const Model::PutApprovalResultRequest& request) const;
 
        template<typename PutApprovalResultRequestT = Model::PutApprovalResultRequest>
        Model::PutApprovalResultOutcomeCallable PutApprovalResultCallable(const PutApprovalResultRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PutApprovalResult, request);
        }
 
        template<typename PutApprovalResultRequestT = Model::PutApprovalResultRequest>
        void PutApprovalResultAsync(const PutApprovalResultRequestT& request, const PutApprovalResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PutApprovalResult, request, handler, context);
        }
 
        virtual Model::PutJobFailureResultOutcome PutJobFailureResult(const Model::PutJobFailureResultRequest& request) const;
 
        template<typename PutJobFailureResultRequestT = Model::PutJobFailureResultRequest>
        Model::PutJobFailureResultOutcomeCallable PutJobFailureResultCallable(const PutJobFailureResultRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PutJobFailureResult, request);
        }
 
        template<typename PutJobFailureResultRequestT = Model::PutJobFailureResultRequest>
        void PutJobFailureResultAsync(const PutJobFailureResultRequestT& request, const PutJobFailureResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PutJobFailureResult, request, handler, context);
        }
 
        virtual Model::PutJobSuccessResultOutcome PutJobSuccessResult(const Model::PutJobSuccessResultRequest& request) const;
 
        template<typename PutJobSuccessResultRequestT = Model::PutJobSuccessResultRequest>
        Model::PutJobSuccessResultOutcomeCallable PutJobSuccessResultCallable(const PutJobSuccessResultRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PutJobSuccessResult, request);
        }
 
        template<typename PutJobSuccessResultRequestT = Model::PutJobSuccessResultRequest>
        void PutJobSuccessResultAsync(const PutJobSuccessResultRequestT& request, const PutJobSuccessResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PutJobSuccessResult, request, handler, context);
        }
 
        virtual Model::PutThirdPartyJobFailureResultOutcome PutThirdPartyJobFailureResult(const Model::PutThirdPartyJobFailureResultRequest& request) const;
 
        template<typename PutThirdPartyJobFailureResultRequestT = Model::PutThirdPartyJobFailureResultRequest>
        Model::PutThirdPartyJobFailureResultOutcomeCallable PutThirdPartyJobFailureResultCallable(const PutThirdPartyJobFailureResultRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PutThirdPartyJobFailureResult, request);
        }
 
        template<typename PutThirdPartyJobFailureResultRequestT = Model::PutThirdPartyJobFailureResultRequest>
        void PutThirdPartyJobFailureResultAsync(const PutThirdPartyJobFailureResultRequestT& request, const PutThirdPartyJobFailureResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PutThirdPartyJobFailureResult, request, handler, context);
        }
 
        virtual Model::PutThirdPartyJobSuccessResultOutcome PutThirdPartyJobSuccessResult(const Model::PutThirdPartyJobSuccessResultRequest& request) const;
 
        template<typename PutThirdPartyJobSuccessResultRequestT = Model::PutThirdPartyJobSuccessResultRequest>
        Model::PutThirdPartyJobSuccessResultOutcomeCallable PutThirdPartyJobSuccessResultCallable(const PutThirdPartyJobSuccessResultRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PutThirdPartyJobSuccessResult, request);
        }
 
        template<typename PutThirdPartyJobSuccessResultRequestT = Model::PutThirdPartyJobSuccessResultRequest>
        void PutThirdPartyJobSuccessResultAsync(const PutThirdPartyJobSuccessResultRequestT& request, const PutThirdPartyJobSuccessResultResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PutThirdPartyJobSuccessResult, request, handler, context);
        }
 
        virtual Model::PutWebhookOutcome PutWebhook(const Model::PutWebhookRequest& request) const;
 
        template<typename PutWebhookRequestT = Model::PutWebhookRequest>
        Model::PutWebhookOutcomeCallable PutWebhookCallable(const PutWebhookRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::PutWebhook, request);
        }
 
        template<typename PutWebhookRequestT = Model::PutWebhookRequest>
        void PutWebhookAsync(const PutWebhookRequestT& request, const PutWebhookResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::PutWebhook, request, handler, context);
        }
 
        virtual Model::RegisterWebhookWithThirdPartyOutcome RegisterWebhookWithThirdParty(const Model::RegisterWebhookWithThirdPartyRequest& request = {}) const;
 
        template<typename RegisterWebhookWithThirdPartyRequestT = Model::RegisterWebhookWithThirdPartyRequest>
        Model::RegisterWebhookWithThirdPartyOutcomeCallable RegisterWebhookWithThirdPartyCallable(const RegisterWebhookWithThirdPartyRequestT& request = {}) const
        {
            return SubmitCallable(&CodePipelineClient::RegisterWebhookWithThirdParty, request);
        }
 
        template<typename RegisterWebhookWithThirdPartyRequestT = Model::RegisterWebhookWithThirdPartyRequest>
        void RegisterWebhookWithThirdPartyAsync(const RegisterWebhookWithThirdPartyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RegisterWebhookWithThirdPartyRequestT& request = {}) const
        {
            return SubmitAsync(&CodePipelineClient::RegisterWebhookWithThirdParty, request, handler, context);
        }
 
        virtual Model::RetryStageExecutionOutcome RetryStageExecution(const Model::RetryStageExecutionRequest& request) const;
 
        template<typename RetryStageExecutionRequestT = Model::RetryStageExecutionRequest>
        Model::RetryStageExecutionOutcomeCallable RetryStageExecutionCallable(const RetryStageExecutionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::RetryStageExecution, request);
        }
 
        template<typename RetryStageExecutionRequestT = Model::RetryStageExecutionRequest>
        void RetryStageExecutionAsync(const RetryStageExecutionRequestT& request, const RetryStageExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::RetryStageExecution, request, handler, context);
        }
 
        virtual Model::RollbackStageOutcome RollbackStage(const Model::RollbackStageRequest& request) const;
 
        template<typename RollbackStageRequestT = Model::RollbackStageRequest>
        Model::RollbackStageOutcomeCallable RollbackStageCallable(const RollbackStageRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::RollbackStage, request);
        }
 
        template<typename RollbackStageRequestT = Model::RollbackStageRequest>
        void RollbackStageAsync(const RollbackStageRequestT& request, const RollbackStageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::RollbackStage, request, handler, context);
        }
 
        virtual Model::StartPipelineExecutionOutcome StartPipelineExecution(const Model::StartPipelineExecutionRequest& request) const;
 
        template<typename StartPipelineExecutionRequestT = Model::StartPipelineExecutionRequest>
        Model::StartPipelineExecutionOutcomeCallable StartPipelineExecutionCallable(const StartPipelineExecutionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::StartPipelineExecution, request);
        }
 
        template<typename StartPipelineExecutionRequestT = Model::StartPipelineExecutionRequest>
        void StartPipelineExecutionAsync(const StartPipelineExecutionRequestT& request, const StartPipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::StartPipelineExecution, request, handler, context);
        }
 
        virtual Model::StopPipelineExecutionOutcome StopPipelineExecution(const Model::StopPipelineExecutionRequest& request) const;
 
        template<typename StopPipelineExecutionRequestT = Model::StopPipelineExecutionRequest>
        Model::StopPipelineExecutionOutcomeCallable StopPipelineExecutionCallable(const StopPipelineExecutionRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::StopPipelineExecution, request);
        }
 
        template<typename StopPipelineExecutionRequestT = Model::StopPipelineExecutionRequest>
        void StopPipelineExecutionAsync(const StopPipelineExecutionRequestT& request, const StopPipelineExecutionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::StopPipelineExecution, 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(&CodePipelineClient::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(&CodePipelineClient::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(&CodePipelineClient::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(&CodePipelineClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateActionTypeOutcome UpdateActionType(const Model::UpdateActionTypeRequest& request) const;
 
        template<typename UpdateActionTypeRequestT = Model::UpdateActionTypeRequest>
        Model::UpdateActionTypeOutcomeCallable UpdateActionTypeCallable(const UpdateActionTypeRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::UpdateActionType, request);
        }
 
        template<typename UpdateActionTypeRequestT = Model::UpdateActionTypeRequest>
        void UpdateActionTypeAsync(const UpdateActionTypeRequestT& request, const UpdateActionTypeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::UpdateActionType, request, handler, context);
        }
 
        virtual Model::UpdatePipelineOutcome UpdatePipeline(const Model::UpdatePipelineRequest& request) const;
 
        template<typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
        Model::UpdatePipelineOutcomeCallable UpdatePipelineCallable(const UpdatePipelineRequestT& request) const
        {
            return SubmitCallable(&CodePipelineClient::UpdatePipeline, request);
        }
 
        template<typename UpdatePipelineRequestT = Model::UpdatePipelineRequest>
        void UpdatePipelineAsync(const UpdatePipelineRequestT& request, const UpdatePipelineResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodePipelineClient::UpdatePipeline, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodePipelineEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodePipelineClient>;
      void init(const CodePipelineClientConfiguration& clientConfiguration);
 
      CodePipelineClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodePipelineEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodePipeline
} // namespace Aws