MigrationHubClient.h

 
#pragma once
#include <aws/AWSMigrationHub/MigrationHubServiceClientModel.h>
#include <aws/AWSMigrationHub/MigrationHub_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace MigrationHub {
class AWS_MIGRATIONHUB_API MigrationHubClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<MigrationHubClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MigrationHubClientConfiguration ClientConfigurationType;
  typedef MigrationHubEndpointProvider EndpointProviderType;
 
  MigrationHubClient(
      const Aws::MigrationHub::MigrationHubClientConfiguration& clientConfiguration = Aws::MigrationHub::MigrationHubClientConfiguration(),
      std::shared_ptr<MigrationHubEndpointProviderBase> endpointProvider = nullptr);
 
  MigrationHubClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<MigrationHubEndpointProviderBase> endpointProvider = nullptr,
      const Aws::MigrationHub::MigrationHubClientConfiguration& clientConfiguration = Aws::MigrationHub::MigrationHubClientConfiguration());
 
  MigrationHubClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<MigrationHubEndpointProviderBase> endpointProvider = nullptr,
      const Aws::MigrationHub::MigrationHubClientConfiguration& clientConfiguration = Aws::MigrationHub::MigrationHubClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MigrationHubClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MigrationHubClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MigrationHubClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MigrationHubClient();
 
  virtual Model::AssociateCreatedArtifactOutcome AssociateCreatedArtifact(const Model::AssociateCreatedArtifactRequest& request) const;
 
  template <typename AssociateCreatedArtifactRequestT = Model::AssociateCreatedArtifactRequest>
  Model::AssociateCreatedArtifactOutcomeCallable AssociateCreatedArtifactCallable(const AssociateCreatedArtifactRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::AssociateCreatedArtifact, request);
  }
 
  template <typename AssociateCreatedArtifactRequestT = Model::AssociateCreatedArtifactRequest>
  void AssociateCreatedArtifactAsync(const AssociateCreatedArtifactRequestT& request,
                                     const AssociateCreatedArtifactResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::AssociateCreatedArtifact, request, handler, context);
  }
 
  virtual Model::AssociateDiscoveredResourceOutcome AssociateDiscoveredResource(
      const Model::AssociateDiscoveredResourceRequest& request) const;
 
  template <typename AssociateDiscoveredResourceRequestT = Model::AssociateDiscoveredResourceRequest>
  Model::AssociateDiscoveredResourceOutcomeCallable AssociateDiscoveredResourceCallable(
      const AssociateDiscoveredResourceRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::AssociateDiscoveredResource, request);
  }
 
  template <typename AssociateDiscoveredResourceRequestT = Model::AssociateDiscoveredResourceRequest>
  void AssociateDiscoveredResourceAsync(const AssociateDiscoveredResourceRequestT& request,
                                        const AssociateDiscoveredResourceResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::AssociateDiscoveredResource, request, handler, context);
  }
 
  virtual Model::AssociateSourceResourceOutcome AssociateSourceResource(const Model::AssociateSourceResourceRequest& request) const;
 
  template <typename AssociateSourceResourceRequestT = Model::AssociateSourceResourceRequest>
  Model::AssociateSourceResourceOutcomeCallable AssociateSourceResourceCallable(const AssociateSourceResourceRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::AssociateSourceResource, request);
  }
 
  template <typename AssociateSourceResourceRequestT = Model::AssociateSourceResourceRequest>
  void AssociateSourceResourceAsync(const AssociateSourceResourceRequestT& request,
                                    const AssociateSourceResourceResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::AssociateSourceResource, request, handler, context);
  }
 
  virtual Model::CreateProgressUpdateStreamOutcome CreateProgressUpdateStream(
      const Model::CreateProgressUpdateStreamRequest& request) const;
 
  template <typename CreateProgressUpdateStreamRequestT = Model::CreateProgressUpdateStreamRequest>
  Model::CreateProgressUpdateStreamOutcomeCallable CreateProgressUpdateStreamCallable(
      const CreateProgressUpdateStreamRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::CreateProgressUpdateStream, request);
  }
 
  template <typename CreateProgressUpdateStreamRequestT = Model::CreateProgressUpdateStreamRequest>
  void CreateProgressUpdateStreamAsync(const CreateProgressUpdateStreamRequestT& request,
                                       const CreateProgressUpdateStreamResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::CreateProgressUpdateStream, request, handler, context);
  }
 
  virtual Model::DeleteProgressUpdateStreamOutcome DeleteProgressUpdateStream(
      const Model::DeleteProgressUpdateStreamRequest& request) const;
 
  template <typename DeleteProgressUpdateStreamRequestT = Model::DeleteProgressUpdateStreamRequest>
  Model::DeleteProgressUpdateStreamOutcomeCallable DeleteProgressUpdateStreamCallable(
      const DeleteProgressUpdateStreamRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::DeleteProgressUpdateStream, request);
  }
 
  template <typename DeleteProgressUpdateStreamRequestT = Model::DeleteProgressUpdateStreamRequest>
  void DeleteProgressUpdateStreamAsync(const DeleteProgressUpdateStreamRequestT& request,
                                       const DeleteProgressUpdateStreamResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::DeleteProgressUpdateStream, request, handler, context);
  }
 
  virtual Model::DescribeApplicationStateOutcome DescribeApplicationState(const Model::DescribeApplicationStateRequest& request) const;
 
  template <typename DescribeApplicationStateRequestT = Model::DescribeApplicationStateRequest>
  Model::DescribeApplicationStateOutcomeCallable DescribeApplicationStateCallable(const DescribeApplicationStateRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::DescribeApplicationState, request);
  }
 
  template <typename DescribeApplicationStateRequestT = Model::DescribeApplicationStateRequest>
  void DescribeApplicationStateAsync(const DescribeApplicationStateRequestT& request,
                                     const DescribeApplicationStateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::DescribeApplicationState, request, handler, context);
  }
 
  virtual Model::DescribeMigrationTaskOutcome DescribeMigrationTask(const Model::DescribeMigrationTaskRequest& request) const;
 
  template <typename DescribeMigrationTaskRequestT = Model::DescribeMigrationTaskRequest>
  Model::DescribeMigrationTaskOutcomeCallable DescribeMigrationTaskCallable(const DescribeMigrationTaskRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::DescribeMigrationTask, request);
  }
 
  template <typename DescribeMigrationTaskRequestT = Model::DescribeMigrationTaskRequest>
  void DescribeMigrationTaskAsync(const DescribeMigrationTaskRequestT& request, const DescribeMigrationTaskResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::DescribeMigrationTask, request, handler, context);
  }
 
  virtual Model::DisassociateCreatedArtifactOutcome DisassociateCreatedArtifact(
      const Model::DisassociateCreatedArtifactRequest& request) const;
 
  template <typename DisassociateCreatedArtifactRequestT = Model::DisassociateCreatedArtifactRequest>
  Model::DisassociateCreatedArtifactOutcomeCallable DisassociateCreatedArtifactCallable(
      const DisassociateCreatedArtifactRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::DisassociateCreatedArtifact, request);
  }
 
  template <typename DisassociateCreatedArtifactRequestT = Model::DisassociateCreatedArtifactRequest>
  void DisassociateCreatedArtifactAsync(const DisassociateCreatedArtifactRequestT& request,
                                        const DisassociateCreatedArtifactResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::DisassociateCreatedArtifact, request, handler, context);
  }
 
  virtual Model::DisassociateDiscoveredResourceOutcome DisassociateDiscoveredResource(
      const Model::DisassociateDiscoveredResourceRequest& request) const;
 
  template <typename DisassociateDiscoveredResourceRequestT = Model::DisassociateDiscoveredResourceRequest>
  Model::DisassociateDiscoveredResourceOutcomeCallable DisassociateDiscoveredResourceCallable(
      const DisassociateDiscoveredResourceRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::DisassociateDiscoveredResource, request);
  }
 
  template <typename DisassociateDiscoveredResourceRequestT = Model::DisassociateDiscoveredResourceRequest>
  void DisassociateDiscoveredResourceAsync(const DisassociateDiscoveredResourceRequestT& request,
                                           const DisassociateDiscoveredResourceResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::DisassociateDiscoveredResource, request, handler, context);
  }
 
  virtual Model::DisassociateSourceResourceOutcome DisassociateSourceResource(
      const Model::DisassociateSourceResourceRequest& request) const;
 
  template <typename DisassociateSourceResourceRequestT = Model::DisassociateSourceResourceRequest>
  Model::DisassociateSourceResourceOutcomeCallable DisassociateSourceResourceCallable(
      const DisassociateSourceResourceRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::DisassociateSourceResource, request);
  }
 
  template <typename DisassociateSourceResourceRequestT = Model::DisassociateSourceResourceRequest>
  void DisassociateSourceResourceAsync(const DisassociateSourceResourceRequestT& request,
                                       const DisassociateSourceResourceResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::DisassociateSourceResource, request, handler, context);
  }
 
  virtual Model::ImportMigrationTaskOutcome ImportMigrationTask(const Model::ImportMigrationTaskRequest& request) const;
 
  template <typename ImportMigrationTaskRequestT = Model::ImportMigrationTaskRequest>
  Model::ImportMigrationTaskOutcomeCallable ImportMigrationTaskCallable(const ImportMigrationTaskRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::ImportMigrationTask, request);
  }
 
  template <typename ImportMigrationTaskRequestT = Model::ImportMigrationTaskRequest>
  void ImportMigrationTaskAsync(const ImportMigrationTaskRequestT& request, const ImportMigrationTaskResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::ImportMigrationTask, request, handler, context);
  }
 
  virtual Model::ListApplicationStatesOutcome ListApplicationStates(const Model::ListApplicationStatesRequest& request = {}) const;
 
  template <typename ListApplicationStatesRequestT = Model::ListApplicationStatesRequest>
  Model::ListApplicationStatesOutcomeCallable ListApplicationStatesCallable(const ListApplicationStatesRequestT& request = {}) const {
    return SubmitCallable(&MigrationHubClient::ListApplicationStates, request);
  }
 
  template <typename ListApplicationStatesRequestT = Model::ListApplicationStatesRequest>
  void ListApplicationStatesAsync(const ListApplicationStatesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const ListApplicationStatesRequestT& request = {}) const {
    return SubmitAsync(&MigrationHubClient::ListApplicationStates, request, handler, context);
  }
 
  virtual Model::ListCreatedArtifactsOutcome ListCreatedArtifacts(const Model::ListCreatedArtifactsRequest& request) const;
 
  template <typename ListCreatedArtifactsRequestT = Model::ListCreatedArtifactsRequest>
  Model::ListCreatedArtifactsOutcomeCallable ListCreatedArtifactsCallable(const ListCreatedArtifactsRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::ListCreatedArtifacts, request);
  }
 
  template <typename ListCreatedArtifactsRequestT = Model::ListCreatedArtifactsRequest>
  void ListCreatedArtifactsAsync(const ListCreatedArtifactsRequestT& request, const ListCreatedArtifactsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::ListCreatedArtifacts, request, handler, context);
  }
 
  virtual Model::ListDiscoveredResourcesOutcome ListDiscoveredResources(const Model::ListDiscoveredResourcesRequest& request) const;
 
  template <typename ListDiscoveredResourcesRequestT = Model::ListDiscoveredResourcesRequest>
  Model::ListDiscoveredResourcesOutcomeCallable ListDiscoveredResourcesCallable(const ListDiscoveredResourcesRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::ListDiscoveredResources, request);
  }
 
  template <typename ListDiscoveredResourcesRequestT = Model::ListDiscoveredResourcesRequest>
  void ListDiscoveredResourcesAsync(const ListDiscoveredResourcesRequestT& request,
                                    const ListDiscoveredResourcesResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::ListDiscoveredResources, request, handler, context);
  }
 
  virtual Model::ListMigrationTaskUpdatesOutcome ListMigrationTaskUpdates(const Model::ListMigrationTaskUpdatesRequest& request) const;
 
  template <typename ListMigrationTaskUpdatesRequestT = Model::ListMigrationTaskUpdatesRequest>
  Model::ListMigrationTaskUpdatesOutcomeCallable ListMigrationTaskUpdatesCallable(const ListMigrationTaskUpdatesRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::ListMigrationTaskUpdates, request);
  }
 
  template <typename ListMigrationTaskUpdatesRequestT = Model::ListMigrationTaskUpdatesRequest>
  void ListMigrationTaskUpdatesAsync(const ListMigrationTaskUpdatesRequestT& request,
                                     const ListMigrationTaskUpdatesResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::ListMigrationTaskUpdates, request, handler, context);
  }
 
  virtual Model::ListMigrationTasksOutcome ListMigrationTasks(const Model::ListMigrationTasksRequest& request = {}) const;
 
  template <typename ListMigrationTasksRequestT = Model::ListMigrationTasksRequest>
  Model::ListMigrationTasksOutcomeCallable ListMigrationTasksCallable(const ListMigrationTasksRequestT& request = {}) const {
    return SubmitCallable(&MigrationHubClient::ListMigrationTasks, request);
  }
 
  template <typename ListMigrationTasksRequestT = Model::ListMigrationTasksRequest>
  void ListMigrationTasksAsync(const ListMigrationTasksResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListMigrationTasksRequestT& request = {}) const {
    return SubmitAsync(&MigrationHubClient::ListMigrationTasks, request, handler, context);
  }
 
  virtual Model::ListProgressUpdateStreamsOutcome ListProgressUpdateStreams(
      const Model::ListProgressUpdateStreamsRequest& request = {}) const;
 
  template <typename ListProgressUpdateStreamsRequestT = Model::ListProgressUpdateStreamsRequest>
  Model::ListProgressUpdateStreamsOutcomeCallable ListProgressUpdateStreamsCallable(
      const ListProgressUpdateStreamsRequestT& request = {}) const {
    return SubmitCallable(&MigrationHubClient::ListProgressUpdateStreams, request);
  }
 
  template <typename ListProgressUpdateStreamsRequestT = Model::ListProgressUpdateStreamsRequest>
  void ListProgressUpdateStreamsAsync(const ListProgressUpdateStreamsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                      const ListProgressUpdateStreamsRequestT& request = {}) const {
    return SubmitAsync(&MigrationHubClient::ListProgressUpdateStreams, request, handler, context);
  }
 
  virtual Model::ListSourceResourcesOutcome ListSourceResources(const Model::ListSourceResourcesRequest& request) const;
 
  template <typename ListSourceResourcesRequestT = Model::ListSourceResourcesRequest>
  Model::ListSourceResourcesOutcomeCallable ListSourceResourcesCallable(const ListSourceResourcesRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::ListSourceResources, request);
  }
 
  template <typename ListSourceResourcesRequestT = Model::ListSourceResourcesRequest>
  void ListSourceResourcesAsync(const ListSourceResourcesRequestT& request, const ListSourceResourcesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::ListSourceResources, request, handler, context);
  }
 
  virtual Model::NotifyApplicationStateOutcome NotifyApplicationState(const Model::NotifyApplicationStateRequest& request) const;
 
  template <typename NotifyApplicationStateRequestT = Model::NotifyApplicationStateRequest>
  Model::NotifyApplicationStateOutcomeCallable NotifyApplicationStateCallable(const NotifyApplicationStateRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::NotifyApplicationState, request);
  }
 
  template <typename NotifyApplicationStateRequestT = Model::NotifyApplicationStateRequest>
  void NotifyApplicationStateAsync(const NotifyApplicationStateRequestT& request,
                                   const NotifyApplicationStateResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::NotifyApplicationState, request, handler, context);
  }
 
  virtual Model::NotifyMigrationTaskStateOutcome NotifyMigrationTaskState(const Model::NotifyMigrationTaskStateRequest& request) const;
 
  template <typename NotifyMigrationTaskStateRequestT = Model::NotifyMigrationTaskStateRequest>
  Model::NotifyMigrationTaskStateOutcomeCallable NotifyMigrationTaskStateCallable(const NotifyMigrationTaskStateRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::NotifyMigrationTaskState, request);
  }
 
  template <typename NotifyMigrationTaskStateRequestT = Model::NotifyMigrationTaskStateRequest>
  void NotifyMigrationTaskStateAsync(const NotifyMigrationTaskStateRequestT& request,
                                     const NotifyMigrationTaskStateResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::NotifyMigrationTaskState, request, handler, context);
  }
 
  virtual Model::PutResourceAttributesOutcome PutResourceAttributes(const Model::PutResourceAttributesRequest& request) const;
 
  template <typename PutResourceAttributesRequestT = Model::PutResourceAttributesRequest>
  Model::PutResourceAttributesOutcomeCallable PutResourceAttributesCallable(const PutResourceAttributesRequestT& request) const {
    return SubmitCallable(&MigrationHubClient::PutResourceAttributes, request);
  }
 
  template <typename PutResourceAttributesRequestT = Model::PutResourceAttributesRequest>
  void PutResourceAttributesAsync(const PutResourceAttributesRequestT& request, const PutResourceAttributesResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MigrationHubClient::PutResourceAttributes, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<MigrationHubEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MigrationHubClient>;
  void init(const MigrationHubClientConfiguration& clientConfiguration);
 
  MigrationHubClientConfiguration m_clientConfiguration;
  std::shared_ptr<MigrationHubEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MigrationHub
}  // namespace Aws