CodeCatalystClient.h

 
#pragma once
#include <aws/codecatalyst/CodeCatalyst_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/codecatalyst/CodeCatalystServiceClientModel.h>
 
namespace Aws
{
namespace CodeCatalyst
{
  class AWS_CODECATALYST_API CodeCatalystClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CodeCatalystClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CodeCatalystClientConfiguration ClientConfigurationType;
      typedef CodeCatalystEndpointProvider EndpointProviderType;
 
        CodeCatalystClient(const Aws::Auth::BearerTokenAuthSignerProvider& bearerTokenProvider,
                           std::shared_ptr<CodeCatalystEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::CodeCatalyst::CodeCatalystClientConfiguration& clientConfiguration = Aws::CodeCatalyst::CodeCatalystClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CodeCatalystClient(const Aws::Auth::BearerTokenAuthSignerProvider& bearerTokenProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CodeCatalystClient();
 
        virtual Model::CreateAccessTokenOutcome CreateAccessToken(const Model::CreateAccessTokenRequest& request) const;
 
        template<typename CreateAccessTokenRequestT = Model::CreateAccessTokenRequest>
        Model::CreateAccessTokenOutcomeCallable CreateAccessTokenCallable(const CreateAccessTokenRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::CreateAccessToken, request);
        }
 
        template<typename CreateAccessTokenRequestT = Model::CreateAccessTokenRequest>
        void CreateAccessTokenAsync(const CreateAccessTokenRequestT& request, const CreateAccessTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::CreateAccessToken, request, handler, context);
        }
 
        virtual Model::CreateDevEnvironmentOutcome CreateDevEnvironment(const Model::CreateDevEnvironmentRequest& request) const;
 
        template<typename CreateDevEnvironmentRequestT = Model::CreateDevEnvironmentRequest>
        Model::CreateDevEnvironmentOutcomeCallable CreateDevEnvironmentCallable(const CreateDevEnvironmentRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::CreateDevEnvironment, request);
        }
 
        template<typename CreateDevEnvironmentRequestT = Model::CreateDevEnvironmentRequest>
        void CreateDevEnvironmentAsync(const CreateDevEnvironmentRequestT& request, const CreateDevEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::CreateDevEnvironment, 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(&CodeCatalystClient::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(&CodeCatalystClient::CreateProject, request, handler, context);
        }
 
        virtual Model::CreateSourceRepositoryOutcome CreateSourceRepository(const Model::CreateSourceRepositoryRequest& request) const;
 
        template<typename CreateSourceRepositoryRequestT = Model::CreateSourceRepositoryRequest>
        Model::CreateSourceRepositoryOutcomeCallable CreateSourceRepositoryCallable(const CreateSourceRepositoryRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::CreateSourceRepository, request);
        }
 
