CodeStarconnectionsClient.h

 
#pragma once
#include <aws/codestar-connections/CodeStarconnections_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/codestar-connections/CodeStarconnectionsServiceClientModel.h>
 
namespace Aws
{
namespace CodeStarconnections
{
  class AWS_CODESTARCONNECTIONS_API CodeStarconnectionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<CodeStarconnectionsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef CodeStarconnectionsClientConfiguration ClientConfigurationType;
      typedef CodeStarconnectionsEndpointProvider EndpointProviderType;
 
        CodeStarconnectionsClient(const Aws::CodeStarconnections::CodeStarconnectionsClientConfiguration& clientConfiguration = Aws::CodeStarconnections::CodeStarconnectionsClientConfiguration(),
                                  std::shared_ptr<CodeStarconnectionsEndpointProviderBase> endpointProvider = nullptr);
 
        CodeStarconnectionsClient(const Aws::Auth::AWSCredentials& credentials,
                                  std::shared_ptr<CodeStarconnectionsEndpointProviderBase> endpointProvider = nullptr,
                                  const Aws::CodeStarconnections::CodeStarconnectionsClientConfiguration& clientConfiguration = Aws::CodeStarconnections::CodeStarconnectionsClientConfiguration());
 
        CodeStarconnectionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                  std::shared_ptr<CodeStarconnectionsEndpointProviderBase> endpointProvider = nullptr,
                                  const Aws::CodeStarconnections::CodeStarconnectionsClientConfiguration& clientConfiguration = Aws::CodeStarconnections::CodeStarconnectionsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        CodeStarconnectionsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodeStarconnectionsClient(const Aws::Auth::AWSCredentials& credentials,
                                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        CodeStarconnectionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~CodeStarconnectionsClient();
 
        virtual Model::CreateConnectionOutcome CreateConnection(const Model::CreateConnectionRequest& request) const;
 
        template<typename CreateConnectionRequestT = Model::CreateConnectionRequest>
        Model::CreateConnectionOutcomeCallable CreateConnectionCallable(const CreateConnectionRequestT& request) const
        {
            return SubmitCallable(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::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(&CodeStarconnectionsClient::UpdateSyncConfiguration, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodeStarconnectionsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeStarconnectionsClient>;
      void init(const CodeStarconnectionsClientConfiguration& clientConfiguration);
 
      CodeStarconnectionsClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodeStarconnectionsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodeStarconnections
} // namespace Aws