DeadlineClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/deadline/DeadlineServiceClientModel.h>
#include <aws/deadline/Deadline_EXPORTS.h>
 
namespace Aws {
namespace deadline {
class AWS_DEADLINE_API DeadlineClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<DeadlineClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef DeadlineClientConfiguration ClientConfigurationType;
  typedef DeadlineEndpointProvider EndpointProviderType;
 
  DeadlineClient(const Aws::deadline::DeadlineClientConfiguration& clientConfiguration = Aws::deadline::DeadlineClientConfiguration(),
                 std::shared_ptr<DeadlineEndpointProviderBase> endpointProvider = nullptr);
 
  DeadlineClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<DeadlineEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::deadline::DeadlineClientConfiguration& clientConfiguration = Aws::deadline::DeadlineClientConfiguration());
 
  DeadlineClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 std::shared_ptr<DeadlineEndpointProviderBase> endpointProvider = nullptr,
                 const Aws::deadline::DeadlineClientConfiguration& clientConfiguration = Aws::deadline::DeadlineClientConfiguration());
 
  /* Legacy constructors due deprecation */
  DeadlineClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DeadlineClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  DeadlineClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                 const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~DeadlineClient();
 
  virtual Model::AssociateMemberToFarmOutcome AssociateMemberToFarm(const Model::AssociateMemberToFarmRequest& request) const;
 
  template <typename AssociateMemberToFarmRequestT = Model::AssociateMemberToFarmRequest>
  Model::AssociateMemberToFarmOutcomeCallable AssociateMemberToFarmCallable(const AssociateMemberToFarmRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssociateMemberToFarm, request);
  }
 
  template <typename AssociateMemberToFarmRequestT = Model::AssociateMemberToFarmRequest>
  void AssociateMemberToFarmAsync(const AssociateMemberToFarmRequestT& request, const AssociateMemberToFarmResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssociateMemberToFarm, request, handler, context);
  }
 
  virtual Model::AssociateMemberToFleetOutcome AssociateMemberToFleet(const Model::AssociateMemberToFleetRequest& request) const;
 
  template <typename AssociateMemberToFleetRequestT = Model::AssociateMemberToFleetRequest>
  Model::AssociateMemberToFleetOutcomeCallable AssociateMemberToFleetCallable(const AssociateMemberToFleetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssociateMemberToFleet, request);
  }
 
  template <typename AssociateMemberToFleetRequestT = Model::AssociateMemberToFleetRequest>
  void AssociateMemberToFleetAsync(const AssociateMemberToFleetRequestT& request,
                                   const AssociateMemberToFleetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssociateMemberToFleet, request, handler, context);
  }
 
  virtual Model::AssociateMemberToJobOutcome AssociateMemberToJob(const Model::AssociateMemberToJobRequest& request) const;
 
  template <typename AssociateMemberToJobRequestT = Model::AssociateMemberToJobRequest>
  Model::AssociateMemberToJobOutcomeCallable AssociateMemberToJobCallable(const AssociateMemberToJobRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssociateMemberToJob, request);
  }
 
  template <typename AssociateMemberToJobRequestT = Model::AssociateMemberToJobRequest>
  void AssociateMemberToJobAsync(const AssociateMemberToJobRequestT& request, const AssociateMemberToJobResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssociateMemberToJob, request, handler, context);
  }
 
  virtual Model::AssociateMemberToQueueOutcome AssociateMemberToQueue(const Model::AssociateMemberToQueueRequest& request) const;
 
  template <typename AssociateMemberToQueueRequestT = Model::AssociateMemberToQueueRequest>
  Model::AssociateMemberToQueueOutcomeCallable AssociateMemberToQueueCallable(const AssociateMemberToQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssociateMemberToQueue, request);
  }
 
  template <typename AssociateMemberToQueueRequestT = Model::AssociateMemberToQueueRequest>
  void AssociateMemberToQueueAsync(const AssociateMemberToQueueRequestT& request,
                                   const AssociateMemberToQueueResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssociateMemberToQueue, request, handler, context);
  }
 
  virtual Model::AssumeFleetRoleForReadOutcome AssumeFleetRoleForRead(const Model::AssumeFleetRoleForReadRequest& request) const;
 
  template <typename AssumeFleetRoleForReadRequestT = Model::AssumeFleetRoleForReadRequest>
  Model::AssumeFleetRoleForReadOutcomeCallable AssumeFleetRoleForReadCallable(const AssumeFleetRoleForReadRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssumeFleetRoleForRead, request);
  }
 
  template <typename AssumeFleetRoleForReadRequestT = Model::AssumeFleetRoleForReadRequest>
  void AssumeFleetRoleForReadAsync(const AssumeFleetRoleForReadRequestT& request,
                                   const AssumeFleetRoleForReadResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssumeFleetRoleForRead, request, handler, context);
  }
 
  virtual Model::AssumeFleetRoleForWorkerOutcome AssumeFleetRoleForWorker(const Model::AssumeFleetRoleForWorkerRequest& request) const;
 
  template <typename AssumeFleetRoleForWorkerRequestT = Model::AssumeFleetRoleForWorkerRequest>
  Model::AssumeFleetRoleForWorkerOutcomeCallable AssumeFleetRoleForWorkerCallable(const AssumeFleetRoleForWorkerRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssumeFleetRoleForWorker, request);
  }
 
  template <typename AssumeFleetRoleForWorkerRequestT = Model::AssumeFleetRoleForWorkerRequest>
  void AssumeFleetRoleForWorkerAsync(const AssumeFleetRoleForWorkerRequestT& request,
                                     const AssumeFleetRoleForWorkerResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssumeFleetRoleForWorker, request, handler, context);
  }
 
  virtual Model::AssumeQueueRoleForReadOutcome AssumeQueueRoleForRead(const Model::AssumeQueueRoleForReadRequest& request) const;
 
  template <typename AssumeQueueRoleForReadRequestT = Model::AssumeQueueRoleForReadRequest>
  Model::AssumeQueueRoleForReadOutcomeCallable AssumeQueueRoleForReadCallable(const AssumeQueueRoleForReadRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssumeQueueRoleForRead, request);
  }
 
  template <typename AssumeQueueRoleForReadRequestT = Model::AssumeQueueRoleForReadRequest>
  void AssumeQueueRoleForReadAsync(const AssumeQueueRoleForReadRequestT& request,
                                   const AssumeQueueRoleForReadResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssumeQueueRoleForRead, request, handler, context);
  }
 
  virtual Model::AssumeQueueRoleForUserOutcome AssumeQueueRoleForUser(const Model::AssumeQueueRoleForUserRequest& request) const;
 
  template <typename AssumeQueueRoleForUserRequestT = Model::AssumeQueueRoleForUserRequest>
  Model::AssumeQueueRoleForUserOutcomeCallable AssumeQueueRoleForUserCallable(const AssumeQueueRoleForUserRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssumeQueueRoleForUser, request);
  }
 
  template <typename AssumeQueueRoleForUserRequestT = Model::AssumeQueueRoleForUserRequest>
  void AssumeQueueRoleForUserAsync(const AssumeQueueRoleForUserRequestT& request,
                                   const AssumeQueueRoleForUserResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssumeQueueRoleForUser, request, handler, context);
  }
 
  virtual Model::AssumeQueueRoleForWorkerOutcome AssumeQueueRoleForWorker(const Model::AssumeQueueRoleForWorkerRequest& request) const;
 
  template <typename AssumeQueueRoleForWorkerRequestT = Model::AssumeQueueRoleForWorkerRequest>
  Model::AssumeQueueRoleForWorkerOutcomeCallable AssumeQueueRoleForWorkerCallable(const AssumeQueueRoleForWorkerRequestT& request) const {
    return SubmitCallable(&DeadlineClient::AssumeQueueRoleForWorker, request);
  }
 
  template <typename AssumeQueueRoleForWorkerRequestT = Model::AssumeQueueRoleForWorkerRequest>
  void AssumeQueueRoleForWorkerAsync(const AssumeQueueRoleForWorkerRequestT& request,
                                     const AssumeQueueRoleForWorkerResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::AssumeQueueRoleForWorker, request, handler, context);
  }
 
  virtual Model::BatchGetJobEntityOutcome BatchGetJobEntity(const Model::BatchGetJobEntityRequest& request) const;
 
  template <typename BatchGetJobEntityRequestT = Model::BatchGetJobEntityRequest>
  Model::BatchGetJobEntityOutcomeCallable BatchGetJobEntityCallable(const BatchGetJobEntityRequestT& request) const {
    return SubmitCallable(&DeadlineClient::BatchGetJobEntity, request);
  }
 
  template <typename BatchGetJobEntityRequestT = Model::BatchGetJobEntityRequest>
  void BatchGetJobEntityAsync(const BatchGetJobEntityRequestT& request, const BatchGetJobEntityResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::BatchGetJobEntity, request, handler, context);
  }
 
  virtual Model::CopyJobTemplateOutcome CopyJobTemplate(const Model::CopyJobTemplateRequest& request) const;
 
  template <typename CopyJobTemplateRequestT = Model::CopyJobTemplateRequest>
  Model::CopyJobTemplateOutcomeCallable CopyJobTemplateCallable(const CopyJobTemplateRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CopyJobTemplate, request);
  }
 
  template <typename CopyJobTemplateRequestT = Model::CopyJobTemplateRequest>
  void CopyJobTemplateAsync(const CopyJobTemplateRequestT& request, const CopyJobTemplateResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CopyJobTemplate, request, handler, context);
  }
 
  virtual Model::CreateBudgetOutcome CreateBudget(const Model::CreateBudgetRequest& request) const;
 
  template <typename CreateBudgetRequestT = Model::CreateBudgetRequest>
  Model::CreateBudgetOutcomeCallable CreateBudgetCallable(const CreateBudgetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateBudget, request);
  }
 
  template <typename CreateBudgetRequestT = Model::CreateBudgetRequest>
  void CreateBudgetAsync(const CreateBudgetRequestT& request, const CreateBudgetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateBudget, request, handler, context);
  }
 
  virtual Model::CreateFarmOutcome CreateFarm(const Model::CreateFarmRequest& request) const;
 
  template <typename CreateFarmRequestT = Model::CreateFarmRequest>
  Model::CreateFarmOutcomeCallable CreateFarmCallable(const CreateFarmRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateFarm, request);
  }
 
  template <typename CreateFarmRequestT = Model::CreateFarmRequest>
  void CreateFarmAsync(const CreateFarmRequestT& request, const CreateFarmResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateFarm, request, handler, context);
  }
 
  virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const;
 
  template <typename CreateFleetRequestT = Model::CreateFleetRequest>
  Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateFleet, request);
  }
 
  template <typename CreateFleetRequestT = Model::CreateFleetRequest>
  void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateFleet, request, handler, context);
  }
 
  virtual Model::CreateJobOutcome CreateJob(const Model::CreateJobRequest& request) const;
 
  template <typename CreateJobRequestT = Model::CreateJobRequest>
  Model::CreateJobOutcomeCallable CreateJobCallable(const CreateJobRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateJob, request);
  }
 
  template <typename CreateJobRequestT = Model::CreateJobRequest>
  void CreateJobAsync(const CreateJobRequestT& request, const CreateJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateJob, request, handler, context);
  }
 
  virtual Model::CreateLicenseEndpointOutcome CreateLicenseEndpoint(const Model::CreateLicenseEndpointRequest& request) const;
 
  template <typename CreateLicenseEndpointRequestT = Model::CreateLicenseEndpointRequest>
  Model::CreateLicenseEndpointOutcomeCallable CreateLicenseEndpointCallable(const CreateLicenseEndpointRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateLicenseEndpoint, request);
  }
 
  template <typename CreateLicenseEndpointRequestT = Model::CreateLicenseEndpointRequest>
  void CreateLicenseEndpointAsync(const CreateLicenseEndpointRequestT& request, const CreateLicenseEndpointResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateLicenseEndpoint, request, handler, context);
  }
 
  virtual Model::CreateLimitOutcome CreateLimit(const Model::CreateLimitRequest& request) const;
 
  template <typename CreateLimitRequestT = Model::CreateLimitRequest>
  Model::CreateLimitOutcomeCallable CreateLimitCallable(const CreateLimitRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateLimit, request);
  }
 
  template <typename CreateLimitRequestT = Model::CreateLimitRequest>
  void CreateLimitAsync(const CreateLimitRequestT& request, const CreateLimitResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateLimit, request, handler, context);
  }
 
  virtual Model::CreateMonitorOutcome CreateMonitor(const Model::CreateMonitorRequest& request) const;
 
  template <typename CreateMonitorRequestT = Model::CreateMonitorRequest>
  Model::CreateMonitorOutcomeCallable CreateMonitorCallable(const CreateMonitorRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateMonitor, request);
  }
 
  template <typename CreateMonitorRequestT = Model::CreateMonitorRequest>
  void CreateMonitorAsync(const CreateMonitorRequestT& request, const CreateMonitorResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateMonitor, request, handler, context);
  }
 
  virtual Model::CreateQueueOutcome CreateQueue(const Model::CreateQueueRequest& request) const;
 
  template <typename CreateQueueRequestT = Model::CreateQueueRequest>
  Model::CreateQueueOutcomeCallable CreateQueueCallable(const CreateQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateQueue, request);
  }
 
  template <typename CreateQueueRequestT = Model::CreateQueueRequest>
  void CreateQueueAsync(const CreateQueueRequestT& request, const CreateQueueResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateQueue, request, handler, context);
  }
 
  virtual Model::CreateQueueEnvironmentOutcome CreateQueueEnvironment(const Model::CreateQueueEnvironmentRequest& request) const;
 
  template <typename CreateQueueEnvironmentRequestT = Model::CreateQueueEnvironmentRequest>
  Model::CreateQueueEnvironmentOutcomeCallable CreateQueueEnvironmentCallable(const CreateQueueEnvironmentRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateQueueEnvironment, request);
  }
 
  template <typename CreateQueueEnvironmentRequestT = Model::CreateQueueEnvironmentRequest>
  void CreateQueueEnvironmentAsync(const CreateQueueEnvironmentRequestT& request,
                                   const CreateQueueEnvironmentResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateQueueEnvironment, request, handler, context);
  }
 
  virtual Model::CreateQueueFleetAssociationOutcome CreateQueueFleetAssociation(
      const Model::CreateQueueFleetAssociationRequest& request) const;
 
  template <typename CreateQueueFleetAssociationRequestT = Model::CreateQueueFleetAssociationRequest>
  Model::CreateQueueFleetAssociationOutcomeCallable CreateQueueFleetAssociationCallable(
      const CreateQueueFleetAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateQueueFleetAssociation, request);
  }
 
  template <typename CreateQueueFleetAssociationRequestT = Model::CreateQueueFleetAssociationRequest>
  void CreateQueueFleetAssociationAsync(const CreateQueueFleetAssociationRequestT& request,
                                        const CreateQueueFleetAssociationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateQueueFleetAssociation, request, handler, context);
  }
 
  virtual Model::CreateQueueLimitAssociationOutcome CreateQueueLimitAssociation(
      const Model::CreateQueueLimitAssociationRequest& request) const;
 
  template <typename CreateQueueLimitAssociationRequestT = Model::CreateQueueLimitAssociationRequest>
  Model::CreateQueueLimitAssociationOutcomeCallable CreateQueueLimitAssociationCallable(
      const CreateQueueLimitAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateQueueLimitAssociation, request);
  }
 
  template <typename CreateQueueLimitAssociationRequestT = Model::CreateQueueLimitAssociationRequest>
  void CreateQueueLimitAssociationAsync(const CreateQueueLimitAssociationRequestT& request,
                                        const CreateQueueLimitAssociationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateQueueLimitAssociation, request, handler, context);
  }
 
  virtual Model::CreateStorageProfileOutcome CreateStorageProfile(const Model::CreateStorageProfileRequest& request) const;
 
  template <typename CreateStorageProfileRequestT = Model::CreateStorageProfileRequest>
  Model::CreateStorageProfileOutcomeCallable CreateStorageProfileCallable(const CreateStorageProfileRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateStorageProfile, request);
  }
 
  template <typename CreateStorageProfileRequestT = Model::CreateStorageProfileRequest>
  void CreateStorageProfileAsync(const CreateStorageProfileRequestT& request, const CreateStorageProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateStorageProfile, request, handler, context);
  }
 
  virtual Model::CreateWorkerOutcome CreateWorker(const Model::CreateWorkerRequest& request) const;
 
  template <typename CreateWorkerRequestT = Model::CreateWorkerRequest>
  Model::CreateWorkerOutcomeCallable CreateWorkerCallable(const CreateWorkerRequestT& request) const {
    return SubmitCallable(&DeadlineClient::CreateWorker, request);
  }
 
  template <typename CreateWorkerRequestT = Model::CreateWorkerRequest>
  void CreateWorkerAsync(const CreateWorkerRequestT& request, const CreateWorkerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::CreateWorker, request, handler, context);
  }
 
  virtual Model::DeleteBudgetOutcome DeleteBudget(const Model::DeleteBudgetRequest& request) const;
 
  template <typename DeleteBudgetRequestT = Model::DeleteBudgetRequest>
  Model::DeleteBudgetOutcomeCallable DeleteBudgetCallable(const DeleteBudgetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteBudget, request);
  }
 
  template <typename DeleteBudgetRequestT = Model::DeleteBudgetRequest>
  void DeleteBudgetAsync(const DeleteBudgetRequestT& request, const DeleteBudgetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteBudget, request, handler, context);
  }
 
  virtual Model::DeleteFarmOutcome DeleteFarm(const Model::DeleteFarmRequest& request) const;
 
  template <typename DeleteFarmRequestT = Model::DeleteFarmRequest>
  Model::DeleteFarmOutcomeCallable DeleteFarmCallable(const DeleteFarmRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteFarm, request);
  }
 
  template <typename DeleteFarmRequestT = Model::DeleteFarmRequest>
  void DeleteFarmAsync(const DeleteFarmRequestT& request, const DeleteFarmResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteFarm, request, handler, context);
  }
 
  virtual Model::DeleteFleetOutcome DeleteFleet(const Model::DeleteFleetRequest& request) const;
 
  template <typename DeleteFleetRequestT = Model::DeleteFleetRequest>
  Model::DeleteFleetOutcomeCallable DeleteFleetCallable(const DeleteFleetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteFleet, request);
  }
 
  template <typename DeleteFleetRequestT = Model::DeleteFleetRequest>
  void DeleteFleetAsync(const DeleteFleetRequestT& request, const DeleteFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteFleet, request, handler, context);
  }
 
  virtual Model::DeleteLicenseEndpointOutcome DeleteLicenseEndpoint(const Model::DeleteLicenseEndpointRequest& request) const;
 
  template <typename DeleteLicenseEndpointRequestT = Model::DeleteLicenseEndpointRequest>
  Model::DeleteLicenseEndpointOutcomeCallable DeleteLicenseEndpointCallable(const DeleteLicenseEndpointRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteLicenseEndpoint, request);
  }
 
  template <typename DeleteLicenseEndpointRequestT = Model::DeleteLicenseEndpointRequest>
  void DeleteLicenseEndpointAsync(const DeleteLicenseEndpointRequestT& request, const DeleteLicenseEndpointResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteLicenseEndpoint, request, handler, context);
  }
 
  virtual Model::DeleteLimitOutcome DeleteLimit(const Model::DeleteLimitRequest& request) const;
 
  template <typename DeleteLimitRequestT = Model::DeleteLimitRequest>
  Model::DeleteLimitOutcomeCallable DeleteLimitCallable(const DeleteLimitRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteLimit, request);
  }
 
  template <typename DeleteLimitRequestT = Model::DeleteLimitRequest>
  void DeleteLimitAsync(const DeleteLimitRequestT& request, const DeleteLimitResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteLimit, request, handler, context);
  }
 
  virtual Model::DeleteMeteredProductOutcome DeleteMeteredProduct(const Model::DeleteMeteredProductRequest& request) const;
 
  template <typename DeleteMeteredProductRequestT = Model::DeleteMeteredProductRequest>
  Model::DeleteMeteredProductOutcomeCallable DeleteMeteredProductCallable(const DeleteMeteredProductRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteMeteredProduct, request);
  }
 
  template <typename DeleteMeteredProductRequestT = Model::DeleteMeteredProductRequest>
  void DeleteMeteredProductAsync(const DeleteMeteredProductRequestT& request, const DeleteMeteredProductResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteMeteredProduct, request, handler, context);
  }
 
  virtual Model::DeleteMonitorOutcome DeleteMonitor(const Model::DeleteMonitorRequest& request) const;
 
  template <typename DeleteMonitorRequestT = Model::DeleteMonitorRequest>
  Model::DeleteMonitorOutcomeCallable DeleteMonitorCallable(const DeleteMonitorRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteMonitor, request);
  }
 
  template <typename DeleteMonitorRequestT = Model::DeleteMonitorRequest>
  void DeleteMonitorAsync(const DeleteMonitorRequestT& request, const DeleteMonitorResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteMonitor, request, handler, context);
  }
 
  virtual Model::DeleteQueueOutcome DeleteQueue(const Model::DeleteQueueRequest& request) const;
 
  template <typename DeleteQueueRequestT = Model::DeleteQueueRequest>
  Model::DeleteQueueOutcomeCallable DeleteQueueCallable(const DeleteQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteQueue, request);
  }
 
  template <typename DeleteQueueRequestT = Model::DeleteQueueRequest>
  void DeleteQueueAsync(const DeleteQueueRequestT& request, const DeleteQueueResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteQueue, request, handler, context);
  }
 
  virtual Model::DeleteQueueEnvironmentOutcome DeleteQueueEnvironment(const Model::DeleteQueueEnvironmentRequest& request) const;
 
  template <typename DeleteQueueEnvironmentRequestT = Model::DeleteQueueEnvironmentRequest>
  Model::DeleteQueueEnvironmentOutcomeCallable DeleteQueueEnvironmentCallable(const DeleteQueueEnvironmentRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteQueueEnvironment, request);
  }
 
  template <typename DeleteQueueEnvironmentRequestT = Model::DeleteQueueEnvironmentRequest>
  void DeleteQueueEnvironmentAsync(const DeleteQueueEnvironmentRequestT& request,
                                   const DeleteQueueEnvironmentResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteQueueEnvironment, request, handler, context);
  }
 
  virtual Model::DeleteQueueFleetAssociationOutcome DeleteQueueFleetAssociation(
      const Model::DeleteQueueFleetAssociationRequest& request) const;
 
  template <typename DeleteQueueFleetAssociationRequestT = Model::DeleteQueueFleetAssociationRequest>
  Model::DeleteQueueFleetAssociationOutcomeCallable DeleteQueueFleetAssociationCallable(
      const DeleteQueueFleetAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteQueueFleetAssociation, request);
  }
 
  template <typename DeleteQueueFleetAssociationRequestT = Model::DeleteQueueFleetAssociationRequest>
  void DeleteQueueFleetAssociationAsync(const DeleteQueueFleetAssociationRequestT& request,
                                        const DeleteQueueFleetAssociationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteQueueFleetAssociation, request, handler, context);
  }
 
  virtual Model::DeleteQueueLimitAssociationOutcome DeleteQueueLimitAssociation(
      const Model::DeleteQueueLimitAssociationRequest& request) const;
 
  template <typename DeleteQueueLimitAssociationRequestT = Model::DeleteQueueLimitAssociationRequest>
  Model::DeleteQueueLimitAssociationOutcomeCallable DeleteQueueLimitAssociationCallable(
      const DeleteQueueLimitAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteQueueLimitAssociation, request);
  }
 
  template <typename DeleteQueueLimitAssociationRequestT = Model::DeleteQueueLimitAssociationRequest>
  void DeleteQueueLimitAssociationAsync(const DeleteQueueLimitAssociationRequestT& request,
                                        const DeleteQueueLimitAssociationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteQueueLimitAssociation, request, handler, context);
  }
 
  virtual Model::DeleteStorageProfileOutcome DeleteStorageProfile(const Model::DeleteStorageProfileRequest& request) const;
 
  template <typename DeleteStorageProfileRequestT = Model::DeleteStorageProfileRequest>
  Model::DeleteStorageProfileOutcomeCallable DeleteStorageProfileCallable(const DeleteStorageProfileRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteStorageProfile, request);
  }
 
  template <typename DeleteStorageProfileRequestT = Model::DeleteStorageProfileRequest>
  void DeleteStorageProfileAsync(const DeleteStorageProfileRequestT& request, const DeleteStorageProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteStorageProfile, request, handler, context);
  }
 
  virtual Model::DeleteWorkerOutcome DeleteWorker(const Model::DeleteWorkerRequest& request) const;
 
  template <typename DeleteWorkerRequestT = Model::DeleteWorkerRequest>
  Model::DeleteWorkerOutcomeCallable DeleteWorkerCallable(const DeleteWorkerRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DeleteWorker, request);
  }
 
  template <typename DeleteWorkerRequestT = Model::DeleteWorkerRequest>
  void DeleteWorkerAsync(const DeleteWorkerRequestT& request, const DeleteWorkerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DeleteWorker, request, handler, context);
  }
 
  virtual Model::DisassociateMemberFromFarmOutcome DisassociateMemberFromFarm(
      const Model::DisassociateMemberFromFarmRequest& request) const;
 
  template <typename DisassociateMemberFromFarmRequestT = Model::DisassociateMemberFromFarmRequest>
  Model::DisassociateMemberFromFarmOutcomeCallable DisassociateMemberFromFarmCallable(
      const DisassociateMemberFromFarmRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DisassociateMemberFromFarm, request);
  }
 
  template <typename DisassociateMemberFromFarmRequestT = Model::DisassociateMemberFromFarmRequest>
  void DisassociateMemberFromFarmAsync(const DisassociateMemberFromFarmRequestT& request,
                                       const DisassociateMemberFromFarmResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DisassociateMemberFromFarm, request, handler, context);
  }
 
  virtual Model::DisassociateMemberFromFleetOutcome DisassociateMemberFromFleet(
      const Model::DisassociateMemberFromFleetRequest& request) const;
 
  template <typename DisassociateMemberFromFleetRequestT = Model::DisassociateMemberFromFleetRequest>
  Model::DisassociateMemberFromFleetOutcomeCallable DisassociateMemberFromFleetCallable(
      const DisassociateMemberFromFleetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DisassociateMemberFromFleet, request);
  }
 
  template <typename DisassociateMemberFromFleetRequestT = Model::DisassociateMemberFromFleetRequest>
  void DisassociateMemberFromFleetAsync(const DisassociateMemberFromFleetRequestT& request,
                                        const DisassociateMemberFromFleetResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DisassociateMemberFromFleet, request, handler, context);
  }
 
  virtual Model::DisassociateMemberFromJobOutcome DisassociateMemberFromJob(const Model::DisassociateMemberFromJobRequest& request) const;
 
  template <typename DisassociateMemberFromJobRequestT = Model::DisassociateMemberFromJobRequest>
  Model::DisassociateMemberFromJobOutcomeCallable DisassociateMemberFromJobCallable(
      const DisassociateMemberFromJobRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DisassociateMemberFromJob, request);
  }
 
  template <typename DisassociateMemberFromJobRequestT = Model::DisassociateMemberFromJobRequest>
  void DisassociateMemberFromJobAsync(const DisassociateMemberFromJobRequestT& request,
                                      const DisassociateMemberFromJobResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DisassociateMemberFromJob, request, handler, context);
  }
 
  virtual Model::DisassociateMemberFromQueueOutcome DisassociateMemberFromQueue(
      const Model::DisassociateMemberFromQueueRequest& request) const;
 
  template <typename DisassociateMemberFromQueueRequestT = Model::DisassociateMemberFromQueueRequest>
  Model::DisassociateMemberFromQueueOutcomeCallable DisassociateMemberFromQueueCallable(
      const DisassociateMemberFromQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::DisassociateMemberFromQueue, request);
  }
 
  template <typename DisassociateMemberFromQueueRequestT = Model::DisassociateMemberFromQueueRequest>
  void DisassociateMemberFromQueueAsync(const DisassociateMemberFromQueueRequestT& request,
                                        const DisassociateMemberFromQueueResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::DisassociateMemberFromQueue, request, handler, context);
  }
 
  virtual Model::GetBudgetOutcome GetBudget(const Model::GetBudgetRequest& request) const;
 
  template <typename GetBudgetRequestT = Model::GetBudgetRequest>
  Model::GetBudgetOutcomeCallable GetBudgetCallable(const GetBudgetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetBudget, request);
  }
 
  template <typename GetBudgetRequestT = Model::GetBudgetRequest>
  void GetBudgetAsync(const GetBudgetRequestT& request, const GetBudgetResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetBudget, request, handler, context);
  }
 
  virtual Model::GetFarmOutcome GetFarm(const Model::GetFarmRequest& request) const;
 
  template <typename GetFarmRequestT = Model::GetFarmRequest>
  Model::GetFarmOutcomeCallable GetFarmCallable(const GetFarmRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetFarm, request);
  }
 
  template <typename GetFarmRequestT = Model::GetFarmRequest>
  void GetFarmAsync(const GetFarmRequestT& request, const GetFarmResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetFarm, request, handler, context);
  }
 
  virtual Model::GetFleetOutcome GetFleet(const Model::GetFleetRequest& request) const;
 
  template <typename GetFleetRequestT = Model::GetFleetRequest>
  Model::GetFleetOutcomeCallable GetFleetCallable(const GetFleetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetFleet, request);
  }
 
  template <typename GetFleetRequestT = Model::GetFleetRequest>
  void GetFleetAsync(const GetFleetRequestT& request, const GetFleetResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetFleet, request, handler, context);
  }
 
  virtual Model::GetJobOutcome GetJob(const Model::GetJobRequest& request) const;
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  Model::GetJobOutcomeCallable GetJobCallable(const GetJobRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetJob, request);
  }
 
  template <typename GetJobRequestT = Model::GetJobRequest>
  void GetJobAsync(const GetJobRequestT& request, const GetJobResponseReceivedHandler& handler,
                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetJob, request, handler, context);
  }
 
  virtual Model::GetLicenseEndpointOutcome GetLicenseEndpoint(const Model::GetLicenseEndpointRequest& request) const;
 
  template <typename GetLicenseEndpointRequestT = Model::GetLicenseEndpointRequest>
  Model::GetLicenseEndpointOutcomeCallable GetLicenseEndpointCallable(const GetLicenseEndpointRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetLicenseEndpoint, request);
  }
 
  template <typename GetLicenseEndpointRequestT = Model::GetLicenseEndpointRequest>
  void GetLicenseEndpointAsync(const GetLicenseEndpointRequestT& request, const GetLicenseEndpointResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetLicenseEndpoint, request, handler, context);
  }
 
  virtual Model::GetLimitOutcome GetLimit(const Model::GetLimitRequest& request) const;
 
  template <typename GetLimitRequestT = Model::GetLimitRequest>
  Model::GetLimitOutcomeCallable GetLimitCallable(const GetLimitRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetLimit, request);
  }
 
  template <typename GetLimitRequestT = Model::GetLimitRequest>
  void GetLimitAsync(const GetLimitRequestT& request, const GetLimitResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetLimit, request, handler, context);
  }
 
  virtual Model::GetMonitorOutcome GetMonitor(const Model::GetMonitorRequest& request) const;
 
  template <typename GetMonitorRequestT = Model::GetMonitorRequest>
  Model::GetMonitorOutcomeCallable GetMonitorCallable(const GetMonitorRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetMonitor, request);
  }
 
  template <typename GetMonitorRequestT = Model::GetMonitorRequest>
  void GetMonitorAsync(const GetMonitorRequestT& request, const GetMonitorResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetMonitor, request, handler, context);
  }
 
  virtual Model::GetQueueOutcome GetQueue(const Model::GetQueueRequest& request) const;
 
  template <typename GetQueueRequestT = Model::GetQueueRequest>
  Model::GetQueueOutcomeCallable GetQueueCallable(const GetQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetQueue, request);
  }
 
  template <typename GetQueueRequestT = Model::GetQueueRequest>
  void GetQueueAsync(const GetQueueRequestT& request, const GetQueueResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetQueue, request, handler, context);
  }
 
  virtual Model::GetQueueEnvironmentOutcome GetQueueEnvironment(const Model::GetQueueEnvironmentRequest& request) const;
 
  template <typename GetQueueEnvironmentRequestT = Model::GetQueueEnvironmentRequest>
  Model::GetQueueEnvironmentOutcomeCallable GetQueueEnvironmentCallable(const GetQueueEnvironmentRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetQueueEnvironment, request);
  }
 
  template <typename GetQueueEnvironmentRequestT = Model::GetQueueEnvironmentRequest>
  void GetQueueEnvironmentAsync(const GetQueueEnvironmentRequestT& request, const GetQueueEnvironmentResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetQueueEnvironment, request, handler, context);
  }
 
  virtual Model::GetQueueFleetAssociationOutcome GetQueueFleetAssociation(const Model::GetQueueFleetAssociationRequest& request) const;
 
  template <typename GetQueueFleetAssociationRequestT = Model::GetQueueFleetAssociationRequest>
  Model::GetQueueFleetAssociationOutcomeCallable GetQueueFleetAssociationCallable(const GetQueueFleetAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetQueueFleetAssociation, request);
  }
 
  template <typename GetQueueFleetAssociationRequestT = Model::GetQueueFleetAssociationRequest>
  void GetQueueFleetAssociationAsync(const GetQueueFleetAssociationRequestT& request,
                                     const GetQueueFleetAssociationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetQueueFleetAssociation, request, handler, context);
  }
 
  virtual Model::GetQueueLimitAssociationOutcome GetQueueLimitAssociation(const Model::GetQueueLimitAssociationRequest& request) const;
 
  template <typename GetQueueLimitAssociationRequestT = Model::GetQueueLimitAssociationRequest>
  Model::GetQueueLimitAssociationOutcomeCallable GetQueueLimitAssociationCallable(const GetQueueLimitAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetQueueLimitAssociation, request);
  }
 
  template <typename GetQueueLimitAssociationRequestT = Model::GetQueueLimitAssociationRequest>
  void GetQueueLimitAssociationAsync(const GetQueueLimitAssociationRequestT& request,
                                     const GetQueueLimitAssociationResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetQueueLimitAssociation, request, handler, context);
  }
 
  virtual Model::GetSessionOutcome GetSession(const Model::GetSessionRequest& request) const;
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  Model::GetSessionOutcomeCallable GetSessionCallable(const GetSessionRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetSession, request);
  }
 
  template <typename GetSessionRequestT = Model::GetSessionRequest>
  void GetSessionAsync(const GetSessionRequestT& request, const GetSessionResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetSession, request, handler, context);
  }
 
  virtual Model::GetSessionActionOutcome GetSessionAction(const Model::GetSessionActionRequest& request) const;
 
  template <typename GetSessionActionRequestT = Model::GetSessionActionRequest>
  Model::GetSessionActionOutcomeCallable GetSessionActionCallable(const GetSessionActionRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetSessionAction, request);
  }
 
  template <typename GetSessionActionRequestT = Model::GetSessionActionRequest>
  void GetSessionActionAsync(const GetSessionActionRequestT& request, const GetSessionActionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetSessionAction, request, handler, context);
  }
 
  virtual Model::GetSessionsStatisticsAggregationOutcome GetSessionsStatisticsAggregation(
      const Model::GetSessionsStatisticsAggregationRequest& request) const;
 
  template <typename GetSessionsStatisticsAggregationRequestT = Model::GetSessionsStatisticsAggregationRequest>
  Model::GetSessionsStatisticsAggregationOutcomeCallable GetSessionsStatisticsAggregationCallable(
      const GetSessionsStatisticsAggregationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetSessionsStatisticsAggregation, request);
  }
 
  template <typename GetSessionsStatisticsAggregationRequestT = Model::GetSessionsStatisticsAggregationRequest>
  void GetSessionsStatisticsAggregationAsync(const GetSessionsStatisticsAggregationRequestT& request,
                                             const GetSessionsStatisticsAggregationResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetSessionsStatisticsAggregation, request, handler, context);
  }
 
  virtual Model::GetStepOutcome GetStep(const Model::GetStepRequest& request) const;
 
  template <typename GetStepRequestT = Model::GetStepRequest>
  Model::GetStepOutcomeCallable GetStepCallable(const GetStepRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetStep, request);
  }
 
  template <typename GetStepRequestT = Model::GetStepRequest>
  void GetStepAsync(const GetStepRequestT& request, const GetStepResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetStep, request, handler, context);
  }
 
  virtual Model::GetStorageProfileOutcome GetStorageProfile(const Model::GetStorageProfileRequest& request) const;
 
  template <typename GetStorageProfileRequestT = Model::GetStorageProfileRequest>
  Model::GetStorageProfileOutcomeCallable GetStorageProfileCallable(const GetStorageProfileRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetStorageProfile, request);
  }
 
  template <typename GetStorageProfileRequestT = Model::GetStorageProfileRequest>
  void GetStorageProfileAsync(const GetStorageProfileRequestT& request, const GetStorageProfileResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetStorageProfile, request, handler, context);
  }
 
  virtual Model::GetStorageProfileForQueueOutcome GetStorageProfileForQueue(const Model::GetStorageProfileForQueueRequest& request) const;
 
  template <typename GetStorageProfileForQueueRequestT = Model::GetStorageProfileForQueueRequest>
  Model::GetStorageProfileForQueueOutcomeCallable GetStorageProfileForQueueCallable(
      const GetStorageProfileForQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetStorageProfileForQueue, request);
  }
 
  template <typename GetStorageProfileForQueueRequestT = Model::GetStorageProfileForQueueRequest>
  void GetStorageProfileForQueueAsync(const GetStorageProfileForQueueRequestT& request,
                                      const GetStorageProfileForQueueResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetStorageProfileForQueue, request, handler, context);
  }
 
  virtual Model::GetTaskOutcome GetTask(const Model::GetTaskRequest& request) const;
 
  template <typename GetTaskRequestT = Model::GetTaskRequest>
  Model::GetTaskOutcomeCallable GetTaskCallable(const GetTaskRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetTask, request);
  }
 
  template <typename GetTaskRequestT = Model::GetTaskRequest>
  void GetTaskAsync(const GetTaskRequestT& request, const GetTaskResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetTask, request, handler, context);
  }
 
  virtual Model::GetWorkerOutcome GetWorker(const Model::GetWorkerRequest& request) const;
 
  template <typename GetWorkerRequestT = Model::GetWorkerRequest>
  Model::GetWorkerOutcomeCallable GetWorkerCallable(const GetWorkerRequestT& request) const {
    return SubmitCallable(&DeadlineClient::GetWorker, request);
  }
 
  template <typename GetWorkerRequestT = Model::GetWorkerRequest>
  void GetWorkerAsync(const GetWorkerRequestT& request, const GetWorkerResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::GetWorker, request, handler, context);
  }
 
  virtual Model::ListAvailableMeteredProductsOutcome ListAvailableMeteredProducts(
      const Model::ListAvailableMeteredProductsRequest& request = {}) const;
 
  template <typename ListAvailableMeteredProductsRequestT = Model::ListAvailableMeteredProductsRequest>
  Model::ListAvailableMeteredProductsOutcomeCallable ListAvailableMeteredProductsCallable(
      const ListAvailableMeteredProductsRequestT& request = {}) const {
    return SubmitCallable(&DeadlineClient::ListAvailableMeteredProducts, request);
  }
 
  template <typename ListAvailableMeteredProductsRequestT = Model::ListAvailableMeteredProductsRequest>
  void ListAvailableMeteredProductsAsync(const ListAvailableMeteredProductsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                         const ListAvailableMeteredProductsRequestT& request = {}) const {
    return SubmitAsync(&DeadlineClient::ListAvailableMeteredProducts, request, handler, context);
  }
 
  virtual Model::ListBudgetsOutcome ListBudgets(const Model::ListBudgetsRequest& request) const;
 
  template <typename ListBudgetsRequestT = Model::ListBudgetsRequest>
  Model::ListBudgetsOutcomeCallable ListBudgetsCallable(const ListBudgetsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListBudgets, request);
  }
 
  template <typename ListBudgetsRequestT = Model::ListBudgetsRequest>
  void ListBudgetsAsync(const ListBudgetsRequestT& request, const ListBudgetsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListBudgets, request, handler, context);
  }
 
  virtual Model::ListFarmMembersOutcome ListFarmMembers(const Model::ListFarmMembersRequest& request) const;
 
  template <typename ListFarmMembersRequestT = Model::ListFarmMembersRequest>
  Model::ListFarmMembersOutcomeCallable ListFarmMembersCallable(const ListFarmMembersRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListFarmMembers, request);
  }
 
  template <typename ListFarmMembersRequestT = Model::ListFarmMembersRequest>
  void ListFarmMembersAsync(const ListFarmMembersRequestT& request, const ListFarmMembersResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListFarmMembers, request, handler, context);
  }
 
  virtual Model::ListFarmsOutcome ListFarms(const Model::ListFarmsRequest& request = {}) const;
 
  template <typename ListFarmsRequestT = Model::ListFarmsRequest>
  Model::ListFarmsOutcomeCallable ListFarmsCallable(const ListFarmsRequestT& request = {}) const {
    return SubmitCallable(&DeadlineClient::ListFarms, request);
  }
 
  template <typename ListFarmsRequestT = Model::ListFarmsRequest>
  void ListFarmsAsync(const ListFarmsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListFarmsRequestT& request = {}) const {
    return SubmitAsync(&DeadlineClient::ListFarms, request, handler, context);
  }
 
  virtual Model::ListFleetMembersOutcome ListFleetMembers(const Model::ListFleetMembersRequest& request) const;
 
  template <typename ListFleetMembersRequestT = Model::ListFleetMembersRequest>
  Model::ListFleetMembersOutcomeCallable ListFleetMembersCallable(const ListFleetMembersRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListFleetMembers, request);
  }
 
  template <typename ListFleetMembersRequestT = Model::ListFleetMembersRequest>
  void ListFleetMembersAsync(const ListFleetMembersRequestT& request, const ListFleetMembersResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListFleetMembers, request, handler, context);
  }
 
  virtual Model::ListFleetsOutcome ListFleets(const Model::ListFleetsRequest& request) const;
 
  template <typename ListFleetsRequestT = Model::ListFleetsRequest>
  Model::ListFleetsOutcomeCallable ListFleetsCallable(const ListFleetsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListFleets, request);
  }
 
  template <typename ListFleetsRequestT = Model::ListFleetsRequest>
  void ListFleetsAsync(const ListFleetsRequestT& request, const ListFleetsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListFleets, request, handler, context);
  }
 
  virtual Model::ListJobMembersOutcome ListJobMembers(const Model::ListJobMembersRequest& request) const;
 
  template <typename ListJobMembersRequestT = Model::ListJobMembersRequest>
  Model::ListJobMembersOutcomeCallable ListJobMembersCallable(const ListJobMembersRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListJobMembers, request);
  }
 
  template <typename ListJobMembersRequestT = Model::ListJobMembersRequest>
  void ListJobMembersAsync(const ListJobMembersRequestT& request, const ListJobMembersResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListJobMembers, request, handler, context);
  }
 
  virtual Model::ListJobParameterDefinitionsOutcome ListJobParameterDefinitions(
      const Model::ListJobParameterDefinitionsRequest& request) const;
 
  template <typename ListJobParameterDefinitionsRequestT = Model::ListJobParameterDefinitionsRequest>
  Model::ListJobParameterDefinitionsOutcomeCallable ListJobParameterDefinitionsCallable(
      const ListJobParameterDefinitionsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListJobParameterDefinitions, request);
  }
 
  template <typename ListJobParameterDefinitionsRequestT = Model::ListJobParameterDefinitionsRequest>
  void ListJobParameterDefinitionsAsync(const ListJobParameterDefinitionsRequestT& request,
                                        const ListJobParameterDefinitionsResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListJobParameterDefinitions, 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(&DeadlineClient::ListJobs, request);
  }
 
  template <typename ListJobsRequestT = Model::ListJobsRequest>
  void ListJobsAsync(const ListJobsRequestT& request, const ListJobsResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListJobs, request, handler, context);
  }
 
  virtual Model::ListLicenseEndpointsOutcome ListLicenseEndpoints(const Model::ListLicenseEndpointsRequest& request = {}) const;
 
  template <typename ListLicenseEndpointsRequestT = Model::ListLicenseEndpointsRequest>
  Model::ListLicenseEndpointsOutcomeCallable ListLicenseEndpointsCallable(const ListLicenseEndpointsRequestT& request = {}) const {
    return SubmitCallable(&DeadlineClient::ListLicenseEndpoints, request);
  }
 
  template <typename ListLicenseEndpointsRequestT = Model::ListLicenseEndpointsRequest>
  void ListLicenseEndpointsAsync(const ListLicenseEndpointsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListLicenseEndpointsRequestT& request = {}) const {
    return SubmitAsync(&DeadlineClient::ListLicenseEndpoints, request, handler, context);
  }
 
  virtual Model::ListLimitsOutcome ListLimits(const Model::ListLimitsRequest& request) const;
 
  template <typename ListLimitsRequestT = Model::ListLimitsRequest>
  Model::ListLimitsOutcomeCallable ListLimitsCallable(const ListLimitsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListLimits, request);
  }
 
  template <typename ListLimitsRequestT = Model::ListLimitsRequest>
  void ListLimitsAsync(const ListLimitsRequestT& request, const ListLimitsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListLimits, request, handler, context);
  }
 
  virtual Model::ListMeteredProductsOutcome ListMeteredProducts(const Model::ListMeteredProductsRequest& request) const;
 
  template <typename ListMeteredProductsRequestT = Model::ListMeteredProductsRequest>
  Model::ListMeteredProductsOutcomeCallable ListMeteredProductsCallable(const ListMeteredProductsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListMeteredProducts, request);
  }
 
  template <typename ListMeteredProductsRequestT = Model::ListMeteredProductsRequest>
  void ListMeteredProductsAsync(const ListMeteredProductsRequestT& request, const ListMeteredProductsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListMeteredProducts, request, handler, context);
  }
 
  virtual Model::ListMonitorsOutcome ListMonitors(const Model::ListMonitorsRequest& request = {}) const;
 
  template <typename ListMonitorsRequestT = Model::ListMonitorsRequest>
  Model::ListMonitorsOutcomeCallable ListMonitorsCallable(const ListMonitorsRequestT& request = {}) const {
    return SubmitCallable(&DeadlineClient::ListMonitors, request);
  }
 
  template <typename ListMonitorsRequestT = Model::ListMonitorsRequest>
  void ListMonitorsAsync(const ListMonitorsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListMonitorsRequestT& request = {}) const {
    return SubmitAsync(&DeadlineClient::ListMonitors, request, handler, context);
  }
 
  virtual Model::ListQueueEnvironmentsOutcome ListQueueEnvironments(const Model::ListQueueEnvironmentsRequest& request) const;
 
  template <typename ListQueueEnvironmentsRequestT = Model::ListQueueEnvironmentsRequest>
  Model::ListQueueEnvironmentsOutcomeCallable ListQueueEnvironmentsCallable(const ListQueueEnvironmentsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListQueueEnvironments, request);
  }
 
  template <typename ListQueueEnvironmentsRequestT = Model::ListQueueEnvironmentsRequest>
  void ListQueueEnvironmentsAsync(const ListQueueEnvironmentsRequestT& request, const ListQueueEnvironmentsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListQueueEnvironments, request, handler, context);
  }
 
  virtual Model::ListQueueFleetAssociationsOutcome ListQueueFleetAssociations(
      const Model::ListQueueFleetAssociationsRequest& request) const;
 
  template <typename ListQueueFleetAssociationsRequestT = Model::ListQueueFleetAssociationsRequest>
  Model::ListQueueFleetAssociationsOutcomeCallable ListQueueFleetAssociationsCallable(
      const ListQueueFleetAssociationsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListQueueFleetAssociations, request);
  }
 
  template <typename ListQueueFleetAssociationsRequestT = Model::ListQueueFleetAssociationsRequest>
  void ListQueueFleetAssociationsAsync(const ListQueueFleetAssociationsRequestT& request,
                                       const ListQueueFleetAssociationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListQueueFleetAssociations, request, handler, context);
  }
 
  virtual Model::ListQueueLimitAssociationsOutcome ListQueueLimitAssociations(
      const Model::ListQueueLimitAssociationsRequest& request) const;
 
  template <typename ListQueueLimitAssociationsRequestT = Model::ListQueueLimitAssociationsRequest>
  Model::ListQueueLimitAssociationsOutcomeCallable ListQueueLimitAssociationsCallable(
      const ListQueueLimitAssociationsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListQueueLimitAssociations, request);
  }
 
  template <typename ListQueueLimitAssociationsRequestT = Model::ListQueueLimitAssociationsRequest>
  void ListQueueLimitAssociationsAsync(const ListQueueLimitAssociationsRequestT& request,
                                       const ListQueueLimitAssociationsResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListQueueLimitAssociations, request, handler, context);
  }
 
  virtual Model::ListQueueMembersOutcome ListQueueMembers(const Model::ListQueueMembersRequest& request) const;
 
  template <typename ListQueueMembersRequestT = Model::ListQueueMembersRequest>
  Model::ListQueueMembersOutcomeCallable ListQueueMembersCallable(const ListQueueMembersRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListQueueMembers, request);
  }
 
  template <typename ListQueueMembersRequestT = Model::ListQueueMembersRequest>
  void ListQueueMembersAsync(const ListQueueMembersRequestT& request, const ListQueueMembersResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListQueueMembers, request, handler, context);
  }
 
  virtual Model::ListQueuesOutcome ListQueues(const Model::ListQueuesRequest& request) const;
 
  template <typename ListQueuesRequestT = Model::ListQueuesRequest>
  Model::ListQueuesOutcomeCallable ListQueuesCallable(const ListQueuesRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListQueues, request);
  }
 
  template <typename ListQueuesRequestT = Model::ListQueuesRequest>
  void ListQueuesAsync(const ListQueuesRequestT& request, const ListQueuesResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListQueues, request, handler, context);
  }
 
  virtual Model::ListSessionActionsOutcome ListSessionActions(const Model::ListSessionActionsRequest& request) const;
 
  template <typename ListSessionActionsRequestT = Model::ListSessionActionsRequest>
  Model::ListSessionActionsOutcomeCallable ListSessionActionsCallable(const ListSessionActionsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListSessionActions, request);
  }
 
  template <typename ListSessionActionsRequestT = Model::ListSessionActionsRequest>
  void ListSessionActionsAsync(const ListSessionActionsRequestT& request, const ListSessionActionsResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListSessionActions, request, handler, context);
  }
 
  virtual Model::ListSessionsOutcome ListSessions(const Model::ListSessionsRequest& request) const;
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  Model::ListSessionsOutcomeCallable ListSessionsCallable(const ListSessionsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListSessions, request);
  }
 
  template <typename ListSessionsRequestT = Model::ListSessionsRequest>
  void ListSessionsAsync(const ListSessionsRequestT& request, const ListSessionsResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListSessions, request, handler, context);
  }
 
  virtual Model::ListSessionsForWorkerOutcome ListSessionsForWorker(const Model::ListSessionsForWorkerRequest& request) const;
 
  template <typename ListSessionsForWorkerRequestT = Model::ListSessionsForWorkerRequest>
  Model::ListSessionsForWorkerOutcomeCallable ListSessionsForWorkerCallable(const ListSessionsForWorkerRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListSessionsForWorker, request);
  }
 
  template <typename ListSessionsForWorkerRequestT = Model::ListSessionsForWorkerRequest>
  void ListSessionsForWorkerAsync(const ListSessionsForWorkerRequestT& request, const ListSessionsForWorkerResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListSessionsForWorker, request, handler, context);
  }
 
  virtual Model::ListStepConsumersOutcome ListStepConsumers(const Model::ListStepConsumersRequest& request) const;
 
  template <typename ListStepConsumersRequestT = Model::ListStepConsumersRequest>
  Model::ListStepConsumersOutcomeCallable ListStepConsumersCallable(const ListStepConsumersRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListStepConsumers, request);
  }
 
  template <typename ListStepConsumersRequestT = Model::ListStepConsumersRequest>
  void ListStepConsumersAsync(const ListStepConsumersRequestT& request, const ListStepConsumersResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListStepConsumers, request, handler, context);
  }
 
  virtual Model::ListStepDependenciesOutcome ListStepDependencies(const Model::ListStepDependenciesRequest& request) const;
 
  template <typename ListStepDependenciesRequestT = Model::ListStepDependenciesRequest>
  Model::ListStepDependenciesOutcomeCallable ListStepDependenciesCallable(const ListStepDependenciesRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListStepDependencies, request);
  }
 
  template <typename ListStepDependenciesRequestT = Model::ListStepDependenciesRequest>
  void ListStepDependenciesAsync(const ListStepDependenciesRequestT& request, const ListStepDependenciesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListStepDependencies, request, handler, context);
  }
 
  virtual Model::ListStepsOutcome ListSteps(const Model::ListStepsRequest& request) const;
 
  template <typename ListStepsRequestT = Model::ListStepsRequest>
  Model::ListStepsOutcomeCallable ListStepsCallable(const ListStepsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListSteps, request);
  }
 
  template <typename ListStepsRequestT = Model::ListStepsRequest>
  void ListStepsAsync(const ListStepsRequestT& request, const ListStepsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListSteps, request, handler, context);
  }
 
  virtual Model::ListStorageProfilesOutcome ListStorageProfiles(const Model::ListStorageProfilesRequest& request) const;
 
  template <typename ListStorageProfilesRequestT = Model::ListStorageProfilesRequest>
  Model::ListStorageProfilesOutcomeCallable ListStorageProfilesCallable(const ListStorageProfilesRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListStorageProfiles, request);
  }
 
  template <typename ListStorageProfilesRequestT = Model::ListStorageProfilesRequest>
  void ListStorageProfilesAsync(const ListStorageProfilesRequestT& request, const ListStorageProfilesResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListStorageProfiles, request, handler, context);
  }
 
  virtual Model::ListStorageProfilesForQueueOutcome ListStorageProfilesForQueue(
      const Model::ListStorageProfilesForQueueRequest& request) const;
 
  template <typename ListStorageProfilesForQueueRequestT = Model::ListStorageProfilesForQueueRequest>
  Model::ListStorageProfilesForQueueOutcomeCallable ListStorageProfilesForQueueCallable(
      const ListStorageProfilesForQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListStorageProfilesForQueue, request);
  }
 
  template <typename ListStorageProfilesForQueueRequestT = Model::ListStorageProfilesForQueueRequest>
  void ListStorageProfilesForQueueAsync(const ListStorageProfilesForQueueRequestT& request,
                                        const ListStorageProfilesForQueueResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListStorageProfilesForQueue, 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(&DeadlineClient::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(&DeadlineClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTasksOutcome ListTasks(const Model::ListTasksRequest& request) const;
 
  template <typename ListTasksRequestT = Model::ListTasksRequest>
  Model::ListTasksOutcomeCallable ListTasksCallable(const ListTasksRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListTasks, request);
  }
 
  template <typename ListTasksRequestT = Model::ListTasksRequest>
  void ListTasksAsync(const ListTasksRequestT& request, const ListTasksResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListTasks, request, handler, context);
  }
 
  virtual Model::ListWorkersOutcome ListWorkers(const Model::ListWorkersRequest& request) const;
 
  template <typename ListWorkersRequestT = Model::ListWorkersRequest>
  Model::ListWorkersOutcomeCallable ListWorkersCallable(const ListWorkersRequestT& request) const {
    return SubmitCallable(&DeadlineClient::ListWorkers, request);
  }
 
  template <typename ListWorkersRequestT = Model::ListWorkersRequest>
  void ListWorkersAsync(const ListWorkersRequestT& request, const ListWorkersResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::ListWorkers, request, handler, context);
  }
 
  virtual Model::PutMeteredProductOutcome PutMeteredProduct(const Model::PutMeteredProductRequest& request) const;
 
  template <typename PutMeteredProductRequestT = Model::PutMeteredProductRequest>
  Model::PutMeteredProductOutcomeCallable PutMeteredProductCallable(const PutMeteredProductRequestT& request) const {
    return SubmitCallable(&DeadlineClient::PutMeteredProduct, request);
  }
 
  template <typename PutMeteredProductRequestT = Model::PutMeteredProductRequest>
  void PutMeteredProductAsync(const PutMeteredProductRequestT& request, const PutMeteredProductResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::PutMeteredProduct, request, handler, context);
  }
 
  virtual Model::SearchJobsOutcome SearchJobs(const Model::SearchJobsRequest& request) const;
 
  template <typename SearchJobsRequestT = Model::SearchJobsRequest>
  Model::SearchJobsOutcomeCallable SearchJobsCallable(const SearchJobsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::SearchJobs, request);
  }
 
  template <typename SearchJobsRequestT = Model::SearchJobsRequest>
  void SearchJobsAsync(const SearchJobsRequestT& request, const SearchJobsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::SearchJobs, request, handler, context);
  }
 
  virtual Model::SearchStepsOutcome SearchSteps(const Model::SearchStepsRequest& request) const;
 
  template <typename SearchStepsRequestT = Model::SearchStepsRequest>
  Model::SearchStepsOutcomeCallable SearchStepsCallable(const SearchStepsRequestT& request) const {
    return SubmitCallable(&DeadlineClient::SearchSteps, request);
  }
 
  template <typename SearchStepsRequestT = Model::SearchStepsRequest>
  void SearchStepsAsync(const SearchStepsRequestT& request, const SearchStepsResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::SearchSteps, request, handler, context);
  }
 
  virtual Model::SearchTasksOutcome SearchTasks(const Model::SearchTasksRequest& request) const;
 
  template <typename SearchTasksRequestT = Model::SearchTasksRequest>
  Model::SearchTasksOutcomeCallable SearchTasksCallable(const SearchTasksRequestT& request) const {
    return SubmitCallable(&DeadlineClient::SearchTasks, request);
  }
 
  template <typename SearchTasksRequestT = Model::SearchTasksRequest>
  void SearchTasksAsync(const SearchTasksRequestT& request, const SearchTasksResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::SearchTasks, request, handler, context);
  }
 
  virtual Model::SearchWorkersOutcome SearchWorkers(const Model::SearchWorkersRequest& request) const;
 
  template <typename SearchWorkersRequestT = Model::SearchWorkersRequest>
  Model::SearchWorkersOutcomeCallable SearchWorkersCallable(const SearchWorkersRequestT& request) const {
    return SubmitCallable(&DeadlineClient::SearchWorkers, request);
  }
 
  template <typename SearchWorkersRequestT = Model::SearchWorkersRequest>
  void SearchWorkersAsync(const SearchWorkersRequestT& request, const SearchWorkersResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::SearchWorkers, request, handler, context);
  }
 
  virtual Model::StartSessionsStatisticsAggregationOutcome StartSessionsStatisticsAggregation(
      const Model::StartSessionsStatisticsAggregationRequest& request) const;
 
  template <typename StartSessionsStatisticsAggregationRequestT = Model::StartSessionsStatisticsAggregationRequest>
  Model::StartSessionsStatisticsAggregationOutcomeCallable StartSessionsStatisticsAggregationCallable(
      const StartSessionsStatisticsAggregationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::StartSessionsStatisticsAggregation, request);
  }
 
  template <typename StartSessionsStatisticsAggregationRequestT = Model::StartSessionsStatisticsAggregationRequest>
  void StartSessionsStatisticsAggregationAsync(const StartSessionsStatisticsAggregationRequestT& request,
                                               const StartSessionsStatisticsAggregationResponseReceivedHandler& handler,
                                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::StartSessionsStatisticsAggregation, 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(&DeadlineClient::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(&DeadlineClient::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(&DeadlineClient::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(&DeadlineClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBudgetOutcome UpdateBudget(const Model::UpdateBudgetRequest& request) const;
 
  template <typename UpdateBudgetRequestT = Model::UpdateBudgetRequest>
  Model::UpdateBudgetOutcomeCallable UpdateBudgetCallable(const UpdateBudgetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateBudget, request);
  }
 
  template <typename UpdateBudgetRequestT = Model::UpdateBudgetRequest>
  void UpdateBudgetAsync(const UpdateBudgetRequestT& request, const UpdateBudgetResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateBudget, request, handler, context);
  }
 
  virtual Model::UpdateFarmOutcome UpdateFarm(const Model::UpdateFarmRequest& request) const;
 
  template <typename UpdateFarmRequestT = Model::UpdateFarmRequest>
  Model::UpdateFarmOutcomeCallable UpdateFarmCallable(const UpdateFarmRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateFarm, request);
  }
 
  template <typename UpdateFarmRequestT = Model::UpdateFarmRequest>
  void UpdateFarmAsync(const UpdateFarmRequestT& request, const UpdateFarmResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateFarm, request, handler, context);
  }
 
  virtual Model::UpdateFleetOutcome UpdateFleet(const Model::UpdateFleetRequest& request) const;
 
  template <typename UpdateFleetRequestT = Model::UpdateFleetRequest>
  Model::UpdateFleetOutcomeCallable UpdateFleetCallable(const UpdateFleetRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateFleet, request);
  }
 
  template <typename UpdateFleetRequestT = Model::UpdateFleetRequest>
  void UpdateFleetAsync(const UpdateFleetRequestT& request, const UpdateFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateFleet, request, handler, context);
  }
 
  virtual Model::UpdateJobOutcome UpdateJob(const Model::UpdateJobRequest& request) const;
 
  template <typename UpdateJobRequestT = Model::UpdateJobRequest>
  Model::UpdateJobOutcomeCallable UpdateJobCallable(const UpdateJobRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateJob, request);
  }
 
  template <typename UpdateJobRequestT = Model::UpdateJobRequest>
  void UpdateJobAsync(const UpdateJobRequestT& request, const UpdateJobResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateJob, request, handler, context);
  }
 
  virtual Model::UpdateLimitOutcome UpdateLimit(const Model::UpdateLimitRequest& request) const;
 
  template <typename UpdateLimitRequestT = Model::UpdateLimitRequest>
  Model::UpdateLimitOutcomeCallable UpdateLimitCallable(const UpdateLimitRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateLimit, request);
  }
 
  template <typename UpdateLimitRequestT = Model::UpdateLimitRequest>
  void UpdateLimitAsync(const UpdateLimitRequestT& request, const UpdateLimitResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateLimit, request, handler, context);
  }
 
  virtual Model::UpdateMonitorOutcome UpdateMonitor(const Model::UpdateMonitorRequest& request) const;
 
  template <typename UpdateMonitorRequestT = Model::UpdateMonitorRequest>
  Model::UpdateMonitorOutcomeCallable UpdateMonitorCallable(const UpdateMonitorRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateMonitor, request);
  }
 
  template <typename UpdateMonitorRequestT = Model::UpdateMonitorRequest>
  void UpdateMonitorAsync(const UpdateMonitorRequestT& request, const UpdateMonitorResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateMonitor, request, handler, context);
  }
 
  virtual Model::UpdateQueueOutcome UpdateQueue(const Model::UpdateQueueRequest& request) const;
 
  template <typename UpdateQueueRequestT = Model::UpdateQueueRequest>
  Model::UpdateQueueOutcomeCallable UpdateQueueCallable(const UpdateQueueRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateQueue, request);
  }
 
  template <typename UpdateQueueRequestT = Model::UpdateQueueRequest>
  void UpdateQueueAsync(const UpdateQueueRequestT& request, const UpdateQueueResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateQueue, request, handler, context);
  }
 
  virtual Model::UpdateQueueEnvironmentOutcome UpdateQueueEnvironment(const Model::UpdateQueueEnvironmentRequest& request) const;
 
  template <typename UpdateQueueEnvironmentRequestT = Model::UpdateQueueEnvironmentRequest>
  Model::UpdateQueueEnvironmentOutcomeCallable UpdateQueueEnvironmentCallable(const UpdateQueueEnvironmentRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateQueueEnvironment, request);
  }
 
  template <typename UpdateQueueEnvironmentRequestT = Model::UpdateQueueEnvironmentRequest>
  void UpdateQueueEnvironmentAsync(const UpdateQueueEnvironmentRequestT& request,
                                   const UpdateQueueEnvironmentResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateQueueEnvironment, request, handler, context);
  }
 
  virtual Model::UpdateQueueFleetAssociationOutcome UpdateQueueFleetAssociation(
      const Model::UpdateQueueFleetAssociationRequest& request) const;
 
  template <typename UpdateQueueFleetAssociationRequestT = Model::UpdateQueueFleetAssociationRequest>
  Model::UpdateQueueFleetAssociationOutcomeCallable UpdateQueueFleetAssociationCallable(
      const UpdateQueueFleetAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateQueueFleetAssociation, request);
  }
 
  template <typename UpdateQueueFleetAssociationRequestT = Model::UpdateQueueFleetAssociationRequest>
  void UpdateQueueFleetAssociationAsync(const UpdateQueueFleetAssociationRequestT& request,
                                        const UpdateQueueFleetAssociationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateQueueFleetAssociation, request, handler, context);
  }
 
  virtual Model::UpdateQueueLimitAssociationOutcome UpdateQueueLimitAssociation(
      const Model::UpdateQueueLimitAssociationRequest& request) const;
 
  template <typename UpdateQueueLimitAssociationRequestT = Model::UpdateQueueLimitAssociationRequest>
  Model::UpdateQueueLimitAssociationOutcomeCallable UpdateQueueLimitAssociationCallable(
      const UpdateQueueLimitAssociationRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateQueueLimitAssociation, request);
  }
 
  template <typename UpdateQueueLimitAssociationRequestT = Model::UpdateQueueLimitAssociationRequest>
  void UpdateQueueLimitAssociationAsync(const UpdateQueueLimitAssociationRequestT& request,
                                        const UpdateQueueLimitAssociationResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateQueueLimitAssociation, request, handler, context);
  }
 
  virtual Model::UpdateSessionOutcome UpdateSession(const Model::UpdateSessionRequest& request) const;
 
  template <typename UpdateSessionRequestT = Model::UpdateSessionRequest>
  Model::UpdateSessionOutcomeCallable UpdateSessionCallable(const UpdateSessionRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateSession, request);
  }
 
  template <typename UpdateSessionRequestT = Model::UpdateSessionRequest>
  void UpdateSessionAsync(const UpdateSessionRequestT& request, const UpdateSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateSession, request, handler, context);
  }
 
  virtual Model::UpdateStepOutcome UpdateStep(const Model::UpdateStepRequest& request) const;
 
  template <typename UpdateStepRequestT = Model::UpdateStepRequest>
  Model::UpdateStepOutcomeCallable UpdateStepCallable(const UpdateStepRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateStep, request);
  }
 
  template <typename UpdateStepRequestT = Model::UpdateStepRequest>
  void UpdateStepAsync(const UpdateStepRequestT& request, const UpdateStepResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateStep, request, handler, context);
  }
 
  virtual Model::UpdateStorageProfileOutcome UpdateStorageProfile(const Model::UpdateStorageProfileRequest& request) const;
 
  template <typename UpdateStorageProfileRequestT = Model::UpdateStorageProfileRequest>
  Model::UpdateStorageProfileOutcomeCallable UpdateStorageProfileCallable(const UpdateStorageProfileRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateStorageProfile, request);
  }
 
  template <typename UpdateStorageProfileRequestT = Model::UpdateStorageProfileRequest>
  void UpdateStorageProfileAsync(const UpdateStorageProfileRequestT& request, const UpdateStorageProfileResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateStorageProfile, request, handler, context);
  }
 
  virtual Model::UpdateTaskOutcome UpdateTask(const Model::UpdateTaskRequest& request) const;
 
  template <typename UpdateTaskRequestT = Model::UpdateTaskRequest>
  Model::UpdateTaskOutcomeCallable UpdateTaskCallable(const UpdateTaskRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateTask, request);
  }
 
  template <typename UpdateTaskRequestT = Model::UpdateTaskRequest>
  void UpdateTaskAsync(const UpdateTaskRequestT& request, const UpdateTaskResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateTask, request, handler, context);
  }
 
  virtual Model::UpdateWorkerOutcome UpdateWorker(const Model::UpdateWorkerRequest& request) const;
 
  template <typename UpdateWorkerRequestT = Model::UpdateWorkerRequest>
  Model::UpdateWorkerOutcomeCallable UpdateWorkerCallable(const UpdateWorkerRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateWorker, request);
  }
 
  template <typename UpdateWorkerRequestT = Model::UpdateWorkerRequest>
  void UpdateWorkerAsync(const UpdateWorkerRequestT& request, const UpdateWorkerResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateWorker, request, handler, context);
  }
 
  virtual Model::UpdateWorkerScheduleOutcome UpdateWorkerSchedule(const Model::UpdateWorkerScheduleRequest& request) const;
 
  template <typename UpdateWorkerScheduleRequestT = Model::UpdateWorkerScheduleRequest>
  Model::UpdateWorkerScheduleOutcomeCallable UpdateWorkerScheduleCallable(const UpdateWorkerScheduleRequestT& request) const {
    return SubmitCallable(&DeadlineClient::UpdateWorkerSchedule, request);
  }
 
  template <typename UpdateWorkerScheduleRequestT = Model::UpdateWorkerScheduleRequest>
  void UpdateWorkerScheduleAsync(const UpdateWorkerScheduleRequestT& request, const UpdateWorkerScheduleResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&DeadlineClient::UpdateWorkerSchedule, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<DeadlineEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<DeadlineClient>;
  void init(const DeadlineClientConfiguration& clientConfiguration);
 
  DeadlineClientConfiguration m_clientConfiguration;
  std::shared_ptr<DeadlineEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace deadline
}  // namespace Aws