CodeBuildClient.h

 
#pragma once
#include <aws/codebuild/CodeBuildPaginationBase.h>
#include <aws/codebuild/CodeBuildServiceClientModel.h>
#include <aws/codebuild/CodeBuildWaiter.h>
#include <aws/codebuild/CodeBuild_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace CodeBuild {
class AWS_CODEBUILD_API CodeBuildClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<CodeBuildClient>,
                                          public CodeBuildPaginationBase<CodeBuildClient>,
                                          public CodeBuildWaiter<CodeBuildClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CodeBuildClientConfiguration ClientConfigurationType;
  typedef CodeBuildEndpointProvider EndpointProviderType;
 
  CodeBuildClient(const Aws::CodeBuild::CodeBuildClientConfiguration& clientConfiguration = Aws::CodeBuild::CodeBuildClientConfiguration(),
                  std::shared_ptr<CodeBuildEndpointProviderBase> endpointProvider = nullptr);
 
  CodeBuildClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<CodeBuildEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::CodeBuild::CodeBuildClientConfiguration& clientConfiguration = Aws::CodeBuild::CodeBuildClientConfiguration());
 
  CodeBuildClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<CodeBuildEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::CodeBuild::CodeBuildClientConfiguration& clientConfiguration = Aws::CodeBuild::CodeBuildClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CodeBuildClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeBuildClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeBuildClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CodeBuildClient();
 
  virtual Model::BatchDeleteBuildsOutcome BatchDeleteBuilds(const Model::BatchDeleteBuildsRequest& request) const;
 
  template <typename BatchDeleteBuildsRequestT = Model::BatchDeleteBuildsRequest>
  Model::BatchDeleteBuildsOutcomeCallable BatchDeleteBuildsCallable(const BatchDeleteBuildsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchDeleteBuilds, request);
  }
 
  template <typename BatchDeleteBuildsRequestT = Model::BatchDeleteBuildsRequest>
  void BatchDeleteBuildsAsync(const BatchDeleteBuildsRequestT& request, const BatchDeleteBuildsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchDeleteBuilds, request, handler, context);
  }
 
  virtual Model::BatchGetBuildBatchesOutcome BatchGetBuildBatches(const Model::BatchGetBuildBatchesRequest& request) const;
 
  template <typename BatchGetBuildBatchesRequestT = Model::BatchGetBuildBatchesRequest>
  Model::BatchGetBuildBatchesOutcomeCallable BatchGetBuildBatchesCallable(const BatchGetBuildBatchesRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetBuildBatches, request);
  }
 
  template <typename BatchGetBuildBatchesRequestT = Model::BatchGetBuildBatchesRequest>
  void BatchGetBuildBatchesAsync(const BatchGetBuildBatchesRequestT& request, const BatchGetBuildBatchesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetBuildBatches, request, handler, context);
  }
 
  virtual Model::BatchGetBuildsOutcome BatchGetBuilds(const Model::BatchGetBuildsRequest& request) const;
 
  template <typename BatchGetBuildsRequestT = Model::BatchGetBuildsRequest>
  Model::BatchGetBuildsOutcomeCallable BatchGetBuildsCallable(const BatchGetBuildsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetBuilds, request);
  }
 
  template <typename BatchGetBuildsRequestT = Model::BatchGetBuildsRequest>
  void BatchGetBuildsAsync(const BatchGetBuildsRequestT& request, const BatchGetBuildsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetBuilds, request, handler, context);
  }
 
  virtual Model::BatchGetCommandExecutionsOutcome BatchGetCommandExecutions(const Model::BatchGetCommandExecutionsRequest& request) const;
 
  template <typename BatchGetCommandExecutionsRequestT = Model::BatchGetCommandExecutionsRequest>
  Model::BatchGetCommandExecutionsOutcomeCallable BatchGetCommandExecutionsCallable(
      const BatchGetCommandExecutionsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetCommandExecutions, request);
  }
 
  template <typename BatchGetCommandExecutionsRequestT = Model::BatchGetCommandExecutionsRequest>
  void BatchGetCommandExecutionsAsync(const BatchGetCommandExecutionsRequestT& request,
                                      const BatchGetCommandExecutionsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetCommandExecutions, request, handler, context);
  }
 
  virtual Model::BatchGetFleetsOutcome BatchGetFleets(const Model::BatchGetFleetsRequest& request) const;
 
  template <typename BatchGetFleetsRequestT = Model::BatchGetFleetsRequest>
  Model::BatchGetFleetsOutcomeCallable BatchGetFleetsCallable(const BatchGetFleetsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetFleets, request);
  }
 
  template <typename BatchGetFleetsRequestT = Model::BatchGetFleetsRequest>
  void BatchGetFleetsAsync(const BatchGetFleetsRequestT& request, const BatchGetFleetsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetFleets, request, handler, context);
  }
 
  virtual Model::BatchGetProjectsOutcome BatchGetProjects(const Model::BatchGetProjectsRequest& request) const;
 
  template <typename BatchGetProjectsRequestT = Model::BatchGetProjectsRequest>
  Model::BatchGetProjectsOutcomeCallable BatchGetProjectsCallable(const BatchGetProjectsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetProjects, request);
  }
 
  template <typename BatchGetProjectsRequestT = Model::BatchGetProjectsRequest>
  void BatchGetProjectsAsync(const BatchGetProjectsRequestT& request, const BatchGetProjectsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetProjects, request, handler, context);
  }
 
  virtual Model::BatchGetReportGroupsOutcome BatchGetReportGroups(const Model::BatchGetReportGroupsRequest& request) const;
 
  template <typename BatchGetReportGroupsRequestT = Model::BatchGetReportGroupsRequest>
  Model::BatchGetReportGroupsOutcomeCallable BatchGetReportGroupsCallable(const BatchGetReportGroupsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetReportGroups, request);
  }
 
  template <typename BatchGetReportGroupsRequestT = Model::BatchGetReportGroupsRequest>
  void BatchGetReportGroupsAsync(const BatchGetReportGroupsRequestT& request, const BatchGetReportGroupsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetReportGroups, request, handler, context);
  }
 
  virtual Model::BatchGetReportsOutcome BatchGetReports(const Model::BatchGetReportsRequest& request) const;
 
  template <typename BatchGetReportsRequestT = Model::BatchGetReportsRequest>
  Model::BatchGetReportsOutcomeCallable BatchGetReportsCallable(const BatchGetReportsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetReports, request);
  }
 
  template <typename BatchGetReportsRequestT = Model::BatchGetReportsRequest>
  void BatchGetReportsAsync(const BatchGetReportsRequestT& request, const BatchGetReportsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetReports, request, handler, context);
  }
 
  virtual Model::BatchGetSandboxesOutcome BatchGetSandboxes(const Model::BatchGetSandboxesRequest& request) const;
 
  template <typename BatchGetSandboxesRequestT = Model::BatchGetSandboxesRequest>
  Model::BatchGetSandboxesOutcomeCallable BatchGetSandboxesCallable(const BatchGetSandboxesRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::BatchGetSandboxes, request);
  }
 
  template <typename BatchGetSandboxesRequestT = Model::BatchGetSandboxesRequest>
  void BatchGetSandboxesAsync(const BatchGetSandboxesRequestT& request, const BatchGetSandboxesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::BatchGetSandboxes, request, handler, context);
  }
 
  virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const;
 
  template <typename CreateFleetRequestT = Model::CreateFleetRequest>
  Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::CreateFleet, request);
  }
 
  template <typename CreateFleetRequestT = Model::CreateFleetRequest>
  void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::CreateFleet, request, handler, context);
  }
 
  virtual Model::CreateProjectOutcome CreateProject(const Model::CreateProjectRequest& request) const;
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  Model::CreateProjectOutcomeCallable CreateProjectCallable(const CreateProjectRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::CreateProject, request);
  }
 
  template <typename CreateProjectRequestT = Model::CreateProjectRequest>
  void CreateProjectAsync(const CreateProjectRequestT& request, const CreateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::CreateProject, request, handler, context);
  }
 
  virtual Model::CreateReportGroupOutcome CreateReportGroup(const Model::CreateReportGroupRequest& request) const;
 
  template <typename CreateReportGroupRequestT = Model::CreateReportGroupRequest>
  Model::CreateReportGroupOutcomeCallable CreateReportGroupCallable(const CreateReportGroupRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::CreateReportGroup, request);
  }
 
  template <typename CreateReportGroupRequestT = Model::CreateReportGroupRequest>
  void CreateReportGroupAsync(const CreateReportGroupRequestT& request, const CreateReportGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::CreateReportGroup, request, handler, context);
  }
 
  virtual Model::CreateWebhookOutcome CreateWebhook(const Model::CreateWebhookRequest& request) const;
 
  template <typename CreateWebhookRequestT = Model::CreateWebhookRequest>
  Model::CreateWebhookOutcomeCallable CreateWebhookCallable(const CreateWebhookRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::CreateWebhook, request);
  }
 
  template <typename CreateWebhookRequestT = Model::CreateWebhookRequest>
  void CreateWebhookAsync(const CreateWebhookRequestT& request, const CreateWebhookResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::CreateWebhook, request, handler, context);
  }
 
  virtual Model::DeleteBuildBatchOutcome DeleteBuildBatch(const Model::DeleteBuildBatchRequest& request) const;
 
  template <typename DeleteBuildBatchRequestT = Model::DeleteBuildBatchRequest>
  Model::DeleteBuildBatchOutcomeCallable DeleteBuildBatchCallable(const DeleteBuildBatchRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteBuildBatch, request);
  }
 
  template <typename DeleteBuildBatchRequestT = Model::DeleteBuildBatchRequest>
  void DeleteBuildBatchAsync(const DeleteBuildBatchRequestT& request, const DeleteBuildBatchResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteBuildBatch, request, handler, context);
  }
 
  virtual Model::DeleteFleetOutcome DeleteFleet(const Model::DeleteFleetRequest& request) const;
 
  template <typename DeleteFleetRequestT = Model::DeleteFleetRequest>
  Model::DeleteFleetOutcomeCallable DeleteFleetCallable(const DeleteFleetRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteFleet, request);
  }
 
  template <typename DeleteFleetRequestT = Model::DeleteFleetRequest>
  void DeleteFleetAsync(const DeleteFleetRequestT& request, const DeleteFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteFleet, request, handler, context);
  }
 
  virtual Model::DeleteProjectOutcome DeleteProject(const Model::DeleteProjectRequest& request) const;
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  Model::DeleteProjectOutcomeCallable DeleteProjectCallable(const DeleteProjectRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteProject, request);
  }
 
  template <typename DeleteProjectRequestT = Model::DeleteProjectRequest>
  void DeleteProjectAsync(const DeleteProjectRequestT& request, const DeleteProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteProject, request, handler, context);
  }
 
  virtual Model::DeleteReportOutcome DeleteReport(const Model::DeleteReportRequest& request) const;
 
  template <typename DeleteReportRequestT = Model::DeleteReportRequest>
  Model::DeleteReportOutcomeCallable DeleteReportCallable(const DeleteReportRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteReport, request);
  }
 
  template <typename DeleteReportRequestT = Model::DeleteReportRequest>
  void DeleteReportAsync(const DeleteReportRequestT& request, const DeleteReportResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteReport, request, handler, context);
  }
 
  virtual Model::DeleteReportGroupOutcome DeleteReportGroup(const Model::DeleteReportGroupRequest& request) const;
 
  template <typename DeleteReportGroupRequestT = Model::DeleteReportGroupRequest>
  Model::DeleteReportGroupOutcomeCallable DeleteReportGroupCallable(const DeleteReportGroupRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteReportGroup, request);
  }
 
  template <typename DeleteReportGroupRequestT = Model::DeleteReportGroupRequest>
  void DeleteReportGroupAsync(const DeleteReportGroupRequestT& request, const DeleteReportGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteReportGroup, request, handler, context);
  }
 
  virtual Model::DeleteResourcePolicyOutcome DeleteResourcePolicy(const Model::DeleteResourcePolicyRequest& request) const;
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  Model::DeleteResourcePolicyOutcomeCallable DeleteResourcePolicyCallable(const DeleteResourcePolicyRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteResourcePolicy, request);
  }
 
  template <typename DeleteResourcePolicyRequestT = Model::DeleteResourcePolicyRequest>
  void DeleteResourcePolicyAsync(const DeleteResourcePolicyRequestT& request, const DeleteResourcePolicyResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteResourcePolicy, request, handler, context);
  }
 
  virtual Model::DeleteSourceCredentialsOutcome DeleteSourceCredentials(const Model::DeleteSourceCredentialsRequest& request) const;
 
  template <typename DeleteSourceCredentialsRequestT = Model::DeleteSourceCredentialsRequest>
  Model::DeleteSourceCredentialsOutcomeCallable DeleteSourceCredentialsCallable(const DeleteSourceCredentialsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteSourceCredentials, request);
  }
 
  template <typename DeleteSourceCredentialsRequestT = Model::DeleteSourceCredentialsRequest>
  void DeleteSourceCredentialsAsync(const DeleteSourceCredentialsRequestT& request,
                                    const DeleteSourceCredentialsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteSourceCredentials, request, handler, context);
  }
 
  virtual Model::DeleteWebhookOutcome DeleteWebhook(const Model::DeleteWebhookRequest& request) const;
 
  template <typename DeleteWebhookRequestT = Model::DeleteWebhookRequest>
  Model::DeleteWebhookOutcomeCallable DeleteWebhookCallable(const DeleteWebhookRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DeleteWebhook, request);
  }
 
  template <typename DeleteWebhookRequestT = Model::DeleteWebhookRequest>
  void DeleteWebhookAsync(const DeleteWebhookRequestT& request, const DeleteWebhookResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DeleteWebhook, request, handler, context);
  }
 
  virtual Model::DescribeCodeCoveragesOutcome DescribeCodeCoverages(const Model::DescribeCodeCoveragesRequest& request) const;
 
  template <typename DescribeCodeCoveragesRequestT = Model::DescribeCodeCoveragesRequest>
  Model::DescribeCodeCoveragesOutcomeCallable DescribeCodeCoveragesCallable(const DescribeCodeCoveragesRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DescribeCodeCoverages, request);
  }
 
  template <typename DescribeCodeCoveragesRequestT = Model::DescribeCodeCoveragesRequest>
  void DescribeCodeCoveragesAsync(const DescribeCodeCoveragesRequestT& request, const DescribeCodeCoveragesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DescribeCodeCoverages, request, handler, context);
  }
 
  virtual Model::DescribeTestCasesOutcome DescribeTestCases(const Model::DescribeTestCasesRequest& request) const;
 
  template <typename DescribeTestCasesRequestT = Model::DescribeTestCasesRequest>
  Model::DescribeTestCasesOutcomeCallable DescribeTestCasesCallable(const DescribeTestCasesRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::DescribeTestCases, request);
  }
 
  template <typename DescribeTestCasesRequestT = Model::DescribeTestCasesRequest>
  void DescribeTestCasesAsync(const DescribeTestCasesRequestT& request, const DescribeTestCasesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::DescribeTestCases, request, handler, context);
  }
 
  virtual Model::GetReportGroupTrendOutcome GetReportGroupTrend(const Model::GetReportGroupTrendRequest& request) const;
 
  template <typename GetReportGroupTrendRequestT = Model::GetReportGroupTrendRequest>
  Model::GetReportGroupTrendOutcomeCallable GetReportGroupTrendCallable(const GetReportGroupTrendRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::GetReportGroupTrend, request);
  }
 
  template <typename GetReportGroupTrendRequestT = Model::GetReportGroupTrendRequest>
  void GetReportGroupTrendAsync(const GetReportGroupTrendRequestT& request, const GetReportGroupTrendResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::GetReportGroupTrend, request, handler, context);
  }
 
  virtual Model::GetResourcePolicyOutcome GetResourcePolicy(const Model::GetResourcePolicyRequest& request) const;
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  Model::GetResourcePolicyOutcomeCallable GetResourcePolicyCallable(const GetResourcePolicyRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::GetResourcePolicy, request);
  }
 
  template <typename GetResourcePolicyRequestT = Model::GetResourcePolicyRequest>
  void GetResourcePolicyAsync(const GetResourcePolicyRequestT& request, const GetResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::GetResourcePolicy, request, handler, context);
  }
 
  virtual Model::ImportSourceCredentialsOutcome ImportSourceCredentials(const Model::ImportSourceCredentialsRequest& request) const;
 
  template <typename ImportSourceCredentialsRequestT = Model::ImportSourceCredentialsRequest>
  Model::ImportSourceCredentialsOutcomeCallable ImportSourceCredentialsCallable(const ImportSourceCredentialsRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::ImportSourceCredentials, request);
  }
 
  template <typename ImportSourceCredentialsRequestT = Model::ImportSourceCredentialsRequest>
  void ImportSourceCredentialsAsync(const ImportSourceCredentialsRequestT& request,
                                    const ImportSourceCredentialsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::ImportSourceCredentials, request, handler, context);
  }
 
  virtual Model::InvalidateProjectCacheOutcome InvalidateProjectCache(const Model::InvalidateProjectCacheRequest& request) const;
 
  template <typename InvalidateProjectCacheRequestT = Model::InvalidateProjectCacheRequest>
  Model::InvalidateProjectCacheOutcomeCallable InvalidateProjectCacheCallable(const InvalidateProjectCacheRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::InvalidateProjectCache, request);
  }
 
  template <typename InvalidateProjectCacheRequestT = Model::InvalidateProjectCacheRequest>
  void InvalidateProjectCacheAsync(const InvalidateProjectCacheRequestT& request,
                                   const InvalidateProjectCacheResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::InvalidateProjectCache, request, handler, context);
  }
 
  virtual Model::ListBuildBatchesOutcome ListBuildBatches(const Model::ListBuildBatchesRequest& request = {}) const;
 
  template <typename ListBuildBatchesRequestT = Model::ListBuildBatchesRequest>
  Model::ListBuildBatchesOutcomeCallable ListBuildBatchesCallable(const ListBuildBatchesRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListBuildBatches, request);
  }
 
  template <typename ListBuildBatchesRequestT = Model::ListBuildBatchesRequest>
  void ListBuildBatchesAsync(const ListBuildBatchesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListBuildBatchesRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListBuildBatches, request, handler, context);
  }
 
  virtual Model::ListBuildBatchesForProjectOutcome ListBuildBatchesForProject(
      const Model::ListBuildBatchesForProjectRequest& request = {}) const;
 
  template <typename ListBuildBatchesForProjectRequestT = Model::ListBuildBatchesForProjectRequest>
  Model::ListBuildBatchesForProjectOutcomeCallable ListBuildBatchesForProjectCallable(
      const ListBuildBatchesForProjectRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListBuildBatchesForProject, request);
  }
 
  template <typename ListBuildBatchesForProjectRequestT = Model::ListBuildBatchesForProjectRequest>
  void ListBuildBatchesForProjectAsync(const ListBuildBatchesForProjectResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                       const ListBuildBatchesForProjectRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListBuildBatchesForProject, request, handler, context);
  }
 
  virtual Model::ListBuildsOutcome ListBuilds(const Model::ListBuildsRequest& request = {}) const;
 
  template <typename ListBuildsRequestT = Model::ListBuildsRequest>
  Model::ListBuildsOutcomeCallable ListBuildsCallable(const ListBuildsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListBuilds, request);
  }
 
  template <typename ListBuildsRequestT = Model::ListBuildsRequest>
  void ListBuildsAsync(const ListBuildsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListBuildsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListBuilds, request, handler, context);
  }
 
  virtual Model::ListBuildsForProjectOutcome ListBuildsForProject(const Model::ListBuildsForProjectRequest& request) const;
 
  template <typename ListBuildsForProjectRequestT = Model::ListBuildsForProjectRequest>
  Model::ListBuildsForProjectOutcomeCallable ListBuildsForProjectCallable(const ListBuildsForProjectRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::ListBuildsForProject, request);
  }
 
  template <typename ListBuildsForProjectRequestT = Model::ListBuildsForProjectRequest>
  void ListBuildsForProjectAsync(const ListBuildsForProjectRequestT& request, const ListBuildsForProjectResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::ListBuildsForProject, request, handler, context);
  }
 
  virtual Model::ListCommandExecutionsForSandboxOutcome ListCommandExecutionsForSandbox(
      const Model::ListCommandExecutionsForSandboxRequest& request) const;
 
  template <typename ListCommandExecutionsForSandboxRequestT = Model::ListCommandExecutionsForSandboxRequest>
  Model::ListCommandExecutionsForSandboxOutcomeCallable ListCommandExecutionsForSandboxCallable(
      const ListCommandExecutionsForSandboxRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::ListCommandExecutionsForSandbox, request);
  }
 
  template <typename ListCommandExecutionsForSandboxRequestT = Model::ListCommandExecutionsForSandboxRequest>
  void ListCommandExecutionsForSandboxAsync(const ListCommandExecutionsForSandboxRequestT& request,
                                            const ListCommandExecutionsForSandboxResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::ListCommandExecutionsForSandbox, request, handler, context);
  }
 
  virtual Model::ListCuratedEnvironmentImagesOutcome ListCuratedEnvironmentImages(
      const Model::ListCuratedEnvironmentImagesRequest& request = {}) const;
 
  template <typename ListCuratedEnvironmentImagesRequestT = Model::ListCuratedEnvironmentImagesRequest>
  Model::ListCuratedEnvironmentImagesOutcomeCallable ListCuratedEnvironmentImagesCallable(
      const ListCuratedEnvironmentImagesRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListCuratedEnvironmentImages, request);
  }
 
  template <typename ListCuratedEnvironmentImagesRequestT = Model::ListCuratedEnvironmentImagesRequest>
  void ListCuratedEnvironmentImagesAsync(const ListCuratedEnvironmentImagesResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListCuratedEnvironmentImagesRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListCuratedEnvironmentImages, request, handler, context);
  }
 
  virtual Model::ListFleetsOutcome ListFleets(const Model::ListFleetsRequest& request = {}) const;
 
  template <typename ListFleetsRequestT = Model::ListFleetsRequest>
  Model::ListFleetsOutcomeCallable ListFleetsCallable(const ListFleetsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListFleets, request);
  }
 
  template <typename ListFleetsRequestT = Model::ListFleetsRequest>
  void ListFleetsAsync(const ListFleetsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const ListFleetsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListFleets, request, handler, context);
  }
 
  virtual Model::ListProjectsOutcome ListProjects(const Model::ListProjectsRequest& request = {}) const;
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  Model::ListProjectsOutcomeCallable ListProjectsCallable(const ListProjectsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListProjects, request);
  }
 
  template <typename ListProjectsRequestT = Model::ListProjectsRequest>
  void ListProjectsAsync(const ListProjectsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListProjectsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListProjects, request, handler, context);
  }
 
  virtual Model::ListReportGroupsOutcome ListReportGroups(const Model::ListReportGroupsRequest& request = {}) const;
 
  template <typename ListReportGroupsRequestT = Model::ListReportGroupsRequest>
  Model::ListReportGroupsOutcomeCallable ListReportGroupsCallable(const ListReportGroupsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListReportGroups, request);
  }
 
  template <typename ListReportGroupsRequestT = Model::ListReportGroupsRequest>
  void ListReportGroupsAsync(const ListReportGroupsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListReportGroupsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListReportGroups, request, handler, context);
  }
 
  virtual Model::ListReportsOutcome ListReports(const Model::ListReportsRequest& request = {}) const;
 
  template <typename ListReportsRequestT = Model::ListReportsRequest>
  Model::ListReportsOutcomeCallable ListReportsCallable(const ListReportsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListReports, request);
  }
 
  template <typename ListReportsRequestT = Model::ListReportsRequest>
  void ListReportsAsync(const ListReportsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListReportsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListReports, request, handler, context);
  }
 
  virtual Model::ListReportsForReportGroupOutcome ListReportsForReportGroup(const Model::ListReportsForReportGroupRequest& request) const;
 
  template <typename ListReportsForReportGroupRequestT = Model::ListReportsForReportGroupRequest>
  Model::ListReportsForReportGroupOutcomeCallable ListReportsForReportGroupCallable(
      const ListReportsForReportGroupRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::ListReportsForReportGroup, request);
  }
 
  template <typename ListReportsForReportGroupRequestT = Model::ListReportsForReportGroupRequest>
  void ListReportsForReportGroupAsync(const ListReportsForReportGroupRequestT& request,
                                      const ListReportsForReportGroupResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::ListReportsForReportGroup, request, handler, context);
  }
 
  virtual Model::ListSandboxesOutcome ListSandboxes(const Model::ListSandboxesRequest& request = {}) const;
 
  template <typename ListSandboxesRequestT = Model::ListSandboxesRequest>
  Model::ListSandboxesOutcomeCallable ListSandboxesCallable(const ListSandboxesRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListSandboxes, request);
  }
 
  template <typename ListSandboxesRequestT = Model::ListSandboxesRequest>
  void ListSandboxesAsync(const ListSandboxesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListSandboxesRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListSandboxes, request, handler, context);
  }
 
  virtual Model::ListSandboxesForProjectOutcome ListSandboxesForProject(const Model::ListSandboxesForProjectRequest& request) const;
 
  template <typename ListSandboxesForProjectRequestT = Model::ListSandboxesForProjectRequest>
  Model::ListSandboxesForProjectOutcomeCallable ListSandboxesForProjectCallable(const ListSandboxesForProjectRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::ListSandboxesForProject, request);
  }
 
  template <typename ListSandboxesForProjectRequestT = Model::ListSandboxesForProjectRequest>
  void ListSandboxesForProjectAsync(const ListSandboxesForProjectRequestT& request,
                                    const ListSandboxesForProjectResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::ListSandboxesForProject, request, handler, context);
  }
 
  virtual Model::ListSharedProjectsOutcome ListSharedProjects(const Model::ListSharedProjectsRequest& request = {}) const;
 
  template <typename ListSharedProjectsRequestT = Model::ListSharedProjectsRequest>
  Model::ListSharedProjectsOutcomeCallable ListSharedProjectsCallable(const ListSharedProjectsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListSharedProjects, request);
  }
 
  template <typename ListSharedProjectsRequestT = Model::ListSharedProjectsRequest>
  void ListSharedProjectsAsync(const ListSharedProjectsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListSharedProjectsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListSharedProjects, request, handler, context);
  }
 
  virtual Model::ListSharedReportGroupsOutcome ListSharedReportGroups(const Model::ListSharedReportGroupsRequest& request = {}) const;
 
  template <typename ListSharedReportGroupsRequestT = Model::ListSharedReportGroupsRequest>
  Model::ListSharedReportGroupsOutcomeCallable ListSharedReportGroupsCallable(const ListSharedReportGroupsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListSharedReportGroups, request);
  }
 
  template <typename ListSharedReportGroupsRequestT = Model::ListSharedReportGroupsRequest>
  void ListSharedReportGroupsAsync(const ListSharedReportGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListSharedReportGroupsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListSharedReportGroups, request, handler, context);
  }
 
  virtual Model::ListSourceCredentialsOutcome ListSourceCredentials(const Model::ListSourceCredentialsRequest& request = {}) const;
 
  template <typename ListSourceCredentialsRequestT = Model::ListSourceCredentialsRequest>
  Model::ListSourceCredentialsOutcomeCallable ListSourceCredentialsCallable(const ListSourceCredentialsRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::ListSourceCredentials, request);
  }
 
  template <typename ListSourceCredentialsRequestT = Model::ListSourceCredentialsRequest>
  void ListSourceCredentialsAsync(const ListSourceCredentialsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListSourceCredentialsRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::ListSourceCredentials, request, handler, context);
  }
 
  virtual Model::PutResourcePolicyOutcome PutResourcePolicy(const Model::PutResourcePolicyRequest& request) const;
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  Model::PutResourcePolicyOutcomeCallable PutResourcePolicyCallable(const PutResourcePolicyRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::PutResourcePolicy, request);
  }
 
  template <typename PutResourcePolicyRequestT = Model::PutResourcePolicyRequest>
  void PutResourcePolicyAsync(const PutResourcePolicyRequestT& request, const PutResourcePolicyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::PutResourcePolicy, request, handler, context);
  }
 
  virtual Model::RetryBuildOutcome RetryBuild(const Model::RetryBuildRequest& request = {}) const;
 
  template <typename RetryBuildRequestT = Model::RetryBuildRequest>
  Model::RetryBuildOutcomeCallable RetryBuildCallable(const RetryBuildRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::RetryBuild, request);
  }
 
  template <typename RetryBuildRequestT = Model::RetryBuildRequest>
  void RetryBuildAsync(const RetryBuildResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                       const RetryBuildRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::RetryBuild, request, handler, context);
  }
 
  virtual Model::RetryBuildBatchOutcome RetryBuildBatch(const Model::RetryBuildBatchRequest& request = {}) const;
 
  template <typename RetryBuildBatchRequestT = Model::RetryBuildBatchRequest>
  Model::RetryBuildBatchOutcomeCallable RetryBuildBatchCallable(const RetryBuildBatchRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::RetryBuildBatch, request);
  }
 
  template <typename RetryBuildBatchRequestT = Model::RetryBuildBatchRequest>
  void RetryBuildBatchAsync(const RetryBuildBatchResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const RetryBuildBatchRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::RetryBuildBatch, request, handler, context);
  }
 
  virtual Model::StartBuildOutcome StartBuild(const Model::StartBuildRequest& request) const;
 
  template <typename StartBuildRequestT = Model::StartBuildRequest>
  Model::StartBuildOutcomeCallable StartBuildCallable(const StartBuildRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::StartBuild, request);
  }
 
  template <typename StartBuildRequestT = Model::StartBuildRequest>
  void StartBuildAsync(const StartBuildRequestT& request, const StartBuildResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::StartBuild, request, handler, context);
  }
 
  virtual Model::StartBuildBatchOutcome StartBuildBatch(const Model::StartBuildBatchRequest& request) const;
 
  template <typename StartBuildBatchRequestT = Model::StartBuildBatchRequest>
  Model::StartBuildBatchOutcomeCallable StartBuildBatchCallable(const StartBuildBatchRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::StartBuildBatch, request);
  }
 
  template <typename StartBuildBatchRequestT = Model::StartBuildBatchRequest>
  void StartBuildBatchAsync(const StartBuildBatchRequestT& request, const StartBuildBatchResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::StartBuildBatch, request, handler, context);
  }
 
  virtual Model::StartCommandExecutionOutcome StartCommandExecution(const Model::StartCommandExecutionRequest& request) const;
 
  template <typename StartCommandExecutionRequestT = Model::StartCommandExecutionRequest>
  Model::StartCommandExecutionOutcomeCallable StartCommandExecutionCallable(const StartCommandExecutionRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::StartCommandExecution, request);
  }
 
  template <typename StartCommandExecutionRequestT = Model::StartCommandExecutionRequest>
  void StartCommandExecutionAsync(const StartCommandExecutionRequestT& request, const StartCommandExecutionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::StartCommandExecution, request, handler, context);
  }
 
  virtual Model::StartSandboxOutcome StartSandbox(const Model::StartSandboxRequest& request = {}) const;
 
  template <typename StartSandboxRequestT = Model::StartSandboxRequest>
  Model::StartSandboxOutcomeCallable StartSandboxCallable(const StartSandboxRequestT& request = {}) const {
    return SubmitCallable(&CodeBuildClient::StartSandbox, request);
  }
 
  template <typename StartSandboxRequestT = Model::StartSandboxRequest>
  void StartSandboxAsync(const StartSandboxResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const StartSandboxRequestT& request = {}) const {
    return SubmitAsync(&CodeBuildClient::StartSandbox, request, handler, context);
  }
 
  virtual Model::StartSandboxConnectionOutcome StartSandboxConnection(const Model::StartSandboxConnectionRequest& request) const;
 
  template <typename StartSandboxConnectionRequestT = Model::StartSandboxConnectionRequest>
  Model::StartSandboxConnectionOutcomeCallable StartSandboxConnectionCallable(const StartSandboxConnectionRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::StartSandboxConnection, request);
  }
 
  template <typename StartSandboxConnectionRequestT = Model::StartSandboxConnectionRequest>
  void StartSandboxConnectionAsync(const StartSandboxConnectionRequestT& request,
                                   const StartSandboxConnectionResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::StartSandboxConnection, request, handler, context);
  }
 
  virtual Model::StopBuildOutcome StopBuild(const Model::StopBuildRequest& request) const;
 
  template <typename StopBuildRequestT = Model::StopBuildRequest>
  Model::StopBuildOutcomeCallable StopBuildCallable(const StopBuildRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::StopBuild, request);
  }
 
  template <typename StopBuildRequestT = Model::StopBuildRequest>
  void StopBuildAsync(const StopBuildRequestT& request, const StopBuildResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::StopBuild, request, handler, context);
  }
 
  virtual Model::StopBuildBatchOutcome StopBuildBatch(const Model::StopBuildBatchRequest& request) const;
 
  template <typename StopBuildBatchRequestT = Model::StopBuildBatchRequest>
  Model::StopBuildBatchOutcomeCallable StopBuildBatchCallable(const StopBuildBatchRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::StopBuildBatch, request);
  }
 
  template <typename StopBuildBatchRequestT = Model::StopBuildBatchRequest>
  void StopBuildBatchAsync(const StopBuildBatchRequestT& request, const StopBuildBatchResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::StopBuildBatch, request, handler, context);
  }
 
  virtual Model::StopSandboxOutcome StopSandbox(const Model::StopSandboxRequest& request) const;
 
  template <typename StopSandboxRequestT = Model::StopSandboxRequest>
  Model::StopSandboxOutcomeCallable StopSandboxCallable(const StopSandboxRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::StopSandbox, request);
  }
 
  template <typename StopSandboxRequestT = Model::StopSandboxRequest>
  void StopSandboxAsync(const StopSandboxRequestT& request, const StopSandboxResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::StopSandbox, request, handler, context);
  }
 
  virtual Model::UpdateFleetOutcome UpdateFleet(const Model::UpdateFleetRequest& request) const;
 
  template <typename UpdateFleetRequestT = Model::UpdateFleetRequest>
  Model::UpdateFleetOutcomeCallable UpdateFleetCallable(const UpdateFleetRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::UpdateFleet, request);
  }
 
  template <typename UpdateFleetRequestT = Model::UpdateFleetRequest>
  void UpdateFleetAsync(const UpdateFleetRequestT& request, const UpdateFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::UpdateFleet, request, handler, context);
  }
 
  virtual Model::UpdateProjectOutcome UpdateProject(const Model::UpdateProjectRequest& request) const;
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  Model::UpdateProjectOutcomeCallable UpdateProjectCallable(const UpdateProjectRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::UpdateProject, request);
  }
 
  template <typename UpdateProjectRequestT = Model::UpdateProjectRequest>
  void UpdateProjectAsync(const UpdateProjectRequestT& request, const UpdateProjectResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::UpdateProject, request, handler, context);
  }
 
  virtual Model::UpdateProjectVisibilityOutcome UpdateProjectVisibility(const Model::UpdateProjectVisibilityRequest& request) const;
 
  template <typename UpdateProjectVisibilityRequestT = Model::UpdateProjectVisibilityRequest>
  Model::UpdateProjectVisibilityOutcomeCallable UpdateProjectVisibilityCallable(const UpdateProjectVisibilityRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::UpdateProjectVisibility, request);
  }
 
  template <typename UpdateProjectVisibilityRequestT = Model::UpdateProjectVisibilityRequest>
  void UpdateProjectVisibilityAsync(const UpdateProjectVisibilityRequestT& request,
                                    const UpdateProjectVisibilityResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::UpdateProjectVisibility, request, handler, context);
  }
 
  virtual Model::UpdateReportGroupOutcome UpdateReportGroup(const Model::UpdateReportGroupRequest& request) const;
 
  template <typename UpdateReportGroupRequestT = Model::UpdateReportGroupRequest>
  Model::UpdateReportGroupOutcomeCallable UpdateReportGroupCallable(const UpdateReportGroupRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::UpdateReportGroup, request);
  }
 
  template <typename UpdateReportGroupRequestT = Model::UpdateReportGroupRequest>
  void UpdateReportGroupAsync(const UpdateReportGroupRequestT& request, const UpdateReportGroupResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::UpdateReportGroup, request, handler, context);
  }
 
  virtual Model::UpdateWebhookOutcome UpdateWebhook(const Model::UpdateWebhookRequest& request) const;
 
  template <typename UpdateWebhookRequestT = Model::UpdateWebhookRequest>
  Model::UpdateWebhookOutcomeCallable UpdateWebhookCallable(const UpdateWebhookRequestT& request) const {
    return SubmitCallable(&CodeBuildClient::UpdateWebhook, request);
  }
 
  template <typename UpdateWebhookRequestT = Model::UpdateWebhookRequest>
  void UpdateWebhookAsync(const UpdateWebhookRequestT& request, const UpdateWebhookResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeBuildClient::UpdateWebhook, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CodeBuildEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeBuildClient>;
  void init(const CodeBuildClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CodeBuildError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CodeBuildClientConfiguration m_clientConfiguration;
  std::shared_ptr<CodeBuildEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CodeBuild
}  // namespace Aws