BatchClient.h

 
#pragma once
#include <aws/batch/Batch_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/batch/BatchServiceClientModel.h>
 
namespace Aws
{
namespace Batch
{
  class AWS_BATCH_API BatchClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BatchClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BatchClientConfiguration ClientConfigurationType;
      typedef BatchEndpointProvider EndpointProviderType;
 
        BatchClient(const Aws::Batch::BatchClientConfiguration& clientConfiguration = Aws::Batch::BatchClientConfiguration(),
                    std::shared_ptr<BatchEndpointProviderBase> endpointProvider = nullptr);
 
        BatchClient(const Aws::Auth::AWSCredentials& credentials,
                    std::shared_ptr<BatchEndpointProviderBase> endpointProvider = nullptr,
                    const Aws::Batch::BatchClientConfiguration& clientConfiguration = Aws::Batch::BatchClientConfiguration());
 
        BatchClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    std::shared_ptr<BatchEndpointProviderBase> endpointProvider = nullptr,
                    const Aws::Batch::BatchClientConfiguration& clientConfiguration = Aws::Batch::BatchClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BatchClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BatchClient(const Aws::Auth::AWSCredentials& credentials,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BatchClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                    const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BatchClient();
 
        virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const;
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const
        {
            return SubmitCallable(&BatchClient::CancelJob, request);
        }
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        void CancelJobAsync(const CancelJobRequestT& request, const CancelJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::CancelJob, request, handler, context);
        }
 
        virtual Model::CreateComputeEnvironmentOutcome CreateComputeEnvironment(const Model::CreateComputeEnvironmentRequest& request) const;
 
        template<typename CreateComputeEnvironmentRequestT = Model::CreateComputeEnvironmentRequest>
        Model::CreateComputeEnvironmentOutcomeCallable CreateComputeEnvironmentCallable(const CreateComputeEnvironmentRequestT& request) const
        {
            return SubmitCallable(&BatchClient::CreateComputeEnvironment, request);
        }
 
        template<typename CreateComputeEnvironmentRequestT = Model::CreateComputeEnvironmentRequest>
        void CreateComputeEnvironmentAsync(const CreateComputeEnvironmentRequestT& request, const CreateComputeEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::CreateComputeEnvironment, request, handler, context);
        }
 
        virtual Model::CreateConsumableResourceOutcome CreateConsumableResource(const Model::CreateConsumableResourceRequest& request) const;
 
        template<typename CreateConsumableResourceRequestT = Model::CreateConsumableResourceRequest>
        Model::CreateConsumableResourceOutcomeCallable CreateConsumableResourceCallable(const CreateConsumableResourceRequestT& request) const
        {
            return SubmitCallable(&BatchClient::CreateConsumableResource, request);
        }
 
