MainframeModernizationClient.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/m2/MainframeModernizationPaginationBase.h>
#include <aws/m2/MainframeModernizationServiceClientModel.h>
#include <aws/m2/MainframeModernizationWaiter.h>
#include <aws/m2/MainframeModernization_EXPORTS.h>
 
namespace Aws {
namespace MainframeModernization {
class AWS_MAINFRAMEMODERNIZATION_API MainframeModernizationClient
    : public Aws::Client::AWSJsonClient,
      public Aws::Client::ClientWithAsyncTemplateMethods<MainframeModernizationClient>,
      public MainframeModernizationPaginationBase<MainframeModernizationClient>,
      public MainframeModernizationWaiter<MainframeModernizationClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MainframeModernizationClientConfiguration ClientConfigurationType;
  typedef MainframeModernizationEndpointProvider EndpointProviderType;
 
  MainframeModernizationClient(const Aws::MainframeModernization::MainframeModernizationClientConfiguration& clientConfiguration =
                                   Aws::MainframeModernization::MainframeModernizationClientConfiguration(),
                               std::shared_ptr<MainframeModernizationEndpointProviderBase> endpointProvider = nullptr);
 
  MainframeModernizationClient(const Aws::Auth::AWSCredentials& credentials,
                               std::shared_ptr<MainframeModernizationEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::MainframeModernization::MainframeModernizationClientConfiguration& clientConfiguration =
                                   Aws::MainframeModernization::MainframeModernizationClientConfiguration());
 
  MainframeModernizationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               std::shared_ptr<MainframeModernizationEndpointProviderBase> endpointProvider = nullptr,
                               const Aws::MainframeModernization::MainframeModernizationClientConfiguration& clientConfiguration =
                                   Aws::MainframeModernization::MainframeModernizationClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MainframeModernizationClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MainframeModernizationClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MainframeModernizationClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                               const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MainframeModernizationClient();
 
  virtual Model::CancelBatchJobExecutionOutcome CancelBatchJobExecution(const Model::CancelBatchJobExecutionRequest& request) const;
 
  template <typename CancelBatchJobExecutionRequestT = Model::CancelBatchJobExecutionRequest>
  Model::CancelBatchJobExecutionOutcomeCallable CancelBatchJobExecutionCallable(const CancelBatchJobExecutionRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::CancelBatchJobExecution, request);
  }
 
  template <typename CancelBatchJobExecutionRequestT = Model::CancelBatchJobExecutionRequest>
  void CancelBatchJobExecutionAsync(const CancelBatchJobExecutionRequestT& request,
                                    const CancelBatchJobExecutionResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::CancelBatchJobExecution, 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(&MainframeModernizationClient::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(&MainframeModernizationClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateDataSetExportTaskOutcome CreateDataSetExportTask(const Model::CreateDataSetExportTaskRequest& request) const;
 
  template <typename CreateDataSetExportTaskRequestT = Model::CreateDataSetExportTaskRequest>
  Model::CreateDataSetExportTaskOutcomeCallable CreateDataSetExportTaskCallable(const CreateDataSetExportTaskRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::CreateDataSetExportTask, request);
  }
 
  template <typename CreateDataSetExportTaskRequestT = Model::CreateDataSetExportTaskRequest>
  void CreateDataSetExportTaskAsync(const CreateDataSetExportTaskRequestT& request,
                                    const CreateDataSetExportTaskResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::CreateDataSetExportTask, request, handler, context);
  }
 
  virtual Model::CreateDataSetImportTaskOutcome CreateDataSetImportTask(const Model::CreateDataSetImportTaskRequest& request) const;
 
  template <typename CreateDataSetImportTaskRequestT = Model::CreateDataSetImportTaskRequest>
  Model::CreateDataSetImportTaskOutcomeCallable CreateDataSetImportTaskCallable(const CreateDataSetImportTaskRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::CreateDataSetImportTask, request);
  }
 
