CodePipelineClient.h

 
#pragma once
#include <aws/codepipeline/CodePipelineServiceClientModel.h>
#include <aws/codepipeline/CodePipeline_EXPORTS.h>
#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>
 
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