MediaConvertClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/mediaconvert/MediaConvertPaginationBase.h>
#include <aws/mediaconvert/MediaConvertServiceClientModel.h>
#include <aws/mediaconvert/MediaConvertWaiter.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
 
namespace Aws {
namespace MediaConvert {
class AWS_MEDIACONVERT_API MediaConvertClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<MediaConvertClient>,
                                                public MediaConvertPaginationBase<MediaConvertClient>,
                                                public MediaConvertWaiter<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::GetJobsQueryResultsOutcome GetJobsQueryResults(const Model::GetJobsQueryResultsRequest& request) const;
 
  template <typename GetJobsQueryResultsRequestT = Model::GetJobsQueryResultsRequest>
  Model::GetJobsQueryResultsOutcomeCallable GetJobsQueryResultsCallable(const GetJobsQueryResultsRequestT& request) const {
    return SubmitCallable(&MediaConvertClient::GetJobsQueryResults, request);
  }
 
  template <typename GetJobsQueryResultsRequestT = Model::GetJobsQueryResultsRequest>
  void GetJobsQueryResultsAsync(const GetJobsQueryResultsRequestT& request, const GetJobsQueryResultsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConvertClient::GetJobsQueryResults, 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::StartJobsQueryOutcome StartJobsQuery(const Model::StartJobsQueryRequest& request = {}) const;
 
  template <typename StartJobsQueryRequestT = Model::StartJobsQueryRequest>
  Model::StartJobsQueryOutcomeCallable StartJobsQueryCallable(const StartJobsQueryRequestT& request = {}) const {
    return SubmitCallable(&MediaConvertClient::StartJobsQuery, request);
  }
 
  template <typename StartJobsQueryRequestT = Model::StartJobsQueryRequest>
  void StartJobsQueryAsync(const StartJobsQueryResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const StartJobsQueryRequestT& request = {}) const {
    return SubmitAsync(&MediaConvertClient::StartJobsQuery, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MediaConvertEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaConvertClient>;
  void init(const MediaConvertClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MediaConvertError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  MediaConvertClientConfiguration m_clientConfiguration;
  std::shared_ptr<MediaConvertEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MediaConvert
}  // namespace Aws