RoboMakerClient.h

 
#pragma once
#include <aws/robomaker/RoboMaker_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/robomaker/RoboMakerServiceClientModel.h>
 
namespace Aws
{
namespace RoboMaker
{
  class AWS_ROBOMAKER_API RoboMakerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<RoboMakerClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef RoboMakerClientConfiguration ClientConfigurationType;
      typedef RoboMakerEndpointProvider EndpointProviderType;
 
        RoboMakerClient(const Aws::RoboMaker::RoboMakerClientConfiguration& clientConfiguration = Aws::RoboMaker::RoboMakerClientConfiguration(),
                        std::shared_ptr<RoboMakerEndpointProviderBase> endpointProvider = nullptr);
 
        RoboMakerClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<RoboMakerEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::RoboMaker::RoboMakerClientConfiguration& clientConfiguration = Aws::RoboMaker::RoboMakerClientConfiguration());
 
        RoboMakerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<RoboMakerEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::RoboMaker::RoboMakerClientConfiguration& clientConfiguration = Aws::RoboMaker::RoboMakerClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        RoboMakerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        RoboMakerClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        RoboMakerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~RoboMakerClient();
 
        virtual Model::BatchDeleteWorldsOutcome BatchDeleteWorlds(const Model::BatchDeleteWorldsRequest& request) const;
 
