CodeCatalystClient.h

 
#pragma once
#include <aws/codecatalyst/CodeCatalystServiceClientModel.h>
#include <aws/codecatalyst/CodeCatalyst_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 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