CodeCommitClient.h

 
#pragma once
#include <aws/codecommit/CodeCommit_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/codecommit/CodeCommitServiceClientModel.h>
 
namespace Aws
{
namespace CodeCommit
{
  class AWS_CODECOMMIT_API CodeCommitClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodeCommitEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeCommitClient>;
      void init(const CodeCommitClientConfiguration& clientConfiguration);
 
      CodeCommitClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodeCommitEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodeCommit
} // namespace Aws