CodeCommitClient.h

 
#pragma once
#include <aws/codecommit/CodeCommitPaginationBase.h>
#include <aws/codecommit/CodeCommitServiceClientModel.h>
#include <aws/codecommit/CodeCommitWaiter.h>
#include <aws/codecommit/CodeCommit_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 CodeCommit {
class AWS_CODECOMMIT_API CodeCommitClient : public Aws::Client::AWSJsonClient,
                                            public Aws::Client::ClientWithAsyncTemplateMethods<CodeCommitClient>,
                                            public CodeCommitPaginationBase<CodeCommitClient>,
                                            public CodeCommitWaiter<CodeCommitClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CodeCommitClientConfiguration ClientConfigurationType;
  typedef CodeCommitEndpointProvider EndpointProviderType;
 
  CodeCommitClient(
      const Aws::CodeCommit::CodeCommitClientConfiguration& clientConfiguration = Aws::CodeCommit::CodeCommitClientConfiguration(),
      std::shared_ptr<CodeCommitEndpointProviderBase> endpointProvider = nullptr);
 
  CodeCommitClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CodeCommitEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CodeCommit::CodeCommitClientConfiguration& clientConfiguration = Aws::CodeCommit::CodeCommitClientConfiguration());
 
  CodeCommitClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<CodeCommitEndpointProviderBase> endpointProvider = nullptr,
      const Aws::CodeCommit::CodeCommitClientConfiguration& clientConfiguration = Aws::CodeCommit::CodeCommitClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CodeCommitClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeCommitClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeCommitClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                   const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CodeCommitClient();
 
  virtual Model::AssociateApprovalRuleTemplateWithRepositoryOutcome AssociateApprovalRuleTemplateWithRepository(
      const Model::AssociateApprovalRuleTemplateWithRepositoryRequest& request) const;
 
  template <typename AssociateApprovalRuleTemplateWithRepositoryRequestT = Model::AssociateApprovalRuleTemplateWithRepositoryRequest>
  Model::AssociateApprovalRuleTemplateWithRepositoryOutcomeCallable AssociateApprovalRuleTemplateWithRepositoryCallable(
      const AssociateApprovalRuleTemplateWithRepositoryRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::AssociateApprovalRuleTemplateWithRepository, request);
  }
 
  template <typename AssociateApprovalRuleTemplateWithRepositoryRequestT = Model::AssociateApprovalRuleTemplateWithRepositoryRequest>
  void AssociateApprovalRuleTemplateWithRepositoryAsync(
      const AssociateApprovalRuleTemplateWithRepositoryRequestT& request,
      const AssociateApprovalRuleTemplateWithRepositoryResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::AssociateApprovalRuleTemplateWithRepository, request, handler, context);
  }
 
  virtual Model::BatchAssociateApprovalRuleTemplateWithRepositoriesOutcome BatchAssociateApprovalRuleTemplateWithRepositories(
      const Model::BatchAssociateApprovalRuleTemplateWithRepositoriesRequest& request) const;
 
  template <typename BatchAssociateApprovalRuleTemplateWithRepositoriesRequestT =
                Model::BatchAssociateApprovalRuleTemplateWithRepositoriesRequest>
  Model::BatchAssociateApprovalRuleTemplateWithRepositoriesOutcomeCallable BatchAssociateApprovalRuleTemplateWithRepositoriesCallable(
      const BatchAssociateApprovalRuleTemplateWithRepositoriesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::BatchAssociateApprovalRuleTemplateWithRepositories, request);
  }
 
  template <typename BatchAssociateApprovalRuleTemplateWithRepositoriesRequestT =
                Model::BatchAssociateApprovalRuleTemplateWithRepositoriesRequest>
  void BatchAssociateApprovalRuleTemplateWithRepositoriesAsync(
      const BatchAssociateApprovalRuleTemplateWithRepositoriesRequestT& request,
      const BatchAssociateApprovalRuleTemplateWithRepositoriesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::BatchAssociateApprovalRuleTemplateWithRepositories, request, handler, context);
  }
 
  virtual Model::BatchDescribeMergeConflictsOutcome BatchDescribeMergeConflicts(
      const Model::BatchDescribeMergeConflictsRequest& request) const;
 
  template <typename BatchDescribeMergeConflictsRequestT = Model::BatchDescribeMergeConflictsRequest>
  Model::BatchDescribeMergeConflictsOutcomeCallable BatchDescribeMergeConflictsCallable(
      const BatchDescribeMergeConflictsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::BatchDescribeMergeConflicts, request);
  }
 
  template <typename BatchDescribeMergeConflictsRequestT = Model::BatchDescribeMergeConflictsRequest>
  void BatchDescribeMergeConflictsAsync(const BatchDescribeMergeConflictsRequestT& request,
                                        const BatchDescribeMergeConflictsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::BatchDescribeMergeConflicts, request, handler, context);
  }
 
  virtual Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesOutcome BatchDisassociateApprovalRuleTemplateFromRepositories(
      const Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesRequest& request) const;
 
  template <typename BatchDisassociateApprovalRuleTemplateFromRepositoriesRequestT =
                Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesRequest>
  Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesOutcomeCallable BatchDisassociateApprovalRuleTemplateFromRepositoriesCallable(
      const BatchDisassociateApprovalRuleTemplateFromRepositoriesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::BatchDisassociateApprovalRuleTemplateFromRepositories, request);
  }
 
  template <typename BatchDisassociateApprovalRuleTemplateFromRepositoriesRequestT =
                Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesRequest>
  void BatchDisassociateApprovalRuleTemplateFromRepositoriesAsync(
      const BatchDisassociateApprovalRuleTemplateFromRepositoriesRequestT& request,
      const BatchDisassociateApprovalRuleTemplateFromRepositoriesResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::BatchDisassociateApprovalRuleTemplateFromRepositories, request, handler, context);
  }
 
  virtual Model::BatchGetCommitsOutcome BatchGetCommits(const Model::BatchGetCommitsRequest& request) const;
 
  template <typename BatchGetCommitsRequestT = Model::BatchGetCommitsRequest>
  Model::BatchGetCommitsOutcomeCallable BatchGetCommitsCallable(const BatchGetCommitsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::BatchGetCommits, request);
  }
 
  template <typename BatchGetCommitsRequestT = Model::BatchGetCommitsRequest>
  void BatchGetCommitsAsync(const BatchGetCommitsRequestT& request, const BatchGetCommitsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::BatchGetCommits, request, handler, context);
  }
 
  virtual Model::BatchGetRepositoriesOutcome BatchGetRepositories(const Model::BatchGetRepositoriesRequest& request) const;
 
  template <typename BatchGetRepositoriesRequestT = Model::BatchGetRepositoriesRequest>
  Model::BatchGetRepositoriesOutcomeCallable BatchGetRepositoriesCallable(const BatchGetRepositoriesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::BatchGetRepositories, request);
  }
 
  template <typename BatchGetRepositoriesRequestT = Model::BatchGetRepositoriesRequest>
  void BatchGetRepositoriesAsync(const BatchGetRepositoriesRequestT& request, const BatchGetRepositoriesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::BatchGetRepositories, request, handler, context);
  }
 
  virtual Model::CreateApprovalRuleTemplateOutcome CreateApprovalRuleTemplate(
      const Model::CreateApprovalRuleTemplateRequest& request) const;
 
  template <typename CreateApprovalRuleTemplateRequestT = Model::CreateApprovalRuleTemplateRequest>
  Model::CreateApprovalRuleTemplateOutcomeCallable CreateApprovalRuleTemplateCallable(
      const CreateApprovalRuleTemplateRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::CreateApprovalRuleTemplate, request);
  }
 
  template <typename CreateApprovalRuleTemplateRequestT = Model::CreateApprovalRuleTemplateRequest>
  void CreateApprovalRuleTemplateAsync(const CreateApprovalRuleTemplateRequestT& request,
                                       const CreateApprovalRuleTemplateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::CreateApprovalRuleTemplate, request, handler, context);
  }
 
  virtual Model::CreateBranchOutcome CreateBranch(const Model::CreateBranchRequest& request) const;
 
  template <typename CreateBranchRequestT = Model::CreateBranchRequest>
  Model::CreateBranchOutcomeCallable CreateBranchCallable(const CreateBranchRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::CreateBranch, request);
  }
 
  template <typename CreateBranchRequestT = Model::CreateBranchRequest>
  void CreateBranchAsync(const CreateBranchRequestT& request, const CreateBranchResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::CreateBranch, request, handler, context);
  }
 
  virtual Model::CreateCommitOutcome CreateCommit(const Model::CreateCommitRequest& request) const;
 
  template <typename CreateCommitRequestT = Model::CreateCommitRequest>
  Model::CreateCommitOutcomeCallable CreateCommitCallable(const CreateCommitRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::CreateCommit, request);
  }
 
  template <typename CreateCommitRequestT = Model::CreateCommitRequest>
  void CreateCommitAsync(const CreateCommitRequestT& request, const CreateCommitResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::CreateCommit, request, handler, context);
  }
 
  virtual Model::CreatePullRequestOutcome CreatePullRequest(const Model::CreatePullRequestRequest& request) const;
 
  template <typename CreatePullRequestRequestT = Model::CreatePullRequestRequest>
  Model::CreatePullRequestOutcomeCallable CreatePullRequestCallable(const CreatePullRequestRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::CreatePullRequest, request);
  }
 
  template <typename CreatePullRequestRequestT = Model::CreatePullRequestRequest>
  void CreatePullRequestAsync(const CreatePullRequestRequestT& request, const CreatePullRequestResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::CreatePullRequest, request, handler, context);
  }
 
  virtual Model::CreatePullRequestApprovalRuleOutcome CreatePullRequestApprovalRule(
      const Model::CreatePullRequestApprovalRuleRequest& request) const;
 
  template <typename CreatePullRequestApprovalRuleRequestT = Model::CreatePullRequestApprovalRuleRequest>
  Model::CreatePullRequestApprovalRuleOutcomeCallable CreatePullRequestApprovalRuleCallable(
      const CreatePullRequestApprovalRuleRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::CreatePullRequestApprovalRule, request);
  }
 
  template <typename CreatePullRequestApprovalRuleRequestT = Model::CreatePullRequestApprovalRuleRequest>
  void CreatePullRequestApprovalRuleAsync(const CreatePullRequestApprovalRuleRequestT& request,
                                          const CreatePullRequestApprovalRuleResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::CreatePullRequestApprovalRule, request, handler, context);
  }
 
  virtual Model::CreateRepositoryOutcome CreateRepository(const Model::CreateRepositoryRequest& request) const;
 
  template <typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
  Model::CreateRepositoryOutcomeCallable CreateRepositoryCallable(const CreateRepositoryRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::CreateRepository, request);
  }
 
  template <typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
  void CreateRepositoryAsync(const CreateRepositoryRequestT& request, const CreateRepositoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::CreateRepository, request, handler, context);
  }
 
  virtual Model::CreateUnreferencedMergeCommitOutcome CreateUnreferencedMergeCommit(
      const Model::CreateUnreferencedMergeCommitRequest& request) const;
 
  template <typename CreateUnreferencedMergeCommitRequestT = Model::CreateUnreferencedMergeCommitRequest>
  Model::CreateUnreferencedMergeCommitOutcomeCallable CreateUnreferencedMergeCommitCallable(
      const CreateUnreferencedMergeCommitRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::CreateUnreferencedMergeCommit, request);
  }
 
  template <typename CreateUnreferencedMergeCommitRequestT = Model::CreateUnreferencedMergeCommitRequest>
  void CreateUnreferencedMergeCommitAsync(const CreateUnreferencedMergeCommitRequestT& request,
                                          const CreateUnreferencedMergeCommitResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::CreateUnreferencedMergeCommit, request, handler, context);
  }
 
  virtual Model::DeleteApprovalRuleTemplateOutcome DeleteApprovalRuleTemplate(
      const Model::DeleteApprovalRuleTemplateRequest& request) const;
 
  template <typename DeleteApprovalRuleTemplateRequestT = Model::DeleteApprovalRuleTemplateRequest>
  Model::DeleteApprovalRuleTemplateOutcomeCallable DeleteApprovalRuleTemplateCallable(
      const DeleteApprovalRuleTemplateRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DeleteApprovalRuleTemplate, request);
  }
 
  template <typename DeleteApprovalRuleTemplateRequestT = Model::DeleteApprovalRuleTemplateRequest>
  void DeleteApprovalRuleTemplateAsync(const DeleteApprovalRuleTemplateRequestT& request,
                                       const DeleteApprovalRuleTemplateResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DeleteApprovalRuleTemplate, request, handler, context);
  }
 
  virtual Model::DeleteBranchOutcome DeleteBranch(const Model::DeleteBranchRequest& request) const;
 
  template <typename DeleteBranchRequestT = Model::DeleteBranchRequest>
  Model::DeleteBranchOutcomeCallable DeleteBranchCallable(const DeleteBranchRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DeleteBranch, request);
  }
 
  template <typename DeleteBranchRequestT = Model::DeleteBranchRequest>
  void DeleteBranchAsync(const DeleteBranchRequestT& request, const DeleteBranchResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DeleteBranch, request, handler, context);
  }
 
  virtual Model::DeleteCommentContentOutcome DeleteCommentContent(const Model::DeleteCommentContentRequest& request) const;
 
  template <typename DeleteCommentContentRequestT = Model::DeleteCommentContentRequest>
  Model::DeleteCommentContentOutcomeCallable DeleteCommentContentCallable(const DeleteCommentContentRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DeleteCommentContent, request);
  }
 
  template <typename DeleteCommentContentRequestT = Model::DeleteCommentContentRequest>
  void DeleteCommentContentAsync(const DeleteCommentContentRequestT& request, const DeleteCommentContentResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DeleteCommentContent, request, handler, context);
  }
 
  virtual Model::DeleteFileOutcome DeleteFile(const Model::DeleteFileRequest& request) const;
 
  template <typename DeleteFileRequestT = Model::DeleteFileRequest>
  Model::DeleteFileOutcomeCallable DeleteFileCallable(const DeleteFileRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DeleteFile, request);
  }
 
  template <typename DeleteFileRequestT = Model::DeleteFileRequest>
  void DeleteFileAsync(const DeleteFileRequestT& request, const DeleteFileResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DeleteFile, request, handler, context);
  }
 
  virtual Model::DeletePullRequestApprovalRuleOutcome DeletePullRequestApprovalRule(
      const Model::DeletePullRequestApprovalRuleRequest& request) const;
 
  template <typename DeletePullRequestApprovalRuleRequestT = Model::DeletePullRequestApprovalRuleRequest>
  Model::DeletePullRequestApprovalRuleOutcomeCallable DeletePullRequestApprovalRuleCallable(
      const DeletePullRequestApprovalRuleRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DeletePullRequestApprovalRule, request);
  }
 
  template <typename DeletePullRequestApprovalRuleRequestT = Model::DeletePullRequestApprovalRuleRequest>
  void DeletePullRequestApprovalRuleAsync(const DeletePullRequestApprovalRuleRequestT& request,
                                          const DeletePullRequestApprovalRuleResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DeletePullRequestApprovalRule, request, handler, context);
  }
 
  virtual Model::DeleteRepositoryOutcome DeleteRepository(const Model::DeleteRepositoryRequest& request) const;
 
  template <typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
  Model::DeleteRepositoryOutcomeCallable DeleteRepositoryCallable(const DeleteRepositoryRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DeleteRepository, request);
  }
 
  template <typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
  void DeleteRepositoryAsync(const DeleteRepositoryRequestT& request, const DeleteRepositoryResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DeleteRepository, request, handler, context);
  }
 
  virtual Model::DescribeMergeConflictsOutcome DescribeMergeConflicts(const Model::DescribeMergeConflictsRequest& request) const;
 
  template <typename DescribeMergeConflictsRequestT = Model::DescribeMergeConflictsRequest>
  Model::DescribeMergeConflictsOutcomeCallable DescribeMergeConflictsCallable(const DescribeMergeConflictsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DescribeMergeConflicts, request);
  }
 
  template <typename DescribeMergeConflictsRequestT = Model::DescribeMergeConflictsRequest>
  void DescribeMergeConflictsAsync(const DescribeMergeConflictsRequestT& request,
                                   const DescribeMergeConflictsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DescribeMergeConflicts, request, handler, context);
  }
 
  virtual Model::DescribePullRequestEventsOutcome DescribePullRequestEvents(const Model::DescribePullRequestEventsRequest& request) const;
 
  template <typename DescribePullRequestEventsRequestT = Model::DescribePullRequestEventsRequest>
  Model::DescribePullRequestEventsOutcomeCallable DescribePullRequestEventsCallable(
      const DescribePullRequestEventsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DescribePullRequestEvents, request);
  }
 
  template <typename DescribePullRequestEventsRequestT = Model::DescribePullRequestEventsRequest>
  void DescribePullRequestEventsAsync(const DescribePullRequestEventsRequestT& request,
                                      const DescribePullRequestEventsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DescribePullRequestEvents, request, handler, context);
  }
 
  virtual Model::DisassociateApprovalRuleTemplateFromRepositoryOutcome DisassociateApprovalRuleTemplateFromRepository(
      const Model::DisassociateApprovalRuleTemplateFromRepositoryRequest& request) const;
 
  template <typename DisassociateApprovalRuleTemplateFromRepositoryRequestT = Model::DisassociateApprovalRuleTemplateFromRepositoryRequest>
  Model::DisassociateApprovalRuleTemplateFromRepositoryOutcomeCallable DisassociateApprovalRuleTemplateFromRepositoryCallable(
      const DisassociateApprovalRuleTemplateFromRepositoryRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::DisassociateApprovalRuleTemplateFromRepository, request);
  }
 
  template <typename DisassociateApprovalRuleTemplateFromRepositoryRequestT = Model::DisassociateApprovalRuleTemplateFromRepositoryRequest>
  void DisassociateApprovalRuleTemplateFromRepositoryAsync(
      const DisassociateApprovalRuleTemplateFromRepositoryRequestT& request,
      const DisassociateApprovalRuleTemplateFromRepositoryResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::DisassociateApprovalRuleTemplateFromRepository, request, handler, context);
  }
 
  virtual Model::EvaluatePullRequestApprovalRulesOutcome EvaluatePullRequestApprovalRules(
      const Model::EvaluatePullRequestApprovalRulesRequest& request) const;
 
  template <typename EvaluatePullRequestApprovalRulesRequestT = Model::EvaluatePullRequestApprovalRulesRequest>
  Model::EvaluatePullRequestApprovalRulesOutcomeCallable EvaluatePullRequestApprovalRulesCallable(
      const EvaluatePullRequestApprovalRulesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::EvaluatePullRequestApprovalRules, request);
  }
 
  template <typename EvaluatePullRequestApprovalRulesRequestT = Model::EvaluatePullRequestApprovalRulesRequest>
  void EvaluatePullRequestApprovalRulesAsync(const EvaluatePullRequestApprovalRulesRequestT& request,
                                             const EvaluatePullRequestApprovalRulesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::EvaluatePullRequestApprovalRules, request, handler, context);
  }
 
  virtual Model::GetApprovalRuleTemplateOutcome GetApprovalRuleTemplate(const Model::GetApprovalRuleTemplateRequest& request) const;
 
  template <typename GetApprovalRuleTemplateRequestT = Model::GetApprovalRuleTemplateRequest>
  Model::GetApprovalRuleTemplateOutcomeCallable GetApprovalRuleTemplateCallable(const GetApprovalRuleTemplateRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetApprovalRuleTemplate, request);
  }
 
  template <typename GetApprovalRuleTemplateRequestT = Model::GetApprovalRuleTemplateRequest>
  void GetApprovalRuleTemplateAsync(const GetApprovalRuleTemplateRequestT& request,
                                    const GetApprovalRuleTemplateResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetApprovalRuleTemplate, request, handler, context);
  }
 
  virtual Model::GetBlobOutcome GetBlob(const Model::GetBlobRequest& request) const;
 
  template <typename GetBlobRequestT = Model::GetBlobRequest>
  Model::GetBlobOutcomeCallable GetBlobCallable(const GetBlobRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetBlob, request);
  }
 
  template <typename GetBlobRequestT = Model::GetBlobRequest>
  void GetBlobAsync(const GetBlobRequestT& request, const GetBlobResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetBlob, request, handler, context);
  }
 
  virtual Model::GetBranchOutcome GetBranch(const Model::GetBranchRequest& request = {}) const;
 
  template <typename GetBranchRequestT = Model::GetBranchRequest>
  Model::GetBranchOutcomeCallable GetBranchCallable(const GetBranchRequestT& request = {}) const {
    return SubmitCallable(&CodeCommitClient::GetBranch, request);
  }
 
  template <typename GetBranchRequestT = Model::GetBranchRequest>
  void GetBranchAsync(const GetBranchResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const GetBranchRequestT& request = {}) const {
    return SubmitAsync(&CodeCommitClient::GetBranch, request, handler, context);
  }
 
  virtual Model::GetCommentOutcome GetComment(const Model::GetCommentRequest& request) const;
 
  template <typename GetCommentRequestT = Model::GetCommentRequest>
  Model::GetCommentOutcomeCallable GetCommentCallable(const GetCommentRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetComment, request);
  }
 
  template <typename GetCommentRequestT = Model::GetCommentRequest>
  void GetCommentAsync(const GetCommentRequestT& request, const GetCommentResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetComment, request, handler, context);
  }
 
  virtual Model::GetCommentReactionsOutcome GetCommentReactions(const Model::GetCommentReactionsRequest& request) const;
 
  template <typename GetCommentReactionsRequestT = Model::GetCommentReactionsRequest>
  Model::GetCommentReactionsOutcomeCallable GetCommentReactionsCallable(const GetCommentReactionsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetCommentReactions, request);
  }
 
  template <typename GetCommentReactionsRequestT = Model::GetCommentReactionsRequest>
  void GetCommentReactionsAsync(const GetCommentReactionsRequestT& request, const GetCommentReactionsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetCommentReactions, request, handler, context);
  }
 
  virtual Model::GetCommentsForComparedCommitOutcome GetCommentsForComparedCommit(
      const Model::GetCommentsForComparedCommitRequest& request) const;
 
  template <typename GetCommentsForComparedCommitRequestT = Model::GetCommentsForComparedCommitRequest>
  Model::GetCommentsForComparedCommitOutcomeCallable GetCommentsForComparedCommitCallable(
      const GetCommentsForComparedCommitRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetCommentsForComparedCommit, request);
  }
 
  template <typename GetCommentsForComparedCommitRequestT = Model::GetCommentsForComparedCommitRequest>
  void GetCommentsForComparedCommitAsync(const GetCommentsForComparedCommitRequestT& request,
                                         const GetCommentsForComparedCommitResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetCommentsForComparedCommit, request, handler, context);
  }
 
  virtual Model::GetCommentsForPullRequestOutcome GetCommentsForPullRequest(const Model::GetCommentsForPullRequestRequest& request) const;
 
  template <typename GetCommentsForPullRequestRequestT = Model::GetCommentsForPullRequestRequest>
  Model::GetCommentsForPullRequestOutcomeCallable GetCommentsForPullRequestCallable(
      const GetCommentsForPullRequestRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetCommentsForPullRequest, request);
  }
 
  template <typename GetCommentsForPullRequestRequestT = Model::GetCommentsForPullRequestRequest>
  void GetCommentsForPullRequestAsync(const GetCommentsForPullRequestRequestT& request,
                                      const GetCommentsForPullRequestResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetCommentsForPullRequest, request, handler, context);
  }
 
  virtual Model::GetCommitOutcome GetCommit(const Model::GetCommitRequest& request) const;
 
  template <typename GetCommitRequestT = Model::GetCommitRequest>
  Model::GetCommitOutcomeCallable GetCommitCallable(const GetCommitRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetCommit, request);
  }
 
  template <typename GetCommitRequestT = Model::GetCommitRequest>
  void GetCommitAsync(const GetCommitRequestT& request, const GetCommitResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetCommit, request, handler, context);
  }
 
  virtual Model::GetDifferencesOutcome GetDifferences(const Model::GetDifferencesRequest& request) const;
 
  template <typename GetDifferencesRequestT = Model::GetDifferencesRequest>
  Model::GetDifferencesOutcomeCallable GetDifferencesCallable(const GetDifferencesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetDifferences, request);
  }
 
  template <typename GetDifferencesRequestT = Model::GetDifferencesRequest>
  void GetDifferencesAsync(const GetDifferencesRequestT& request, const GetDifferencesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetDifferences, request, handler, context);
  }
 
  virtual Model::GetFileOutcome GetFile(const Model::GetFileRequest& request) const;
 
  template <typename GetFileRequestT = Model::GetFileRequest>
  Model::GetFileOutcomeCallable GetFileCallable(const GetFileRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetFile, request);
  }
 
  template <typename GetFileRequestT = Model::GetFileRequest>
  void GetFileAsync(const GetFileRequestT& request, const GetFileResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetFile, request, handler, context);
  }
 
  virtual Model::GetFolderOutcome GetFolder(const Model::GetFolderRequest& request) const;
 
  template <typename GetFolderRequestT = Model::GetFolderRequest>
  Model::GetFolderOutcomeCallable GetFolderCallable(const GetFolderRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetFolder, request);
  }
 
  template <typename GetFolderRequestT = Model::GetFolderRequest>
  void GetFolderAsync(const GetFolderRequestT& request, const GetFolderResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetFolder, request, handler, context);
  }
 
  virtual Model::GetMergeCommitOutcome GetMergeCommit(const Model::GetMergeCommitRequest& request) const;
 
  template <typename GetMergeCommitRequestT = Model::GetMergeCommitRequest>
  Model::GetMergeCommitOutcomeCallable GetMergeCommitCallable(const GetMergeCommitRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetMergeCommit, request);
  }
 
  template <typename GetMergeCommitRequestT = Model::GetMergeCommitRequest>
  void GetMergeCommitAsync(const GetMergeCommitRequestT& request, const GetMergeCommitResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetMergeCommit, request, handler, context);
  }
 
  virtual Model::GetMergeConflictsOutcome GetMergeConflicts(const Model::GetMergeConflictsRequest& request) const;
 
  template <typename GetMergeConflictsRequestT = Model::GetMergeConflictsRequest>
  Model::GetMergeConflictsOutcomeCallable GetMergeConflictsCallable(const GetMergeConflictsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetMergeConflicts, request);
  }
 
  template <typename GetMergeConflictsRequestT = Model::GetMergeConflictsRequest>
  void GetMergeConflictsAsync(const GetMergeConflictsRequestT& request, const GetMergeConflictsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetMergeConflicts, request, handler, context);
  }
 
  virtual Model::GetMergeOptionsOutcome GetMergeOptions(const Model::GetMergeOptionsRequest& request) const;
 
  template <typename GetMergeOptionsRequestT = Model::GetMergeOptionsRequest>
  Model::GetMergeOptionsOutcomeCallable GetMergeOptionsCallable(const GetMergeOptionsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetMergeOptions, request);
  }
 
  template <typename GetMergeOptionsRequestT = Model::GetMergeOptionsRequest>
  void GetMergeOptionsAsync(const GetMergeOptionsRequestT& request, const GetMergeOptionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetMergeOptions, request, handler, context);
  }
 
  virtual Model::GetPullRequestOutcome GetPullRequest(const Model::GetPullRequestRequest& request) const;
 
  template <typename GetPullRequestRequestT = Model::GetPullRequestRequest>
  Model::GetPullRequestOutcomeCallable GetPullRequestCallable(const GetPullRequestRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetPullRequest, request);
  }
 
  template <typename GetPullRequestRequestT = Model::GetPullRequestRequest>
  void GetPullRequestAsync(const GetPullRequestRequestT& request, const GetPullRequestResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetPullRequest, request, handler, context);
  }
 
  virtual Model::GetPullRequestApprovalStatesOutcome GetPullRequestApprovalStates(
      const Model::GetPullRequestApprovalStatesRequest& request) const;
 
  template <typename GetPullRequestApprovalStatesRequestT = Model::GetPullRequestApprovalStatesRequest>
  Model::GetPullRequestApprovalStatesOutcomeCallable GetPullRequestApprovalStatesCallable(
      const GetPullRequestApprovalStatesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetPullRequestApprovalStates, request);
  }
 
  template <typename GetPullRequestApprovalStatesRequestT = Model::GetPullRequestApprovalStatesRequest>
  void GetPullRequestApprovalStatesAsync(const GetPullRequestApprovalStatesRequestT& request,
                                         const GetPullRequestApprovalStatesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetPullRequestApprovalStates, request, handler, context);
  }
 
  virtual Model::GetPullRequestOverrideStateOutcome GetPullRequestOverrideState(
      const Model::GetPullRequestOverrideStateRequest& request) const;
 
  template <typename GetPullRequestOverrideStateRequestT = Model::GetPullRequestOverrideStateRequest>
  Model::GetPullRequestOverrideStateOutcomeCallable GetPullRequestOverrideStateCallable(
      const GetPullRequestOverrideStateRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetPullRequestOverrideState, request);
  }
 
  template <typename GetPullRequestOverrideStateRequestT = Model::GetPullRequestOverrideStateRequest>
  void GetPullRequestOverrideStateAsync(const GetPullRequestOverrideStateRequestT& request,
                                        const GetPullRequestOverrideStateResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetPullRequestOverrideState, request, handler, context);
  }
 
  virtual Model::GetRepositoryOutcome GetRepository(const Model::GetRepositoryRequest& request) const;
 
  template <typename GetRepositoryRequestT = Model::GetRepositoryRequest>
  Model::GetRepositoryOutcomeCallable GetRepositoryCallable(const GetRepositoryRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetRepository, request);
  }
 
  template <typename GetRepositoryRequestT = Model::GetRepositoryRequest>
  void GetRepositoryAsync(const GetRepositoryRequestT& request, const GetRepositoryResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetRepository, request, handler, context);
  }
 
  virtual Model::GetRepositoryTriggersOutcome GetRepositoryTriggers(const Model::GetRepositoryTriggersRequest& request) const;
 
  template <typename GetRepositoryTriggersRequestT = Model::GetRepositoryTriggersRequest>
  Model::GetRepositoryTriggersOutcomeCallable GetRepositoryTriggersCallable(const GetRepositoryTriggersRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::GetRepositoryTriggers, request);
  }
 
  template <typename GetRepositoryTriggersRequestT = Model::GetRepositoryTriggersRequest>
  void GetRepositoryTriggersAsync(const GetRepositoryTriggersRequestT& request, const GetRepositoryTriggersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::GetRepositoryTriggers, request, handler, context);
  }
 
  virtual Model::ListApprovalRuleTemplatesOutcome ListApprovalRuleTemplates(
      const Model::ListApprovalRuleTemplatesRequest& request = {}) const;
 
  template <typename ListApprovalRuleTemplatesRequestT = Model::ListApprovalRuleTemplatesRequest>
  Model::ListApprovalRuleTemplatesOutcomeCallable ListApprovalRuleTemplatesCallable(
      const ListApprovalRuleTemplatesRequestT& request = {}) const {
    return SubmitCallable(&CodeCommitClient::ListApprovalRuleTemplates, request);
  }
 
  template <typename ListApprovalRuleTemplatesRequestT = Model::ListApprovalRuleTemplatesRequest>
  void ListApprovalRuleTemplatesAsync(const ListApprovalRuleTemplatesResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListApprovalRuleTemplatesRequestT& request = {}) const {
    return SubmitAsync(&CodeCommitClient::ListApprovalRuleTemplates, request, handler, context);
  }
 
  virtual Model::ListAssociatedApprovalRuleTemplatesForRepositoryOutcome ListAssociatedApprovalRuleTemplatesForRepository(
      const Model::ListAssociatedApprovalRuleTemplatesForRepositoryRequest& request) const;
 
  template <
      typename ListAssociatedApprovalRuleTemplatesForRepositoryRequestT = Model::ListAssociatedApprovalRuleTemplatesForRepositoryRequest>
  Model::ListAssociatedApprovalRuleTemplatesForRepositoryOutcomeCallable ListAssociatedApprovalRuleTemplatesForRepositoryCallable(
      const ListAssociatedApprovalRuleTemplatesForRepositoryRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::ListAssociatedApprovalRuleTemplatesForRepository, request);
  }
 
  template <
      typename ListAssociatedApprovalRuleTemplatesForRepositoryRequestT = Model::ListAssociatedApprovalRuleTemplatesForRepositoryRequest>
  void ListAssociatedApprovalRuleTemplatesForRepositoryAsync(
      const ListAssociatedApprovalRuleTemplatesForRepositoryRequestT& request,
      const ListAssociatedApprovalRuleTemplatesForRepositoryResponseReceivedHandler& handler,
      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::ListAssociatedApprovalRuleTemplatesForRepository, request, handler, context);
  }
 
  virtual Model::ListBranchesOutcome ListBranches(const Model::ListBranchesRequest& request) const;
 
  template <typename ListBranchesRequestT = Model::ListBranchesRequest>
  Model::ListBranchesOutcomeCallable ListBranchesCallable(const ListBranchesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::ListBranches, request);
  }
 
  template <typename ListBranchesRequestT = Model::ListBranchesRequest>
  void ListBranchesAsync(const ListBranchesRequestT& request, const ListBranchesResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::ListBranches, request, handler, context);
  }
 
  virtual Model::ListFileCommitHistoryOutcome ListFileCommitHistory(const Model::ListFileCommitHistoryRequest& request) const;
 
  template <typename ListFileCommitHistoryRequestT = Model::ListFileCommitHistoryRequest>
  Model::ListFileCommitHistoryOutcomeCallable ListFileCommitHistoryCallable(const ListFileCommitHistoryRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::ListFileCommitHistory, request);
  }
 
  template <typename ListFileCommitHistoryRequestT = Model::ListFileCommitHistoryRequest>
  void ListFileCommitHistoryAsync(const ListFileCommitHistoryRequestT& request, const ListFileCommitHistoryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::ListFileCommitHistory, request, handler, context);
  }
 
  virtual Model::ListPullRequestsOutcome ListPullRequests(const Model::ListPullRequestsRequest& request) const;
 
  template <typename ListPullRequestsRequestT = Model::ListPullRequestsRequest>
  Model::ListPullRequestsOutcomeCallable ListPullRequestsCallable(const ListPullRequestsRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::ListPullRequests, request);
  }
 
  template <typename ListPullRequestsRequestT = Model::ListPullRequestsRequest>
  void ListPullRequestsAsync(const ListPullRequestsRequestT& request, const ListPullRequestsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::ListPullRequests, request, handler, context);
  }
 
  virtual Model::ListRepositoriesOutcome ListRepositories(const Model::ListRepositoriesRequest& request = {}) const;
 
  template <typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
  Model::ListRepositoriesOutcomeCallable ListRepositoriesCallable(const ListRepositoriesRequestT& request = {}) const {
    return SubmitCallable(&CodeCommitClient::ListRepositories, request);
  }
 
  template <typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
  void ListRepositoriesAsync(const ListRepositoriesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListRepositoriesRequestT& request = {}) const {
    return SubmitAsync(&CodeCommitClient::ListRepositories, request, handler, context);
  }
 
  virtual Model::ListRepositoriesForApprovalRuleTemplateOutcome ListRepositoriesForApprovalRuleTemplate(
      const Model::ListRepositoriesForApprovalRuleTemplateRequest& request) const;
 
  template <typename ListRepositoriesForApprovalRuleTemplateRequestT = Model::ListRepositoriesForApprovalRuleTemplateRequest>
  Model::ListRepositoriesForApprovalRuleTemplateOutcomeCallable ListRepositoriesForApprovalRuleTemplateCallable(
      const ListRepositoriesForApprovalRuleTemplateRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::ListRepositoriesForApprovalRuleTemplate, request);
  }
 
  template <typename ListRepositoriesForApprovalRuleTemplateRequestT = Model::ListRepositoriesForApprovalRuleTemplateRequest>
  void ListRepositoriesForApprovalRuleTemplateAsync(const ListRepositoriesForApprovalRuleTemplateRequestT& request,
                                                    const ListRepositoriesForApprovalRuleTemplateResponseReceivedHandler& handler,
                                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::ListRepositoriesForApprovalRuleTemplate, 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(&CodeCommitClient::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(&CodeCommitClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::MergeBranchesByFastForwardOutcome MergeBranchesByFastForward(
      const Model::MergeBranchesByFastForwardRequest& request) const;
 
  template <typename MergeBranchesByFastForwardRequestT = Model::MergeBranchesByFastForwardRequest>
  Model::MergeBranchesByFastForwardOutcomeCallable MergeBranchesByFastForwardCallable(
      const MergeBranchesByFastForwardRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::MergeBranchesByFastForward, request);
  }
 
  template <typename MergeBranchesByFastForwardRequestT = Model::MergeBranchesByFastForwardRequest>
  void MergeBranchesByFastForwardAsync(const MergeBranchesByFastForwardRequestT& request,
                                       const MergeBranchesByFastForwardResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::MergeBranchesByFastForward, request, handler, context);
  }
 
  virtual Model::MergeBranchesBySquashOutcome MergeBranchesBySquash(const Model::MergeBranchesBySquashRequest& request) const;
 
  template <typename MergeBranchesBySquashRequestT = Model::MergeBranchesBySquashRequest>
  Model::MergeBranchesBySquashOutcomeCallable MergeBranchesBySquashCallable(const MergeBranchesBySquashRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::MergeBranchesBySquash, request);
  }
 
  template <typename MergeBranchesBySquashRequestT = Model::MergeBranchesBySquashRequest>
  void MergeBranchesBySquashAsync(const MergeBranchesBySquashRequestT& request, const MergeBranchesBySquashResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::MergeBranchesBySquash, request, handler, context);
  }
 
  virtual Model::MergeBranchesByThreeWayOutcome MergeBranchesByThreeWay(const Model::MergeBranchesByThreeWayRequest& request) const;
 
  template <typename MergeBranchesByThreeWayRequestT = Model::MergeBranchesByThreeWayRequest>
  Model::MergeBranchesByThreeWayOutcomeCallable MergeBranchesByThreeWayCallable(const MergeBranchesByThreeWayRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::MergeBranchesByThreeWay, request);
  }
 
  template <typename MergeBranchesByThreeWayRequestT = Model::MergeBranchesByThreeWayRequest>
  void MergeBranchesByThreeWayAsync(const MergeBranchesByThreeWayRequestT& request,
                                    const MergeBranchesByThreeWayResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::MergeBranchesByThreeWay, request, handler, context);
  }
 
  virtual Model::MergePullRequestByFastForwardOutcome MergePullRequestByFastForward(
      const Model::MergePullRequestByFastForwardRequest& request) const;
 
  template <typename MergePullRequestByFastForwardRequestT = Model::MergePullRequestByFastForwardRequest>
  Model::MergePullRequestByFastForwardOutcomeCallable MergePullRequestByFastForwardCallable(
      const MergePullRequestByFastForwardRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::MergePullRequestByFastForward, request);
  }
 
  template <typename MergePullRequestByFastForwardRequestT = Model::MergePullRequestByFastForwardRequest>
  void MergePullRequestByFastForwardAsync(const MergePullRequestByFastForwardRequestT& request,
                                          const MergePullRequestByFastForwardResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::MergePullRequestByFastForward, request, handler, context);
  }
 
  virtual Model::MergePullRequestBySquashOutcome MergePullRequestBySquash(const Model::MergePullRequestBySquashRequest& request) const;
 
  template <typename MergePullRequestBySquashRequestT = Model::MergePullRequestBySquashRequest>
  Model::MergePullRequestBySquashOutcomeCallable MergePullRequestBySquashCallable(const MergePullRequestBySquashRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::MergePullRequestBySquash, request);
  }
 
  template <typename MergePullRequestBySquashRequestT = Model::MergePullRequestBySquashRequest>
  void MergePullRequestBySquashAsync(const MergePullRequestBySquashRequestT& request,
                                     const MergePullRequestBySquashResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::MergePullRequestBySquash, request, handler, context);
  }
 
  virtual Model::MergePullRequestByThreeWayOutcome MergePullRequestByThreeWay(
      const Model::MergePullRequestByThreeWayRequest& request) const;
 
  template <typename MergePullRequestByThreeWayRequestT = Model::MergePullRequestByThreeWayRequest>
  Model::MergePullRequestByThreeWayOutcomeCallable MergePullRequestByThreeWayCallable(
      const MergePullRequestByThreeWayRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::MergePullRequestByThreeWay, request);
  }
 
  template <typename MergePullRequestByThreeWayRequestT = Model::MergePullRequestByThreeWayRequest>
  void MergePullRequestByThreeWayAsync(const MergePullRequestByThreeWayRequestT& request,
                                       const MergePullRequestByThreeWayResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::MergePullRequestByThreeWay, request, handler, context);
  }
 
  virtual Model::OverridePullRequestApprovalRulesOutcome OverridePullRequestApprovalRules(
      const Model::OverridePullRequestApprovalRulesRequest& request) const;
 
  template <typename OverridePullRequestApprovalRulesRequestT = Model::OverridePullRequestApprovalRulesRequest>
  Model::OverridePullRequestApprovalRulesOutcomeCallable OverridePullRequestApprovalRulesCallable(
      const OverridePullRequestApprovalRulesRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::OverridePullRequestApprovalRules, request);
  }
 
  template <typename OverridePullRequestApprovalRulesRequestT = Model::OverridePullRequestApprovalRulesRequest>
  void OverridePullRequestApprovalRulesAsync(const OverridePullRequestApprovalRulesRequestT& request,
                                             const OverridePullRequestApprovalRulesResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::OverridePullRequestApprovalRules, request, handler, context);
  }
 
  virtual Model::PostCommentForComparedCommitOutcome PostCommentForComparedCommit(
      const Model::PostCommentForComparedCommitRequest& request) const;
 
  template <typename PostCommentForComparedCommitRequestT = Model::PostCommentForComparedCommitRequest>
  Model::PostCommentForComparedCommitOutcomeCallable PostCommentForComparedCommitCallable(
      const PostCommentForComparedCommitRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::PostCommentForComparedCommit, request);
  }
 
  template <typename PostCommentForComparedCommitRequestT = Model::PostCommentForComparedCommitRequest>
  void PostCommentForComparedCommitAsync(const PostCommentForComparedCommitRequestT& request,
                                         const PostCommentForComparedCommitResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::PostCommentForComparedCommit, request, handler, context);
  }
 
  virtual Model::PostCommentForPullRequestOutcome PostCommentForPullRequest(const Model::PostCommentForPullRequestRequest& request) const;
 
  template <typename PostCommentForPullRequestRequestT = Model::PostCommentForPullRequestRequest>
  Model::PostCommentForPullRequestOutcomeCallable PostCommentForPullRequestCallable(
      const PostCommentForPullRequestRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::PostCommentForPullRequest, request);
  }
 
  template <typename PostCommentForPullRequestRequestT = Model::PostCommentForPullRequestRequest>
  void PostCommentForPullRequestAsync(const PostCommentForPullRequestRequestT& request,
                                      const PostCommentForPullRequestResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::PostCommentForPullRequest, request, handler, context);
  }
 
  virtual Model::PostCommentReplyOutcome PostCommentReply(const Model::PostCommentReplyRequest& request) const;
 
  template <typename PostCommentReplyRequestT = Model::PostCommentReplyRequest>
  Model::PostCommentReplyOutcomeCallable PostCommentReplyCallable(const PostCommentReplyRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::PostCommentReply, request);
  }
 
  template <typename PostCommentReplyRequestT = Model::PostCommentReplyRequest>
  void PostCommentReplyAsync(const PostCommentReplyRequestT& request, const PostCommentReplyResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::PostCommentReply, request, handler, context);
  }
 
  virtual Model::PutCommentReactionOutcome PutCommentReaction(const Model::PutCommentReactionRequest& request) const;
 
  template <typename PutCommentReactionRequestT = Model::PutCommentReactionRequest>
  Model::PutCommentReactionOutcomeCallable PutCommentReactionCallable(const PutCommentReactionRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::PutCommentReaction, request);
  }
 
  template <typename PutCommentReactionRequestT = Model::PutCommentReactionRequest>
  void PutCommentReactionAsync(const PutCommentReactionRequestT& request, const PutCommentReactionResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::PutCommentReaction, request, handler, context);
  }
 
  virtual Model::PutFileOutcome PutFile(const Model::PutFileRequest& request) const;
 
  template <typename PutFileRequestT = Model::PutFileRequest>
  Model::PutFileOutcomeCallable PutFileCallable(const PutFileRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::PutFile, request);
  }
 
  template <typename PutFileRequestT = Model::PutFileRequest>
  void PutFileAsync(const PutFileRequestT& request, const PutFileResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::PutFile, request, handler, context);
  }
 
  virtual Model::PutRepositoryTriggersOutcome PutRepositoryTriggers(const Model::PutRepositoryTriggersRequest& request) const;
 
  template <typename PutRepositoryTriggersRequestT = Model::PutRepositoryTriggersRequest>
  Model::PutRepositoryTriggersOutcomeCallable PutRepositoryTriggersCallable(const PutRepositoryTriggersRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::PutRepositoryTriggers, request);
  }
 
  template <typename PutRepositoryTriggersRequestT = Model::PutRepositoryTriggersRequest>
  void PutRepositoryTriggersAsync(const PutRepositoryTriggersRequestT& request, const PutRepositoryTriggersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::PutRepositoryTriggers, 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(&CodeCommitClient::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(&CodeCommitClient::TagResource, request, handler, context);
  }
 
  virtual Model::TestRepositoryTriggersOutcome TestRepositoryTriggers(const Model::TestRepositoryTriggersRequest& request) const;
 
  template <typename TestRepositoryTriggersRequestT = Model::TestRepositoryTriggersRequest>
  Model::TestRepositoryTriggersOutcomeCallable TestRepositoryTriggersCallable(const TestRepositoryTriggersRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::TestRepositoryTriggers, request);
  }
 
  template <typename TestRepositoryTriggersRequestT = Model::TestRepositoryTriggersRequest>
  void TestRepositoryTriggersAsync(const TestRepositoryTriggersRequestT& request,
                                   const TestRepositoryTriggersResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::TestRepositoryTriggers, 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(&CodeCommitClient::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(&CodeCommitClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateApprovalRuleTemplateContentOutcome UpdateApprovalRuleTemplateContent(
      const Model::UpdateApprovalRuleTemplateContentRequest& request) const;
 
  template <typename UpdateApprovalRuleTemplateContentRequestT = Model::UpdateApprovalRuleTemplateContentRequest>
  Model::UpdateApprovalRuleTemplateContentOutcomeCallable UpdateApprovalRuleTemplateContentCallable(
      const UpdateApprovalRuleTemplateContentRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateApprovalRuleTemplateContent, request);
  }
 
  template <typename UpdateApprovalRuleTemplateContentRequestT = Model::UpdateApprovalRuleTemplateContentRequest>
  void UpdateApprovalRuleTemplateContentAsync(const UpdateApprovalRuleTemplateContentRequestT& request,
                                              const UpdateApprovalRuleTemplateContentResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateApprovalRuleTemplateContent, request, handler, context);
  }
 
  virtual Model::UpdateApprovalRuleTemplateDescriptionOutcome UpdateApprovalRuleTemplateDescription(
      const Model::UpdateApprovalRuleTemplateDescriptionRequest& request) const;
 
  template <typename UpdateApprovalRuleTemplateDescriptionRequestT = Model::UpdateApprovalRuleTemplateDescriptionRequest>
  Model::UpdateApprovalRuleTemplateDescriptionOutcomeCallable UpdateApprovalRuleTemplateDescriptionCallable(
      const UpdateApprovalRuleTemplateDescriptionRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateApprovalRuleTemplateDescription, request);
  }
 
  template <typename UpdateApprovalRuleTemplateDescriptionRequestT = Model::UpdateApprovalRuleTemplateDescriptionRequest>
  void UpdateApprovalRuleTemplateDescriptionAsync(const UpdateApprovalRuleTemplateDescriptionRequestT& request,
                                                  const UpdateApprovalRuleTemplateDescriptionResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateApprovalRuleTemplateDescription, request, handler, context);
  }
 
  virtual Model::UpdateApprovalRuleTemplateNameOutcome UpdateApprovalRuleTemplateName(
      const Model::UpdateApprovalRuleTemplateNameRequest& request) const;
 
  template <typename UpdateApprovalRuleTemplateNameRequestT = Model::UpdateApprovalRuleTemplateNameRequest>
  Model::UpdateApprovalRuleTemplateNameOutcomeCallable UpdateApprovalRuleTemplateNameCallable(
      const UpdateApprovalRuleTemplateNameRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateApprovalRuleTemplateName, request);
  }
 
  template <typename UpdateApprovalRuleTemplateNameRequestT = Model::UpdateApprovalRuleTemplateNameRequest>
  void UpdateApprovalRuleTemplateNameAsync(const UpdateApprovalRuleTemplateNameRequestT& request,
                                           const UpdateApprovalRuleTemplateNameResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateApprovalRuleTemplateName, request, handler, context);
  }
 
  virtual Model::UpdateCommentOutcome UpdateComment(const Model::UpdateCommentRequest& request) const;
 
  template <typename UpdateCommentRequestT = Model::UpdateCommentRequest>
  Model::UpdateCommentOutcomeCallable UpdateCommentCallable(const UpdateCommentRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateComment, request);
  }
 
  template <typename UpdateCommentRequestT = Model::UpdateCommentRequest>
  void UpdateCommentAsync(const UpdateCommentRequestT& request, const UpdateCommentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateComment, request, handler, context);
  }
 
  virtual Model::UpdateDefaultBranchOutcome UpdateDefaultBranch(const Model::UpdateDefaultBranchRequest& request) const;
 
  template <typename UpdateDefaultBranchRequestT = Model::UpdateDefaultBranchRequest>
  Model::UpdateDefaultBranchOutcomeCallable UpdateDefaultBranchCallable(const UpdateDefaultBranchRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateDefaultBranch, request);
  }
 
  template <typename UpdateDefaultBranchRequestT = Model::UpdateDefaultBranchRequest>
  void UpdateDefaultBranchAsync(const UpdateDefaultBranchRequestT& request, const UpdateDefaultBranchResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateDefaultBranch, request, handler, context);
  }
 
  virtual Model::UpdatePullRequestApprovalRuleContentOutcome UpdatePullRequestApprovalRuleContent(
      const Model::UpdatePullRequestApprovalRuleContentRequest& request) const;
 
  template <typename UpdatePullRequestApprovalRuleContentRequestT = Model::UpdatePullRequestApprovalRuleContentRequest>
  Model::UpdatePullRequestApprovalRuleContentOutcomeCallable UpdatePullRequestApprovalRuleContentCallable(
      const UpdatePullRequestApprovalRuleContentRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdatePullRequestApprovalRuleContent, request);
  }
 
  template <typename UpdatePullRequestApprovalRuleContentRequestT = Model::UpdatePullRequestApprovalRuleContentRequest>
  void UpdatePullRequestApprovalRuleContentAsync(const UpdatePullRequestApprovalRuleContentRequestT& request,
                                                 const UpdatePullRequestApprovalRuleContentResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdatePullRequestApprovalRuleContent, request, handler, context);
  }
 
  virtual Model::UpdatePullRequestApprovalStateOutcome UpdatePullRequestApprovalState(
      const Model::UpdatePullRequestApprovalStateRequest& request) const;
 
  template <typename UpdatePullRequestApprovalStateRequestT = Model::UpdatePullRequestApprovalStateRequest>
  Model::UpdatePullRequestApprovalStateOutcomeCallable UpdatePullRequestApprovalStateCallable(
      const UpdatePullRequestApprovalStateRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdatePullRequestApprovalState, request);
  }
 
  template <typename UpdatePullRequestApprovalStateRequestT = Model::UpdatePullRequestApprovalStateRequest>
  void UpdatePullRequestApprovalStateAsync(const UpdatePullRequestApprovalStateRequestT& request,
                                           const UpdatePullRequestApprovalStateResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdatePullRequestApprovalState, request, handler, context);
  }
 
  virtual Model::UpdatePullRequestDescriptionOutcome UpdatePullRequestDescription(
      const Model::UpdatePullRequestDescriptionRequest& request) const;
 
  template <typename UpdatePullRequestDescriptionRequestT = Model::UpdatePullRequestDescriptionRequest>
  Model::UpdatePullRequestDescriptionOutcomeCallable UpdatePullRequestDescriptionCallable(
      const UpdatePullRequestDescriptionRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdatePullRequestDescription, request);
  }
 
  template <typename UpdatePullRequestDescriptionRequestT = Model::UpdatePullRequestDescriptionRequest>
  void UpdatePullRequestDescriptionAsync(const UpdatePullRequestDescriptionRequestT& request,
                                         const UpdatePullRequestDescriptionResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdatePullRequestDescription, request, handler, context);
  }
 
  virtual Model::UpdatePullRequestStatusOutcome UpdatePullRequestStatus(const Model::UpdatePullRequestStatusRequest& request) const;
 
  template <typename UpdatePullRequestStatusRequestT = Model::UpdatePullRequestStatusRequest>
  Model::UpdatePullRequestStatusOutcomeCallable UpdatePullRequestStatusCallable(const UpdatePullRequestStatusRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdatePullRequestStatus, request);
  }
 
  template <typename UpdatePullRequestStatusRequestT = Model::UpdatePullRequestStatusRequest>
  void UpdatePullRequestStatusAsync(const UpdatePullRequestStatusRequestT& request,
                                    const UpdatePullRequestStatusResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdatePullRequestStatus, request, handler, context);
  }
 
  virtual Model::UpdatePullRequestTitleOutcome UpdatePullRequestTitle(const Model::UpdatePullRequestTitleRequest& request) const;
 
  template <typename UpdatePullRequestTitleRequestT = Model::UpdatePullRequestTitleRequest>
  Model::UpdatePullRequestTitleOutcomeCallable UpdatePullRequestTitleCallable(const UpdatePullRequestTitleRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdatePullRequestTitle, request);
  }
 
  template <typename UpdatePullRequestTitleRequestT = Model::UpdatePullRequestTitleRequest>
  void UpdatePullRequestTitleAsync(const UpdatePullRequestTitleRequestT& request,
                                   const UpdatePullRequestTitleResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdatePullRequestTitle, request, handler, context);
  }
 
  virtual Model::UpdateRepositoryDescriptionOutcome UpdateRepositoryDescription(
      const Model::UpdateRepositoryDescriptionRequest& request) const;
 
  template <typename UpdateRepositoryDescriptionRequestT = Model::UpdateRepositoryDescriptionRequest>
  Model::UpdateRepositoryDescriptionOutcomeCallable UpdateRepositoryDescriptionCallable(
      const UpdateRepositoryDescriptionRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateRepositoryDescription, request);
  }
 
  template <typename UpdateRepositoryDescriptionRequestT = Model::UpdateRepositoryDescriptionRequest>
  void UpdateRepositoryDescriptionAsync(const UpdateRepositoryDescriptionRequestT& request,
                                        const UpdateRepositoryDescriptionResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateRepositoryDescription, request, handler, context);
  }
 
  virtual Model::UpdateRepositoryEncryptionKeyOutcome UpdateRepositoryEncryptionKey(
      const Model::UpdateRepositoryEncryptionKeyRequest& request) const;
 
  template <typename UpdateRepositoryEncryptionKeyRequestT = Model::UpdateRepositoryEncryptionKeyRequest>
  Model::UpdateRepositoryEncryptionKeyOutcomeCallable UpdateRepositoryEncryptionKeyCallable(
      const UpdateRepositoryEncryptionKeyRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateRepositoryEncryptionKey, request);
  }
 
  template <typename UpdateRepositoryEncryptionKeyRequestT = Model::UpdateRepositoryEncryptionKeyRequest>
  void UpdateRepositoryEncryptionKeyAsync(const UpdateRepositoryEncryptionKeyRequestT& request,
                                          const UpdateRepositoryEncryptionKeyResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateRepositoryEncryptionKey, request, handler, context);
  }
 
  virtual Model::UpdateRepositoryNameOutcome UpdateRepositoryName(const Model::UpdateRepositoryNameRequest& request) const;
 
  template <typename UpdateRepositoryNameRequestT = Model::UpdateRepositoryNameRequest>
  Model::UpdateRepositoryNameOutcomeCallable UpdateRepositoryNameCallable(const UpdateRepositoryNameRequestT& request) const {
    return SubmitCallable(&CodeCommitClient::UpdateRepositoryName, request);
  }
 
  template <typename UpdateRepositoryNameRequestT = Model::UpdateRepositoryNameRequest>
  void UpdateRepositoryNameAsync(const UpdateRepositoryNameRequestT& request, const UpdateRepositoryNameResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeCommitClient::UpdateRepositoryName, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CodeCommitEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeCommitClient>;
  void init(const CodeCommitClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CodeCommitError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CodeCommitClientConfiguration m_clientConfiguration;
  std::shared_ptr<CodeCommitEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CodeCommit
}  // namespace Aws