CodeBuildClient.h

 
#pragma once
#include <aws/codebuild/CodeBuild_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/codebuild/CodeBuildServiceClientModel.h>
 
namespace Aws
{
namespace CodeBuild
{
  class AWS_CODEBUILD_API CodeBuildClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodeBuildEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeBuildClient>;
      void init(const CodeBuildClientConfiguration& clientConfiguration);
 
      CodeBuildClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodeBuildEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodeBuild
} // namespace Aws