ApplicationDiscoveryServiceClient.h

 
#pragma once
#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>
#include <aws/discovery/ApplicationDiscoveryServicePaginationBase.h>
#include <aws/discovery/ApplicationDiscoveryServiceServiceClientModel.h>
#include <aws/discovery/ApplicationDiscoveryService_EXPORTS.h>
 
namespace Aws {
namespace ApplicationDiscoveryService {
class AWS_APPLICATIONDISCOVERYSERVICE_API ApplicationDiscoveryServiceClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<ApplicationDiscoveryServiceClient>,
      public ApplicationDiscoveryServicePaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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