MediaConvertClient.h

 
#pragma once
#include <aws/mediaconvert/MediaConvert_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/mediaconvert/MediaConvertServiceClientModel.h>
 
namespace Aws
{
namespace MediaConvert
{
  class AWS_MEDIACONVERT_API MediaConvertClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MediaConvertClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef MediaConvertClientConfiguration ClientConfigurationType;
      typedef MediaConvertEndpointProvider EndpointProviderType;
 
        MediaConvertClient(const Aws::MediaConvert::MediaConvertClientConfiguration& clientConfiguration = Aws::MediaConvert::MediaConvertClientConfiguration(),
                           std::shared_ptr<MediaConvertEndpointProviderBase> endpointProvider = nullptr);
 
        MediaConvertClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<MediaConvertEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::MediaConvert::MediaConvertClientConfiguration& clientConfiguration = Aws::MediaConvert::MediaConvertClientConfiguration());
 
        MediaConvertClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<MediaConvertEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::MediaConvert::MediaConvertClientConfiguration& clientConfiguration = Aws::MediaConvert::MediaConvertClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        MediaConvertClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaConvertClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaConvertClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~MediaConvertClient();
 
        virtual Model::AssociateCertificateOutcome AssociateCertificate(const Model::AssociateCertificateRequest& request) const;
 