        template<typename CreateSourceRepositoryRequestT = Model::CreateSourceRepositoryRequest>
        void CreateSourceRepositoryAsync(const CreateSourceRepositoryRequestT& request, const CreateSourceRepositoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::CreateSourceRepository, request, handler, context);
        }
 
        virtual Model::CreateSourceRepositoryBranchOutcome CreateSourceRepositoryBranch(const Model::CreateSourceRepositoryBranchRequest& request) const;
 
        template<typename CreateSourceRepositoryBranchRequestT = Model::CreateSourceRepositoryBranchRequest>
        Model::CreateSourceRepositoryBranchOutcomeCallable CreateSourceRepositoryBranchCallable(const CreateSourceRepositoryBranchRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::CreateSourceRepositoryBranch, request);
        }
 
        template<typename CreateSourceRepositoryBranchRequestT = Model::CreateSourceRepositoryBranchRequest>
        void CreateSourceRepositoryBranchAsync(const CreateSourceRepositoryBranchRequestT& request, const CreateSourceRepositoryBranchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::CreateSourceRepositoryBranch, request, handler, context);
        }
 
        virtual Model::DeleteAccessTokenOutcome DeleteAccessToken(const Model::DeleteAccessTokenRequest& request) const;
 
        template<typename DeleteAccessTokenRequestT = Model::DeleteAccessTokenRequest>
        Model::DeleteAccessTokenOutcomeCallable DeleteAccessTokenCallable(const DeleteAccessTokenRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::DeleteAccessToken, request);
        }
 
        template<typename DeleteAccessTokenRequestT = Model::DeleteAccessTokenRequest>
        void DeleteAccessTokenAsync(const DeleteAccessTokenRequestT& request, const DeleteAccessTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::DeleteAccessToken, request, handler, context);
        }
 
        virtual Model::DeleteDevEnvironmentOutcome DeleteDevEnvironment(const Model::DeleteDevEnvironmentRequest& request) const;
 
        template<typename DeleteDevEnvironmentRequestT = Model::DeleteDevEnvironmentRequest>
        Model::DeleteDevEnvironmentOutcomeCallable DeleteDevEnvironmentCallable(const DeleteDevEnvironmentRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::DeleteDevEnvironment, request);
        }
 
        template<typename DeleteDevEnvironmentRequestT = Model::DeleteDevEnvironmentRequest>
        void DeleteDevEnvironmentAsync(const DeleteDevEnvironmentRequestT& request, const DeleteDevEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::DeleteDevEnvironment, 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(&CodeCatalystClient::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(&CodeCatalystClient::DeleteProject, request, handler, context);
        }
 
        virtual Model::DeleteSourceRepositoryOutcome DeleteSourceRepository(const Model::DeleteSourceRepositoryRequest& request) const;
 
        template<typename DeleteSourceRepositoryRequestT = Model::DeleteSourceRepositoryRequest>
        Model::DeleteSourceRepositoryOutcomeCallable DeleteSourceRepositoryCallable(const DeleteSourceRepositoryRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::DeleteSourceRepository, request);
        }
 
        template<typename DeleteSourceRepositoryRequestT = Model::DeleteSourceRepositoryRequest>
        void DeleteSourceRepositoryAsync(const DeleteSourceRepositoryRequestT& request, const DeleteSourceRepositoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::DeleteSourceRepository, request, handler, context);
        }
 
        virtual Model::DeleteSpaceOutcome DeleteSpace(const Model::DeleteSpaceRequest& request) const;
 
        template<typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
        Model::DeleteSpaceOutcomeCallable DeleteSpaceCallable(const DeleteSpaceRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::DeleteSpace, request);
        }
 
        template<typename DeleteSpaceRequestT = Model::DeleteSpaceRequest>
        void DeleteSpaceAsync(const DeleteSpaceRequestT& request, const DeleteSpaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::DeleteSpace, request, handler, context);
        }
 
        virtual Model::GetDevEnvironmentOutcome GetDevEnvironment(const Model::GetDevEnvironmentRequest& request) const;
 
        template<typename GetDevEnvironmentRequestT = Model::GetDevEnvironmentRequest>
        Model::GetDevEnvironmentOutcomeCallable GetDevEnvironmentCallable(const GetDevEnvironmentRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetDevEnvironment, request);
        }
 
        template<typename GetDevEnvironmentRequestT = Model::GetDevEnvironmentRequest>
        void GetDevEnvironmentAsync(const GetDevEnvironmentRequestT& request, const GetDevEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetDevEnvironment, request, handler, context);
        }
 
        virtual Model::GetProjectOutcome GetProject(const Model::GetProjectRequest& request) const;
 
        template<typename GetProjectRequestT = Model::GetProjectRequest>
        Model::GetProjectOutcomeCallable GetProjectCallable(const GetProjectRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetProject, request);
        }
 
        template<typename GetProjectRequestT = Model::GetProjectRequest>
        void GetProjectAsync(const GetProjectRequestT& request, const GetProjectResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetProject, request, handler, context);
        }
 
        virtual Model::GetSourceRepositoryOutcome GetSourceRepository(const Model::GetSourceRepositoryRequest& request) const;
 
        template<typename GetSourceRepositoryRequestT = Model::GetSourceRepositoryRequest>
        Model::GetSourceRepositoryOutcomeCallable GetSourceRepositoryCallable(const GetSourceRepositoryRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetSourceRepository, request);
        }
 
        template<typename GetSourceRepositoryRequestT = Model::GetSourceRepositoryRequest>
        void GetSourceRepositoryAsync(const GetSourceRepositoryRequestT& request, const GetSourceRepositoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetSourceRepository, request, handler, context);
        }
 
        virtual Model::GetSourceRepositoryCloneUrlsOutcome GetSourceRepositoryCloneUrls(const Model::GetSourceRepositoryCloneUrlsRequest& request) const;
 
        template<typename GetSourceRepositoryCloneUrlsRequestT = Model::GetSourceRepositoryCloneUrlsRequest>
        Model::GetSourceRepositoryCloneUrlsOutcomeCallable GetSourceRepositoryCloneUrlsCallable(const GetSourceRepositoryCloneUrlsRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetSourceRepositoryCloneUrls, request);
        }
 
        template<typename GetSourceRepositoryCloneUrlsRequestT = Model::GetSourceRepositoryCloneUrlsRequest>
        void GetSourceRepositoryCloneUrlsAsync(const GetSourceRepositoryCloneUrlsRequestT& request, const GetSourceRepositoryCloneUrlsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetSourceRepositoryCloneUrls, request, handler, context);
        }
 
        virtual Model::GetSpaceOutcome GetSpace(const Model::GetSpaceRequest& request) const;
 
        template<typename GetSpaceRequestT = Model::GetSpaceRequest>
        Model::GetSpaceOutcomeCallable GetSpaceCallable(const GetSpaceRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetSpace, request);
        }
 
        template<typename GetSpaceRequestT = Model::GetSpaceRequest>
        void GetSpaceAsync(const GetSpaceRequestT& request, const GetSpaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetSpace, request, handler, context);
        }
 
        virtual Model::GetSubscriptionOutcome GetSubscription(const Model::GetSubscriptionRequest& request) const;
 
        template<typename GetSubscriptionRequestT = Model::GetSubscriptionRequest>
        Model::GetSubscriptionOutcomeCallable GetSubscriptionCallable(const GetSubscriptionRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetSubscription, request);
        }
 
        template<typename GetSubscriptionRequestT = Model::GetSubscriptionRequest>
        void GetSubscriptionAsync(const GetSubscriptionRequestT& request, const GetSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetSubscription, request, handler, context);
        }
 
        virtual Model::GetUserDetailsOutcome GetUserDetails(const Model::GetUserDetailsRequest& request = {}) const;
 
        template<typename GetUserDetailsRequestT = Model::GetUserDetailsRequest>
        Model::GetUserDetailsOutcomeCallable GetUserDetailsCallable(const GetUserDetailsRequestT& request = {}) const
        {
            return SubmitCallable(&CodeCatalystClient::GetUserDetails, request);
        }
 
        template<typename GetUserDetailsRequestT = Model::GetUserDetailsRequest>
        void GetUserDetailsAsync(const GetUserDetailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetUserDetailsRequestT& request = {}) const
        {
            return SubmitAsync(&CodeCatalystClient::GetUserDetails, request, handler, context);
        }
 
        virtual Model::GetWorkflowOutcome GetWorkflow(const Model::GetWorkflowRequest& request) const;
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        Model::GetWorkflowOutcomeCallable GetWorkflowCallable(const GetWorkflowRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetWorkflow, request);
        }
 
        template<typename GetWorkflowRequestT = Model::GetWorkflowRequest>
        void GetWorkflowAsync(const GetWorkflowRequestT& request, const GetWorkflowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetWorkflow, request, handler, context);
        }
 
        virtual Model::GetWorkflowRunOutcome GetWorkflowRun(const Model::GetWorkflowRunRequest& request) const;
 
        template<typename GetWorkflowRunRequestT = Model::GetWorkflowRunRequest>
        Model::GetWorkflowRunOutcomeCallable GetWorkflowRunCallable(const GetWorkflowRunRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::GetWorkflowRun, request);
        }
 
        template<typename GetWorkflowRunRequestT = Model::GetWorkflowRunRequest>
        void GetWorkflowRunAsync(const GetWorkflowRunRequestT& request, const GetWorkflowRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::GetWorkflowRun, request, handler, context);
        }
 
        virtual Model::ListAccessTokensOutcome ListAccessTokens(const Model::ListAccessTokensRequest& request = {}) const;
 
        template<typename ListAccessTokensRequestT = Model::ListAccessTokensRequest>
        Model::ListAccessTokensOutcomeCallable ListAccessTokensCallable(const ListAccessTokensRequestT& request = {}) const
        {
            return SubmitCallable(&CodeCatalystClient::ListAccessTokens, request);
        }
 
        template<typename ListAccessTokensRequestT = Model::ListAccessTokensRequest>
        void ListAccessTokensAsync(const ListAccessTokensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccessTokensRequestT& request = {}) const
        {
            return SubmitAsync(&CodeCatalystClient::ListAccessTokens, request, handler, context);
        }
 
        virtual Model::ListDevEnvironmentSessionsOutcome ListDevEnvironmentSessions(const Model::ListDevEnvironmentSessionsRequest& request) const;
 
        template<typename ListDevEnvironmentSessionsRequestT = Model::ListDevEnvironmentSessionsRequest>
        Model::ListDevEnvironmentSessionsOutcomeCallable ListDevEnvironmentSessionsCallable(const ListDevEnvironmentSessionsRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::ListDevEnvironmentSessions, request);
        }
 
        template<typename ListDevEnvironmentSessionsRequestT = Model::ListDevEnvironmentSessionsRequest>
        void ListDevEnvironmentSessionsAsync(const ListDevEnvironmentSessionsRequestT& request, const ListDevEnvironmentSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListDevEnvironmentSessions, request, handler, context);
        }
 
        virtual Model::ListDevEnvironmentsOutcome ListDevEnvironments(const Model::ListDevEnvironmentsRequest& request) const;
 
        template<typename ListDevEnvironmentsRequestT = Model::ListDevEnvironmentsRequest>
        Model::ListDevEnvironmentsOutcomeCallable ListDevEnvironmentsCallable(const ListDevEnvironmentsRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::ListDevEnvironments, request);
        }
 
        template<typename ListDevEnvironmentsRequestT = Model::ListDevEnvironmentsRequest>
        void ListDevEnvironmentsAsync(const ListDevEnvironmentsRequestT& request, const ListDevEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListDevEnvironments, request, handler, context);
        }
 
        virtual Model::ListEventLogsOutcome ListEventLogs(const Model::ListEventLogsRequest& request) const;
 
        template<typename ListEventLogsRequestT = Model::ListEventLogsRequest>
        Model::ListEventLogsOutcomeCallable ListEventLogsCallable(const ListEventLogsRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::ListEventLogs, request);
        }
 
        template<typename ListEventLogsRequestT = Model::ListEventLogsRequest>
        void ListEventLogsAsync(const ListEventLogsRequestT& request, const ListEventLogsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListEventLogs, 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(&CodeCatalystClient::ListProjects, request);
        }
 
        template<typename ListProjectsRequestT = Model::ListProjectsRequest>
        void ListProjectsAsync(const ListProjectsRequestT& request, const ListProjectsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListProjects, request, handler, context);
        }
 
        virtual Model::ListSourceRepositoriesOutcome ListSourceRepositories(const Model::ListSourceRepositoriesRequest& request) const;
 
        template<typename ListSourceRepositoriesRequestT = Model::ListSourceRepositoriesRequest>
        Model::ListSourceRepositoriesOutcomeCallable ListSourceRepositoriesCallable(const ListSourceRepositoriesRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::ListSourceRepositories, request);
        }
 
        template<typename ListSourceRepositoriesRequestT = Model::ListSourceRepositoriesRequest>
        void ListSourceRepositoriesAsync(const ListSourceRepositoriesRequestT& request, const ListSourceRepositoriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListSourceRepositories, request, handler, context);
        }
 
        virtual Model::ListSourceRepositoryBranchesOutcome ListSourceRepositoryBranches(const Model::ListSourceRepositoryBranchesRequest& request) const;
 
        template<typename ListSourceRepositoryBranchesRequestT = Model::ListSourceRepositoryBranchesRequest>
        Model::ListSourceRepositoryBranchesOutcomeCallable ListSourceRepositoryBranchesCallable(const ListSourceRepositoryBranchesRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::ListSourceRepositoryBranches, request);
        }
 
        template<typename ListSourceRepositoryBranchesRequestT = Model::ListSourceRepositoryBranchesRequest>
        void ListSourceRepositoryBranchesAsync(const ListSourceRepositoryBranchesRequestT& request, const ListSourceRepositoryBranchesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListSourceRepositoryBranches, request, handler, context);
        }
 
        virtual Model::ListSpacesOutcome ListSpaces(const Model::ListSpacesRequest& request = {}) const;
 
        template<typename ListSpacesRequestT = Model::ListSpacesRequest>
        Model::ListSpacesOutcomeCallable ListSpacesCallable(const ListSpacesRequestT& request = {}) const
        {
            return SubmitCallable(&CodeCatalystClient::ListSpaces, request);
        }
 
        template<typename ListSpacesRequestT = Model::ListSpacesRequest>
        void ListSpacesAsync(const ListSpacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSpacesRequestT& request = {}) const
        {
            return SubmitAsync(&CodeCatalystClient::ListSpaces, request, handler, context);
        }
 
        virtual Model::ListWorkflowRunsOutcome ListWorkflowRuns(const Model::ListWorkflowRunsRequest& request) const;
 
        template<typename ListWorkflowRunsRequestT = Model::ListWorkflowRunsRequest>
        Model::ListWorkflowRunsOutcomeCallable ListWorkflowRunsCallable(const ListWorkflowRunsRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::ListWorkflowRuns, request);
        }
 
        template<typename ListWorkflowRunsRequestT = Model::ListWorkflowRunsRequest>
        void ListWorkflowRunsAsync(const ListWorkflowRunsRequestT& request, const ListWorkflowRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListWorkflowRuns, request, handler, context);
        }
 
        virtual Model::ListWorkflowsOutcome ListWorkflows(const Model::ListWorkflowsRequest& request) const;
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        Model::ListWorkflowsOutcomeCallable ListWorkflowsCallable(const ListWorkflowsRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::ListWorkflows, request);
        }
 
        template<typename ListWorkflowsRequestT = Model::ListWorkflowsRequest>
        void ListWorkflowsAsync(const ListWorkflowsRequestT& request, const ListWorkflowsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::ListWorkflows, request, handler, context);
        }
 
        virtual Model::StartDevEnvironmentOutcome StartDevEnvironment(const Model::StartDevEnvironmentRequest& request) const;
 
        template<typename StartDevEnvironmentRequestT = Model::StartDevEnvironmentRequest>
        Model::StartDevEnvironmentOutcomeCallable StartDevEnvironmentCallable(const StartDevEnvironmentRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::StartDevEnvironment, request);
        }
 
        template<typename StartDevEnvironmentRequestT = Model::StartDevEnvironmentRequest>
        void StartDevEnvironmentAsync(const StartDevEnvironmentRequestT& request, const StartDevEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::StartDevEnvironment, request, handler, context);
        }
 
        virtual Model::StartDevEnvironmentSessionOutcome StartDevEnvironmentSession(const Model::StartDevEnvironmentSessionRequest& request) const;
 
        template<typename StartDevEnvironmentSessionRequestT = Model::StartDevEnvironmentSessionRequest>
        Model::StartDevEnvironmentSessionOutcomeCallable StartDevEnvironmentSessionCallable(const StartDevEnvironmentSessionRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::StartDevEnvironmentSession, request);
        }
 
        template<typename StartDevEnvironmentSessionRequestT = Model::StartDevEnvironmentSessionRequest>
        void StartDevEnvironmentSessionAsync(const StartDevEnvironmentSessionRequestT& request, const StartDevEnvironmentSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::StartDevEnvironmentSession, request, handler, context);
        }
 
        virtual Model::StartWorkflowRunOutcome StartWorkflowRun(const Model::StartWorkflowRunRequest& request) const;
 
        template<typename StartWorkflowRunRequestT = Model::StartWorkflowRunRequest>
        Model::StartWorkflowRunOutcomeCallable StartWorkflowRunCallable(const StartWorkflowRunRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::StartWorkflowRun, request);
        }
 
        template<typename StartWorkflowRunRequestT = Model::StartWorkflowRunRequest>
        void StartWorkflowRunAsync(const StartWorkflowRunRequestT& request, const StartWorkflowRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::StartWorkflowRun, request, handler, context);
        }
 
        virtual Model::StopDevEnvironmentOutcome StopDevEnvironment(const Model::StopDevEnvironmentRequest& request) const;
 
        template<typename StopDevEnvironmentRequestT = Model::StopDevEnvironmentRequest>
        Model::StopDevEnvironmentOutcomeCallable StopDevEnvironmentCallable(const StopDevEnvironmentRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::StopDevEnvironment, request);
        }
 
        template<typename StopDevEnvironmentRequestT = Model::StopDevEnvironmentRequest>
        void StopDevEnvironmentAsync(const StopDevEnvironmentRequestT& request, const StopDevEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::StopDevEnvironment, request, handler, context);
        }
 
        virtual Model::StopDevEnvironmentSessionOutcome StopDevEnvironmentSession(const Model::StopDevEnvironmentSessionRequest& request) const;
 
        template<typename StopDevEnvironmentSessionRequestT = Model::StopDevEnvironmentSessionRequest>
        Model::StopDevEnvironmentSessionOutcomeCallable StopDevEnvironmentSessionCallable(const StopDevEnvironmentSessionRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::StopDevEnvironmentSession, request);
        }
 
        template<typename StopDevEnvironmentSessionRequestT = Model::StopDevEnvironmentSessionRequest>
        void StopDevEnvironmentSessionAsync(const StopDevEnvironmentSessionRequestT& request, const StopDevEnvironmentSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::StopDevEnvironmentSession, request, handler, context);
        }
 
        virtual Model::UpdateDevEnvironmentOutcome UpdateDevEnvironment(const Model::UpdateDevEnvironmentRequest& request) const;
 
        template<typename UpdateDevEnvironmentRequestT = Model::UpdateDevEnvironmentRequest>
        Model::UpdateDevEnvironmentOutcomeCallable UpdateDevEnvironmentCallable(const UpdateDevEnvironmentRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::UpdateDevEnvironment, request);
        }
 
        template<typename UpdateDevEnvironmentRequestT = Model::UpdateDevEnvironmentRequest>
        void UpdateDevEnvironmentAsync(const UpdateDevEnvironmentRequestT& request, const UpdateDevEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::UpdateDevEnvironment, 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(&CodeCatalystClient::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(&CodeCatalystClient::UpdateProject, request, handler, context);
        }
 
        virtual Model::UpdateSpaceOutcome UpdateSpace(const Model::UpdateSpaceRequest& request) const;
 
        template<typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
        Model::UpdateSpaceOutcomeCallable UpdateSpaceCallable(const UpdateSpaceRequestT& request) const
        {
            return SubmitCallable(&CodeCatalystClient::UpdateSpace, request);
        }
 
        template<typename UpdateSpaceRequestT = Model::UpdateSpaceRequest>
        void UpdateSpaceAsync(const UpdateSpaceRequestT& request, const UpdateSpaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&CodeCatalystClient::UpdateSpace, request, handler, context);
        }
 
        virtual Model::VerifySessionOutcome VerifySession(const Model::VerifySessionRequest& request = {}) const;
 
        template<typename VerifySessionRequestT = Model::VerifySessionRequest>
        Model::VerifySessionOutcomeCallable VerifySessionCallable(const VerifySessionRequestT& request = {}) const
        {
            return SubmitCallable(&CodeCatalystClient::VerifySession, request);
        }
 
        template<typename VerifySessionRequestT = Model::VerifySessionRequest>
        void VerifySessionAsync(const VerifySessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const VerifySessionRequestT& request = {}) const
        {
            return SubmitAsync(&CodeCatalystClient::VerifySession, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodeCatalystEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeCatalystClient>;
      void init(const CodeCatalystClientConfiguration& clientConfiguration);
 
      CodeCatalystClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodeCatalystEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodeCatalyst
} // namespace Aws