MigrationHubClient.h

 
#pragma once
#include <aws/AWSMigrationHub/MigrationHub_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/AWSMigrationHub/MigrationHubServiceClientModel.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