BatchClient.h

 
#pragma once
#include <aws/batch/BatchPaginationBase.h>
#include <aws/batch/BatchServiceClientModel.h>
#include <aws/batch/BatchWaiter.h>
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace Batch {
class AWS_BATCH_API BatchClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<BatchClient>,
                                  public BatchPaginationBase<BatchClient>,
                                  public BatchWaiter<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::CancelJobsOutcome CancelJobs(const Model::CancelJobsRequest& request) const;
 
  template <typename CancelJobsRequestT = Model::CancelJobsRequest>
  Model::CancelJobsOutcomeCallable CancelJobsCallable(const CancelJobsRequestT& request) const {
    return SubmitCallable(&BatchClient::CancelJobs, request);
  }
 
  template <typename CancelJobsRequestT = Model::CancelJobsRequest>
  void CancelJobsAsync(const CancelJobsRequestT& request, const CancelJobsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::CancelJobs, 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::CreateQuotaShareOutcome CreateQuotaShare(const Model::CreateQuotaShareRequest& request) const;
 
  template <typename CreateQuotaShareRequestT = Model::CreateQuotaShareRequest>
  Model::CreateQuotaShareOutcomeCallable CreateQuotaShareCallable(const CreateQuotaShareRequestT& request) const {
    return SubmitCallable(&BatchClient::CreateQuotaShare, request);
  }
 
  template <typename CreateQuotaShareRequestT = Model::CreateQuotaShareRequest>
  void CreateQuotaShareAsync(const CreateQuotaShareRequestT& request, const CreateQuotaShareResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::CreateQuotaShare, 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::DeleteQuotaShareOutcome DeleteQuotaShare(const Model::DeleteQuotaShareRequest& request) const;
 
  template <typename DeleteQuotaShareRequestT = Model::DeleteQuotaShareRequest>
  Model::DeleteQuotaShareOutcomeCallable DeleteQuotaShareCallable(const DeleteQuotaShareRequestT& request) const {
    return SubmitCallable(&BatchClient::DeleteQuotaShare, request);
  }
 
  template <typename DeleteQuotaShareRequestT = Model::DeleteQuotaShareRequest>
  void DeleteQuotaShareAsync(const DeleteQuotaShareRequestT& request, const DeleteQuotaShareResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::DeleteQuotaShare, 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::DescribeQuotaShareOutcome DescribeQuotaShare(const Model::DescribeQuotaShareRequest& request) const;
 
  template <typename DescribeQuotaShareRequestT = Model::DescribeQuotaShareRequest>
  Model::DescribeQuotaShareOutcomeCallable DescribeQuotaShareCallable(const DescribeQuotaShareRequestT& request) const {
    return SubmitCallable(&BatchClient::DescribeQuotaShare, request);
  }
 
  template <typename DescribeQuotaShareRequestT = Model::DescribeQuotaShareRequest>
  void DescribeQuotaShareAsync(const DescribeQuotaShareRequestT& request, const DescribeQuotaShareResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::DescribeQuotaShare, 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::ListQuotaSharesOutcome ListQuotaShares(const Model::ListQuotaSharesRequest& request) const;
 
  template <typename ListQuotaSharesRequestT = Model::ListQuotaSharesRequest>
  Model::ListQuotaSharesOutcomeCallable ListQuotaSharesCallable(const ListQuotaSharesRequestT& request) const {
    return SubmitCallable(&BatchClient::ListQuotaShares, request);
  }
 
  template <typename ListQuotaSharesRequestT = Model::ListQuotaSharesRequest>
  void ListQuotaSharesAsync(const ListQuotaSharesRequestT& request, const ListQuotaSharesResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::ListQuotaShares, 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::TerminateJobsOutcome TerminateJobs(const Model::TerminateJobsRequest& request) const;
 
  template <typename TerminateJobsRequestT = Model::TerminateJobsRequest>
  Model::TerminateJobsOutcomeCallable TerminateJobsCallable(const TerminateJobsRequestT& request) const {
    return SubmitCallable(&BatchClient::TerminateJobs, request);
  }
 
  template <typename TerminateJobsRequestT = Model::TerminateJobsRequest>
  void TerminateJobsAsync(const TerminateJobsRequestT& request, const TerminateJobsResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::TerminateJobs, 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::TerminateServiceJobsOutcome TerminateServiceJobs(const Model::TerminateServiceJobsRequest& request) const;
 
  template <typename TerminateServiceJobsRequestT = Model::TerminateServiceJobsRequest>
  Model::TerminateServiceJobsOutcomeCallable TerminateServiceJobsCallable(const TerminateServiceJobsRequestT& request) const {
    return SubmitCallable(&BatchClient::TerminateServiceJobs, request);
  }
 
  template <typename TerminateServiceJobsRequestT = Model::TerminateServiceJobsRequest>
  void TerminateServiceJobsAsync(const TerminateServiceJobsRequestT& request, const TerminateServiceJobsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::TerminateServiceJobs, 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::UpdateQuotaShareOutcome UpdateQuotaShare(const Model::UpdateQuotaShareRequest& request) const;
 
  template <typename UpdateQuotaShareRequestT = Model::UpdateQuotaShareRequest>
  Model::UpdateQuotaShareOutcomeCallable UpdateQuotaShareCallable(const UpdateQuotaShareRequestT& request) const {
    return SubmitCallable(&BatchClient::UpdateQuotaShare, request);
  }
 
  template <typename UpdateQuotaShareRequestT = Model::UpdateQuotaShareRequest>
  void UpdateQuotaShareAsync(const UpdateQuotaShareRequestT& request, const UpdateQuotaShareResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::UpdateQuotaShare, 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);
  }
 
  virtual Model::UpdateServiceJobOutcome UpdateServiceJob(const Model::UpdateServiceJobRequest& request) const;
 
  template <typename UpdateServiceJobRequestT = Model::UpdateServiceJobRequest>
  Model::UpdateServiceJobOutcomeCallable UpdateServiceJobCallable(const UpdateServiceJobRequestT& request) const {
    return SubmitCallable(&BatchClient::UpdateServiceJob, request);
  }
 
  template <typename UpdateServiceJobRequestT = Model::UpdateServiceJobRequest>
  void UpdateServiceJobAsync(const UpdateServiceJobRequestT& request, const UpdateServiceJobResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&BatchClient::UpdateServiceJob, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<BatchEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<BatchClient>;
  void init(const BatchClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, BatchError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  BatchClientConfiguration m_clientConfiguration;
  std::shared_ptr<BatchEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Batch
}  // namespace Aws