DeadlineClient.h

 
#pragma once
#include <aws/deadline/Deadline_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/deadline/DeadlineServiceClientModel.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