        template<typename AssociateCertificateRequestT = Model::AssociateCertificateRequest>
        Model::AssociateCertificateOutcomeCallable AssociateCertificateCallable(const AssociateCertificateRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::AssociateCertificate, request);
        }
 
        template<typename AssociateCertificateRequestT = Model::AssociateCertificateRequest>
        void AssociateCertificateAsync(const AssociateCertificateRequestT& request, const AssociateCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::AssociateCertificate, request, handler, context);
        }
 
        virtual Model::CancelJobOutcome CancelJob(const Model::CancelJobRequest& request) const;
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        Model::CancelJobOutcomeCallable CancelJobCallable(const CancelJobRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::CancelJob, request);
        }
 
        template<typename CancelJobRequestT = Model::CancelJobRequest>
        void CancelJobAsync(const CancelJobRequestT& request, const CancelJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::CancelJob, 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(&MediaConvertClient::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(&MediaConvertClient::CreateJob, request, handler, context);
        }
 
        virtual Model::CreateJobTemplateOutcome CreateJobTemplate(const Model::CreateJobTemplateRequest& request) const;
 
        template<typename CreateJobTemplateRequestT = Model::CreateJobTemplateRequest>
        Model::CreateJobTemplateOutcomeCallable CreateJobTemplateCallable(const CreateJobTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::CreateJobTemplate, request);
        }
 
        template<typename CreateJobTemplateRequestT = Model::CreateJobTemplateRequest>
        void CreateJobTemplateAsync(const CreateJobTemplateRequestT& request, const CreateJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::CreateJobTemplate, request, handler, context);
        }
 
        virtual Model::CreatePresetOutcome CreatePreset(const Model::CreatePresetRequest& request) const;
 
        template<typename CreatePresetRequestT = Model::CreatePresetRequest>
        Model::CreatePresetOutcomeCallable CreatePresetCallable(const CreatePresetRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::CreatePreset, request);
        }
 
        template<typename CreatePresetRequestT = Model::CreatePresetRequest>
        void CreatePresetAsync(const CreatePresetRequestT& request, const CreatePresetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::CreatePreset, 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(&MediaConvertClient::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(&MediaConvertClient::CreateQueue, request, handler, context);
        }
 
        virtual Model::CreateResourceShareOutcome CreateResourceShare(const Model::CreateResourceShareRequest& request) const;
 
        template<typename CreateResourceShareRequestT = Model::CreateResourceShareRequest>
        Model::CreateResourceShareOutcomeCallable CreateResourceShareCallable(const CreateResourceShareRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::CreateResourceShare, request);
        }
 
        template<typename CreateResourceShareRequestT = Model::CreateResourceShareRequest>
        void CreateResourceShareAsync(const CreateResourceShareRequestT& request, const CreateResourceShareResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::CreateResourceShare, request, handler, context);
        }
 
        virtual Model::DeleteJobTemplateOutcome DeleteJobTemplate(const Model::DeleteJobTemplateRequest& request) const;
 
        template<typename DeleteJobTemplateRequestT = Model::DeleteJobTemplateRequest>
        Model::DeleteJobTemplateOutcomeCallable DeleteJobTemplateCallable(const DeleteJobTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::DeleteJobTemplate, request);
        }
 
        template<typename DeleteJobTemplateRequestT = Model::DeleteJobTemplateRequest>
        void DeleteJobTemplateAsync(const DeleteJobTemplateRequestT& request, const DeleteJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::DeleteJobTemplate, request, handler, context);
        }
 
        virtual Model::DeletePolicyOutcome DeletePolicy(const Model::DeletePolicyRequest& request = {}) const;
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        Model::DeletePolicyOutcomeCallable DeletePolicyCallable(const DeletePolicyRequestT& request = {}) const
        {
            return SubmitCallable(&MediaConvertClient::DeletePolicy, request);
        }
 
        template<typename DeletePolicyRequestT = Model::DeletePolicyRequest>
        void DeletePolicyAsync(const DeletePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeletePolicyRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::DeletePolicy, request, handler, context);
        }
 
        virtual Model::DeletePresetOutcome DeletePreset(const Model::DeletePresetRequest& request) const;
 
        template<typename DeletePresetRequestT = Model::DeletePresetRequest>
        Model::DeletePresetOutcomeCallable DeletePresetCallable(const DeletePresetRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::DeletePreset, request);
        }
 
        template<typename DeletePresetRequestT = Model::DeletePresetRequest>
        void DeletePresetAsync(const DeletePresetRequestT& request, const DeletePresetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::DeletePreset, 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(&MediaConvertClient::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(&MediaConvertClient::DeleteQueue, request, handler, context);
        }
 
        virtual Model::DisassociateCertificateOutcome DisassociateCertificate(const Model::DisassociateCertificateRequest& request) const;
 
        template<typename DisassociateCertificateRequestT = Model::DisassociateCertificateRequest>
        Model::DisassociateCertificateOutcomeCallable DisassociateCertificateCallable(const DisassociateCertificateRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::DisassociateCertificate, request);
        }
 
        template<typename DisassociateCertificateRequestT = Model::DisassociateCertificateRequest>
        void DisassociateCertificateAsync(const DisassociateCertificateRequestT& request, const DisassociateCertificateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::DisassociateCertificate, 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(&MediaConvertClient::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(&MediaConvertClient::GetJob, request, handler, context);
        }
 
        virtual Model::GetJobTemplateOutcome GetJobTemplate(const Model::GetJobTemplateRequest& request) const;
 
        template<typename GetJobTemplateRequestT = Model::GetJobTemplateRequest>
        Model::GetJobTemplateOutcomeCallable GetJobTemplateCallable(const GetJobTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::GetJobTemplate, request);
        }
 
        template<typename GetJobTemplateRequestT = Model::GetJobTemplateRequest>
        void GetJobTemplateAsync(const GetJobTemplateRequestT& request, const GetJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::GetJobTemplate, request, handler, context);
        }
 
        virtual Model::GetPolicyOutcome GetPolicy(const Model::GetPolicyRequest& request = {}) const;
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        Model::GetPolicyOutcomeCallable GetPolicyCallable(const GetPolicyRequestT& request = {}) const
        {
            return SubmitCallable(&MediaConvertClient::GetPolicy, request);
        }
 
        template<typename GetPolicyRequestT = Model::GetPolicyRequest>
        void GetPolicyAsync(const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetPolicyRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::GetPolicy, request, handler, context);
        }
 
        virtual Model::GetPresetOutcome GetPreset(const Model::GetPresetRequest& request) const;
 
        template<typename GetPresetRequestT = Model::GetPresetRequest>
        Model::GetPresetOutcomeCallable GetPresetCallable(const GetPresetRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::GetPreset, request);
        }
 
        template<typename GetPresetRequestT = Model::GetPresetRequest>
        void GetPresetAsync(const GetPresetRequestT& request, const GetPresetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::GetPreset, 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(&MediaConvertClient::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(&MediaConvertClient::GetQueue, request, handler, context);
        }
 
        virtual Model::ListJobTemplatesOutcome ListJobTemplates(const Model::ListJobTemplatesRequest& request = {}) const;
 
        template<typename ListJobTemplatesRequestT = Model::ListJobTemplatesRequest>
        Model::ListJobTemplatesOutcomeCallable ListJobTemplatesCallable(const ListJobTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&MediaConvertClient::ListJobTemplates, request);
        }
 
        template<typename ListJobTemplatesRequestT = Model::ListJobTemplatesRequest>
        void ListJobTemplatesAsync(const ListJobTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListJobTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::ListJobTemplates, 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(&MediaConvertClient::ListJobs, request);
        }
 
        template<typename ListJobsRequestT = Model::ListJobsRequest>
        void ListJobsAsync(const ListJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListJobsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::ListJobs, request, handler, context);
        }
 
        virtual Model::ListPresetsOutcome ListPresets(const Model::ListPresetsRequest& request = {}) const;
 
        template<typename ListPresetsRequestT = Model::ListPresetsRequest>
        Model::ListPresetsOutcomeCallable ListPresetsCallable(const ListPresetsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaConvertClient::ListPresets, request);
        }
 
        template<typename ListPresetsRequestT = Model::ListPresetsRequest>
        void ListPresetsAsync(const ListPresetsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPresetsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::ListPresets, 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(&MediaConvertClient::ListQueues, request);
        }
 
        template<typename ListQueuesRequestT = Model::ListQueuesRequest>
        void ListQueuesAsync(const ListQueuesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListQueuesRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::ListQueues, 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(&MediaConvertClient::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(&MediaConvertClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListVersionsOutcome ListVersions(const Model::ListVersionsRequest& request = {}) const;
 
        template<typename ListVersionsRequestT = Model::ListVersionsRequest>
        Model::ListVersionsOutcomeCallable ListVersionsCallable(const ListVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaConvertClient::ListVersions, request);
        }
 
        template<typename ListVersionsRequestT = Model::ListVersionsRequest>
        void ListVersionsAsync(const ListVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::ListVersions, request, handler, context);
        }
 
        virtual Model::ProbeOutcome Probe(const Model::ProbeRequest& request = {}) const;
 
        template<typename ProbeRequestT = Model::ProbeRequest>
        Model::ProbeOutcomeCallable ProbeCallable(const ProbeRequestT& request = {}) const
        {
            return SubmitCallable(&MediaConvertClient::Probe, request);
        }
 
        template<typename ProbeRequestT = Model::ProbeRequest>
        void ProbeAsync(const ProbeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ProbeRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::Probe, request, handler, context);
        }
 
        virtual Model::PutPolicyOutcome PutPolicy(const Model::PutPolicyRequest& request) const;
 
        template<typename PutPolicyRequestT = Model::PutPolicyRequest>
        Model::PutPolicyOutcomeCallable PutPolicyCallable(const PutPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::PutPolicy, request);
        }
 
        template<typename PutPolicyRequestT = Model::PutPolicyRequest>
        void PutPolicyAsync(const PutPolicyRequestT& request, const PutPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::PutPolicy, 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(&MediaConvertClient::SearchJobs, request);
        }
 
        template<typename SearchJobsRequestT = Model::SearchJobsRequest>
        void SearchJobsAsync(const SearchJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SearchJobsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaConvertClient::SearchJobs, 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(&MediaConvertClient::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(&MediaConvertClient::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(&MediaConvertClient::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(&MediaConvertClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateJobTemplateOutcome UpdateJobTemplate(const Model::UpdateJobTemplateRequest& request) const;
 
        template<typename UpdateJobTemplateRequestT = Model::UpdateJobTemplateRequest>
        Model::UpdateJobTemplateOutcomeCallable UpdateJobTemplateCallable(const UpdateJobTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::UpdateJobTemplate, request);
        }
 
        template<typename UpdateJobTemplateRequestT = Model::UpdateJobTemplateRequest>
        void UpdateJobTemplateAsync(const UpdateJobTemplateRequestT& request, const UpdateJobTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::UpdateJobTemplate, request, handler, context);
        }
 
        virtual Model::UpdatePresetOutcome UpdatePreset(const Model::UpdatePresetRequest& request) const;
 
        template<typename UpdatePresetRequestT = Model::UpdatePresetRequest>
        Model::UpdatePresetOutcomeCallable UpdatePresetCallable(const UpdatePresetRequestT& request) const
        {
            return SubmitCallable(&MediaConvertClient::UpdatePreset, request);
        }
 
        template<typename UpdatePresetRequestT = Model::UpdatePresetRequest>
        void UpdatePresetAsync(const UpdatePresetRequestT& request, const UpdatePresetResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaConvertClient::UpdatePreset, 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(&MediaConvertClient::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(&MediaConvertClient::UpdateQueue, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MediaConvertEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaConvertClient>;
      void init(const MediaConvertClientConfiguration& clientConfiguration);
 
      MediaConvertClientConfiguration m_clientConfiguration;
      std::shared_ptr<MediaConvertEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MediaConvert
} // namespace Aws