        template<typename BatchDeleteWorldsRequestT = Model::BatchDeleteWorldsRequest>
        Model::BatchDeleteWorldsOutcomeCallable BatchDeleteWorldsCallable(const BatchDeleteWorldsRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::BatchDeleteWorlds, request);
        }
 
        template<typename BatchDeleteWorldsRequestT = Model::BatchDeleteWorldsRequest>
        void BatchDeleteWorldsAsync(const BatchDeleteWorldsRequestT& request, const BatchDeleteWorldsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::BatchDeleteWorlds, request, handler, context);
        }
 
        virtual Model::BatchDescribeSimulationJobOutcome BatchDescribeSimulationJob(const Model::BatchDescribeSimulationJobRequest& request) const;
 
        template<typename BatchDescribeSimulationJobRequestT = Model::BatchDescribeSimulationJobRequest>
        Model::BatchDescribeSimulationJobOutcomeCallable BatchDescribeSimulationJobCallable(const BatchDescribeSimulationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::BatchDescribeSimulationJob, request);
        }
 
        template<typename BatchDescribeSimulationJobRequestT = Model::BatchDescribeSimulationJobRequest>
        void BatchDescribeSimulationJobAsync(const BatchDescribeSimulationJobRequestT& request, const BatchDescribeSimulationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::BatchDescribeSimulationJob, request, handler, context);
        }
 
        virtual Model::CancelSimulationJobOutcome CancelSimulationJob(const Model::CancelSimulationJobRequest& request) const;
 
        template<typename CancelSimulationJobRequestT = Model::CancelSimulationJobRequest>
        Model::CancelSimulationJobOutcomeCallable CancelSimulationJobCallable(const CancelSimulationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CancelSimulationJob, request);
        }
 
        template<typename CancelSimulationJobRequestT = Model::CancelSimulationJobRequest>
        void CancelSimulationJobAsync(const CancelSimulationJobRequestT& request, const CancelSimulationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CancelSimulationJob, request, handler, context);
        }
 
        virtual Model::CancelSimulationJobBatchOutcome CancelSimulationJobBatch(const Model::CancelSimulationJobBatchRequest& request) const;
 
        template<typename CancelSimulationJobBatchRequestT = Model::CancelSimulationJobBatchRequest>
        Model::CancelSimulationJobBatchOutcomeCallable CancelSimulationJobBatchCallable(const CancelSimulationJobBatchRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CancelSimulationJobBatch, request);
        }
 
        template<typename CancelSimulationJobBatchRequestT = Model::CancelSimulationJobBatchRequest>
        void CancelSimulationJobBatchAsync(const CancelSimulationJobBatchRequestT& request, const CancelSimulationJobBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CancelSimulationJobBatch, request, handler, context);
        }
 
        virtual Model::CancelWorldExportJobOutcome CancelWorldExportJob(const Model::CancelWorldExportJobRequest& request) const;
 
        template<typename CancelWorldExportJobRequestT = Model::CancelWorldExportJobRequest>
        Model::CancelWorldExportJobOutcomeCallable CancelWorldExportJobCallable(const CancelWorldExportJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CancelWorldExportJob, request);
        }
 
        template<typename CancelWorldExportJobRequestT = Model::CancelWorldExportJobRequest>
        void CancelWorldExportJobAsync(const CancelWorldExportJobRequestT& request, const CancelWorldExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CancelWorldExportJob, request, handler, context);
        }
 
        virtual Model::CancelWorldGenerationJobOutcome CancelWorldGenerationJob(const Model::CancelWorldGenerationJobRequest& request) const;
 
        template<typename CancelWorldGenerationJobRequestT = Model::CancelWorldGenerationJobRequest>
        Model::CancelWorldGenerationJobOutcomeCallable CancelWorldGenerationJobCallable(const CancelWorldGenerationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CancelWorldGenerationJob, request);
        }
 
        template<typename CancelWorldGenerationJobRequestT = Model::CancelWorldGenerationJobRequest>
        void CancelWorldGenerationJobAsync(const CancelWorldGenerationJobRequestT& request, const CancelWorldGenerationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CancelWorldGenerationJob, request, handler, context);
        }
 
        virtual Model::CreateRobotApplicationOutcome CreateRobotApplication(const Model::CreateRobotApplicationRequest& request) const;
 
        template<typename CreateRobotApplicationRequestT = Model::CreateRobotApplicationRequest>
        Model::CreateRobotApplicationOutcomeCallable CreateRobotApplicationCallable(const CreateRobotApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CreateRobotApplication, request);
        }
 
        template<typename CreateRobotApplicationRequestT = Model::CreateRobotApplicationRequest>
        void CreateRobotApplicationAsync(const CreateRobotApplicationRequestT& request, const CreateRobotApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CreateRobotApplication, request, handler, context);
        }
 
        virtual Model::CreateRobotApplicationVersionOutcome CreateRobotApplicationVersion(const Model::CreateRobotApplicationVersionRequest& request) const;
 
        template<typename CreateRobotApplicationVersionRequestT = Model::CreateRobotApplicationVersionRequest>
        Model::CreateRobotApplicationVersionOutcomeCallable CreateRobotApplicationVersionCallable(const CreateRobotApplicationVersionRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CreateRobotApplicationVersion, request);
        }
 
        template<typename CreateRobotApplicationVersionRequestT = Model::CreateRobotApplicationVersionRequest>
        void CreateRobotApplicationVersionAsync(const CreateRobotApplicationVersionRequestT& request, const CreateRobotApplicationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CreateRobotApplicationVersion, request, handler, context);
        }
 
        virtual Model::CreateSimulationApplicationOutcome CreateSimulationApplication(const Model::CreateSimulationApplicationRequest& request) const;
 
        template<typename CreateSimulationApplicationRequestT = Model::CreateSimulationApplicationRequest>
        Model::CreateSimulationApplicationOutcomeCallable CreateSimulationApplicationCallable(const CreateSimulationApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CreateSimulationApplication, request);
        }
 
        template<typename CreateSimulationApplicationRequestT = Model::CreateSimulationApplicationRequest>
        void CreateSimulationApplicationAsync(const CreateSimulationApplicationRequestT& request, const CreateSimulationApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CreateSimulationApplication, request, handler, context);
        }
 
        virtual Model::CreateSimulationApplicationVersionOutcome CreateSimulationApplicationVersion(const Model::CreateSimulationApplicationVersionRequest& request) const;
 
        template<typename CreateSimulationApplicationVersionRequestT = Model::CreateSimulationApplicationVersionRequest>
        Model::CreateSimulationApplicationVersionOutcomeCallable CreateSimulationApplicationVersionCallable(const CreateSimulationApplicationVersionRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CreateSimulationApplicationVersion, request);
        }
 
        template<typename CreateSimulationApplicationVersionRequestT = Model::CreateSimulationApplicationVersionRequest>
        void CreateSimulationApplicationVersionAsync(const CreateSimulationApplicationVersionRequestT& request, const CreateSimulationApplicationVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CreateSimulationApplicationVersion, request, handler, context);
        }
 
        virtual Model::CreateSimulationJobOutcome CreateSimulationJob(const Model::CreateSimulationJobRequest& request) const;
 
        template<typename CreateSimulationJobRequestT = Model::CreateSimulationJobRequest>
        Model::CreateSimulationJobOutcomeCallable CreateSimulationJobCallable(const CreateSimulationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CreateSimulationJob, request);
        }
 
        template<typename CreateSimulationJobRequestT = Model::CreateSimulationJobRequest>
        void CreateSimulationJobAsync(const CreateSimulationJobRequestT& request, const CreateSimulationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CreateSimulationJob, request, handler, context);
        }
 
        virtual Model::CreateWorldExportJobOutcome CreateWorldExportJob(const Model::CreateWorldExportJobRequest& request) const;
 
        template<typename CreateWorldExportJobRequestT = Model::CreateWorldExportJobRequest>
        Model::CreateWorldExportJobOutcomeCallable CreateWorldExportJobCallable(const CreateWorldExportJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CreateWorldExportJob, request);
        }
 
        template<typename CreateWorldExportJobRequestT = Model::CreateWorldExportJobRequest>
        void CreateWorldExportJobAsync(const CreateWorldExportJobRequestT& request, const CreateWorldExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CreateWorldExportJob, request, handler, context);
        }
 
        virtual Model::CreateWorldGenerationJobOutcome CreateWorldGenerationJob(const Model::CreateWorldGenerationJobRequest& request) const;
 
        template<typename CreateWorldGenerationJobRequestT = Model::CreateWorldGenerationJobRequest>
        Model::CreateWorldGenerationJobOutcomeCallable CreateWorldGenerationJobCallable(const CreateWorldGenerationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::CreateWorldGenerationJob, request);
        }
 
        template<typename CreateWorldGenerationJobRequestT = Model::CreateWorldGenerationJobRequest>
        void CreateWorldGenerationJobAsync(const CreateWorldGenerationJobRequestT& request, const CreateWorldGenerationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::CreateWorldGenerationJob, request, handler, context);
        }
 
        virtual Model::CreateWorldTemplateOutcome CreateWorldTemplate(const Model::CreateWorldTemplateRequest& request = {}) const;
 
        template<typename CreateWorldTemplateRequestT = Model::CreateWorldTemplateRequest>
        Model::CreateWorldTemplateOutcomeCallable CreateWorldTemplateCallable(const CreateWorldTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::CreateWorldTemplate, request);
        }
 
        template<typename CreateWorldTemplateRequestT = Model::CreateWorldTemplateRequest>
        void CreateWorldTemplateAsync(const CreateWorldTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateWorldTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::CreateWorldTemplate, request, handler, context);
        }
 
        virtual Model::DeleteRobotApplicationOutcome DeleteRobotApplication(const Model::DeleteRobotApplicationRequest& request) const;
 
        template<typename DeleteRobotApplicationRequestT = Model::DeleteRobotApplicationRequest>
        Model::DeleteRobotApplicationOutcomeCallable DeleteRobotApplicationCallable(const DeleteRobotApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DeleteRobotApplication, request);
        }
 
        template<typename DeleteRobotApplicationRequestT = Model::DeleteRobotApplicationRequest>
        void DeleteRobotApplicationAsync(const DeleteRobotApplicationRequestT& request, const DeleteRobotApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DeleteRobotApplication, request, handler, context);
        }
 
        virtual Model::DeleteSimulationApplicationOutcome DeleteSimulationApplication(const Model::DeleteSimulationApplicationRequest& request) const;
 
        template<typename DeleteSimulationApplicationRequestT = Model::DeleteSimulationApplicationRequest>
        Model::DeleteSimulationApplicationOutcomeCallable DeleteSimulationApplicationCallable(const DeleteSimulationApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DeleteSimulationApplication, request);
        }
 
        template<typename DeleteSimulationApplicationRequestT = Model::DeleteSimulationApplicationRequest>
        void DeleteSimulationApplicationAsync(const DeleteSimulationApplicationRequestT& request, const DeleteSimulationApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DeleteSimulationApplication, request, handler, context);
        }
 
        virtual Model::DeleteWorldTemplateOutcome DeleteWorldTemplate(const Model::DeleteWorldTemplateRequest& request) const;
 
        template<typename DeleteWorldTemplateRequestT = Model::DeleteWorldTemplateRequest>
        Model::DeleteWorldTemplateOutcomeCallable DeleteWorldTemplateCallable(const DeleteWorldTemplateRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DeleteWorldTemplate, request);
        }
 
        template<typename DeleteWorldTemplateRequestT = Model::DeleteWorldTemplateRequest>
        void DeleteWorldTemplateAsync(const DeleteWorldTemplateRequestT& request, const DeleteWorldTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DeleteWorldTemplate, request, handler, context);
        }
 
        virtual Model::DescribeRobotApplicationOutcome DescribeRobotApplication(const Model::DescribeRobotApplicationRequest& request) const;
 
        template<typename DescribeRobotApplicationRequestT = Model::DescribeRobotApplicationRequest>
        Model::DescribeRobotApplicationOutcomeCallable DescribeRobotApplicationCallable(const DescribeRobotApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeRobotApplication, request);
        }
 
        template<typename DescribeRobotApplicationRequestT = Model::DescribeRobotApplicationRequest>
        void DescribeRobotApplicationAsync(const DescribeRobotApplicationRequestT& request, const DescribeRobotApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeRobotApplication, request, handler, context);
        }
 
        virtual Model::DescribeSimulationApplicationOutcome DescribeSimulationApplication(const Model::DescribeSimulationApplicationRequest& request) const;
 
        template<typename DescribeSimulationApplicationRequestT = Model::DescribeSimulationApplicationRequest>
        Model::DescribeSimulationApplicationOutcomeCallable DescribeSimulationApplicationCallable(const DescribeSimulationApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeSimulationApplication, request);
        }
 
        template<typename DescribeSimulationApplicationRequestT = Model::DescribeSimulationApplicationRequest>
        void DescribeSimulationApplicationAsync(const DescribeSimulationApplicationRequestT& request, const DescribeSimulationApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeSimulationApplication, request, handler, context);
        }
 
        virtual Model::DescribeSimulationJobOutcome DescribeSimulationJob(const Model::DescribeSimulationJobRequest& request) const;
 
        template<typename DescribeSimulationJobRequestT = Model::DescribeSimulationJobRequest>
        Model::DescribeSimulationJobOutcomeCallable DescribeSimulationJobCallable(const DescribeSimulationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeSimulationJob, request);
        }
 
        template<typename DescribeSimulationJobRequestT = Model::DescribeSimulationJobRequest>
        void DescribeSimulationJobAsync(const DescribeSimulationJobRequestT& request, const DescribeSimulationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeSimulationJob, request, handler, context);
        }
 
        virtual Model::DescribeSimulationJobBatchOutcome DescribeSimulationJobBatch(const Model::DescribeSimulationJobBatchRequest& request) const;
 
        template<typename DescribeSimulationJobBatchRequestT = Model::DescribeSimulationJobBatchRequest>
        Model::DescribeSimulationJobBatchOutcomeCallable DescribeSimulationJobBatchCallable(const DescribeSimulationJobBatchRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeSimulationJobBatch, request);
        }
 
        template<typename DescribeSimulationJobBatchRequestT = Model::DescribeSimulationJobBatchRequest>
        void DescribeSimulationJobBatchAsync(const DescribeSimulationJobBatchRequestT& request, const DescribeSimulationJobBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeSimulationJobBatch, request, handler, context);
        }
 
        virtual Model::DescribeWorldOutcome DescribeWorld(const Model::DescribeWorldRequest& request) const;
 
        template<typename DescribeWorldRequestT = Model::DescribeWorldRequest>
        Model::DescribeWorldOutcomeCallable DescribeWorldCallable(const DescribeWorldRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeWorld, request);
        }
 
        template<typename DescribeWorldRequestT = Model::DescribeWorldRequest>
        void DescribeWorldAsync(const DescribeWorldRequestT& request, const DescribeWorldResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeWorld, request, handler, context);
        }
 
        virtual Model::DescribeWorldExportJobOutcome DescribeWorldExportJob(const Model::DescribeWorldExportJobRequest& request) const;
 
        template<typename DescribeWorldExportJobRequestT = Model::DescribeWorldExportJobRequest>
        Model::DescribeWorldExportJobOutcomeCallable DescribeWorldExportJobCallable(const DescribeWorldExportJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeWorldExportJob, request);
        }
 
        template<typename DescribeWorldExportJobRequestT = Model::DescribeWorldExportJobRequest>
        void DescribeWorldExportJobAsync(const DescribeWorldExportJobRequestT& request, const DescribeWorldExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeWorldExportJob, request, handler, context);
        }
 
        virtual Model::DescribeWorldGenerationJobOutcome DescribeWorldGenerationJob(const Model::DescribeWorldGenerationJobRequest& request) const;
 
        template<typename DescribeWorldGenerationJobRequestT = Model::DescribeWorldGenerationJobRequest>
        Model::DescribeWorldGenerationJobOutcomeCallable DescribeWorldGenerationJobCallable(const DescribeWorldGenerationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeWorldGenerationJob, request);
        }
 
        template<typename DescribeWorldGenerationJobRequestT = Model::DescribeWorldGenerationJobRequest>
        void DescribeWorldGenerationJobAsync(const DescribeWorldGenerationJobRequestT& request, const DescribeWorldGenerationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeWorldGenerationJob, request, handler, context);
        }
 
        virtual Model::DescribeWorldTemplateOutcome DescribeWorldTemplate(const Model::DescribeWorldTemplateRequest& request) const;
 
        template<typename DescribeWorldTemplateRequestT = Model::DescribeWorldTemplateRequest>
        Model::DescribeWorldTemplateOutcomeCallable DescribeWorldTemplateCallable(const DescribeWorldTemplateRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::DescribeWorldTemplate, request);
        }
 
        template<typename DescribeWorldTemplateRequestT = Model::DescribeWorldTemplateRequest>
        void DescribeWorldTemplateAsync(const DescribeWorldTemplateRequestT& request, const DescribeWorldTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::DescribeWorldTemplate, request, handler, context);
        }
 
        virtual Model::GetWorldTemplateBodyOutcome GetWorldTemplateBody(const Model::GetWorldTemplateBodyRequest& request = {}) const;
 
        template<typename GetWorldTemplateBodyRequestT = Model::GetWorldTemplateBodyRequest>
        Model::GetWorldTemplateBodyOutcomeCallable GetWorldTemplateBodyCallable(const GetWorldTemplateBodyRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::GetWorldTemplateBody, request);
        }
 
        template<typename GetWorldTemplateBodyRequestT = Model::GetWorldTemplateBodyRequest>
        void GetWorldTemplateBodyAsync(const GetWorldTemplateBodyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetWorldTemplateBodyRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::GetWorldTemplateBody, request, handler, context);
        }
 
        virtual Model::ListRobotApplicationsOutcome ListRobotApplications(const Model::ListRobotApplicationsRequest& request = {}) const;
 
        template<typename ListRobotApplicationsRequestT = Model::ListRobotApplicationsRequest>
        Model::ListRobotApplicationsOutcomeCallable ListRobotApplicationsCallable(const ListRobotApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListRobotApplications, request);
        }
 
        template<typename ListRobotApplicationsRequestT = Model::ListRobotApplicationsRequest>
        void ListRobotApplicationsAsync(const ListRobotApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRobotApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListRobotApplications, request, handler, context);
        }
 
        virtual Model::ListSimulationApplicationsOutcome ListSimulationApplications(const Model::ListSimulationApplicationsRequest& request = {}) const;
 
        template<typename ListSimulationApplicationsRequestT = Model::ListSimulationApplicationsRequest>
        Model::ListSimulationApplicationsOutcomeCallable ListSimulationApplicationsCallable(const ListSimulationApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListSimulationApplications, request);
        }
 
        template<typename ListSimulationApplicationsRequestT = Model::ListSimulationApplicationsRequest>
        void ListSimulationApplicationsAsync(const ListSimulationApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSimulationApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListSimulationApplications, request, handler, context);
        }
 
        virtual Model::ListSimulationJobBatchesOutcome ListSimulationJobBatches(const Model::ListSimulationJobBatchesRequest& request = {}) const;
 
        template<typename ListSimulationJobBatchesRequestT = Model::ListSimulationJobBatchesRequest>
        Model::ListSimulationJobBatchesOutcomeCallable ListSimulationJobBatchesCallable(const ListSimulationJobBatchesRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListSimulationJobBatches, request);
        }
 
        template<typename ListSimulationJobBatchesRequestT = Model::ListSimulationJobBatchesRequest>
        void ListSimulationJobBatchesAsync(const ListSimulationJobBatchesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSimulationJobBatchesRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListSimulationJobBatches, request, handler, context);
        }
 
        virtual Model::ListSimulationJobsOutcome ListSimulationJobs(const Model::ListSimulationJobsRequest& request = {}) const;
 
        template<typename ListSimulationJobsRequestT = Model::ListSimulationJobsRequest>
        Model::ListSimulationJobsOutcomeCallable ListSimulationJobsCallable(const ListSimulationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListSimulationJobs, request);
        }
 
        template<typename ListSimulationJobsRequestT = Model::ListSimulationJobsRequest>
        void ListSimulationJobsAsync(const ListSimulationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSimulationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListSimulationJobs, 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(&RoboMakerClient::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(&RoboMakerClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListWorldExportJobsOutcome ListWorldExportJobs(const Model::ListWorldExportJobsRequest& request = {}) const;
 
        template<typename ListWorldExportJobsRequestT = Model::ListWorldExportJobsRequest>
        Model::ListWorldExportJobsOutcomeCallable ListWorldExportJobsCallable(const ListWorldExportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListWorldExportJobs, request);
        }
 
        template<typename ListWorldExportJobsRequestT = Model::ListWorldExportJobsRequest>
        void ListWorldExportJobsAsync(const ListWorldExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorldExportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListWorldExportJobs, request, handler, context);
        }
 
        virtual Model::ListWorldGenerationJobsOutcome ListWorldGenerationJobs(const Model::ListWorldGenerationJobsRequest& request = {}) const;
 
        template<typename ListWorldGenerationJobsRequestT = Model::ListWorldGenerationJobsRequest>
        Model::ListWorldGenerationJobsOutcomeCallable ListWorldGenerationJobsCallable(const ListWorldGenerationJobsRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListWorldGenerationJobs, request);
        }
 
        template<typename ListWorldGenerationJobsRequestT = Model::ListWorldGenerationJobsRequest>
        void ListWorldGenerationJobsAsync(const ListWorldGenerationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorldGenerationJobsRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListWorldGenerationJobs, request, handler, context);
        }
 
        virtual Model::ListWorldTemplatesOutcome ListWorldTemplates(const Model::ListWorldTemplatesRequest& request = {}) const;
 
        template<typename ListWorldTemplatesRequestT = Model::ListWorldTemplatesRequest>
        Model::ListWorldTemplatesOutcomeCallable ListWorldTemplatesCallable(const ListWorldTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListWorldTemplates, request);
        }
 
        template<typename ListWorldTemplatesRequestT = Model::ListWorldTemplatesRequest>
        void ListWorldTemplatesAsync(const ListWorldTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorldTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListWorldTemplates, request, handler, context);
        }
 
        virtual Model::ListWorldsOutcome ListWorlds(const Model::ListWorldsRequest& request = {}) const;
 
        template<typename ListWorldsRequestT = Model::ListWorldsRequest>
        Model::ListWorldsOutcomeCallable ListWorldsCallable(const ListWorldsRequestT& request = {}) const
        {
            return SubmitCallable(&RoboMakerClient::ListWorlds, request);
        }
 
        template<typename ListWorldsRequestT = Model::ListWorldsRequest>
        void ListWorldsAsync(const ListWorldsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListWorldsRequestT& request = {}) const
        {
            return SubmitAsync(&RoboMakerClient::ListWorlds, request, handler, context);
        }
 
        virtual Model::RestartSimulationJobOutcome RestartSimulationJob(const Model::RestartSimulationJobRequest& request) const;
 
        template<typename RestartSimulationJobRequestT = Model::RestartSimulationJobRequest>
        Model::RestartSimulationJobOutcomeCallable RestartSimulationJobCallable(const RestartSimulationJobRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::RestartSimulationJob, request);
        }
 
        template<typename RestartSimulationJobRequestT = Model::RestartSimulationJobRequest>
        void RestartSimulationJobAsync(const RestartSimulationJobRequestT& request, const RestartSimulationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::RestartSimulationJob, request, handler, context);
        }
 
        virtual Model::StartSimulationJobBatchOutcome StartSimulationJobBatch(const Model::StartSimulationJobBatchRequest& request) const;
 
        template<typename StartSimulationJobBatchRequestT = Model::StartSimulationJobBatchRequest>
        Model::StartSimulationJobBatchOutcomeCallable StartSimulationJobBatchCallable(const StartSimulationJobBatchRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::StartSimulationJobBatch, request);
        }
 
        template<typename StartSimulationJobBatchRequestT = Model::StartSimulationJobBatchRequest>
        void StartSimulationJobBatchAsync(const StartSimulationJobBatchRequestT& request, const StartSimulationJobBatchResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::StartSimulationJobBatch, 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(&RoboMakerClient::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(&RoboMakerClient::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(&RoboMakerClient::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(&RoboMakerClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateRobotApplicationOutcome UpdateRobotApplication(const Model::UpdateRobotApplicationRequest& request) const;
 
        template<typename UpdateRobotApplicationRequestT = Model::UpdateRobotApplicationRequest>
        Model::UpdateRobotApplicationOutcomeCallable UpdateRobotApplicationCallable(const UpdateRobotApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::UpdateRobotApplication, request);
        }
 
        template<typename UpdateRobotApplicationRequestT = Model::UpdateRobotApplicationRequest>
        void UpdateRobotApplicationAsync(const UpdateRobotApplicationRequestT& request, const UpdateRobotApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::UpdateRobotApplication, request, handler, context);
        }
 
        virtual Model::UpdateSimulationApplicationOutcome UpdateSimulationApplication(const Model::UpdateSimulationApplicationRequest& request) const;
 
        template<typename UpdateSimulationApplicationRequestT = Model::UpdateSimulationApplicationRequest>
        Model::UpdateSimulationApplicationOutcomeCallable UpdateSimulationApplicationCallable(const UpdateSimulationApplicationRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::UpdateSimulationApplication, request);
        }
 
        template<typename UpdateSimulationApplicationRequestT = Model::UpdateSimulationApplicationRequest>
        void UpdateSimulationApplicationAsync(const UpdateSimulationApplicationRequestT& request, const UpdateSimulationApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::UpdateSimulationApplication, request, handler, context);
        }
 
        virtual Model::UpdateWorldTemplateOutcome UpdateWorldTemplate(const Model::UpdateWorldTemplateRequest& request) const;
 
        template<typename UpdateWorldTemplateRequestT = Model::UpdateWorldTemplateRequest>
        Model::UpdateWorldTemplateOutcomeCallable UpdateWorldTemplateCallable(const UpdateWorldTemplateRequestT& request) const
        {
            return SubmitCallable(&RoboMakerClient::UpdateWorldTemplate, request);
        }
 
        template<typename UpdateWorldTemplateRequestT = Model::UpdateWorldTemplateRequest>
        void UpdateWorldTemplateAsync(const UpdateWorldTemplateRequestT& request, const UpdateWorldTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&RoboMakerClient::UpdateWorldTemplate, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<RoboMakerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<RoboMakerClient>;
      void init(const RoboMakerClientConfiguration& clientConfiguration);
 
      RoboMakerClientConfiguration m_clientConfiguration;
      std::shared_ptr<RoboMakerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace RoboMaker
} // namespace Aws