CodeConnectionsClient.h

 
#pragma once
#include <aws/codeconnections/CodeConnectionsPaginationBase.h>
#include <aws/codeconnections/CodeConnectionsServiceClientModel.h>
#include <aws/codeconnections/CodeConnectionsWaiter.h>
#include <aws/codeconnections/CodeConnections_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 CodeConnections {
class AWS_CODECONNECTIONS_API CodeConnectionsClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<CodeConnectionsClient>,
                                                      public CodeConnectionsPaginationBase<CodeConnectionsClient>,
                                                      public CodeConnectionsWaiter<CodeConnectionsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CodeConnectionsClientConfiguration ClientConfigurationType;
  typedef CodeConnectionsEndpointProvider EndpointProviderType;
 
  CodeConnectionsClient(const Aws::CodeConnections::CodeConnectionsClientConfiguration& clientConfiguration =
                            Aws::CodeConnections::CodeConnectionsClientConfiguration(),
                        std::shared_ptr<CodeConnectionsEndpointProviderBase> endpointProvider = nullptr);
 
  CodeConnectionsClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<CodeConnectionsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::CodeConnections::CodeConnectionsClientConfiguration& clientConfiguration =
                            Aws::CodeConnections::CodeConnectionsClientConfiguration());
 
  CodeConnectionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<CodeConnectionsEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::CodeConnections::CodeConnectionsClientConfiguration& clientConfiguration =
                            Aws::CodeConnections::CodeConnectionsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CodeConnectionsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeConnectionsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CodeConnectionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CodeConnectionsClient();
 
  virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;
 
  template <typename CreateConnectionRequestT = Model::CreateConnectionRequest>
  Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::CreateConnection, request);
  }
 
  template <typename CreateConnectionRequestT = Model::CreateConnectionRequest>
  void CreateConnectionAsync(const CreateConnectionRequestT& request, const CreateConnectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::CreateConnection, request, handler, context);
  }
 
  virtual Model::CreateHostOutcome CreateHost(const Model::CreateHostRequest& request) const;
 
  template <typename CreateHostRequestT = Model::CreateHostRequest>
  Model::CreateHostOutcomeCallable CreateHostCallable(const CreateHostRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::CreateHost, request);
  }
 
  template <typename CreateHostRequestT = Model::CreateHostRequest>
  void CreateHostAsync(const CreateHostRequestT& request, const CreateHostResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::CreateHost, request, handler, context);
  }
 
  virtual Model::CreateRepositoryLinkOutcome CreateRepositoryLink(const Model::CreateRepositoryLinkRequest& request) const;
 
  template <typename CreateRepositoryLinkRequestT = Model::CreateRepositoryLinkRequest>
  Model::CreateRepositoryLinkOutcomeCallable CreateRepositoryLinkCallable(const CreateRepositoryLinkRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::CreateRepositoryLink, request);
  }
 
  template <typename CreateRepositoryLinkRequestT = Model::CreateRepositoryLinkRequest>
  void CreateRepositoryLinkAsync(const CreateRepositoryLinkRequestT& request, const CreateRepositoryLinkResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::CreateRepositoryLink, request, handler, context);
  }
 
  virtual Model::CreateSyncConfigurationOutcome CreateSyncConfiguration(const Model::CreateSyncConfigurationRequest& request) const;
 
  template <typename CreateSyncConfigurationRequestT = Model::CreateSyncConfigurationRequest>
  Model::CreateSyncConfigurationOutcomeCallable CreateSyncConfigurationCallable(const CreateSyncConfigurationRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::CreateSyncConfiguration, request);
  }
 
  template <typename CreateSyncConfigurationRequestT = Model::CreateSyncConfigurationRequest>
  void CreateSyncConfigurationAsync(const CreateSyncConfigurationRequestT& request,
                                    const CreateSyncConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::CreateSyncConfiguration, request, handler, context);
  }
 
  virtual Model::DeleteConnectionOutcome DeleteConnection(const Model::DeleteConnectionRequest& request) const;
 
  template <typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
  Model::DeleteConnectionOutcomeCallable DeleteConnectionCallable(const DeleteConnectionRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::DeleteConnection, request);
  }
 
  template <typename DeleteConnectionRequestT = Model::DeleteConnectionRequest>
  void DeleteConnectionAsync(const DeleteConnectionRequestT& request, const DeleteConnectionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::DeleteConnection, request, handler, context);
  }
 
  virtual Model::DeleteHostOutcome DeleteHost(const Model::DeleteHostRequest& request) const;
 
  template <typename DeleteHostRequestT = Model::DeleteHostRequest>
  Model::DeleteHostOutcomeCallable DeleteHostCallable(const DeleteHostRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::DeleteHost, request);
  }
 
  template <typename DeleteHostRequestT = Model::DeleteHostRequest>
  void DeleteHostAsync(const DeleteHostRequestT& request, const DeleteHostResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::DeleteHost, request, handler, context);
  }
 
  virtual Model::DeleteRepositoryLinkOutcome DeleteRepositoryLink(const Model::DeleteRepositoryLinkRequest& request) const;
 
  template <typename DeleteRepositoryLinkRequestT = Model::DeleteRepositoryLinkRequest>
  Model::DeleteRepositoryLinkOutcomeCallable DeleteRepositoryLinkCallable(const DeleteRepositoryLinkRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::DeleteRepositoryLink, request);
  }
 
  template <typename DeleteRepositoryLinkRequestT = Model::DeleteRepositoryLinkRequest>
  void DeleteRepositoryLinkAsync(const DeleteRepositoryLinkRequestT& request, const DeleteRepositoryLinkResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::DeleteRepositoryLink, request, handler, context);
  }
 
  virtual Model::DeleteSyncConfigurationOutcome DeleteSyncConfiguration(const Model::DeleteSyncConfigurationRequest& request) const;
 
  template <typename DeleteSyncConfigurationRequestT = Model::DeleteSyncConfigurationRequest>
  Model::DeleteSyncConfigurationOutcomeCallable DeleteSyncConfigurationCallable(const DeleteSyncConfigurationRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::DeleteSyncConfiguration, request);
  }
 
  template <typename DeleteSyncConfigurationRequestT = Model::DeleteSyncConfigurationRequest>
  void DeleteSyncConfigurationAsync(const DeleteSyncConfigurationRequestT& request,
                                    const DeleteSyncConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::DeleteSyncConfiguration, request, handler, context);
  }
 
  virtual Model::GetConnectionOutcome GetConnection(const Model::GetConnectionRequest& request) const;
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  Model::GetConnectionOutcomeCallable GetConnectionCallable(const GetConnectionRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::GetConnection, request);
  }
 
  template <typename GetConnectionRequestT = Model::GetConnectionRequest>
  void GetConnectionAsync(const GetConnectionRequestT& request, const GetConnectionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::GetConnection, request, handler, context);
  }
 
  virtual Model::GetHostOutcome GetHost(const Model::GetHostRequest& request) const;
 
  template <typename GetHostRequestT = Model::GetHostRequest>
  Model::GetHostOutcomeCallable GetHostCallable(const GetHostRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::GetHost, request);
  }
 
  template <typename GetHostRequestT = Model::GetHostRequest>
  void GetHostAsync(const GetHostRequestT& request, const GetHostResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::GetHost, request, handler, context);
  }
 
  virtual Model::GetRepositoryLinkOutcome GetRepositoryLink(const Model::GetRepositoryLinkRequest& request) const;
 
  template <typename GetRepositoryLinkRequestT = Model::GetRepositoryLinkRequest>
  Model::GetRepositoryLinkOutcomeCallable GetRepositoryLinkCallable(const GetRepositoryLinkRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::GetRepositoryLink, request);
  }
 
  template <typename GetRepositoryLinkRequestT = Model::GetRepositoryLinkRequest>
  void GetRepositoryLinkAsync(const GetRepositoryLinkRequestT& request, const GetRepositoryLinkResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::GetRepositoryLink, request, handler, context);
  }
 
  virtual Model::GetRepositorySyncStatusOutcome GetRepositorySyncStatus(const Model::GetRepositorySyncStatusRequest& request) const;
 
  template <typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
  Model::GetRepositorySyncStatusOutcomeCallable GetRepositorySyncStatusCallable(const GetRepositorySyncStatusRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::GetRepositorySyncStatus, request);
  }
 
  template <typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
  void GetRepositorySyncStatusAsync(const GetRepositorySyncStatusRequestT& request,
                                    const GetRepositorySyncStatusResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::GetRepositorySyncStatus, request, handler, context);
  }
 
  virtual Model::GetResourceSyncStatusOutcome GetResourceSyncStatus(const Model::GetResourceSyncStatusRequest& request) const;
 
  template <typename GetResourceSyncStatusRequestT = Model::GetResourceSyncStatusRequest>
  Model::GetResourceSyncStatusOutcomeCallable GetResourceSyncStatusCallable(const GetResourceSyncStatusRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::GetResourceSyncStatus, request);
  }
 
  template <typename GetResourceSyncStatusRequestT = Model::GetResourceSyncStatusRequest>
  void GetResourceSyncStatusAsync(const GetResourceSyncStatusRequestT& request, const GetResourceSyncStatusResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::GetResourceSyncStatus, request, handler, context);
  }
 
  virtual Model::GetSyncBlockerSummaryOutcome GetSyncBlockerSummary(const Model::GetSyncBlockerSummaryRequest& request) const;
 
  template <typename GetSyncBlockerSummaryRequestT = Model::GetSyncBlockerSummaryRequest>
  Model::GetSyncBlockerSummaryOutcomeCallable GetSyncBlockerSummaryCallable(const GetSyncBlockerSummaryRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::GetSyncBlockerSummary, request);
  }
 
  template <typename GetSyncBlockerSummaryRequestT = Model::GetSyncBlockerSummaryRequest>
  void GetSyncBlockerSummaryAsync(const GetSyncBlockerSummaryRequestT& request, const GetSyncBlockerSummaryResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::GetSyncBlockerSummary, request, handler, context);
  }
 
  virtual Model::GetSyncConfigurationOutcome GetSyncConfiguration(const Model::GetSyncConfigurationRequest& request) const;
 
  template <typename GetSyncConfigurationRequestT = Model::GetSyncConfigurationRequest>
  Model::GetSyncConfigurationOutcomeCallable GetSyncConfigurationCallable(const GetSyncConfigurationRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::GetSyncConfiguration, request);
  }
 
  template <typename GetSyncConfigurationRequestT = Model::GetSyncConfigurationRequest>
  void GetSyncConfigurationAsync(const GetSyncConfigurationRequestT& request, const GetSyncConfigurationResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::GetSyncConfiguration, request, handler, context);
  }
 
  virtual Model::ListConnectionsOutcome ListConnections(const Model::ListConnectionsRequest& request = {}) const;
 
  template <typename ListConnectionsRequestT = Model::ListConnectionsRequest>
  Model::ListConnectionsOutcomeCallable ListConnectionsCallable(const ListConnectionsRequestT& request = {}) const {
    return SubmitCallable(&CodeConnectionsClient::ListConnections, request);
  }
 
  template <typename ListConnectionsRequestT = Model::ListConnectionsRequest>
  void ListConnectionsAsync(const ListConnectionsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                            const ListConnectionsRequestT& request = {}) const {
    return SubmitAsync(&CodeConnectionsClient::ListConnections, request, handler, context);
  }
 
  virtual Model::ListHostsOutcome ListHosts(const Model::ListHostsRequest& request = {}) const;
 
  template <typename ListHostsRequestT = Model::ListHostsRequest>
  Model::ListHostsOutcomeCallable ListHostsCallable(const ListHostsRequestT& request = {}) const {
    return SubmitCallable(&CodeConnectionsClient::ListHosts, request);
  }
 
  template <typename ListHostsRequestT = Model::ListHostsRequest>
  void ListHostsAsync(const ListHostsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListHostsRequestT& request = {}) const {
    return SubmitAsync(&CodeConnectionsClient::ListHosts, request, handler, context);
  }
 
  virtual Model::ListRepositoryLinksOutcome ListRepositoryLinks(const Model::ListRepositoryLinksRequest& request = {}) const;
 
  template <typename ListRepositoryLinksRequestT = Model::ListRepositoryLinksRequest>
  Model::ListRepositoryLinksOutcomeCallable ListRepositoryLinksCallable(const ListRepositoryLinksRequestT& request = {}) const {
    return SubmitCallable(&CodeConnectionsClient::ListRepositoryLinks, request);
  }
 
  template <typename ListRepositoryLinksRequestT = Model::ListRepositoryLinksRequest>
  void ListRepositoryLinksAsync(const ListRepositoryLinksResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                const ListRepositoryLinksRequestT& request = {}) const {
    return SubmitAsync(&CodeConnectionsClient::ListRepositoryLinks, request, handler, context);
  }
 
  virtual Model::ListRepositorySyncDefinitionsOutcome ListRepositorySyncDefinitions(
      const Model::ListRepositorySyncDefinitionsRequest& request) const;
 
  template <typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
  Model::ListRepositorySyncDefinitionsOutcomeCallable ListRepositorySyncDefinitionsCallable(
      const ListRepositorySyncDefinitionsRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::ListRepositorySyncDefinitions, request);
  }
 
  template <typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
  void ListRepositorySyncDefinitionsAsync(const ListRepositorySyncDefinitionsRequestT& request,
                                          const ListRepositorySyncDefinitionsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::ListRepositorySyncDefinitions, request, handler, context);
  }
 
  virtual Model::ListSyncConfigurationsOutcome ListSyncConfigurations(const Model::ListSyncConfigurationsRequest& request) const;
 
  template <typename ListSyncConfigurationsRequestT = Model::ListSyncConfigurationsRequest>
  Model::ListSyncConfigurationsOutcomeCallable ListSyncConfigurationsCallable(const ListSyncConfigurationsRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::ListSyncConfigurations, request);
  }
 
  template <typename ListSyncConfigurationsRequestT = Model::ListSyncConfigurationsRequest>
  void ListSyncConfigurationsAsync(const ListSyncConfigurationsRequestT& request,
                                   const ListSyncConfigurationsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::ListSyncConfigurations, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateHostOutcome UpdateHost(const Model::UpdateHostRequest& request) const;
 
  template <typename UpdateHostRequestT = Model::UpdateHostRequest>
  Model::UpdateHostOutcomeCallable UpdateHostCallable(const UpdateHostRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::UpdateHost, request);
  }
 
  template <typename UpdateHostRequestT = Model::UpdateHostRequest>
  void UpdateHostAsync(const UpdateHostRequestT& request, const UpdateHostResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::UpdateHost, request, handler, context);
  }
 
  virtual Model::UpdateRepositoryLinkOutcome UpdateRepositoryLink(const Model::UpdateRepositoryLinkRequest& request) const;
 
  template <typename UpdateRepositoryLinkRequestT = Model::UpdateRepositoryLinkRequest>
  Model::UpdateRepositoryLinkOutcomeCallable UpdateRepositoryLinkCallable(const UpdateRepositoryLinkRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::UpdateRepositoryLink, request);
  }
 
  template <typename UpdateRepositoryLinkRequestT = Model::UpdateRepositoryLinkRequest>
  void UpdateRepositoryLinkAsync(const UpdateRepositoryLinkRequestT& request, const UpdateRepositoryLinkResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::UpdateRepositoryLink, request, handler, context);
  }
 
  virtual Model::UpdateSyncBlockerOutcome UpdateSyncBlocker(const Model::UpdateSyncBlockerRequest& request) const;
 
  template <typename UpdateSyncBlockerRequestT = Model::UpdateSyncBlockerRequest>
  Model::UpdateSyncBlockerOutcomeCallable UpdateSyncBlockerCallable(const UpdateSyncBlockerRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::UpdateSyncBlocker, request);
  }
 
  template <typename UpdateSyncBlockerRequestT = Model::UpdateSyncBlockerRequest>
  void UpdateSyncBlockerAsync(const UpdateSyncBlockerRequestT& request, const UpdateSyncBlockerResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::UpdateSyncBlocker, request, handler, context);
  }
 
  virtual Model::UpdateSyncConfigurationOutcome UpdateSyncConfiguration(const Model::UpdateSyncConfigurationRequest& request) const;
 
  template <typename UpdateSyncConfigurationRequestT = Model::UpdateSyncConfigurationRequest>
  Model::UpdateSyncConfigurationOutcomeCallable UpdateSyncConfigurationCallable(const UpdateSyncConfigurationRequestT& request) const {
    return SubmitCallable(&CodeConnectionsClient::UpdateSyncConfiguration, request);
  }
 
  template <typename UpdateSyncConfigurationRequestT = Model::UpdateSyncConfigurationRequest>
  void UpdateSyncConfigurationAsync(const UpdateSyncConfigurationRequestT& request,
                                    const UpdateSyncConfigurationResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CodeConnectionsClient::UpdateSyncConfiguration, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<CodeConnectionsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeConnectionsClient>;
  void init(const CodeConnectionsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, CodeConnectionsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  CodeConnectionsClientConfiguration m_clientConfiguration;
  std::shared_ptr<CodeConnectionsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CodeConnections
}  // namespace Aws