        template<typename CreateConsumableResourceRequestT = Model::CreateConsumableResourceRequest>
        void CreateConsumableResourceAsync(const CreateConsumableResourceRequestT& request, const CreateConsumableResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::CreateConsumableResource, request, handler, context);
        }
 
        virtual Model::CreateJobQueueOutcome CreateJobQueue(const Model::CreateJobQueueRequest& request) const;
 
        template<typename CreateJobQueueRequestT = Model::CreateJobQueueRequest>
        Model::CreateJobQueueOutcomeCallable CreateJobQueueCallable(const CreateJobQueueRequestT& request) const
        {
            return SubmitCallable(&BatchClient::CreateJobQueue, request);
        }
 
        template<typename CreateJobQueueRequestT = Model::CreateJobQueueRequest>
        void CreateJobQueueAsync(const CreateJobQueueRequestT& request, const CreateJobQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::CreateJobQueue, request, handler, context);
        }
 
        virtual Model::CreateSchedulingPolicyOutcome CreateSchedulingPolicy(const Model::CreateSchedulingPolicyRequest& request) const;
 
        template<typename CreateSchedulingPolicyRequestT = Model::CreateSchedulingPolicyRequest>
        Model::CreateSchedulingPolicyOutcomeCallable CreateSchedulingPolicyCallable(const CreateSchedulingPolicyRequestT& request) const
        {
            return SubmitCallable(&BatchClient::CreateSchedulingPolicy, request);
        }
 
        template<typename CreateSchedulingPolicyRequestT = Model::CreateSchedulingPolicyRequest>
        void CreateSchedulingPolicyAsync(const CreateSchedulingPolicyRequestT& request, const CreateSchedulingPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::CreateSchedulingPolicy, request, handler, context);
        }
 
        virtual Model::CreateServiceEnvironmentOutcome CreateServiceEnvironment(const Model::CreateServiceEnvironmentRequest& request) const;
 
        template<typename CreateServiceEnvironmentRequestT = Model::CreateServiceEnvironmentRequest>
        Model::CreateServiceEnvironmentOutcomeCallable CreateServiceEnvironmentCallable(const CreateServiceEnvironmentRequestT& request) const
        {
            return SubmitCallable(&BatchClient::CreateServiceEnvironment, request);
        }
 
        template<typename CreateServiceEnvironmentRequestT = Model::CreateServiceEnvironmentRequest>
        void CreateServiceEnvironmentAsync(const CreateServiceEnvironmentRequestT& request, const CreateServiceEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::CreateServiceEnvironment, request, handler, context);
        }
 
        virtual Model::DeleteComputeEnvironmentOutcome DeleteComputeEnvironment(const Model::DeleteComputeEnvironmentRequest& request) const;
 
        template<typename DeleteComputeEnvironmentRequestT = Model::DeleteComputeEnvironmentRequest>
        Model::DeleteComputeEnvironmentOutcomeCallable DeleteComputeEnvironmentCallable(const DeleteComputeEnvironmentRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DeleteComputeEnvironment, request);
        }
 
        template<typename DeleteComputeEnvironmentRequestT = Model::DeleteComputeEnvironmentRequest>
        void DeleteComputeEnvironmentAsync(const DeleteComputeEnvironmentRequestT& request, const DeleteComputeEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DeleteComputeEnvironment, request, handler, context);
        }
 
        virtual Model::DeleteConsumableResourceOutcome DeleteConsumableResource(const Model::DeleteConsumableResourceRequest& request) const;
 
        template<typename DeleteConsumableResourceRequestT = Model::DeleteConsumableResourceRequest>
        Model::DeleteConsumableResourceOutcomeCallable DeleteConsumableResourceCallable(const DeleteConsumableResourceRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DeleteConsumableResource, request);
        }
 
        template<typename DeleteConsumableResourceRequestT = Model::DeleteConsumableResourceRequest>
        void DeleteConsumableResourceAsync(const DeleteConsumableResourceRequestT& request, const DeleteConsumableResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DeleteConsumableResource, request, handler, context);
        }
 
        virtual Model::DeleteJobQueueOutcome DeleteJobQueue(const Model::DeleteJobQueueRequest& request) const;
 
        template<typename DeleteJobQueueRequestT = Model::DeleteJobQueueRequest>
        Model::DeleteJobQueueOutcomeCallable DeleteJobQueueCallable(const DeleteJobQueueRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DeleteJobQueue, request);
        }
 
        template<typename DeleteJobQueueRequestT = Model::DeleteJobQueueRequest>
        void DeleteJobQueueAsync(const DeleteJobQueueRequestT& request, const DeleteJobQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DeleteJobQueue, request, handler, context);
        }
 
        virtual Model::DeleteSchedulingPolicyOutcome DeleteSchedulingPolicy(const Model::DeleteSchedulingPolicyRequest& request) const;
 
        template<typename DeleteSchedulingPolicyRequestT = Model::DeleteSchedulingPolicyRequest>
        Model::DeleteSchedulingPolicyOutcomeCallable DeleteSchedulingPolicyCallable(const DeleteSchedulingPolicyRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DeleteSchedulingPolicy, request);
        }
 
        template<typename DeleteSchedulingPolicyRequestT = Model::DeleteSchedulingPolicyRequest>
        void DeleteSchedulingPolicyAsync(const DeleteSchedulingPolicyRequestT& request, const DeleteSchedulingPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DeleteSchedulingPolicy, request, handler, context);
        }
 
        virtual Model::DeleteServiceEnvironmentOutcome DeleteServiceEnvironment(const Model::DeleteServiceEnvironmentRequest& request) const;
 
        template<typename DeleteServiceEnvironmentRequestT = Model::DeleteServiceEnvironmentRequest>
        Model::DeleteServiceEnvironmentOutcomeCallable DeleteServiceEnvironmentCallable(const DeleteServiceEnvironmentRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DeleteServiceEnvironment, request);
        }
 
        template<typename DeleteServiceEnvironmentRequestT = Model::DeleteServiceEnvironmentRequest>
        void DeleteServiceEnvironmentAsync(const DeleteServiceEnvironmentRequestT& request, const DeleteServiceEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DeleteServiceEnvironment, request, handler, context);
        }
 
        virtual Model::DeregisterJobDefinitionOutcome DeregisterJobDefinition(const Model::DeregisterJobDefinitionRequest& request) const;
 
        template<typename DeregisterJobDefinitionRequestT = Model::DeregisterJobDefinitionRequest>
        Model::DeregisterJobDefinitionOutcomeCallable DeregisterJobDefinitionCallable(const DeregisterJobDefinitionRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DeregisterJobDefinition, request);
        }
 
        template<typename DeregisterJobDefinitionRequestT = Model::DeregisterJobDefinitionRequest>
        void DeregisterJobDefinitionAsync(const DeregisterJobDefinitionRequestT& request, const DeregisterJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DeregisterJobDefinition, request, handler, context);
        }
 
        virtual Model::DescribeComputeEnvironmentsOutcome DescribeComputeEnvironments(const Model::DescribeComputeEnvironmentsRequest& request = {}) const;
 
        template<typename DescribeComputeEnvironmentsRequestT = Model::DescribeComputeEnvironmentsRequest>
        Model::DescribeComputeEnvironmentsOutcomeCallable DescribeComputeEnvironmentsCallable(const DescribeComputeEnvironmentsRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::DescribeComputeEnvironments, request);
        }
 
        template<typename DescribeComputeEnvironmentsRequestT = Model::DescribeComputeEnvironmentsRequest>
        void DescribeComputeEnvironmentsAsync(const DescribeComputeEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeComputeEnvironmentsRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::DescribeComputeEnvironments, request, handler, context);
        }
 
        virtual Model::DescribeConsumableResourceOutcome DescribeConsumableResource(const Model::DescribeConsumableResourceRequest& request) const;
 
        template<typename DescribeConsumableResourceRequestT = Model::DescribeConsumableResourceRequest>
        Model::DescribeConsumableResourceOutcomeCallable DescribeConsumableResourceCallable(const DescribeConsumableResourceRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DescribeConsumableResource, request);
        }
 
        template<typename DescribeConsumableResourceRequestT = Model::DescribeConsumableResourceRequest>
        void DescribeConsumableResourceAsync(const DescribeConsumableResourceRequestT& request, const DescribeConsumableResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DescribeConsumableResource, request, handler, context);
        }
 
        virtual Model::DescribeJobDefinitionsOutcome DescribeJobDefinitions(const Model::DescribeJobDefinitionsRequest& request = {}) const;
 
        template<typename DescribeJobDefinitionsRequestT = Model::DescribeJobDefinitionsRequest>
        Model::DescribeJobDefinitionsOutcomeCallable DescribeJobDefinitionsCallable(const DescribeJobDefinitionsRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::DescribeJobDefinitions, request);
        }
 
        template<typename DescribeJobDefinitionsRequestT = Model::DescribeJobDefinitionsRequest>
        void DescribeJobDefinitionsAsync(const DescribeJobDefinitionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeJobDefinitionsRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::DescribeJobDefinitions, request, handler, context);
        }
 
        virtual Model::DescribeJobQueuesOutcome DescribeJobQueues(const Model::DescribeJobQueuesRequest& request = {}) const;
 
        template<typename DescribeJobQueuesRequestT = Model::DescribeJobQueuesRequest>
        Model::DescribeJobQueuesOutcomeCallable DescribeJobQueuesCallable(const DescribeJobQueuesRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::DescribeJobQueues, request);
        }
 
        template<typename DescribeJobQueuesRequestT = Model::DescribeJobQueuesRequest>
        void DescribeJobQueuesAsync(const DescribeJobQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeJobQueuesRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::DescribeJobQueues, request, handler, context);
        }
 
        virtual Model::DescribeJobsOutcome DescribeJobs(const Model::DescribeJobsRequest& request) const;
 
        template<typename DescribeJobsRequestT = Model::DescribeJobsRequest>
        Model::DescribeJobsOutcomeCallable DescribeJobsCallable(const DescribeJobsRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DescribeJobs, request);
        }
 
        template<typename DescribeJobsRequestT = Model::DescribeJobsRequest>
        void DescribeJobsAsync(const DescribeJobsRequestT& request, const DescribeJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DescribeJobs, request, handler, context);
        }
 
        virtual Model::DescribeSchedulingPoliciesOutcome DescribeSchedulingPolicies(const Model::DescribeSchedulingPoliciesRequest& request) const;
 
        template<typename DescribeSchedulingPoliciesRequestT = Model::DescribeSchedulingPoliciesRequest>
        Model::DescribeSchedulingPoliciesOutcomeCallable DescribeSchedulingPoliciesCallable(const DescribeSchedulingPoliciesRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DescribeSchedulingPolicies, request);
        }
 
        template<typename DescribeSchedulingPoliciesRequestT = Model::DescribeSchedulingPoliciesRequest>
        void DescribeSchedulingPoliciesAsync(const DescribeSchedulingPoliciesRequestT& request, const DescribeSchedulingPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DescribeSchedulingPolicies, request, handler, context);
        }
 
        virtual Model::DescribeServiceEnvironmentsOutcome DescribeServiceEnvironments(const Model::DescribeServiceEnvironmentsRequest& request = {}) const;
 
        template<typename DescribeServiceEnvironmentsRequestT = Model::DescribeServiceEnvironmentsRequest>
        Model::DescribeServiceEnvironmentsOutcomeCallable DescribeServiceEnvironmentsCallable(const DescribeServiceEnvironmentsRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::DescribeServiceEnvironments, request);
        }
 
        template<typename DescribeServiceEnvironmentsRequestT = Model::DescribeServiceEnvironmentsRequest>
        void DescribeServiceEnvironmentsAsync(const DescribeServiceEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeServiceEnvironmentsRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::DescribeServiceEnvironments, request, handler, context);
        }
 
        virtual Model::DescribeServiceJobOutcome DescribeServiceJob(const Model::DescribeServiceJobRequest& request) const;
 
        template<typename DescribeServiceJobRequestT = Model::DescribeServiceJobRequest>
        Model::DescribeServiceJobOutcomeCallable DescribeServiceJobCallable(const DescribeServiceJobRequestT& request) const
        {
            return SubmitCallable(&BatchClient::DescribeServiceJob, request);
        }
 
        template<typename DescribeServiceJobRequestT = Model::DescribeServiceJobRequest>
        void DescribeServiceJobAsync(const DescribeServiceJobRequestT& request, const DescribeServiceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::DescribeServiceJob, request, handler, context);
        }
 
        virtual Model::GetJobQueueSnapshotOutcome GetJobQueueSnapshot(const Model::GetJobQueueSnapshotRequest& request) const;
 
        template<typename GetJobQueueSnapshotRequestT = Model::GetJobQueueSnapshotRequest>
        Model::GetJobQueueSnapshotOutcomeCallable GetJobQueueSnapshotCallable(const GetJobQueueSnapshotRequestT& request) const
        {
            return SubmitCallable(&BatchClient::GetJobQueueSnapshot, request);
        }
 
        template<typename GetJobQueueSnapshotRequestT = Model::GetJobQueueSnapshotRequest>
        void GetJobQueueSnapshotAsync(const GetJobQueueSnapshotRequestT& request, const GetJobQueueSnapshotResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::GetJobQueueSnapshot, request, handler, context);
        }
 
        virtual Model::ListConsumableResourcesOutcome ListConsumableResources(const Model::ListConsumableResourcesRequest& request = {}) const;
 
        template<typename ListConsumableResourcesRequestT = Model::ListConsumableResourcesRequest>
        Model::ListConsumableResourcesOutcomeCallable ListConsumableResourcesCallable(const ListConsumableResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::ListConsumableResources, request);
        }
 
        template<typename ListConsumableResourcesRequestT = Model::ListConsumableResourcesRequest>
        void ListConsumableResourcesAsync(const ListConsumableResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListConsumableResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::ListConsumableResources, request, handler, context);
        }
 
        virtual Model::ListJobsOutcome ListJobs(const Model::ListJobsRequest& request = {}) const;
 
        template<typename ListJobsRequestT = Model::ListJobsRequest>
        Model::ListJobsOutcomeCallable ListJobsCallable(const ListJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::ListJobs, request);
        }
 
        template<typename ListJobsRequestT = Model::ListJobsRequest>
        void ListJobsAsync(const ListJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::ListJobs, request, handler, context);
        }
 
        virtual Model::ListJobsByConsumableResourceOutcome ListJobsByConsumableResource(const Model::ListJobsByConsumableResourceRequest& request) const;
 
        template<typename ListJobsByConsumableResourceRequestT = Model::ListJobsByConsumableResourceRequest>
        Model::ListJobsByConsumableResourceOutcomeCallable ListJobsByConsumableResourceCallable(const ListJobsByConsumableResourceRequestT& request) const
        {
            return SubmitCallable(&BatchClient::ListJobsByConsumableResource, request);
        }
 
        template<typename ListJobsByConsumableResourceRequestT = Model::ListJobsByConsumableResourceRequest>
        void ListJobsByConsumableResourceAsync(const ListJobsByConsumableResourceRequestT& request, const ListJobsByConsumableResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::ListJobsByConsumableResource, request, handler, context);
        }
 
        virtual Model::ListSchedulingPoliciesOutcome ListSchedulingPolicies(const Model::ListSchedulingPoliciesRequest& request = {}) const;
 
        template<typename ListSchedulingPoliciesRequestT = Model::ListSchedulingPoliciesRequest>
        Model::ListSchedulingPoliciesOutcomeCallable ListSchedulingPoliciesCallable(const ListSchedulingPoliciesRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::ListSchedulingPolicies, request);
        }
 
        template<typename ListSchedulingPoliciesRequestT = Model::ListSchedulingPoliciesRequest>
        void ListSchedulingPoliciesAsync(const ListSchedulingPoliciesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSchedulingPoliciesRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::ListSchedulingPolicies, request, handler, context);
        }
 
        virtual Model::ListServiceJobsOutcome ListServiceJobs(const Model::ListServiceJobsRequest& request = {}) const;
 
        template<typename ListServiceJobsRequestT = Model::ListServiceJobsRequest>
        Model::ListServiceJobsOutcomeCallable ListServiceJobsCallable(const ListServiceJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BatchClient::ListServiceJobs, request);
        }
 
        template<typename ListServiceJobsRequestT = Model::ListServiceJobsRequest>
        void ListServiceJobsAsync(const ListServiceJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BatchClient::ListServiceJobs, 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(&BatchClient::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(&BatchClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::RegisterJobDefinitionOutcome RegisterJobDefinition(const Model::RegisterJobDefinitionRequest& request) const;
 
        template<typename RegisterJobDefinitionRequestT = Model::RegisterJobDefinitionRequest>
        Model::RegisterJobDefinitionOutcomeCallable RegisterJobDefinitionCallable(const RegisterJobDefinitionRequestT& request) const
        {
            return SubmitCallable(&BatchClient::RegisterJobDefinition, request);
        }
 
        template<typename RegisterJobDefinitionRequestT = Model::RegisterJobDefinitionRequest>
        void RegisterJobDefinitionAsync(const RegisterJobDefinitionRequestT& request, const RegisterJobDefinitionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::RegisterJobDefinition, request, handler, context);
        }
 
        virtual Model::SubmitJobOutcome SubmitJob(const Model::SubmitJobRequest& request) const;
 
        template<typename SubmitJobRequestT = Model::SubmitJobRequest>
        Model::SubmitJobOutcomeCallable SubmitJobCallable(const SubmitJobRequestT& request) const
        {
            return SubmitCallable(&BatchClient::SubmitJob, request);
        }
 
        template<typename SubmitJobRequestT = Model::SubmitJobRequest>
        void SubmitJobAsync(const SubmitJobRequestT& request, const SubmitJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::SubmitJob, request, handler, context);
        }
 
        virtual Model::SubmitServiceJobOutcome SubmitServiceJob(const Model::SubmitServiceJobRequest& request) const;
 
        template<typename SubmitServiceJobRequestT = Model::SubmitServiceJobRequest>
        Model::SubmitServiceJobOutcomeCallable SubmitServiceJobCallable(const SubmitServiceJobRequestT& request) const
        {
            return SubmitCallable(&BatchClient::SubmitServiceJob, request);
        }
 
        template<typename SubmitServiceJobRequestT = Model::SubmitServiceJobRequest>
        void SubmitServiceJobAsync(const SubmitServiceJobRequestT& request, const SubmitServiceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::SubmitServiceJob, 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(&BatchClient::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(&BatchClient::TagResource, request, handler, context);
        }
 
        virtual Model::TerminateJobOutcome TerminateJob(const Model::TerminateJobRequest& request) const;
 
        template<typename TerminateJobRequestT = Model::TerminateJobRequest>
        Model::TerminateJobOutcomeCallable TerminateJobCallable(const TerminateJobRequestT& request) const
        {
            return SubmitCallable(&BatchClient::TerminateJob, request);
        }
 
        template<typename TerminateJobRequestT = Model::TerminateJobRequest>
        void TerminateJobAsync(const TerminateJobRequestT& request, const TerminateJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::TerminateJob, request, handler, context);
        }
 
        virtual Model::TerminateServiceJobOutcome TerminateServiceJob(const Model::TerminateServiceJobRequest& request) const;
 
        template<typename TerminateServiceJobRequestT = Model::TerminateServiceJobRequest>
        Model::TerminateServiceJobOutcomeCallable TerminateServiceJobCallable(const TerminateServiceJobRequestT& request) const
        {
            return SubmitCallable(&BatchClient::TerminateServiceJob, request);
        }
 
        template<typename TerminateServiceJobRequestT = Model::TerminateServiceJobRequest>
        void TerminateServiceJobAsync(const TerminateServiceJobRequestT& request, const TerminateServiceJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::TerminateServiceJob, 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(&BatchClient::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(&BatchClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateComputeEnvironmentOutcome UpdateComputeEnvironment(const Model::UpdateComputeEnvironmentRequest& request) const;
 
        template<typename UpdateComputeEnvironmentRequestT = Model::UpdateComputeEnvironmentRequest>
        Model::UpdateComputeEnvironmentOutcomeCallable UpdateComputeEnvironmentCallable(const UpdateComputeEnvironmentRequestT& request) const
        {
            return SubmitCallable(&BatchClient::UpdateComputeEnvironment, request);
        }
 
        template<typename UpdateComputeEnvironmentRequestT = Model::UpdateComputeEnvironmentRequest>
        void UpdateComputeEnvironmentAsync(const UpdateComputeEnvironmentRequestT& request, const UpdateComputeEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::UpdateComputeEnvironment, request, handler, context);
        }
 
        virtual Model::UpdateConsumableResourceOutcome UpdateConsumableResource(const Model::UpdateConsumableResourceRequest& request) const;
 
        template<typename UpdateConsumableResourceRequestT = Model::UpdateConsumableResourceRequest>
        Model::UpdateConsumableResourceOutcomeCallable UpdateConsumableResourceCallable(const UpdateConsumableResourceRequestT& request) const
        {
            return SubmitCallable(&BatchClient::UpdateConsumableResource, request);
        }
 
        template<typename UpdateConsumableResourceRequestT = Model::UpdateConsumableResourceRequest>
        void UpdateConsumableResourceAsync(const UpdateConsumableResourceRequestT& request, const UpdateConsumableResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::UpdateConsumableResource, request, handler, context);
        }
 
        virtual Model::UpdateJobQueueOutcome UpdateJobQueue(const Model::UpdateJobQueueRequest& request) const;
 
        template<typename UpdateJobQueueRequestT = Model::UpdateJobQueueRequest>
        Model::UpdateJobQueueOutcomeCallable UpdateJobQueueCallable(const UpdateJobQueueRequestT& request) const
        {
            return SubmitCallable(&BatchClient::UpdateJobQueue, request);
        }
 
        template<typename UpdateJobQueueRequestT = Model::UpdateJobQueueRequest>
        void UpdateJobQueueAsync(const UpdateJobQueueRequestT& request, const UpdateJobQueueResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::UpdateJobQueue, request, handler, context);
        }
 
        virtual Model::UpdateSchedulingPolicyOutcome UpdateSchedulingPolicy(const Model::UpdateSchedulingPolicyRequest& request) const;
 
        template<typename UpdateSchedulingPolicyRequestT = Model::UpdateSchedulingPolicyRequest>
        Model::UpdateSchedulingPolicyOutcomeCallable UpdateSchedulingPolicyCallable(const UpdateSchedulingPolicyRequestT& request) const
        {
            return SubmitCallable(&BatchClient::UpdateSchedulingPolicy, request);
        }
 
        template<typename UpdateSchedulingPolicyRequestT = Model::UpdateSchedulingPolicyRequest>
        void UpdateSchedulingPolicyAsync(const UpdateSchedulingPolicyRequestT& request, const UpdateSchedulingPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::UpdateSchedulingPolicy, request, handler, context);
        }
 
        virtual Model::UpdateServiceEnvironmentOutcome UpdateServiceEnvironment(const Model::UpdateServiceEnvironmentRequest& request) const;
 
        template<typename UpdateServiceEnvironmentRequestT = Model::UpdateServiceEnvironmentRequest>
        Model::UpdateServiceEnvironmentOutcomeCallable UpdateServiceEnvironmentCallable(const UpdateServiceEnvironmentRequestT& request) const
        {
            return SubmitCallable(&BatchClient::UpdateServiceEnvironment, request);
        }
 
        template<typename UpdateServiceEnvironmentRequestT = Model::UpdateServiceEnvironmentRequest>
        void UpdateServiceEnvironmentAsync(const UpdateServiceEnvironmentRequestT& request, const UpdateServiceEnvironmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BatchClient::UpdateServiceEnvironment, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BatchEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BatchClient>;
      void init(const BatchClientConfiguration& clientConfiguration);
 
      BatchClientConfiguration m_clientConfiguration;
      std::shared_ptr<BatchEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Batch
} // namespace Aws