ApplicationDiscoveryServiceClient.h

 
#pragma once
#include <aws/discovery/ApplicationDiscoveryService_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/discovery/ApplicationDiscoveryServiceServiceClientModel.h>
 
namespace Aws
{
namespace ApplicationDiscoveryService
{
  class AWS_APPLICATIONDISCOVERYSERVICE_API ApplicationDiscoveryServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationDiscoveryServiceClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ApplicationDiscoveryServiceClientConfiguration ClientConfigurationType;
      typedef ApplicationDiscoveryServiceEndpointProvider EndpointProviderType;
 
        ApplicationDiscoveryServiceClient(const Aws::ApplicationDiscoveryService::ApplicationDiscoveryServiceClientConfiguration& clientConfiguration = Aws::ApplicationDiscoveryService::ApplicationDiscoveryServiceClientConfiguration(),
                                          std::shared_ptr<ApplicationDiscoveryServiceEndpointProviderBase> endpointProvider = nullptr);
 
        ApplicationDiscoveryServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                          std::shared_ptr<ApplicationDiscoveryServiceEndpointProviderBase> endpointProvider = nullptr,
                                          const Aws::ApplicationDiscoveryService::ApplicationDiscoveryServiceClientConfiguration& clientConfiguration = Aws::ApplicationDiscoveryService::ApplicationDiscoveryServiceClientConfiguration());
 
        ApplicationDiscoveryServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                          std::shared_ptr<ApplicationDiscoveryServiceEndpointProviderBase> endpointProvider = nullptr,
                                          const Aws::ApplicationDiscoveryService::ApplicationDiscoveryServiceClientConfiguration& clientConfiguration = Aws::ApplicationDiscoveryService::ApplicationDiscoveryServiceClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ApplicationDiscoveryServiceClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationDiscoveryServiceClient(const Aws::Auth::AWSCredentials& credentials,
                                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ApplicationDiscoveryServiceClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ApplicationDiscoveryServiceClient();
 
        virtual Model::AssociateConfigurationItemsToApplicationOutcome AssociateConfigurationItemsToApplication(const Model::AssociateConfigurationItemsToApplicationRequest& request) const;
 
        template<typename AssociateConfigurationItemsToApplicationRequestT = Model::AssociateConfigurationItemsToApplicationRequest>
        Model::AssociateConfigurationItemsToApplicationOutcomeCallable AssociateConfigurationItemsToApplicationCallable(const AssociateConfigurationItemsToApplicationRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::AssociateConfigurationItemsToApplication, request);
        }
 