  template <typename CreateDataSetImportTaskRequestT = Model::CreateDataSetImportTaskRequest>
  void CreateDataSetImportTaskAsync(const CreateDataSetImportTaskRequestT& request,
                                    const CreateDataSetImportTaskResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::CreateDataSetImportTask, request, handler, context);
  }
 
  virtual Model::CreateDeploymentOutcome CreateDeployment(const Model::CreateDeploymentRequest& request) const;
 
  template <typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
  Model::CreateDeploymentOutcomeCallable CreateDeploymentCallable(const CreateDeploymentRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::CreateDeployment, request);
  }
 
  template <typename CreateDeploymentRequestT = Model::CreateDeploymentRequest>
  void CreateDeploymentAsync(const CreateDeploymentRequestT& request, const CreateDeploymentResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::CreateDeployment, request, handler, context);
  }
 
  virtual Model::CreateEnvironmentOutcome CreateEnvironment(const Model::CreateEnvironmentRequest& request) const;
 
  template <typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
  Model::CreateEnvironmentOutcomeCallable CreateEnvironmentCallable(const CreateEnvironmentRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::CreateEnvironment, request);
  }
 
  template <typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
  void CreateEnvironmentAsync(const CreateEnvironmentRequestT& request, const CreateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::CreateEnvironment, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteApplicationFromEnvironmentOutcome DeleteApplicationFromEnvironment(
      const Model::DeleteApplicationFromEnvironmentRequest& request) const;
 
  template <typename DeleteApplicationFromEnvironmentRequestT = Model::DeleteApplicationFromEnvironmentRequest>
  Model::DeleteApplicationFromEnvironmentOutcomeCallable DeleteApplicationFromEnvironmentCallable(
      const DeleteApplicationFromEnvironmentRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::DeleteApplicationFromEnvironment, request);
  }
 
  template <typename DeleteApplicationFromEnvironmentRequestT = Model::DeleteApplicationFromEnvironmentRequest>
  void DeleteApplicationFromEnvironmentAsync(const DeleteApplicationFromEnvironmentRequestT& request,
                                             const DeleteApplicationFromEnvironmentResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::DeleteApplicationFromEnvironment, request, handler, context);
  }
 
  virtual Model::DeleteEnvironmentOutcome DeleteEnvironment(const Model::DeleteEnvironmentRequest& request) const;
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable(const DeleteEnvironmentRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::DeleteEnvironment, request);
  }
 
  template <typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
  void DeleteEnvironmentAsync(const DeleteEnvironmentRequestT& request, const DeleteEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::DeleteEnvironment, request, handler, context);
  }
 
  virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetApplication, request);
  }
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetApplication, request, handler, context);
  }
 
  virtual Model::GetApplicationVersionOutcome GetApplicationVersion(const Model::GetApplicationVersionRequest& request) const;
 
  template <typename GetApplicationVersionRequestT = Model::GetApplicationVersionRequest>
  Model::GetApplicationVersionOutcomeCallable GetApplicationVersionCallable(const GetApplicationVersionRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetApplicationVersion, request);
  }
 
  template <typename GetApplicationVersionRequestT = Model::GetApplicationVersionRequest>
  void GetApplicationVersionAsync(const GetApplicationVersionRequestT& request, const GetApplicationVersionResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetApplicationVersion, request, handler, context);
  }
 
  virtual Model::GetBatchJobExecutionOutcome GetBatchJobExecution(const Model::GetBatchJobExecutionRequest& request) const;
 
  template <typename GetBatchJobExecutionRequestT = Model::GetBatchJobExecutionRequest>
  Model::GetBatchJobExecutionOutcomeCallable GetBatchJobExecutionCallable(const GetBatchJobExecutionRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetBatchJobExecution, request);
  }
 
  template <typename GetBatchJobExecutionRequestT = Model::GetBatchJobExecutionRequest>
  void GetBatchJobExecutionAsync(const GetBatchJobExecutionRequestT& request, const GetBatchJobExecutionResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetBatchJobExecution, request, handler, context);
  }
 
  virtual Model::GetDataSetDetailsOutcome GetDataSetDetails(const Model::GetDataSetDetailsRequest& request) const;
 
  template <typename GetDataSetDetailsRequestT = Model::GetDataSetDetailsRequest>
  Model::GetDataSetDetailsOutcomeCallable GetDataSetDetailsCallable(const GetDataSetDetailsRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetDataSetDetails, request);
  }
 
  template <typename GetDataSetDetailsRequestT = Model::GetDataSetDetailsRequest>
  void GetDataSetDetailsAsync(const GetDataSetDetailsRequestT& request, const GetDataSetDetailsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetDataSetDetails, request, handler, context);
  }
 
  virtual Model::GetDataSetExportTaskOutcome GetDataSetExportTask(const Model::GetDataSetExportTaskRequest& request) const;
 
  template <typename GetDataSetExportTaskRequestT = Model::GetDataSetExportTaskRequest>
  Model::GetDataSetExportTaskOutcomeCallable GetDataSetExportTaskCallable(const GetDataSetExportTaskRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetDataSetExportTask, request);
  }
 
  template <typename GetDataSetExportTaskRequestT = Model::GetDataSetExportTaskRequest>
  void GetDataSetExportTaskAsync(const GetDataSetExportTaskRequestT& request, const GetDataSetExportTaskResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetDataSetExportTask, request, handler, context);
  }
 
  virtual Model::GetDataSetImportTaskOutcome GetDataSetImportTask(const Model::GetDataSetImportTaskRequest& request) const;
 
  template <typename GetDataSetImportTaskRequestT = Model::GetDataSetImportTaskRequest>
  Model::GetDataSetImportTaskOutcomeCallable GetDataSetImportTaskCallable(const GetDataSetImportTaskRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetDataSetImportTask, request);
  }
 
  template <typename GetDataSetImportTaskRequestT = Model::GetDataSetImportTaskRequest>
  void GetDataSetImportTaskAsync(const GetDataSetImportTaskRequestT& request, const GetDataSetImportTaskResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetDataSetImportTask, request, handler, context);
  }
 
  virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const;
 
  template <typename GetDeploymentRequestT = Model::GetDeploymentRequest>
  Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetDeployment, request);
  }
 
  template <typename GetDeploymentRequestT = Model::GetDeploymentRequest>
  void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetDeployment, request, handler, context);
  }
 
  virtual Model::GetEnvironmentOutcome GetEnvironment(const Model::GetEnvironmentRequest& request) const;
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable(const GetEnvironmentRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::GetEnvironment, request);
  }
 
  template <typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
  void GetEnvironmentAsync(const GetEnvironmentRequestT& request, const GetEnvironmentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::GetEnvironment, request, handler, context);
  }
 
  virtual Model::GetSignedBluinsightsUrlOutcome GetSignedBluinsightsUrl(const Model::GetSignedBluinsightsUrlRequest& request = {}) const;
 
  template <typename GetSignedBluinsightsUrlRequestT = Model::GetSignedBluinsightsUrlRequest>
  Model::GetSignedBluinsightsUrlOutcomeCallable GetSignedBluinsightsUrlCallable(const GetSignedBluinsightsUrlRequestT& request = {}) const {
    return SubmitCallable(&MainframeModernizationClient::GetSignedBluinsightsUrl, request);
  }
 
  template <typename GetSignedBluinsightsUrlRequestT = Model::GetSignedBluinsightsUrlRequest>
  void GetSignedBluinsightsUrlAsync(const GetSignedBluinsightsUrlResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const GetSignedBluinsightsUrlRequestT& request = {}) const {
    return SubmitAsync(&MainframeModernizationClient::GetSignedBluinsightsUrl, request, handler, context);
  }
 
  virtual Model::ListApplicationVersionsOutcome ListApplicationVersions(const Model::ListApplicationVersionsRequest& request) const;
 
  template <typename ListApplicationVersionsRequestT = Model::ListApplicationVersionsRequest>
  Model::ListApplicationVersionsOutcomeCallable ListApplicationVersionsCallable(const ListApplicationVersionsRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListApplicationVersions, request);
  }
 
  template <typename ListApplicationVersionsRequestT = Model::ListApplicationVersionsRequest>
  void ListApplicationVersionsAsync(const ListApplicationVersionsRequestT& request,
                                    const ListApplicationVersionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListApplicationVersions, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&MainframeModernizationClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&MainframeModernizationClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListBatchJobDefinitionsOutcome ListBatchJobDefinitions(const Model::ListBatchJobDefinitionsRequest& request) const;
 
  template <typename ListBatchJobDefinitionsRequestT = Model::ListBatchJobDefinitionsRequest>
  Model::ListBatchJobDefinitionsOutcomeCallable ListBatchJobDefinitionsCallable(const ListBatchJobDefinitionsRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListBatchJobDefinitions, request);
  }
 
  template <typename ListBatchJobDefinitionsRequestT = Model::ListBatchJobDefinitionsRequest>
  void ListBatchJobDefinitionsAsync(const ListBatchJobDefinitionsRequestT& request,
                                    const ListBatchJobDefinitionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListBatchJobDefinitions, request, handler, context);
  }
 
  virtual Model::ListBatchJobExecutionsOutcome ListBatchJobExecutions(const Model::ListBatchJobExecutionsRequest& request) const;
 
  template <typename ListBatchJobExecutionsRequestT = Model::ListBatchJobExecutionsRequest>
  Model::ListBatchJobExecutionsOutcomeCallable ListBatchJobExecutionsCallable(const ListBatchJobExecutionsRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListBatchJobExecutions, request);
  }
 
  template <typename ListBatchJobExecutionsRequestT = Model::ListBatchJobExecutionsRequest>
  void ListBatchJobExecutionsAsync(const ListBatchJobExecutionsRequestT& request,
                                   const ListBatchJobExecutionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListBatchJobExecutions, request, handler, context);
  }
 
  virtual Model::ListBatchJobRestartPointsOutcome ListBatchJobRestartPoints(const Model::ListBatchJobRestartPointsRequest& request) const;
 
  template <typename ListBatchJobRestartPointsRequestT = Model::ListBatchJobRestartPointsRequest>
  Model::ListBatchJobRestartPointsOutcomeCallable ListBatchJobRestartPointsCallable(
      const ListBatchJobRestartPointsRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListBatchJobRestartPoints, request);
  }
 
  template <typename ListBatchJobRestartPointsRequestT = Model::ListBatchJobRestartPointsRequest>
  void ListBatchJobRestartPointsAsync(const ListBatchJobRestartPointsRequestT& request,
                                      const ListBatchJobRestartPointsResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListBatchJobRestartPoints, request, handler, context);
  }
 
  virtual Model::ListDataSetExportHistoryOutcome ListDataSetExportHistory(const Model::ListDataSetExportHistoryRequest& request) const;
 
  template <typename ListDataSetExportHistoryRequestT = Model::ListDataSetExportHistoryRequest>
  Model::ListDataSetExportHistoryOutcomeCallable ListDataSetExportHistoryCallable(const ListDataSetExportHistoryRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListDataSetExportHistory, request);
  }
 
  template <typename ListDataSetExportHistoryRequestT = Model::ListDataSetExportHistoryRequest>
  void ListDataSetExportHistoryAsync(const ListDataSetExportHistoryRequestT& request,
                                     const ListDataSetExportHistoryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListDataSetExportHistory, request, handler, context);
  }
 
  virtual Model::ListDataSetImportHistoryOutcome ListDataSetImportHistory(const Model::ListDataSetImportHistoryRequest& request) const;
 
  template <typename ListDataSetImportHistoryRequestT = Model::ListDataSetImportHistoryRequest>
  Model::ListDataSetImportHistoryOutcomeCallable ListDataSetImportHistoryCallable(const ListDataSetImportHistoryRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListDataSetImportHistory, request);
  }
 
  template <typename ListDataSetImportHistoryRequestT = Model::ListDataSetImportHistoryRequest>
  void ListDataSetImportHistoryAsync(const ListDataSetImportHistoryRequestT& request,
                                     const ListDataSetImportHistoryResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListDataSetImportHistory, request, handler, context);
  }
 
  virtual Model::ListDataSetsOutcome ListDataSets(const Model::ListDataSetsRequest& request) const;
 
  template <typename ListDataSetsRequestT = Model::ListDataSetsRequest>
  Model::ListDataSetsOutcomeCallable ListDataSetsCallable(const ListDataSetsRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListDataSets, request);
  }
 
  template <typename ListDataSetsRequestT = Model::ListDataSetsRequest>
  void ListDataSetsAsync(const ListDataSetsRequestT& request, const ListDataSetsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListDataSets, request, handler, context);
  }
 
  virtual Model::ListDeploymentsOutcome ListDeployments(const Model::ListDeploymentsRequest& request) const;
 
  template <typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
  Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable(const ListDeploymentsRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListDeployments, request);
  }
 
  template <typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
  void ListDeploymentsAsync(const ListDeploymentsRequestT& request, const ListDeploymentsResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListDeployments, request, handler, context);
  }
 
  virtual Model::ListEngineVersionsOutcome ListEngineVersions(const Model::ListEngineVersionsRequest& request = {}) const;
 
  template <typename ListEngineVersionsRequestT = Model::ListEngineVersionsRequest>
  Model::ListEngineVersionsOutcomeCallable ListEngineVersionsCallable(const ListEngineVersionsRequestT& request = {}) const {
    return SubmitCallable(&MainframeModernizationClient::ListEngineVersions, request);
  }
 
  template <typename ListEngineVersionsRequestT = Model::ListEngineVersionsRequest>
  void ListEngineVersionsAsync(const ListEngineVersionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const ListEngineVersionsRequestT& request = {}) const {
    return SubmitAsync(&MainframeModernizationClient::ListEngineVersions, request, handler, context);
  }
 
  virtual Model::ListEnvironmentsOutcome ListEnvironments(const Model::ListEnvironmentsRequest& request = {}) const;
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable(const ListEnvironmentsRequestT& request = {}) const {
    return SubmitCallable(&MainframeModernizationClient::ListEnvironments, request);
  }
 
  template <typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
  void ListEnvironmentsAsync(const ListEnvironmentsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListEnvironmentsRequestT& request = {}) const {
    return SubmitAsync(&MainframeModernizationClient::ListEnvironments, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::StartApplicationOutcome StartApplication(const Model::StartApplicationRequest& request) const;
 
  template <typename StartApplicationRequestT = Model::StartApplicationRequest>
  Model::StartApplicationOutcomeCallable StartApplicationCallable(const StartApplicationRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::StartApplication, request);
  }
 
  template <typename StartApplicationRequestT = Model::StartApplicationRequest>
  void StartApplicationAsync(const StartApplicationRequestT& request, const StartApplicationResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::StartApplication, request, handler, context);
  }
 
  virtual Model::StartBatchJobOutcome StartBatchJob(const Model::StartBatchJobRequest& request) const;
 
  template <typename StartBatchJobRequestT = Model::StartBatchJobRequest>
  Model::StartBatchJobOutcomeCallable StartBatchJobCallable(const StartBatchJobRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::StartBatchJob, request);
  }
 
  template <typename StartBatchJobRequestT = Model::StartBatchJobRequest>
  void StartBatchJobAsync(const StartBatchJobRequestT& request, const StartBatchJobResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::StartBatchJob, request, handler, context);
  }
 
  virtual Model::StopApplicationOutcome StopApplication(const Model::StopApplicationRequest& request) const;
 
  template <typename StopApplicationRequestT = Model::StopApplicationRequest>
  Model::StopApplicationOutcomeCallable StopApplicationCallable(const StopApplicationRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::StopApplication, request);
  }
 
  template <typename StopApplicationRequestT = Model::StopApplicationRequest>
  void StopApplicationAsync(const StopApplicationRequestT& request, const StopApplicationResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::StopApplication, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::UntagResource, 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(&MainframeModernizationClient::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(&MainframeModernizationClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateEnvironmentOutcome UpdateEnvironment(const Model::UpdateEnvironmentRequest& request) const;
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable(const UpdateEnvironmentRequestT& request) const {
    return SubmitCallable(&MainframeModernizationClient::UpdateEnvironment, request);
  }
 
  template <typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
  void UpdateEnvironmentAsync(const UpdateEnvironmentRequestT& request, const UpdateEnvironmentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MainframeModernizationClient::UpdateEnvironment, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MainframeModernizationEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MainframeModernizationClient>;
  void init(const MainframeModernizationClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MainframeModernizationError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  MainframeModernizationClientConfiguration m_clientConfiguration;
  std::shared_ptr<MainframeModernizationEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MainframeModernization
}  // namespace Aws