CodeConnectionsClient.h

 
#pragma once
#include <aws/codeconnections/CodeConnections_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/codeconnections/CodeConnectionsServiceClientModel.h>
 
namespace Aws
{
namespace CodeConnections
{
  class AWS_CODECONNECTIONS_API CodeConnectionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<CodeConnectionsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<CodeConnectionsClient>;
      void init(const CodeConnectionsClientConfiguration& clientConfiguration);
 
      CodeConnectionsClientConfiguration m_clientConfiguration;
      std::shared_ptr<CodeConnectionsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace CodeConnections
} // namespace Aws