MainframeModernizationClient.h

 
#pragma once
#include <aws/m2/MainframeModernization_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/m2/MainframeModernizationServiceClientModel.h>
 
namespace Aws
{
namespace MainframeModernization
{
  class AWS_MAINFRAMEMODERNIZATION_API MainframeModernizationClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MainframeModernizationEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MainframeModernizationClient>;
      void init(const MainframeModernizationClientConfiguration& clientConfiguration);
 
      MainframeModernizationClientConfiguration m_clientConfiguration;
      std::shared_ptr<MainframeModernizationEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MainframeModernization
} // namespace Aws