        template<typename AssociateConfigurationItemsToApplicationRequestT = Model::AssociateConfigurationItemsToApplicationRequest>
        void AssociateConfigurationItemsToApplicationAsync(const AssociateConfigurationItemsToApplicationRequestT& request, const AssociateConfigurationItemsToApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::AssociateConfigurationItemsToApplication, request, handler, context);
        }
 
        virtual Model::BatchDeleteAgentsOutcome BatchDeleteAgents(const Model::BatchDeleteAgentsRequest& request) const;
 
        template<typename BatchDeleteAgentsRequestT = Model::BatchDeleteAgentsRequest>
        Model::BatchDeleteAgentsOutcomeCallable BatchDeleteAgentsCallable(const BatchDeleteAgentsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::BatchDeleteAgents, request);
        }
 
        template<typename BatchDeleteAgentsRequestT = Model::BatchDeleteAgentsRequest>
        void BatchDeleteAgentsAsync(const BatchDeleteAgentsRequestT& request, const BatchDeleteAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::BatchDeleteAgents, request, handler, context);
        }
 
        virtual Model::BatchDeleteImportDataOutcome BatchDeleteImportData(const Model::BatchDeleteImportDataRequest& request) const;
 
        template<typename BatchDeleteImportDataRequestT = Model::BatchDeleteImportDataRequest>
        Model::BatchDeleteImportDataOutcomeCallable BatchDeleteImportDataCallable(const BatchDeleteImportDataRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::BatchDeleteImportData, request);
        }
 
        template<typename BatchDeleteImportDataRequestT = Model::BatchDeleteImportDataRequest>
        void BatchDeleteImportDataAsync(const BatchDeleteImportDataRequestT& request, const BatchDeleteImportDataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::BatchDeleteImportData, request, handler, context);
        }
 
        virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::CreateApplication, request);
        }
 
        template<typename CreateApplicationRequestT = Model::CreateApplicationRequest>
        void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::CreateApplication, request, handler, context);
        }
 
        virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const;
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::CreateTags, request);
        }
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::CreateTags, request, handler, context);
        }
 
        virtual Model::DeleteApplicationsOutcome DeleteApplications(const Model::DeleteApplicationsRequest& request) const;
 
        template<typename DeleteApplicationsRequestT = Model::DeleteApplicationsRequest>
        Model::DeleteApplicationsOutcomeCallable DeleteApplicationsCallable(const DeleteApplicationsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DeleteApplications, request);
        }
 
        template<typename DeleteApplicationsRequestT = Model::DeleteApplicationsRequest>
        void DeleteApplicationsAsync(const DeleteApplicationsRequestT& request, const DeleteApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DeleteApplications, request, handler, context);
        }
 
        virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DeleteTags, request);
        }
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DeleteTags, request, handler, context);
        }
 
        virtual Model::DescribeAgentsOutcome DescribeAgents(const Model::DescribeAgentsRequest& request = {}) const;
 
        template<typename DescribeAgentsRequestT = Model::DescribeAgentsRequest>
        Model::DescribeAgentsOutcomeCallable DescribeAgentsCallable(const DescribeAgentsRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DescribeAgents, request);
        }
 
        template<typename DescribeAgentsRequestT = Model::DescribeAgentsRequest>
        void DescribeAgentsAsync(const DescribeAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAgentsRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DescribeAgents, request, handler, context);
        }
 
        virtual Model::DescribeBatchDeleteConfigurationTaskOutcome DescribeBatchDeleteConfigurationTask(const Model::DescribeBatchDeleteConfigurationTaskRequest& request) const;
 
        template<typename DescribeBatchDeleteConfigurationTaskRequestT = Model::DescribeBatchDeleteConfigurationTaskRequest>
        Model::DescribeBatchDeleteConfigurationTaskOutcomeCallable DescribeBatchDeleteConfigurationTaskCallable(const DescribeBatchDeleteConfigurationTaskRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DescribeBatchDeleteConfigurationTask, request);
        }
 
        template<typename DescribeBatchDeleteConfigurationTaskRequestT = Model::DescribeBatchDeleteConfigurationTaskRequest>
        void DescribeBatchDeleteConfigurationTaskAsync(const DescribeBatchDeleteConfigurationTaskRequestT& request, const DescribeBatchDeleteConfigurationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DescribeBatchDeleteConfigurationTask, request, handler, context);
        }
 
        virtual Model::DescribeConfigurationsOutcome DescribeConfigurations(const Model::DescribeConfigurationsRequest& request) const;
 
        template<typename DescribeConfigurationsRequestT = Model::DescribeConfigurationsRequest>
        Model::DescribeConfigurationsOutcomeCallable DescribeConfigurationsCallable(const DescribeConfigurationsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DescribeConfigurations, request);
        }
 
        template<typename DescribeConfigurationsRequestT = Model::DescribeConfigurationsRequest>
        void DescribeConfigurationsAsync(const DescribeConfigurationsRequestT& request, const DescribeConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DescribeConfigurations, request, handler, context);
        }
 
        virtual Model::DescribeContinuousExportsOutcome DescribeContinuousExports(const Model::DescribeContinuousExportsRequest& request = {}) const;
 
        template<typename DescribeContinuousExportsRequestT = Model::DescribeContinuousExportsRequest>
        Model::DescribeContinuousExportsOutcomeCallable DescribeContinuousExportsCallable(const DescribeContinuousExportsRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DescribeContinuousExports, request);
        }
 
        template<typename DescribeContinuousExportsRequestT = Model::DescribeContinuousExportsRequest>
        void DescribeContinuousExportsAsync(const DescribeContinuousExportsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeContinuousExportsRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DescribeContinuousExports, request, handler, context);
        }
 
        virtual Model::DescribeExportTasksOutcome DescribeExportTasks(const Model::DescribeExportTasksRequest& request = {}) const;
 
        template<typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
        Model::DescribeExportTasksOutcomeCallable DescribeExportTasksCallable(const DescribeExportTasksRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DescribeExportTasks, request);
        }
 
        template<typename DescribeExportTasksRequestT = Model::DescribeExportTasksRequest>
        void DescribeExportTasksAsync(const DescribeExportTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeExportTasksRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DescribeExportTasks, request, handler, context);
        }
 
        virtual Model::DescribeImportTasksOutcome DescribeImportTasks(const Model::DescribeImportTasksRequest& request = {}) const;
 
        template<typename DescribeImportTasksRequestT = Model::DescribeImportTasksRequest>
        Model::DescribeImportTasksOutcomeCallable DescribeImportTasksCallable(const DescribeImportTasksRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DescribeImportTasks, request);
        }
 
        template<typename DescribeImportTasksRequestT = Model::DescribeImportTasksRequest>
        void DescribeImportTasksAsync(const DescribeImportTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeImportTasksRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DescribeImportTasks, request, handler, context);
        }
 
        virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request = {}) const;
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DescribeTags, request);
        }
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        void DescribeTagsAsync(const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeTagsRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DescribeTags, request, handler, context);
        }
 
        virtual Model::DisassociateConfigurationItemsFromApplicationOutcome DisassociateConfigurationItemsFromApplication(const Model::DisassociateConfigurationItemsFromApplicationRequest& request) const;
 
        template<typename DisassociateConfigurationItemsFromApplicationRequestT = Model::DisassociateConfigurationItemsFromApplicationRequest>
        Model::DisassociateConfigurationItemsFromApplicationOutcomeCallable DisassociateConfigurationItemsFromApplicationCallable(const DisassociateConfigurationItemsFromApplicationRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::DisassociateConfigurationItemsFromApplication, request);
        }
 
        template<typename DisassociateConfigurationItemsFromApplicationRequestT = Model::DisassociateConfigurationItemsFromApplicationRequest>
        void DisassociateConfigurationItemsFromApplicationAsync(const DisassociateConfigurationItemsFromApplicationRequestT& request, const DisassociateConfigurationItemsFromApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::DisassociateConfigurationItemsFromApplication, request, handler, context);
        }
 
        virtual Model::GetDiscoverySummaryOutcome GetDiscoverySummary(const Model::GetDiscoverySummaryRequest& request = {}) const;
 
        template<typename GetDiscoverySummaryRequestT = Model::GetDiscoverySummaryRequest>
        Model::GetDiscoverySummaryOutcomeCallable GetDiscoverySummaryCallable(const GetDiscoverySummaryRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::GetDiscoverySummary, request);
        }
 
        template<typename GetDiscoverySummaryRequestT = Model::GetDiscoverySummaryRequest>
        void GetDiscoverySummaryAsync(const GetDiscoverySummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetDiscoverySummaryRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::GetDiscoverySummary, request, handler, context);
        }
 
        virtual Model::ListConfigurationsOutcome ListConfigurations(const Model::ListConfigurationsRequest& request) const;
 
        template<typename ListConfigurationsRequestT = Model::ListConfigurationsRequest>
        Model::ListConfigurationsOutcomeCallable ListConfigurationsCallable(const ListConfigurationsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::ListConfigurations, request);
        }
 
        template<typename ListConfigurationsRequestT = Model::ListConfigurationsRequest>
        void ListConfigurationsAsync(const ListConfigurationsRequestT& request, const ListConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::ListConfigurations, request, handler, context);
        }
 
        virtual Model::ListServerNeighborsOutcome ListServerNeighbors(const Model::ListServerNeighborsRequest& request) const;
 
        template<typename ListServerNeighborsRequestT = Model::ListServerNeighborsRequest>
        Model::ListServerNeighborsOutcomeCallable ListServerNeighborsCallable(const ListServerNeighborsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::ListServerNeighbors, request);
        }
 
        template<typename ListServerNeighborsRequestT = Model::ListServerNeighborsRequest>
        void ListServerNeighborsAsync(const ListServerNeighborsRequestT& request, const ListServerNeighborsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::ListServerNeighbors, request, handler, context);
        }
 
        virtual Model::StartBatchDeleteConfigurationTaskOutcome StartBatchDeleteConfigurationTask(const Model::StartBatchDeleteConfigurationTaskRequest& request) const;
 
        template<typename StartBatchDeleteConfigurationTaskRequestT = Model::StartBatchDeleteConfigurationTaskRequest>
        Model::StartBatchDeleteConfigurationTaskOutcomeCallable StartBatchDeleteConfigurationTaskCallable(const StartBatchDeleteConfigurationTaskRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::StartBatchDeleteConfigurationTask, request);
        }
 
        template<typename StartBatchDeleteConfigurationTaskRequestT = Model::StartBatchDeleteConfigurationTaskRequest>
        void StartBatchDeleteConfigurationTaskAsync(const StartBatchDeleteConfigurationTaskRequestT& request, const StartBatchDeleteConfigurationTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::StartBatchDeleteConfigurationTask, request, handler, context);
        }
 
        virtual Model::StartContinuousExportOutcome StartContinuousExport(const Model::StartContinuousExportRequest& request = {}) const;
 
        template<typename StartContinuousExportRequestT = Model::StartContinuousExportRequest>
        Model::StartContinuousExportOutcomeCallable StartContinuousExportCallable(const StartContinuousExportRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::StartContinuousExport, request);
        }
 
        template<typename StartContinuousExportRequestT = Model::StartContinuousExportRequest>
        void StartContinuousExportAsync(const StartContinuousExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StartContinuousExportRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::StartContinuousExport, request, handler, context);
        }
 
        virtual Model::StartDataCollectionByAgentIdsOutcome StartDataCollectionByAgentIds(const Model::StartDataCollectionByAgentIdsRequest& request) const;
 
        template<typename StartDataCollectionByAgentIdsRequestT = Model::StartDataCollectionByAgentIdsRequest>
        Model::StartDataCollectionByAgentIdsOutcomeCallable StartDataCollectionByAgentIdsCallable(const StartDataCollectionByAgentIdsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::StartDataCollectionByAgentIds, request);
        }
 
        template<typename StartDataCollectionByAgentIdsRequestT = Model::StartDataCollectionByAgentIdsRequest>
        void StartDataCollectionByAgentIdsAsync(const StartDataCollectionByAgentIdsRequestT& request, const StartDataCollectionByAgentIdsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::StartDataCollectionByAgentIds, request, handler, context);
        }
 
        virtual Model::StartExportTaskOutcome StartExportTask(const Model::StartExportTaskRequest& request = {}) const;
 
        template<typename StartExportTaskRequestT = Model::StartExportTaskRequest>
        Model::StartExportTaskOutcomeCallable StartExportTaskCallable(const StartExportTaskRequestT& request = {}) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::StartExportTask, request);
        }
 
        template<typename StartExportTaskRequestT = Model::StartExportTaskRequest>
        void StartExportTaskAsync(const StartExportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StartExportTaskRequestT& request = {}) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::StartExportTask, request, handler, context);
        }
 
        virtual Model::StartImportTaskOutcome StartImportTask(const Model::StartImportTaskRequest& request) const;
 
        template<typename StartImportTaskRequestT = Model::StartImportTaskRequest>
        Model::StartImportTaskOutcomeCallable StartImportTaskCallable(const StartImportTaskRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::StartImportTask, request);
        }
 
        template<typename StartImportTaskRequestT = Model::StartImportTaskRequest>
        void StartImportTaskAsync(const StartImportTaskRequestT& request, const StartImportTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::StartImportTask, request, handler, context);
        }
 
        virtual Model::StopContinuousExportOutcome StopContinuousExport(const Model::StopContinuousExportRequest& request) const;
 
        template<typename StopContinuousExportRequestT = Model::StopContinuousExportRequest>
        Model::StopContinuousExportOutcomeCallable StopContinuousExportCallable(const StopContinuousExportRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::StopContinuousExport, request);
        }
 
        template<typename StopContinuousExportRequestT = Model::StopContinuousExportRequest>
        void StopContinuousExportAsync(const StopContinuousExportRequestT& request, const StopContinuousExportResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::StopContinuousExport, request, handler, context);
        }
 
        virtual Model::StopDataCollectionByAgentIdsOutcome StopDataCollectionByAgentIds(const Model::StopDataCollectionByAgentIdsRequest& request) const;
 
        template<typename StopDataCollectionByAgentIdsRequestT = Model::StopDataCollectionByAgentIdsRequest>
        Model::StopDataCollectionByAgentIdsOutcomeCallable StopDataCollectionByAgentIdsCallable(const StopDataCollectionByAgentIdsRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::StopDataCollectionByAgentIds, request);
        }
 
        template<typename StopDataCollectionByAgentIdsRequestT = Model::StopDataCollectionByAgentIdsRequest>
        void StopDataCollectionByAgentIdsAsync(const StopDataCollectionByAgentIdsRequestT& request, const StopDataCollectionByAgentIdsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::StopDataCollectionByAgentIds, request, handler, context);
        }
 
        virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const
        {
            return SubmitCallable(&ApplicationDiscoveryServiceClient::UpdateApplication, request);
        }
 
        template<typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
        void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ApplicationDiscoveryServiceClient::UpdateApplication, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ApplicationDiscoveryServiceEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ApplicationDiscoveryServiceClient>;
      void init(const ApplicationDiscoveryServiceClientConfiguration& clientConfiguration);
 
      ApplicationDiscoveryServiceClientConfiguration m_clientConfiguration;
      std::shared_ptr<ApplicationDiscoveryServiceEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ApplicationDiscoveryService
} // namespace Aws