/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace CodeCommit { /** * AWS CodeCommit

This is the AWS CodeCommit API * Reference. This reference provides descriptions of the operations and data * types for AWS CodeCommit API along with usage examples.

You can use the * AWS CodeCommit API to work with the following objects:

Repositories, by * calling the following:

  • BatchGetRepositories, which * returns information about one or more repositories associated with your AWS * account.

  • CreateRepository, which creates an AWS * CodeCommit repository.

  • DeleteRepository, which deletes * an AWS CodeCommit repository.

  • GetRepository, which * returns information about a specified repository.

  • * ListRepositories, which lists all AWS CodeCommit repositories associated * with your AWS account.

  • UpdateRepositoryDescription, * which sets or updates the description of the repository.

  • * UpdateRepositoryName, which changes the name of the repository. If you * change the name of a repository, no other users of that repository can access it * until you send them the new HTTPS or SSH URL to use.

*

Branches, by calling the following:

  • CreateBranch, * which creates a branch in a specified repository.

  • * DeleteBranch, which deletes the specified branch in a repository unless * it is the default branch.

  • GetBranch, which returns * information about a specified branch.

  • ListBranches, * which lists all branches for a specified repository.

  • * UpdateDefaultBranch, which changes the default branch for a * repository.

Files, by calling the following:

  • *

    DeleteFile, which deletes the content of a specified file from a * specified branch.

  • GetBlob, which returns the base-64 * encoded content of an individual Git blob object in a repository.

  • *

    GetFile, which returns the base-64 encoded content of a specified * file.

  • GetFolder, which returns the contents of a * specified folder or directory.

  • PutFile, which adds or * modifies a single file in a specified repository and branch.

*

Commits, by calling the following:

  • BatchGetCommits, * which returns information about one or more commits in a repository.

    • *

  • CreateCommit, which creates a commit for changes to a * repository.

  • GetCommit, which returns information about * a commit, including commit messages and author and committer information.

    *

  • GetDifferences, which returns information about the * differences in a valid commit specifier (such as a branch, tag, HEAD, commit ID, * or other fully qualified reference).

Merges, by calling the * following:

  • BatchDescribeMergeConflicts, which returns * information about conflicts in a merge between commits in a repository.

    *

  • CreateUnreferencedMergeCommit, which creates an * unreferenced commit between two branches or commits for the purpose of comparing * them and identifying any potential conflicts.

  • * DescribeMergeConflicts, which returns information about merge conflicts * between the base, source, and destination versions of a file in a potential * merge.

  • GetMergeCommit, which returns information about * the merge between a source and destination commit.

  • * GetMergeConflicts, which returns information about merge conflicts * between the source and destination branch in a pull request.

  • * GetMergeOptions, which returns information about the available merge * options between two branches or commit specifiers.

  • * MergeBranchesByFastForward, which merges two branches using the * fast-forward merge option.

  • MergeBranchesBySquash, * which merges two branches using the squash merge option.

  • * MergeBranchesByThreeWay, which merges two branches using the three-way * merge option.

Pull requests, by calling the following:

*

Approval rule templates, by calling the * following:

*

Comments in a repository, by calling the following:

Tags used to tag * resources in AWS CodeCommit (not Git tags), by calling the following:

    *

  • ListTagsForResource, which gets information about AWS tags for a * specified Amazon Resource Name (ARN) in AWS CodeCommit.

  • * TagResource, which adds or updates tags for a resource in AWS * CodeCommit.

  • UntagResource, which removes tags for a * resource in AWS CodeCommit.

Triggers, by calling the * following:

  • GetRepositoryTriggers, which returns * information about triggers configured for a repository.

  • * PutRepositoryTriggers, which replaces all triggers for a repository and * can be used to create or delete triggers.

  • * TestRepositoryTriggers, which tests the functionality of a repository * trigger by sending data to the trigger target.

For * information about how to use AWS CodeCommit, see the AWS * CodeCommit User Guide.

*/ class AWS_CODECOMMIT_API CodeCommitClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef CodeCommitClientConfiguration ClientConfigurationType; typedef CodeCommitEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CodeCommitClient(const Aws::CodeCommit::CodeCommitClientConfiguration& clientConfiguration = Aws::CodeCommit::CodeCommitClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CodeCommitClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CodeCommit::CodeCommitClientConfiguration& clientConfiguration = Aws::CodeCommit::CodeCommitClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ CodeCommitClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::CodeCommit::CodeCommitClientConfiguration& clientConfiguration = Aws::CodeCommit::CodeCommitClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CodeCommitClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ CodeCommitClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ CodeCommitClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~CodeCommitClient(); /** *

Creates an association between an approval rule template and a specified * repository. Then, the next time a pull request is created in the repository * where the destination reference (if specified) matches the destination reference * (branch) for the pull request, an approval rule that matches the template * conditions is automatically created for that pull request. If no destination * references are specified in the template, an approval rule that matches the * template contents is created for all pull requests in that * repository.

See Also:

AWS * API Reference

*/ virtual Model::AssociateApprovalRuleTemplateWithRepositoryOutcome AssociateApprovalRuleTemplateWithRepository(const Model::AssociateApprovalRuleTemplateWithRepositoryRequest& request) const; /** * A Callable wrapper for AssociateApprovalRuleTemplateWithRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateApprovalRuleTemplateWithRepositoryOutcomeCallable AssociateApprovalRuleTemplateWithRepositoryCallable(const AssociateApprovalRuleTemplateWithRepositoryRequestT& request) const { return SubmitCallable(&CodeCommitClient::AssociateApprovalRuleTemplateWithRepository, request); } /** * An Async wrapper for AssociateApprovalRuleTemplateWithRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateApprovalRuleTemplateWithRepositoryAsync(const AssociateApprovalRuleTemplateWithRepositoryRequestT& request, const AssociateApprovalRuleTemplateWithRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::AssociateApprovalRuleTemplateWithRepository, request, handler, context); } /** *

Creates an association between an approval rule template and one or more * specified repositories.

See Also:

AWS * API Reference

*/ virtual Model::BatchAssociateApprovalRuleTemplateWithRepositoriesOutcome BatchAssociateApprovalRuleTemplateWithRepositories(const Model::BatchAssociateApprovalRuleTemplateWithRepositoriesRequest& request) const; /** * A Callable wrapper for BatchAssociateApprovalRuleTemplateWithRepositories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchAssociateApprovalRuleTemplateWithRepositoriesOutcomeCallable BatchAssociateApprovalRuleTemplateWithRepositoriesCallable(const BatchAssociateApprovalRuleTemplateWithRepositoriesRequestT& request) const { return SubmitCallable(&CodeCommitClient::BatchAssociateApprovalRuleTemplateWithRepositories, request); } /** * An Async wrapper for BatchAssociateApprovalRuleTemplateWithRepositories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchAssociateApprovalRuleTemplateWithRepositoriesAsync(const BatchAssociateApprovalRuleTemplateWithRepositoriesRequestT& request, const BatchAssociateApprovalRuleTemplateWithRepositoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::BatchAssociateApprovalRuleTemplateWithRepositories, request, handler, context); } /** *

Returns information about one or more merge conflicts in the attempted merge * of two commit specifiers using the squash or three-way merge * strategy.

See Also:

AWS * API Reference

*/ virtual Model::BatchDescribeMergeConflictsOutcome BatchDescribeMergeConflicts(const Model::BatchDescribeMergeConflictsRequest& request) const; /** * A Callable wrapper for BatchDescribeMergeConflicts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDescribeMergeConflictsOutcomeCallable BatchDescribeMergeConflictsCallable(const BatchDescribeMergeConflictsRequestT& request) const { return SubmitCallable(&CodeCommitClient::BatchDescribeMergeConflicts, request); } /** * An Async wrapper for BatchDescribeMergeConflicts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDescribeMergeConflictsAsync(const BatchDescribeMergeConflictsRequestT& request, const BatchDescribeMergeConflictsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::BatchDescribeMergeConflicts, request, handler, context); } /** *

Removes the association between an approval rule template and one or more * specified repositories.

See Also:

AWS * API Reference

*/ virtual Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesOutcome BatchDisassociateApprovalRuleTemplateFromRepositories(const Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesRequest& request) const; /** * A Callable wrapper for BatchDisassociateApprovalRuleTemplateFromRepositories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDisassociateApprovalRuleTemplateFromRepositoriesOutcomeCallable BatchDisassociateApprovalRuleTemplateFromRepositoriesCallable(const BatchDisassociateApprovalRuleTemplateFromRepositoriesRequestT& request) const { return SubmitCallable(&CodeCommitClient::BatchDisassociateApprovalRuleTemplateFromRepositories, request); } /** * An Async wrapper for BatchDisassociateApprovalRuleTemplateFromRepositories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDisassociateApprovalRuleTemplateFromRepositoriesAsync(const BatchDisassociateApprovalRuleTemplateFromRepositoriesRequestT& request, const BatchDisassociateApprovalRuleTemplateFromRepositoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::BatchDisassociateApprovalRuleTemplateFromRepositories, request, handler, context); } /** *

Returns information about the contents of one or more commits in a * repository.

See Also:

AWS * API Reference

*/ virtual Model::BatchGetCommitsOutcome BatchGetCommits(const Model::BatchGetCommitsRequest& request) const; /** * A Callable wrapper for BatchGetCommits that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetCommitsOutcomeCallable BatchGetCommitsCallable(const BatchGetCommitsRequestT& request) const { return SubmitCallable(&CodeCommitClient::BatchGetCommits, request); } /** * An Async wrapper for BatchGetCommits that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetCommitsAsync(const BatchGetCommitsRequestT& request, const BatchGetCommitsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::BatchGetCommits, request, handler, context); } /** *

Returns information about one or more repositories.

The * description field for a repository accepts all HTML characters and all valid * Unicode characters. Applications that do not HTML-encode the description and * display it in a webpage can expose users to potentially malicious code. Make * sure that you HTML-encode the description field in any application that uses * this API to display the repository description on a webpage.

*

See Also:

AWS * API Reference

*/ virtual Model::BatchGetRepositoriesOutcome BatchGetRepositories(const Model::BatchGetRepositoriesRequest& request) const; /** * A Callable wrapper for BatchGetRepositories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchGetRepositoriesOutcomeCallable BatchGetRepositoriesCallable(const BatchGetRepositoriesRequestT& request) const { return SubmitCallable(&CodeCommitClient::BatchGetRepositories, request); } /** * An Async wrapper for BatchGetRepositories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchGetRepositoriesAsync(const BatchGetRepositoriesRequestT& request, const BatchGetRepositoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::BatchGetRepositories, request, handler, context); } /** *

Creates a template for approval rules that can then be associated with one or * more repositories in your AWS account. When you associate a template with a * repository, AWS CodeCommit creates an approval rule that matches the conditions * of the template for all pull requests that meet the conditions of the template. * For more information, see * AssociateApprovalRuleTemplateWithRepository.

See Also:

* AWS * API Reference

*/ virtual Model::CreateApprovalRuleTemplateOutcome CreateApprovalRuleTemplate(const Model::CreateApprovalRuleTemplateRequest& request) const; /** * A Callable wrapper for CreateApprovalRuleTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateApprovalRuleTemplateOutcomeCallable CreateApprovalRuleTemplateCallable(const CreateApprovalRuleTemplateRequestT& request) const { return SubmitCallable(&CodeCommitClient::CreateApprovalRuleTemplate, request); } /** * An Async wrapper for CreateApprovalRuleTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateApprovalRuleTemplateAsync(const CreateApprovalRuleTemplateRequestT& request, const CreateApprovalRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::CreateApprovalRuleTemplate, request, handler, context); } /** *

Creates a branch in a repository and points the branch to a commit.

*

Calling the create branch operation does not set a repository's * default branch. To do this, call the update default branch operation.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateBranchOutcome CreateBranch(const Model::CreateBranchRequest& request) const; /** * A Callable wrapper for CreateBranch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBranchOutcomeCallable CreateBranchCallable(const CreateBranchRequestT& request) const { return SubmitCallable(&CodeCommitClient::CreateBranch, request); } /** * An Async wrapper for CreateBranch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBranchAsync(const CreateBranchRequestT& request, const CreateBranchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::CreateBranch, request, handler, context); } /** *

Creates a commit for a repository on the tip of a specified * branch.

See Also:

AWS * API Reference

*/ virtual Model::CreateCommitOutcome CreateCommit(const Model::CreateCommitRequest& request) const; /** * A Callable wrapper for CreateCommit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCommitOutcomeCallable CreateCommitCallable(const CreateCommitRequestT& request) const { return SubmitCallable(&CodeCommitClient::CreateCommit, request); } /** * An Async wrapper for CreateCommit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCommitAsync(const CreateCommitRequestT& request, const CreateCommitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::CreateCommit, request, handler, context); } /** *

Creates a pull request in the specified repository.

See Also:

* AWS * API Reference

*/ virtual Model::CreatePullRequestOutcome CreatePullRequest(const Model::CreatePullRequestRequest& request) const; /** * A Callable wrapper for CreatePullRequest that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePullRequestOutcomeCallable CreatePullRequestCallable(const CreatePullRequestRequestT& request) const { return SubmitCallable(&CodeCommitClient::CreatePullRequest, request); } /** * An Async wrapper for CreatePullRequest that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePullRequestAsync(const CreatePullRequestRequestT& request, const CreatePullRequestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::CreatePullRequest, request, handler, context); } /** *

Creates an approval rule for a pull request.

See Also:

AWS * API Reference

*/ virtual Model::CreatePullRequestApprovalRuleOutcome CreatePullRequestApprovalRule(const Model::CreatePullRequestApprovalRuleRequest& request) const; /** * A Callable wrapper for CreatePullRequestApprovalRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreatePullRequestApprovalRuleOutcomeCallable CreatePullRequestApprovalRuleCallable(const CreatePullRequestApprovalRuleRequestT& request) const { return SubmitCallable(&CodeCommitClient::CreatePullRequestApprovalRule, request); } /** * An Async wrapper for CreatePullRequestApprovalRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreatePullRequestApprovalRuleAsync(const CreatePullRequestApprovalRuleRequestT& request, const CreatePullRequestApprovalRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::CreatePullRequestApprovalRule, request, handler, context); } /** *

Creates a new, empty repository.

See Also:

AWS * API Reference

*/ virtual Model::CreateRepositoryOutcome CreateRepository(const Model::CreateRepositoryRequest& request) const; /** * A Callable wrapper for CreateRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRepositoryOutcomeCallable CreateRepositoryCallable(const CreateRepositoryRequestT& request) const { return SubmitCallable(&CodeCommitClient::CreateRepository, request); } /** * An Async wrapper for CreateRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRepositoryAsync(const CreateRepositoryRequestT& request, const CreateRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::CreateRepository, request, handler, context); } /** *

Creates an unreferenced commit that represents the result of merging two * branches using a specified merge strategy. This can help you determine the * outcome of a potential merge. This API cannot be used with the fast-forward * merge strategy because that strategy does not create a merge commit.

*

This unreferenced merge commit can only be accessed using the GetCommit API * or through git commands such as git fetch. To retrieve this commit, you must * specify its commit ID or otherwise reference it.

See * Also:

AWS * API Reference

*/ virtual Model::CreateUnreferencedMergeCommitOutcome CreateUnreferencedMergeCommit(const Model::CreateUnreferencedMergeCommitRequest& request) const; /** * A Callable wrapper for CreateUnreferencedMergeCommit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUnreferencedMergeCommitOutcomeCallable CreateUnreferencedMergeCommitCallable(const CreateUnreferencedMergeCommitRequestT& request) const { return SubmitCallable(&CodeCommitClient::CreateUnreferencedMergeCommit, request); } /** * An Async wrapper for CreateUnreferencedMergeCommit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUnreferencedMergeCommitAsync(const CreateUnreferencedMergeCommitRequestT& request, const CreateUnreferencedMergeCommitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::CreateUnreferencedMergeCommit, request, handler, context); } /** *

Deletes a specified approval rule template. Deleting a template does not * remove approval rules on pull requests already created with the * template.

See Also:

AWS * API Reference

*/ virtual Model::DeleteApprovalRuleTemplateOutcome DeleteApprovalRuleTemplate(const Model::DeleteApprovalRuleTemplateRequest& request) const; /** * A Callable wrapper for DeleteApprovalRuleTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteApprovalRuleTemplateOutcomeCallable DeleteApprovalRuleTemplateCallable(const DeleteApprovalRuleTemplateRequestT& request) const { return SubmitCallable(&CodeCommitClient::DeleteApprovalRuleTemplate, request); } /** * An Async wrapper for DeleteApprovalRuleTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteApprovalRuleTemplateAsync(const DeleteApprovalRuleTemplateRequestT& request, const DeleteApprovalRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DeleteApprovalRuleTemplate, request, handler, context); } /** *

Deletes a branch from a repository, unless that branch is the default branch * for the repository.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBranchOutcome DeleteBranch(const Model::DeleteBranchRequest& request) const; /** * A Callable wrapper for DeleteBranch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBranchOutcomeCallable DeleteBranchCallable(const DeleteBranchRequestT& request) const { return SubmitCallable(&CodeCommitClient::DeleteBranch, request); } /** * An Async wrapper for DeleteBranch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBranchAsync(const DeleteBranchRequestT& request, const DeleteBranchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DeleteBranch, request, handler, context); } /** *

Deletes the content of a comment made on a change, file, or commit in a * repository.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCommentContentOutcome DeleteCommentContent(const Model::DeleteCommentContentRequest& request) const; /** * A Callable wrapper for DeleteCommentContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCommentContentOutcomeCallable DeleteCommentContentCallable(const DeleteCommentContentRequestT& request) const { return SubmitCallable(&CodeCommitClient::DeleteCommentContent, request); } /** * An Async wrapper for DeleteCommentContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCommentContentAsync(const DeleteCommentContentRequestT& request, const DeleteCommentContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DeleteCommentContent, request, handler, context); } /** *

Deletes a specified file from a specified branch. A commit is created on the * branch that contains the revision. The file still exists in the commits earlier * to the commit that contains the deletion.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFileOutcome DeleteFile(const Model::DeleteFileRequest& request) const; /** * A Callable wrapper for DeleteFile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFileOutcomeCallable DeleteFileCallable(const DeleteFileRequestT& request) const { return SubmitCallable(&CodeCommitClient::DeleteFile, request); } /** * An Async wrapper for DeleteFile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFileAsync(const DeleteFileRequestT& request, const DeleteFileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DeleteFile, request, handler, context); } /** *

Deletes an approval rule from a specified pull request. Approval rules can be * deleted from a pull request only if the pull request is open, and if the * approval rule was created specifically for a pull request and not generated from * an approval rule template associated with the repository where the pull request * was created. You cannot delete an approval rule from a merged or closed pull * request.

See Also:

AWS * API Reference

*/ virtual Model::DeletePullRequestApprovalRuleOutcome DeletePullRequestApprovalRule(const Model::DeletePullRequestApprovalRuleRequest& request) const; /** * A Callable wrapper for DeletePullRequestApprovalRule that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeletePullRequestApprovalRuleOutcomeCallable DeletePullRequestApprovalRuleCallable(const DeletePullRequestApprovalRuleRequestT& request) const { return SubmitCallable(&CodeCommitClient::DeletePullRequestApprovalRule, request); } /** * An Async wrapper for DeletePullRequestApprovalRule that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeletePullRequestApprovalRuleAsync(const DeletePullRequestApprovalRuleRequestT& request, const DeletePullRequestApprovalRuleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DeletePullRequestApprovalRule, request, handler, context); } /** *

Deletes a repository. If a specified repository was already deleted, a null * repository ID is returned.

Deleting a repository also deletes * all associated objects and metadata. After a repository is deleted, all future * push calls to the deleted repository fail.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteRepositoryOutcome DeleteRepository(const Model::DeleteRepositoryRequest& request) const; /** * A Callable wrapper for DeleteRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRepositoryOutcomeCallable DeleteRepositoryCallable(const DeleteRepositoryRequestT& request) const { return SubmitCallable(&CodeCommitClient::DeleteRepository, request); } /** * An Async wrapper for DeleteRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRepositoryAsync(const DeleteRepositoryRequestT& request, const DeleteRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DeleteRepository, request, handler, context); } /** *

Returns information about one or more merge conflicts in the attempted merge * of two commit specifiers using the squash or three-way merge strategy. If the * merge option for the attempted merge is specified as FAST_FORWARD_MERGE, an * exception is thrown.

See Also:

AWS * API Reference

*/ virtual Model::DescribeMergeConflictsOutcome DescribeMergeConflicts(const Model::DescribeMergeConflictsRequest& request) const; /** * A Callable wrapper for DescribeMergeConflicts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeMergeConflictsOutcomeCallable DescribeMergeConflictsCallable(const DescribeMergeConflictsRequestT& request) const { return SubmitCallable(&CodeCommitClient::DescribeMergeConflicts, request); } /** * An Async wrapper for DescribeMergeConflicts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeMergeConflictsAsync(const DescribeMergeConflictsRequestT& request, const DescribeMergeConflictsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DescribeMergeConflicts, request, handler, context); } /** *

Returns information about one or more pull request events.

See * Also:

AWS * API Reference

*/ virtual Model::DescribePullRequestEventsOutcome DescribePullRequestEvents(const Model::DescribePullRequestEventsRequest& request) const; /** * A Callable wrapper for DescribePullRequestEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePullRequestEventsOutcomeCallable DescribePullRequestEventsCallable(const DescribePullRequestEventsRequestT& request) const { return SubmitCallable(&CodeCommitClient::DescribePullRequestEvents, request); } /** * An Async wrapper for DescribePullRequestEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePullRequestEventsAsync(const DescribePullRequestEventsRequestT& request, const DescribePullRequestEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DescribePullRequestEvents, request, handler, context); } /** *

Removes the association between a template and a repository so that approval * rules based on the template are not automatically created when pull requests are * created in the specified repository. This does not delete any approval rules * previously created for pull requests through the template * association.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateApprovalRuleTemplateFromRepositoryOutcome DisassociateApprovalRuleTemplateFromRepository(const Model::DisassociateApprovalRuleTemplateFromRepositoryRequest& request) const; /** * A Callable wrapper for DisassociateApprovalRuleTemplateFromRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateApprovalRuleTemplateFromRepositoryOutcomeCallable DisassociateApprovalRuleTemplateFromRepositoryCallable(const DisassociateApprovalRuleTemplateFromRepositoryRequestT& request) const { return SubmitCallable(&CodeCommitClient::DisassociateApprovalRuleTemplateFromRepository, request); } /** * An Async wrapper for DisassociateApprovalRuleTemplateFromRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateApprovalRuleTemplateFromRepositoryAsync(const DisassociateApprovalRuleTemplateFromRepositoryRequestT& request, const DisassociateApprovalRuleTemplateFromRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::DisassociateApprovalRuleTemplateFromRepository, request, handler, context); } /** *

Evaluates whether a pull request has met all the conditions specified in its * associated approval rules.

See Also:

AWS * API Reference

*/ virtual Model::EvaluatePullRequestApprovalRulesOutcome EvaluatePullRequestApprovalRules(const Model::EvaluatePullRequestApprovalRulesRequest& request) const; /** * A Callable wrapper for EvaluatePullRequestApprovalRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EvaluatePullRequestApprovalRulesOutcomeCallable EvaluatePullRequestApprovalRulesCallable(const EvaluatePullRequestApprovalRulesRequestT& request) const { return SubmitCallable(&CodeCommitClient::EvaluatePullRequestApprovalRules, request); } /** * An Async wrapper for EvaluatePullRequestApprovalRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EvaluatePullRequestApprovalRulesAsync(const EvaluatePullRequestApprovalRulesRequestT& request, const EvaluatePullRequestApprovalRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::EvaluatePullRequestApprovalRules, request, handler, context); } /** *

Returns information about a specified approval rule template.

See * Also:

AWS * API Reference

*/ virtual Model::GetApprovalRuleTemplateOutcome GetApprovalRuleTemplate(const Model::GetApprovalRuleTemplateRequest& request) const; /** * A Callable wrapper for GetApprovalRuleTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetApprovalRuleTemplateOutcomeCallable GetApprovalRuleTemplateCallable(const GetApprovalRuleTemplateRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetApprovalRuleTemplate, request); } /** * An Async wrapper for GetApprovalRuleTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetApprovalRuleTemplateAsync(const GetApprovalRuleTemplateRequestT& request, const GetApprovalRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetApprovalRuleTemplate, request, handler, context); } /** *

Returns the base-64 encoded content of an individual blob in a * repository.

See Also:

AWS * API Reference

*/ virtual Model::GetBlobOutcome GetBlob(const Model::GetBlobRequest& request) const; /** * A Callable wrapper for GetBlob that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBlobOutcomeCallable GetBlobCallable(const GetBlobRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetBlob, request); } /** * An Async wrapper for GetBlob that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBlobAsync(const GetBlobRequestT& request, const GetBlobResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetBlob, request, handler, context); } /** *

Returns information about a repository branch, including its name and the * last commit ID.

See Also:

AWS * API Reference

*/ virtual Model::GetBranchOutcome GetBranch(const Model::GetBranchRequest& request) const; /** * A Callable wrapper for GetBranch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetBranchOutcomeCallable GetBranchCallable(const GetBranchRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetBranch, request); } /** * An Async wrapper for GetBranch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetBranchAsync(const GetBranchRequestT& request, const GetBranchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetBranch, request, handler, context); } /** *

Returns the content of a comment made on a change, file, or commit in a * repository.

Reaction counts might include numbers from user * identities who were deleted after the reaction was made. For a count of * reactions from active identities, use GetCommentReactions.

See * Also:

AWS * API Reference

*/ virtual Model::GetCommentOutcome GetComment(const Model::GetCommentRequest& request) const; /** * A Callable wrapper for GetComment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCommentOutcomeCallable GetCommentCallable(const GetCommentRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetComment, request); } /** * An Async wrapper for GetComment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCommentAsync(const GetCommentRequestT& request, const GetCommentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetComment, request, handler, context); } /** *

Returns information about reactions to a specified comment ID. Reactions from * users who have been deleted will not be included in the count.

See * Also:

AWS * API Reference

*/ virtual Model::GetCommentReactionsOutcome GetCommentReactions(const Model::GetCommentReactionsRequest& request) const; /** * A Callable wrapper for GetCommentReactions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCommentReactionsOutcomeCallable GetCommentReactionsCallable(const GetCommentReactionsRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetCommentReactions, request); } /** * An Async wrapper for GetCommentReactions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCommentReactionsAsync(const GetCommentReactionsRequestT& request, const GetCommentReactionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetCommentReactions, request, handler, context); } /** *

Returns information about comments made on the comparison between two * commits.

Reaction counts might include numbers from user * identities who were deleted after the reaction was made. For a count of * reactions from active identities, use GetCommentReactions.

See * Also:

AWS * API Reference

*/ virtual Model::GetCommentsForComparedCommitOutcome GetCommentsForComparedCommit(const Model::GetCommentsForComparedCommitRequest& request) const; /** * A Callable wrapper for GetCommentsForComparedCommit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCommentsForComparedCommitOutcomeCallable GetCommentsForComparedCommitCallable(const GetCommentsForComparedCommitRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetCommentsForComparedCommit, request); } /** * An Async wrapper for GetCommentsForComparedCommit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCommentsForComparedCommitAsync(const GetCommentsForComparedCommitRequestT& request, const GetCommentsForComparedCommitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetCommentsForComparedCommit, request, handler, context); } /** *

Returns comments made on a pull request.

Reaction counts might * include numbers from user identities who were deleted after the reaction was * made. For a count of reactions from active identities, use * GetCommentReactions.

See Also:

AWS * API Reference

*/ virtual Model::GetCommentsForPullRequestOutcome GetCommentsForPullRequest(const Model::GetCommentsForPullRequestRequest& request) const; /** * A Callable wrapper for GetCommentsForPullRequest that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCommentsForPullRequestOutcomeCallable GetCommentsForPullRequestCallable(const GetCommentsForPullRequestRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetCommentsForPullRequest, request); } /** * An Async wrapper for GetCommentsForPullRequest that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCommentsForPullRequestAsync(const GetCommentsForPullRequestRequestT& request, const GetCommentsForPullRequestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetCommentsForPullRequest, request, handler, context); } /** *

Returns information about a commit, including commit message and committer * information.

See Also:

AWS * API Reference

*/ virtual Model::GetCommitOutcome GetCommit(const Model::GetCommitRequest& request) const; /** * A Callable wrapper for GetCommit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetCommitOutcomeCallable GetCommitCallable(const GetCommitRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetCommit, request); } /** * An Async wrapper for GetCommit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetCommitAsync(const GetCommitRequestT& request, const GetCommitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetCommit, request, handler, context); } /** *

Returns information about the differences in a valid commit specifier (such * as a branch, tag, HEAD, commit ID, or other fully qualified reference). Results * can be limited to a specified path.

See Also:

AWS * API Reference

*/ virtual Model::GetDifferencesOutcome GetDifferences(const Model::GetDifferencesRequest& request) const; /** * A Callable wrapper for GetDifferences that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDifferencesOutcomeCallable GetDifferencesCallable(const GetDifferencesRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetDifferences, request); } /** * An Async wrapper for GetDifferences that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDifferencesAsync(const GetDifferencesRequestT& request, const GetDifferencesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetDifferences, request, handler, context); } /** *

Returns the base-64 encoded contents of a specified file and its * metadata.

See Also:

AWS * API Reference

*/ virtual Model::GetFileOutcome GetFile(const Model::GetFileRequest& request) const; /** * A Callable wrapper for GetFile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFileOutcomeCallable GetFileCallable(const GetFileRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetFile, request); } /** * An Async wrapper for GetFile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFileAsync(const GetFileRequestT& request, const GetFileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetFile, request, handler, context); } /** *

Returns the contents of a specified folder in a repository.

See * Also:

AWS * API Reference

*/ virtual Model::GetFolderOutcome GetFolder(const Model::GetFolderRequest& request) const; /** * A Callable wrapper for GetFolder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetFolderOutcomeCallable GetFolderCallable(const GetFolderRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetFolder, request); } /** * An Async wrapper for GetFolder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetFolderAsync(const GetFolderRequestT& request, const GetFolderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetFolder, request, handler, context); } /** *

Returns information about a specified merge commit.

See Also:

* AWS * API Reference

*/ virtual Model::GetMergeCommitOutcome GetMergeCommit(const Model::GetMergeCommitRequest& request) const; /** * A Callable wrapper for GetMergeCommit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMergeCommitOutcomeCallable GetMergeCommitCallable(const GetMergeCommitRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetMergeCommit, request); } /** * An Async wrapper for GetMergeCommit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMergeCommitAsync(const GetMergeCommitRequestT& request, const GetMergeCommitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetMergeCommit, request, handler, context); } /** *

Returns information about merge conflicts between the before and after commit * IDs for a pull request in a repository.

See Also:

AWS * API Reference

*/ virtual Model::GetMergeConflictsOutcome GetMergeConflicts(const Model::GetMergeConflictsRequest& request) const; /** * A Callable wrapper for GetMergeConflicts that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMergeConflictsOutcomeCallable GetMergeConflictsCallable(const GetMergeConflictsRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetMergeConflicts, request); } /** * An Async wrapper for GetMergeConflicts that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMergeConflictsAsync(const GetMergeConflictsRequestT& request, const GetMergeConflictsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetMergeConflicts, request, handler, context); } /** *

Returns information about the merge options available for merging two * specified branches. For details about why a merge option is not available, use * GetMergeConflicts or DescribeMergeConflicts.

See Also:

AWS * API Reference

*/ virtual Model::GetMergeOptionsOutcome GetMergeOptions(const Model::GetMergeOptionsRequest& request) const; /** * A Callable wrapper for GetMergeOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetMergeOptionsOutcomeCallable GetMergeOptionsCallable(const GetMergeOptionsRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetMergeOptions, request); } /** * An Async wrapper for GetMergeOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetMergeOptionsAsync(const GetMergeOptionsRequestT& request, const GetMergeOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetMergeOptions, request, handler, context); } /** *

Gets information about a pull request in a specified * repository.

See Also:

AWS * API Reference

*/ virtual Model::GetPullRequestOutcome GetPullRequest(const Model::GetPullRequestRequest& request) const; /** * A Callable wrapper for GetPullRequest that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPullRequestOutcomeCallable GetPullRequestCallable(const GetPullRequestRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetPullRequest, request); } /** * An Async wrapper for GetPullRequest that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPullRequestAsync(const GetPullRequestRequestT& request, const GetPullRequestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetPullRequest, request, handler, context); } /** *

Gets information about the approval states for a specified pull request. * Approval states only apply to pull requests that have one or more approval rules * applied to them.

See Also:

AWS * API Reference

*/ virtual Model::GetPullRequestApprovalStatesOutcome GetPullRequestApprovalStates(const Model::GetPullRequestApprovalStatesRequest& request) const; /** * A Callable wrapper for GetPullRequestApprovalStates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPullRequestApprovalStatesOutcomeCallable GetPullRequestApprovalStatesCallable(const GetPullRequestApprovalStatesRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetPullRequestApprovalStates, request); } /** * An Async wrapper for GetPullRequestApprovalStates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPullRequestApprovalStatesAsync(const GetPullRequestApprovalStatesRequestT& request, const GetPullRequestApprovalStatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetPullRequestApprovalStates, request, handler, context); } /** *

Returns information about whether approval rules have been set aside * (overridden) for a pull request, and if so, the Amazon Resource Name (ARN) of * the user or identity that overrode the rules and their requirements for the pull * request.

See Also:

AWS * API Reference

*/ virtual Model::GetPullRequestOverrideStateOutcome GetPullRequestOverrideState(const Model::GetPullRequestOverrideStateRequest& request) const; /** * A Callable wrapper for GetPullRequestOverrideState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetPullRequestOverrideStateOutcomeCallable GetPullRequestOverrideStateCallable(const GetPullRequestOverrideStateRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetPullRequestOverrideState, request); } /** * An Async wrapper for GetPullRequestOverrideState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetPullRequestOverrideStateAsync(const GetPullRequestOverrideStateRequestT& request, const GetPullRequestOverrideStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetPullRequestOverrideState, request, handler, context); } /** *

Returns information about a repository.

The description field * for a repository accepts all HTML characters and all valid Unicode characters. * Applications that do not HTML-encode the description and display it in a webpage * can expose users to potentially malicious code. Make sure that you HTML-encode * the description field in any application that uses this API to display the * repository description on a webpage.

See Also:

AWS * API Reference

*/ virtual Model::GetRepositoryOutcome GetRepository(const Model::GetRepositoryRequest& request) const; /** * A Callable wrapper for GetRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRepositoryOutcomeCallable GetRepositoryCallable(const GetRepositoryRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetRepository, request); } /** * An Async wrapper for GetRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRepositoryAsync(const GetRepositoryRequestT& request, const GetRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetRepository, request, handler, context); } /** *

Gets information about triggers configured for a repository.

See * Also:

AWS * API Reference

*/ virtual Model::GetRepositoryTriggersOutcome GetRepositoryTriggers(const Model::GetRepositoryTriggersRequest& request) const; /** * A Callable wrapper for GetRepositoryTriggers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRepositoryTriggersOutcomeCallable GetRepositoryTriggersCallable(const GetRepositoryTriggersRequestT& request) const { return SubmitCallable(&CodeCommitClient::GetRepositoryTriggers, request); } /** * An Async wrapper for GetRepositoryTriggers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRepositoryTriggersAsync(const GetRepositoryTriggersRequestT& request, const GetRepositoryTriggersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::GetRepositoryTriggers, request, handler, context); } /** *

Lists all approval rule templates in the specified AWS Region in your AWS * account. If an AWS Region is not specified, the AWS Region where you are signed * in is used.

See Also:

AWS * API Reference

*/ virtual Model::ListApprovalRuleTemplatesOutcome ListApprovalRuleTemplates(const Model::ListApprovalRuleTemplatesRequest& request) const; /** * A Callable wrapper for ListApprovalRuleTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListApprovalRuleTemplatesOutcomeCallable ListApprovalRuleTemplatesCallable(const ListApprovalRuleTemplatesRequestT& request) const { return SubmitCallable(&CodeCommitClient::ListApprovalRuleTemplates, request); } /** * An Async wrapper for ListApprovalRuleTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListApprovalRuleTemplatesAsync(const ListApprovalRuleTemplatesRequestT& request, const ListApprovalRuleTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::ListApprovalRuleTemplates, request, handler, context); } /** *

Lists all approval rule templates that are associated with a specified * repository.

See Also:

AWS * API Reference

*/ virtual Model::ListAssociatedApprovalRuleTemplatesForRepositoryOutcome ListAssociatedApprovalRuleTemplatesForRepository(const Model::ListAssociatedApprovalRuleTemplatesForRepositoryRequest& request) const; /** * A Callable wrapper for ListAssociatedApprovalRuleTemplatesForRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssociatedApprovalRuleTemplatesForRepositoryOutcomeCallable ListAssociatedApprovalRuleTemplatesForRepositoryCallable(const ListAssociatedApprovalRuleTemplatesForRepositoryRequestT& request) const { return SubmitCallable(&CodeCommitClient::ListAssociatedApprovalRuleTemplatesForRepository, request); } /** * An Async wrapper for ListAssociatedApprovalRuleTemplatesForRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssociatedApprovalRuleTemplatesForRepositoryAsync(const ListAssociatedApprovalRuleTemplatesForRepositoryRequestT& request, const ListAssociatedApprovalRuleTemplatesForRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::ListAssociatedApprovalRuleTemplatesForRepository, request, handler, context); } /** *

Gets information about one or more branches in a repository.

See * Also:

AWS * API Reference

*/ virtual Model::ListBranchesOutcome ListBranches(const Model::ListBranchesRequest& request) const; /** * A Callable wrapper for ListBranches that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListBranchesOutcomeCallable ListBranchesCallable(const ListBranchesRequestT& request) const { return SubmitCallable(&CodeCommitClient::ListBranches, request); } /** * An Async wrapper for ListBranches that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListBranchesAsync(const ListBranchesRequestT& request, const ListBranchesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::ListBranches, request, handler, context); } /** *

Returns a list of pull requests for a specified repository. The return list * can be refined by pull request status or pull request author ARN.

See * Also:

AWS * API Reference

*/ virtual Model::ListPullRequestsOutcome ListPullRequests(const Model::ListPullRequestsRequest& request) const; /** * A Callable wrapper for ListPullRequests that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListPullRequestsOutcomeCallable ListPullRequestsCallable(const ListPullRequestsRequestT& request) const { return SubmitCallable(&CodeCommitClient::ListPullRequests, request); } /** * An Async wrapper for ListPullRequests that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListPullRequestsAsync(const ListPullRequestsRequestT& request, const ListPullRequestsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::ListPullRequests, request, handler, context); } /** *

Gets information about one or more repositories.

See Also:

* AWS * API Reference

*/ virtual Model::ListRepositoriesOutcome ListRepositories(const Model::ListRepositoriesRequest& request) const; /** * A Callable wrapper for ListRepositories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRepositoriesOutcomeCallable ListRepositoriesCallable(const ListRepositoriesRequestT& request) const { return SubmitCallable(&CodeCommitClient::ListRepositories, request); } /** * An Async wrapper for ListRepositories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRepositoriesAsync(const ListRepositoriesRequestT& request, const ListRepositoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::ListRepositories, request, handler, context); } /** *

Lists all repositories associated with the specified approval rule * template.

See Also:

AWS * API Reference

*/ virtual Model::ListRepositoriesForApprovalRuleTemplateOutcome ListRepositoriesForApprovalRuleTemplate(const Model::ListRepositoriesForApprovalRuleTemplateRequest& request) const; /** * A Callable wrapper for ListRepositoriesForApprovalRuleTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRepositoriesForApprovalRuleTemplateOutcomeCallable ListRepositoriesForApprovalRuleTemplateCallable(const ListRepositoriesForApprovalRuleTemplateRequestT& request) const { return SubmitCallable(&CodeCommitClient::ListRepositoriesForApprovalRuleTemplate, request); } /** * An Async wrapper for ListRepositoriesForApprovalRuleTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRepositoriesForApprovalRuleTemplateAsync(const ListRepositoriesForApprovalRuleTemplateRequestT& request, const ListRepositoriesForApprovalRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::ListRepositoriesForApprovalRuleTemplate, request, handler, context); } /** *

Gets information about AWS tags for a specified Amazon Resource Name (ARN) in * AWS CodeCommit. For a list of valid resources in AWS CodeCommit, see CodeCommit * Resources and Operations in the AWS CodeCommit User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&CodeCommitClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::ListTagsForResource, request, handler, context); } /** *

Merges two branches using the fast-forward merge strategy.

See * Also:

AWS * API Reference

*/ virtual Model::MergeBranchesByFastForwardOutcome MergeBranchesByFastForward(const Model::MergeBranchesByFastForwardRequest& request) const; /** * A Callable wrapper for MergeBranchesByFastForward that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MergeBranchesByFastForwardOutcomeCallable MergeBranchesByFastForwardCallable(const MergeBranchesByFastForwardRequestT& request) const { return SubmitCallable(&CodeCommitClient::MergeBranchesByFastForward, request); } /** * An Async wrapper for MergeBranchesByFastForward that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MergeBranchesByFastForwardAsync(const MergeBranchesByFastForwardRequestT& request, const MergeBranchesByFastForwardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::MergeBranchesByFastForward, request, handler, context); } /** *

Merges two branches using the squash merge strategy.

See Also:

* AWS * API Reference

*/ virtual Model::MergeBranchesBySquashOutcome MergeBranchesBySquash(const Model::MergeBranchesBySquashRequest& request) const; /** * A Callable wrapper for MergeBranchesBySquash that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MergeBranchesBySquashOutcomeCallable MergeBranchesBySquashCallable(const MergeBranchesBySquashRequestT& request) const { return SubmitCallable(&CodeCommitClient::MergeBranchesBySquash, request); } /** * An Async wrapper for MergeBranchesBySquash that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MergeBranchesBySquashAsync(const MergeBranchesBySquashRequestT& request, const MergeBranchesBySquashResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::MergeBranchesBySquash, request, handler, context); } /** *

Merges two specified branches using the three-way merge * strategy.

See Also:

AWS * API Reference

*/ virtual Model::MergeBranchesByThreeWayOutcome MergeBranchesByThreeWay(const Model::MergeBranchesByThreeWayRequest& request) const; /** * A Callable wrapper for MergeBranchesByThreeWay that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MergeBranchesByThreeWayOutcomeCallable MergeBranchesByThreeWayCallable(const MergeBranchesByThreeWayRequestT& request) const { return SubmitCallable(&CodeCommitClient::MergeBranchesByThreeWay, request); } /** * An Async wrapper for MergeBranchesByThreeWay that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MergeBranchesByThreeWayAsync(const MergeBranchesByThreeWayRequestT& request, const MergeBranchesByThreeWayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::MergeBranchesByThreeWay, request, handler, context); } /** *

Attempts to merge the source commit of a pull request into the specified * destination branch for that pull request at the specified commit using the * fast-forward merge strategy. If the merge is successful, it closes the pull * request.

See Also:

AWS * API Reference

*/ virtual Model::MergePullRequestByFastForwardOutcome MergePullRequestByFastForward(const Model::MergePullRequestByFastForwardRequest& request) const; /** * A Callable wrapper for MergePullRequestByFastForward that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MergePullRequestByFastForwardOutcomeCallable MergePullRequestByFastForwardCallable(const MergePullRequestByFastForwardRequestT& request) const { return SubmitCallable(&CodeCommitClient::MergePullRequestByFastForward, request); } /** * An Async wrapper for MergePullRequestByFastForward that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MergePullRequestByFastForwardAsync(const MergePullRequestByFastForwardRequestT& request, const MergePullRequestByFastForwardResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::MergePullRequestByFastForward, request, handler, context); } /** *

Attempts to merge the source commit of a pull request into the specified * destination branch for that pull request at the specified commit using the * squash merge strategy. If the merge is successful, it closes the pull * request.

See Also:

AWS * API Reference

*/ virtual Model::MergePullRequestBySquashOutcome MergePullRequestBySquash(const Model::MergePullRequestBySquashRequest& request) const; /** * A Callable wrapper for MergePullRequestBySquash that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MergePullRequestBySquashOutcomeCallable MergePullRequestBySquashCallable(const MergePullRequestBySquashRequestT& request) const { return SubmitCallable(&CodeCommitClient::MergePullRequestBySquash, request); } /** * An Async wrapper for MergePullRequestBySquash that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MergePullRequestBySquashAsync(const MergePullRequestBySquashRequestT& request, const MergePullRequestBySquashResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::MergePullRequestBySquash, request, handler, context); } /** *

Attempts to merge the source commit of a pull request into the specified * destination branch for that pull request at the specified commit using the * three-way merge strategy. If the merge is successful, it closes the pull * request.

See Also:

AWS * API Reference

*/ virtual Model::MergePullRequestByThreeWayOutcome MergePullRequestByThreeWay(const Model::MergePullRequestByThreeWayRequest& request) const; /** * A Callable wrapper for MergePullRequestByThreeWay that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MergePullRequestByThreeWayOutcomeCallable MergePullRequestByThreeWayCallable(const MergePullRequestByThreeWayRequestT& request) const { return SubmitCallable(&CodeCommitClient::MergePullRequestByThreeWay, request); } /** * An Async wrapper for MergePullRequestByThreeWay that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MergePullRequestByThreeWayAsync(const MergePullRequestByThreeWayRequestT& request, const MergePullRequestByThreeWayResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::MergePullRequestByThreeWay, request, handler, context); } /** *

Sets aside (overrides) all approval rule requirements for a specified pull * request.

See Also:

AWS * API Reference

*/ virtual Model::OverridePullRequestApprovalRulesOutcome OverridePullRequestApprovalRules(const Model::OverridePullRequestApprovalRulesRequest& request) const; /** * A Callable wrapper for OverridePullRequestApprovalRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::OverridePullRequestApprovalRulesOutcomeCallable OverridePullRequestApprovalRulesCallable(const OverridePullRequestApprovalRulesRequestT& request) const { return SubmitCallable(&CodeCommitClient::OverridePullRequestApprovalRules, request); } /** * An Async wrapper for OverridePullRequestApprovalRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void OverridePullRequestApprovalRulesAsync(const OverridePullRequestApprovalRulesRequestT& request, const OverridePullRequestApprovalRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::OverridePullRequestApprovalRules, request, handler, context); } /** *

Posts a comment on the comparison between two commits.

See * Also:

AWS * API Reference

*/ virtual Model::PostCommentForComparedCommitOutcome PostCommentForComparedCommit(const Model::PostCommentForComparedCommitRequest& request) const; /** * A Callable wrapper for PostCommentForComparedCommit that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PostCommentForComparedCommitOutcomeCallable PostCommentForComparedCommitCallable(const PostCommentForComparedCommitRequestT& request) const { return SubmitCallable(&CodeCommitClient::PostCommentForComparedCommit, request); } /** * An Async wrapper for PostCommentForComparedCommit that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PostCommentForComparedCommitAsync(const PostCommentForComparedCommitRequestT& request, const PostCommentForComparedCommitResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::PostCommentForComparedCommit, request, handler, context); } /** *

Posts a comment on a pull request.

See Also:

AWS * API Reference

*/ virtual Model::PostCommentForPullRequestOutcome PostCommentForPullRequest(const Model::PostCommentForPullRequestRequest& request) const; /** * A Callable wrapper for PostCommentForPullRequest that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PostCommentForPullRequestOutcomeCallable PostCommentForPullRequestCallable(const PostCommentForPullRequestRequestT& request) const { return SubmitCallable(&CodeCommitClient::PostCommentForPullRequest, request); } /** * An Async wrapper for PostCommentForPullRequest that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PostCommentForPullRequestAsync(const PostCommentForPullRequestRequestT& request, const PostCommentForPullRequestResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::PostCommentForPullRequest, request, handler, context); } /** *

Posts a comment in reply to an existing comment on a comparison between * commits or a pull request.

See Also:

AWS * API Reference

*/ virtual Model::PostCommentReplyOutcome PostCommentReply(const Model::PostCommentReplyRequest& request) const; /** * A Callable wrapper for PostCommentReply that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PostCommentReplyOutcomeCallable PostCommentReplyCallable(const PostCommentReplyRequestT& request) const { return SubmitCallable(&CodeCommitClient::PostCommentReply, request); } /** * An Async wrapper for PostCommentReply that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PostCommentReplyAsync(const PostCommentReplyRequestT& request, const PostCommentReplyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::PostCommentReply, request, handler, context); } /** *

Adds or updates a reaction to a specified comment for the user whose identity * is used to make the request. You can only add or update a reaction for yourself. * You cannot add, modify, or delete a reaction for another user.

See * Also:

AWS * API Reference

*/ virtual Model::PutCommentReactionOutcome PutCommentReaction(const Model::PutCommentReactionRequest& request) const; /** * A Callable wrapper for PutCommentReaction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutCommentReactionOutcomeCallable PutCommentReactionCallable(const PutCommentReactionRequestT& request) const { return SubmitCallable(&CodeCommitClient::PutCommentReaction, request); } /** * An Async wrapper for PutCommentReaction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutCommentReactionAsync(const PutCommentReactionRequestT& request, const PutCommentReactionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::PutCommentReaction, request, handler, context); } /** *

Adds or updates a file in a branch in an AWS CodeCommit repository, and * generates a commit for the addition in the specified branch.

See * Also:

AWS * API Reference

*/ virtual Model::PutFileOutcome PutFile(const Model::PutFileRequest& request) const; /** * A Callable wrapper for PutFile that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutFileOutcomeCallable PutFileCallable(const PutFileRequestT& request) const { return SubmitCallable(&CodeCommitClient::PutFile, request); } /** * An Async wrapper for PutFile that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutFileAsync(const PutFileRequestT& request, const PutFileResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::PutFile, request, handler, context); } /** *

Replaces all triggers for a repository. Used to create or delete * triggers.

See Also:

AWS * API Reference

*/ virtual Model::PutRepositoryTriggersOutcome PutRepositoryTriggers(const Model::PutRepositoryTriggersRequest& request) const; /** * A Callable wrapper for PutRepositoryTriggers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PutRepositoryTriggersOutcomeCallable PutRepositoryTriggersCallable(const PutRepositoryTriggersRequestT& request) const { return SubmitCallable(&CodeCommitClient::PutRepositoryTriggers, request); } /** * An Async wrapper for PutRepositoryTriggers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PutRepositoryTriggersAsync(const PutRepositoryTriggersRequestT& request, const PutRepositoryTriggersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::PutRepositoryTriggers, request, handler, context); } /** *

Adds or updates tags for a resource in AWS CodeCommit. For a list of valid * resources in AWS CodeCommit, see CodeCommit * Resources and Operations in the AWS CodeCommit User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&CodeCommitClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::TagResource, request, handler, context); } /** *

Tests the functionality of repository triggers by sending information to the * trigger target. If real data is available in the repository, the test sends data * from the last commit. If no data is available, sample data is * generated.

See Also:

AWS * API Reference

*/ virtual Model::TestRepositoryTriggersOutcome TestRepositoryTriggers(const Model::TestRepositoryTriggersRequest& request) const; /** * A Callable wrapper for TestRepositoryTriggers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TestRepositoryTriggersOutcomeCallable TestRepositoryTriggersCallable(const TestRepositoryTriggersRequestT& request) const { return SubmitCallable(&CodeCommitClient::TestRepositoryTriggers, request); } /** * An Async wrapper for TestRepositoryTriggers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TestRepositoryTriggersAsync(const TestRepositoryTriggersRequestT& request, const TestRepositoryTriggersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::TestRepositoryTriggers, request, handler, context); } /** *

Removes tags for a resource in AWS CodeCommit. For a list of valid resources * in AWS CodeCommit, see CodeCommit * Resources and Operations in the AWS CodeCommit User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&CodeCommitClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UntagResource, request, handler, context); } /** *

Updates the content of an approval rule template. You can change the number * of required approvals, the membership of the approval rule, and whether an * approval pool is defined.

See Also:

AWS * API Reference

*/ virtual Model::UpdateApprovalRuleTemplateContentOutcome UpdateApprovalRuleTemplateContent(const Model::UpdateApprovalRuleTemplateContentRequest& request) const; /** * A Callable wrapper for UpdateApprovalRuleTemplateContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateApprovalRuleTemplateContentOutcomeCallable UpdateApprovalRuleTemplateContentCallable(const UpdateApprovalRuleTemplateContentRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdateApprovalRuleTemplateContent, request); } /** * An Async wrapper for UpdateApprovalRuleTemplateContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateApprovalRuleTemplateContentAsync(const UpdateApprovalRuleTemplateContentRequestT& request, const UpdateApprovalRuleTemplateContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdateApprovalRuleTemplateContent, request, handler, context); } /** *

Updates the description for a specified approval rule template.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateApprovalRuleTemplateDescriptionOutcome UpdateApprovalRuleTemplateDescription(const Model::UpdateApprovalRuleTemplateDescriptionRequest& request) const; /** * A Callable wrapper for UpdateApprovalRuleTemplateDescription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateApprovalRuleTemplateDescriptionOutcomeCallable UpdateApprovalRuleTemplateDescriptionCallable(const UpdateApprovalRuleTemplateDescriptionRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdateApprovalRuleTemplateDescription, request); } /** * An Async wrapper for UpdateApprovalRuleTemplateDescription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateApprovalRuleTemplateDescriptionAsync(const UpdateApprovalRuleTemplateDescriptionRequestT& request, const UpdateApprovalRuleTemplateDescriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdateApprovalRuleTemplateDescription, request, handler, context); } /** *

Updates the name of a specified approval rule template.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateApprovalRuleTemplateNameOutcome UpdateApprovalRuleTemplateName(const Model::UpdateApprovalRuleTemplateNameRequest& request) const; /** * A Callable wrapper for UpdateApprovalRuleTemplateName that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateApprovalRuleTemplateNameOutcomeCallable UpdateApprovalRuleTemplateNameCallable(const UpdateApprovalRuleTemplateNameRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdateApprovalRuleTemplateName, request); } /** * An Async wrapper for UpdateApprovalRuleTemplateName that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateApprovalRuleTemplateNameAsync(const UpdateApprovalRuleTemplateNameRequestT& request, const UpdateApprovalRuleTemplateNameResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdateApprovalRuleTemplateName, request, handler, context); } /** *

Replaces the contents of a comment.

See Also:

AWS * API Reference

*/ virtual Model::UpdateCommentOutcome UpdateComment(const Model::UpdateCommentRequest& request) const; /** * A Callable wrapper for UpdateComment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateCommentOutcomeCallable UpdateCommentCallable(const UpdateCommentRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdateComment, request); } /** * An Async wrapper for UpdateComment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateCommentAsync(const UpdateCommentRequestT& request, const UpdateCommentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdateComment, request, handler, context); } /** *

Sets or changes the default branch name for the specified repository.

*

If you use this operation to change the default branch name to the * current default branch name, a success message is returned even though the * default branch did not change.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDefaultBranchOutcome UpdateDefaultBranch(const Model::UpdateDefaultBranchRequest& request) const; /** * A Callable wrapper for UpdateDefaultBranch that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDefaultBranchOutcomeCallable UpdateDefaultBranchCallable(const UpdateDefaultBranchRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdateDefaultBranch, request); } /** * An Async wrapper for UpdateDefaultBranch that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDefaultBranchAsync(const UpdateDefaultBranchRequestT& request, const UpdateDefaultBranchResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdateDefaultBranch, request, handler, context); } /** *

Updates the structure of an approval rule created specifically for a pull * request. For example, you can change the number of required approvers and the * approval pool for approvers.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePullRequestApprovalRuleContentOutcome UpdatePullRequestApprovalRuleContent(const Model::UpdatePullRequestApprovalRuleContentRequest& request) const; /** * A Callable wrapper for UpdatePullRequestApprovalRuleContent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePullRequestApprovalRuleContentOutcomeCallable UpdatePullRequestApprovalRuleContentCallable(const UpdatePullRequestApprovalRuleContentRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdatePullRequestApprovalRuleContent, request); } /** * An Async wrapper for UpdatePullRequestApprovalRuleContent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePullRequestApprovalRuleContentAsync(const UpdatePullRequestApprovalRuleContentRequestT& request, const UpdatePullRequestApprovalRuleContentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdatePullRequestApprovalRuleContent, request, handler, context); } /** *

Updates the state of a user's approval on a pull request. The user is derived * from the signed-in account when the request is made.

See Also:

* AWS * API Reference

*/ virtual Model::UpdatePullRequestApprovalStateOutcome UpdatePullRequestApprovalState(const Model::UpdatePullRequestApprovalStateRequest& request) const; /** * A Callable wrapper for UpdatePullRequestApprovalState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePullRequestApprovalStateOutcomeCallable UpdatePullRequestApprovalStateCallable(const UpdatePullRequestApprovalStateRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdatePullRequestApprovalState, request); } /** * An Async wrapper for UpdatePullRequestApprovalState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePullRequestApprovalStateAsync(const UpdatePullRequestApprovalStateRequestT& request, const UpdatePullRequestApprovalStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdatePullRequestApprovalState, request, handler, context); } /** *

Replaces the contents of the description of a pull request.

See * Also:

AWS * API Reference

*/ virtual Model::UpdatePullRequestDescriptionOutcome UpdatePullRequestDescription(const Model::UpdatePullRequestDescriptionRequest& request) const; /** * A Callable wrapper for UpdatePullRequestDescription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePullRequestDescriptionOutcomeCallable UpdatePullRequestDescriptionCallable(const UpdatePullRequestDescriptionRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdatePullRequestDescription, request); } /** * An Async wrapper for UpdatePullRequestDescription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePullRequestDescriptionAsync(const UpdatePullRequestDescriptionRequestT& request, const UpdatePullRequestDescriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdatePullRequestDescription, request, handler, context); } /** *

Updates the status of a pull request.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePullRequestStatusOutcome UpdatePullRequestStatus(const Model::UpdatePullRequestStatusRequest& request) const; /** * A Callable wrapper for UpdatePullRequestStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePullRequestStatusOutcomeCallable UpdatePullRequestStatusCallable(const UpdatePullRequestStatusRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdatePullRequestStatus, request); } /** * An Async wrapper for UpdatePullRequestStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePullRequestStatusAsync(const UpdatePullRequestStatusRequestT& request, const UpdatePullRequestStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdatePullRequestStatus, request, handler, context); } /** *

Replaces the title of a pull request.

See Also:

AWS * API Reference

*/ virtual Model::UpdatePullRequestTitleOutcome UpdatePullRequestTitle(const Model::UpdatePullRequestTitleRequest& request) const; /** * A Callable wrapper for UpdatePullRequestTitle that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdatePullRequestTitleOutcomeCallable UpdatePullRequestTitleCallable(const UpdatePullRequestTitleRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdatePullRequestTitle, request); } /** * An Async wrapper for UpdatePullRequestTitle that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdatePullRequestTitleAsync(const UpdatePullRequestTitleRequestT& request, const UpdatePullRequestTitleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdatePullRequestTitle, request, handler, context); } /** *

Sets or changes the comment or description for a repository.

*

The description field for a repository accepts all HTML characters and all * valid Unicode characters. Applications that do not HTML-encode the description * and display it in a webpage can expose users to potentially malicious code. Make * sure that you HTML-encode the description field in any application that uses * this API to display the repository description on a webpage.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateRepositoryDescriptionOutcome UpdateRepositoryDescription(const Model::UpdateRepositoryDescriptionRequest& request) const; /** * A Callable wrapper for UpdateRepositoryDescription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRepositoryDescriptionOutcomeCallable UpdateRepositoryDescriptionCallable(const UpdateRepositoryDescriptionRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdateRepositoryDescription, request); } /** * An Async wrapper for UpdateRepositoryDescription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRepositoryDescriptionAsync(const UpdateRepositoryDescriptionRequestT& request, const UpdateRepositoryDescriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdateRepositoryDescription, request, handler, context); } /** *

Renames a repository. The repository name must be unique across the calling * AWS account. Repository names are limited to 100 alphanumeric, dash, and * underscore characters, and cannot include certain characters. The suffix .git is * prohibited. For more information about the limits on repository names, see Limits * in the AWS CodeCommit User Guide.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRepositoryNameOutcome UpdateRepositoryName(const Model::UpdateRepositoryNameRequest& request) const; /** * A Callable wrapper for UpdateRepositoryName that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRepositoryNameOutcomeCallable UpdateRepositoryNameCallable(const UpdateRepositoryNameRequestT& request) const { return SubmitCallable(&CodeCommitClient::UpdateRepositoryName, request); } /** * An Async wrapper for UpdateRepositoryName that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRepositoryNameAsync(const UpdateRepositoryNameRequestT& request, const UpdateRepositoryNameResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&CodeCommitClient::UpdateRepositoryName, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const CodeCommitClientConfiguration& clientConfiguration); CodeCommitClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace CodeCommit } // namespace Aws