MediaTailorClient.h

 
#pragma once
#include <aws/mediatailor/MediaTailor_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/mediatailor/MediaTailorServiceClientModel.h>
 
namespace Aws
{
namespace MediaTailor
{
  class AWS_MEDIATAILOR_API MediaTailorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MediaTailorClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef MediaTailorClientConfiguration ClientConfigurationType;
      typedef MediaTailorEndpointProvider EndpointProviderType;
 
        MediaTailorClient(const Aws::MediaTailor::MediaTailorClientConfiguration& clientConfiguration = Aws::MediaTailor::MediaTailorClientConfiguration(),
                          std::shared_ptr<MediaTailorEndpointProviderBase> endpointProvider = nullptr);
 
        MediaTailorClient(const Aws::Auth::AWSCredentials& credentials,
                          std::shared_ptr<MediaTailorEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::MediaTailor::MediaTailorClientConfiguration& clientConfiguration = Aws::MediaTailor::MediaTailorClientConfiguration());
 
        MediaTailorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          std::shared_ptr<MediaTailorEndpointProviderBase> endpointProvider = nullptr,
                          const Aws::MediaTailor::MediaTailorClientConfiguration& clientConfiguration = Aws::MediaTailor::MediaTailorClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        MediaTailorClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaTailorClient(const Aws::Auth::AWSCredentials& credentials,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaTailorClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                          const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~MediaTailorClient();
 
        virtual Model::ConfigureLogsForChannelOutcome ConfigureLogsForChannel(const Model::ConfigureLogsForChannelRequest& request) const;
 
        template<typename ConfigureLogsForChannelRequestT = Model::ConfigureLogsForChannelRequest>
        Model::ConfigureLogsForChannelOutcomeCallable ConfigureLogsForChannelCallable(const ConfigureLogsForChannelRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::ConfigureLogsForChannel, request);
        }
 
        template<typename ConfigureLogsForChannelRequestT = Model::ConfigureLogsForChannelRequest>
        void ConfigureLogsForChannelAsync(const ConfigureLogsForChannelRequestT& request, const ConfigureLogsForChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::ConfigureLogsForChannel, request, handler, context);
        }
 
        virtual Model::ConfigureLogsForPlaybackConfigurationOutcome ConfigureLogsForPlaybackConfiguration(const Model::ConfigureLogsForPlaybackConfigurationRequest& request) const;
 
        template<typename ConfigureLogsForPlaybackConfigurationRequestT = Model::ConfigureLogsForPlaybackConfigurationRequest>
        Model::ConfigureLogsForPlaybackConfigurationOutcomeCallable ConfigureLogsForPlaybackConfigurationCallable(const ConfigureLogsForPlaybackConfigurationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::ConfigureLogsForPlaybackConfiguration, request);
        }
 
        template<typename ConfigureLogsForPlaybackConfigurationRequestT = Model::ConfigureLogsForPlaybackConfigurationRequest>
        void ConfigureLogsForPlaybackConfigurationAsync(const ConfigureLogsForPlaybackConfigurationRequestT& request, const ConfigureLogsForPlaybackConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::ConfigureLogsForPlaybackConfiguration, request, handler, context);
        }
 
        virtual Model::CreateChannelOutcome CreateChannel(const Model::CreateChannelRequest& request) const;
 
        template<typename CreateChannelRequestT = Model::CreateChannelRequest>
        Model::CreateChannelOutcomeCallable CreateChannelCallable(const CreateChannelRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::CreateChannel, request);
        }
 
        template<typename CreateChannelRequestT = Model::CreateChannelRequest>
        void CreateChannelAsync(const CreateChannelRequestT& request, const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::CreateChannel, request, handler, context);
        }
 
        virtual Model::CreateLiveSourceOutcome CreateLiveSource(const Model::CreateLiveSourceRequest& request) const;
 
        template<typename CreateLiveSourceRequestT = Model::CreateLiveSourceRequest>
        Model::CreateLiveSourceOutcomeCallable CreateLiveSourceCallable(const CreateLiveSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::CreateLiveSource, request);
        }
 
        template<typename CreateLiveSourceRequestT = Model::CreateLiveSourceRequest>
        void CreateLiveSourceAsync(const CreateLiveSourceRequestT& request, const CreateLiveSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::CreateLiveSource, request, handler, context);
        }
 
        virtual Model::CreatePrefetchScheduleOutcome CreatePrefetchSchedule(const Model::CreatePrefetchScheduleRequest& request) const;
 
        template<typename CreatePrefetchScheduleRequestT = Model::CreatePrefetchScheduleRequest>
        Model::CreatePrefetchScheduleOutcomeCallable CreatePrefetchScheduleCallable(const CreatePrefetchScheduleRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::CreatePrefetchSchedule, request);
        }
 
        template<typename CreatePrefetchScheduleRequestT = Model::CreatePrefetchScheduleRequest>
        void CreatePrefetchScheduleAsync(const CreatePrefetchScheduleRequestT& request, const CreatePrefetchScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::CreatePrefetchSchedule, request, handler, context);
        }
 
        virtual Model::CreateProgramOutcome CreateProgram(const Model::CreateProgramRequest& request) const;
 
        template<typename CreateProgramRequestT = Model::CreateProgramRequest>
        Model::CreateProgramOutcomeCallable CreateProgramCallable(const CreateProgramRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::CreateProgram, request);
        }
 
        template<typename CreateProgramRequestT = Model::CreateProgramRequest>
        void CreateProgramAsync(const CreateProgramRequestT& request, const CreateProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::CreateProgram, request, handler, context);
        }
 
        virtual Model::CreateSourceLocationOutcome CreateSourceLocation(const Model::CreateSourceLocationRequest& request) const;
 
        template<typename CreateSourceLocationRequestT = Model::CreateSourceLocationRequest>
        Model::CreateSourceLocationOutcomeCallable CreateSourceLocationCallable(const CreateSourceLocationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::CreateSourceLocation, request);
        }
 
        template<typename CreateSourceLocationRequestT = Model::CreateSourceLocationRequest>
        void CreateSourceLocationAsync(const CreateSourceLocationRequestT& request, const CreateSourceLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::CreateSourceLocation, request, handler, context);
        }
 
        virtual Model::CreateVodSourceOutcome CreateVodSource(const Model::CreateVodSourceRequest& request) const;
 
        template<typename CreateVodSourceRequestT = Model::CreateVodSourceRequest>
        Model::CreateVodSourceOutcomeCallable CreateVodSourceCallable(const CreateVodSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::CreateVodSource, request);
        }
 
        template<typename CreateVodSourceRequestT = Model::CreateVodSourceRequest>
        void CreateVodSourceAsync(const CreateVodSourceRequestT& request, const CreateVodSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::CreateVodSource, request, handler, context);
        }
 
        virtual Model::DeleteChannelOutcome DeleteChannel(const Model::DeleteChannelRequest& request) const;
 
        template<typename DeleteChannelRequestT = Model::DeleteChannelRequest>
        Model::DeleteChannelOutcomeCallable DeleteChannelCallable(const DeleteChannelRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeleteChannel, request);
        }
 
        template<typename DeleteChannelRequestT = Model::DeleteChannelRequest>
        void DeleteChannelAsync(const DeleteChannelRequestT& request, const DeleteChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeleteChannel, request, handler, context);
        }
 
        virtual Model::DeleteChannelPolicyOutcome DeleteChannelPolicy(const Model::DeleteChannelPolicyRequest& request) const;
 
        template<typename DeleteChannelPolicyRequestT = Model::DeleteChannelPolicyRequest>
        Model::DeleteChannelPolicyOutcomeCallable DeleteChannelPolicyCallable(const DeleteChannelPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeleteChannelPolicy, request);
        }
 
        template<typename DeleteChannelPolicyRequestT = Model::DeleteChannelPolicyRequest>
        void DeleteChannelPolicyAsync(const DeleteChannelPolicyRequestT& request, const DeleteChannelPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeleteChannelPolicy, request, handler, context);
        }
 
        virtual Model::DeleteLiveSourceOutcome DeleteLiveSource(const Model::DeleteLiveSourceRequest& request) const;
 
        template<typename DeleteLiveSourceRequestT = Model::DeleteLiveSourceRequest>
        Model::DeleteLiveSourceOutcomeCallable DeleteLiveSourceCallable(const DeleteLiveSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeleteLiveSource, request);
        }
 
        template<typename DeleteLiveSourceRequestT = Model::DeleteLiveSourceRequest>
        void DeleteLiveSourceAsync(const DeleteLiveSourceRequestT& request, const DeleteLiveSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeleteLiveSource, request, handler, context);
        }
 
        virtual Model::DeletePlaybackConfigurationOutcome DeletePlaybackConfiguration(const Model::DeletePlaybackConfigurationRequest& request) const;
 
        template<typename DeletePlaybackConfigurationRequestT = Model::DeletePlaybackConfigurationRequest>
        Model::DeletePlaybackConfigurationOutcomeCallable DeletePlaybackConfigurationCallable(const DeletePlaybackConfigurationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeletePlaybackConfiguration, request);
        }
 
        template<typename DeletePlaybackConfigurationRequestT = Model::DeletePlaybackConfigurationRequest>
        void DeletePlaybackConfigurationAsync(const DeletePlaybackConfigurationRequestT& request, const DeletePlaybackConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeletePlaybackConfiguration, request, handler, context);
        }
 
        virtual Model::DeletePrefetchScheduleOutcome DeletePrefetchSchedule(const Model::DeletePrefetchScheduleRequest& request) const;
 
        template<typename DeletePrefetchScheduleRequestT = Model::DeletePrefetchScheduleRequest>
        Model::DeletePrefetchScheduleOutcomeCallable DeletePrefetchScheduleCallable(const DeletePrefetchScheduleRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeletePrefetchSchedule, request);
        }
 
        template<typename DeletePrefetchScheduleRequestT = Model::DeletePrefetchScheduleRequest>
        void DeletePrefetchScheduleAsync(const DeletePrefetchScheduleRequestT& request, const DeletePrefetchScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeletePrefetchSchedule, request, handler, context);
        }
 
        virtual Model::DeleteProgramOutcome DeleteProgram(const Model::DeleteProgramRequest& request) const;
 
        template<typename DeleteProgramRequestT = Model::DeleteProgramRequest>
        Model::DeleteProgramOutcomeCallable DeleteProgramCallable(const DeleteProgramRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeleteProgram, request);
        }
 
        template<typename DeleteProgramRequestT = Model::DeleteProgramRequest>
        void DeleteProgramAsync(const DeleteProgramRequestT& request, const DeleteProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeleteProgram, request, handler, context);
        }
 
        virtual Model::DeleteSourceLocationOutcome DeleteSourceLocation(const Model::DeleteSourceLocationRequest& request) const;
 
        template<typename DeleteSourceLocationRequestT = Model::DeleteSourceLocationRequest>
        Model::DeleteSourceLocationOutcomeCallable DeleteSourceLocationCallable(const DeleteSourceLocationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeleteSourceLocation, request);
        }
 
        template<typename DeleteSourceLocationRequestT = Model::DeleteSourceLocationRequest>
        void DeleteSourceLocationAsync(const DeleteSourceLocationRequestT& request, const DeleteSourceLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeleteSourceLocation, request, handler, context);
        }
 
        virtual Model::DeleteVodSourceOutcome DeleteVodSource(const Model::DeleteVodSourceRequest& request) const;
 
        template<typename DeleteVodSourceRequestT = Model::DeleteVodSourceRequest>
        Model::DeleteVodSourceOutcomeCallable DeleteVodSourceCallable(const DeleteVodSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DeleteVodSource, request);
        }
 
        template<typename DeleteVodSourceRequestT = Model::DeleteVodSourceRequest>
        void DeleteVodSourceAsync(const DeleteVodSourceRequestT& request, const DeleteVodSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DeleteVodSource, request, handler, context);
        }
 
        virtual Model::DescribeChannelOutcome DescribeChannel(const Model::DescribeChannelRequest& request) const;
 
        template<typename DescribeChannelRequestT = Model::DescribeChannelRequest>
        Model::DescribeChannelOutcomeCallable DescribeChannelCallable(const DescribeChannelRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DescribeChannel, request);
        }
 
        template<typename DescribeChannelRequestT = Model::DescribeChannelRequest>
        void DescribeChannelAsync(const DescribeChannelRequestT& request, const DescribeChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DescribeChannel, request, handler, context);
        }
 
        virtual Model::DescribeLiveSourceOutcome DescribeLiveSource(const Model::DescribeLiveSourceRequest& request) const;
 
        template<typename DescribeLiveSourceRequestT = Model::DescribeLiveSourceRequest>
        Model::DescribeLiveSourceOutcomeCallable DescribeLiveSourceCallable(const DescribeLiveSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DescribeLiveSource, request);
        }
 
        template<typename DescribeLiveSourceRequestT = Model::DescribeLiveSourceRequest>
        void DescribeLiveSourceAsync(const DescribeLiveSourceRequestT& request, const DescribeLiveSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DescribeLiveSource, request, handler, context);
        }
 
        virtual Model::DescribeProgramOutcome DescribeProgram(const Model::DescribeProgramRequest& request) const;
 
        template<typename DescribeProgramRequestT = Model::DescribeProgramRequest>
        Model::DescribeProgramOutcomeCallable DescribeProgramCallable(const DescribeProgramRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DescribeProgram, request);
        }
 
        template<typename DescribeProgramRequestT = Model::DescribeProgramRequest>
        void DescribeProgramAsync(const DescribeProgramRequestT& request, const DescribeProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DescribeProgram, request, handler, context);
        }
 
        virtual Model::DescribeSourceLocationOutcome DescribeSourceLocation(const Model::DescribeSourceLocationRequest& request) const;
 
        template<typename DescribeSourceLocationRequestT = Model::DescribeSourceLocationRequest>
        Model::DescribeSourceLocationOutcomeCallable DescribeSourceLocationCallable(const DescribeSourceLocationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DescribeSourceLocation, request);
        }
 
        template<typename DescribeSourceLocationRequestT = Model::DescribeSourceLocationRequest>
        void DescribeSourceLocationAsync(const DescribeSourceLocationRequestT& request, const DescribeSourceLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DescribeSourceLocation, request, handler, context);
        }
 
        virtual Model::DescribeVodSourceOutcome DescribeVodSource(const Model::DescribeVodSourceRequest& request) const;
 
        template<typename DescribeVodSourceRequestT = Model::DescribeVodSourceRequest>
        Model::DescribeVodSourceOutcomeCallable DescribeVodSourceCallable(const DescribeVodSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::DescribeVodSource, request);
        }
 
        template<typename DescribeVodSourceRequestT = Model::DescribeVodSourceRequest>
        void DescribeVodSourceAsync(const DescribeVodSourceRequestT& request, const DescribeVodSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::DescribeVodSource, request, handler, context);
        }
 
        virtual Model::GetChannelPolicyOutcome GetChannelPolicy(const Model::GetChannelPolicyRequest& request) const;
 
        template<typename GetChannelPolicyRequestT = Model::GetChannelPolicyRequest>
        Model::GetChannelPolicyOutcomeCallable GetChannelPolicyCallable(const GetChannelPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::GetChannelPolicy, request);
        }
 
        template<typename GetChannelPolicyRequestT = Model::GetChannelPolicyRequest>
        void GetChannelPolicyAsync(const GetChannelPolicyRequestT& request, const GetChannelPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::GetChannelPolicy, request, handler, context);
        }
 
        virtual Model::GetChannelScheduleOutcome GetChannelSchedule(const Model::GetChannelScheduleRequest& request) const;
 
        template<typename GetChannelScheduleRequestT = Model::GetChannelScheduleRequest>
        Model::GetChannelScheduleOutcomeCallable GetChannelScheduleCallable(const GetChannelScheduleRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::GetChannelSchedule, request);
        }
 
        template<typename GetChannelScheduleRequestT = Model::GetChannelScheduleRequest>
        void GetChannelScheduleAsync(const GetChannelScheduleRequestT& request, const GetChannelScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::GetChannelSchedule, request, handler, context);
        }
 
        virtual Model::GetPlaybackConfigurationOutcome GetPlaybackConfiguration(const Model::GetPlaybackConfigurationRequest& request) const;
 
        template<typename GetPlaybackConfigurationRequestT = Model::GetPlaybackConfigurationRequest>
        Model::GetPlaybackConfigurationOutcomeCallable GetPlaybackConfigurationCallable(const GetPlaybackConfigurationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::GetPlaybackConfiguration, request);
        }
 
        template<typename GetPlaybackConfigurationRequestT = Model::GetPlaybackConfigurationRequest>
        void GetPlaybackConfigurationAsync(const GetPlaybackConfigurationRequestT& request, const GetPlaybackConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::GetPlaybackConfiguration, request, handler, context);
        }
 
        virtual Model::GetPrefetchScheduleOutcome GetPrefetchSchedule(const Model::GetPrefetchScheduleRequest& request) const;
 
        template<typename GetPrefetchScheduleRequestT = Model::GetPrefetchScheduleRequest>
        Model::GetPrefetchScheduleOutcomeCallable GetPrefetchScheduleCallable(const GetPrefetchScheduleRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::GetPrefetchSchedule, request);
        }
 
        template<typename GetPrefetchScheduleRequestT = Model::GetPrefetchScheduleRequest>
        void GetPrefetchScheduleAsync(const GetPrefetchScheduleRequestT& request, const GetPrefetchScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::GetPrefetchSchedule, request, handler, context);
        }
 
        virtual Model::ListAlertsOutcome ListAlerts(const Model::ListAlertsRequest& request) const;
 
        template<typename ListAlertsRequestT = Model::ListAlertsRequest>
        Model::ListAlertsOutcomeCallable ListAlertsCallable(const ListAlertsRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::ListAlerts, request);
        }
 
        template<typename ListAlertsRequestT = Model::ListAlertsRequest>
        void ListAlertsAsync(const ListAlertsRequestT& request, const ListAlertsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::ListAlerts, request, handler, context);
        }
 
        virtual Model::ListChannelsOutcome ListChannels(const Model::ListChannelsRequest& request = {}) const;
 
        template<typename ListChannelsRequestT = Model::ListChannelsRequest>
        Model::ListChannelsOutcomeCallable ListChannelsCallable(const ListChannelsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaTailorClient::ListChannels, request);
        }
 
        template<typename ListChannelsRequestT = Model::ListChannelsRequest>
        void ListChannelsAsync(const ListChannelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListChannelsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaTailorClient::ListChannels, request, handler, context);
        }
 
        virtual Model::ListLiveSourcesOutcome ListLiveSources(const Model::ListLiveSourcesRequest& request) const;
 
        template<typename ListLiveSourcesRequestT = Model::ListLiveSourcesRequest>
        Model::ListLiveSourcesOutcomeCallable ListLiveSourcesCallable(const ListLiveSourcesRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::ListLiveSources, request);
        }
 
        template<typename ListLiveSourcesRequestT = Model::ListLiveSourcesRequest>
        void ListLiveSourcesAsync(const ListLiveSourcesRequestT& request, const ListLiveSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::ListLiveSources, request, handler, context);
        }
 
        virtual Model::ListPlaybackConfigurationsOutcome ListPlaybackConfigurations(const Model::ListPlaybackConfigurationsRequest& request = {}) const;
 
        template<typename ListPlaybackConfigurationsRequestT = Model::ListPlaybackConfigurationsRequest>
        Model::ListPlaybackConfigurationsOutcomeCallable ListPlaybackConfigurationsCallable(const ListPlaybackConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaTailorClient::ListPlaybackConfigurations, request);
        }
 
        template<typename ListPlaybackConfigurationsRequestT = Model::ListPlaybackConfigurationsRequest>
        void ListPlaybackConfigurationsAsync(const ListPlaybackConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListPlaybackConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaTailorClient::ListPlaybackConfigurations, request, handler, context);
        }
 
        virtual Model::ListPrefetchSchedulesOutcome ListPrefetchSchedules(const Model::ListPrefetchSchedulesRequest& request) const;
 
        template<typename ListPrefetchSchedulesRequestT = Model::ListPrefetchSchedulesRequest>
        Model::ListPrefetchSchedulesOutcomeCallable ListPrefetchSchedulesCallable(const ListPrefetchSchedulesRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::ListPrefetchSchedules, request);
        }
 
        template<typename ListPrefetchSchedulesRequestT = Model::ListPrefetchSchedulesRequest>
        void ListPrefetchSchedulesAsync(const ListPrefetchSchedulesRequestT& request, const ListPrefetchSchedulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::ListPrefetchSchedules, request, handler, context);
        }
 
        virtual Model::ListSourceLocationsOutcome ListSourceLocations(const Model::ListSourceLocationsRequest& request = {}) const;
 
        template<typename ListSourceLocationsRequestT = Model::ListSourceLocationsRequest>
        Model::ListSourceLocationsOutcomeCallable ListSourceLocationsCallable(const ListSourceLocationsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaTailorClient::ListSourceLocations, request);
        }
 
        template<typename ListSourceLocationsRequestT = Model::ListSourceLocationsRequest>
        void ListSourceLocationsAsync(const ListSourceLocationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSourceLocationsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaTailorClient::ListSourceLocations, 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(&MediaTailorClient::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(&MediaTailorClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListVodSourcesOutcome ListVodSources(const Model::ListVodSourcesRequest& request) const;
 
        template<typename ListVodSourcesRequestT = Model::ListVodSourcesRequest>
        Model::ListVodSourcesOutcomeCallable ListVodSourcesCallable(const ListVodSourcesRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::ListVodSources, request);
        }
 
        template<typename ListVodSourcesRequestT = Model::ListVodSourcesRequest>
        void ListVodSourcesAsync(const ListVodSourcesRequestT& request, const ListVodSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::ListVodSources, request, handler, context);
        }
 
        virtual Model::PutChannelPolicyOutcome PutChannelPolicy(const Model::PutChannelPolicyRequest& request) const;
 
        template<typename PutChannelPolicyRequestT = Model::PutChannelPolicyRequest>
        Model::PutChannelPolicyOutcomeCallable PutChannelPolicyCallable(const PutChannelPolicyRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::PutChannelPolicy, request);
        }
 
        template<typename PutChannelPolicyRequestT = Model::PutChannelPolicyRequest>
        void PutChannelPolicyAsync(const PutChannelPolicyRequestT& request, const PutChannelPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::PutChannelPolicy, request, handler, context);
        }
 
        virtual Model::PutPlaybackConfigurationOutcome PutPlaybackConfiguration(const Model::PutPlaybackConfigurationRequest& request) const;
 
        template<typename PutPlaybackConfigurationRequestT = Model::PutPlaybackConfigurationRequest>
        Model::PutPlaybackConfigurationOutcomeCallable PutPlaybackConfigurationCallable(const PutPlaybackConfigurationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::PutPlaybackConfiguration, request);
        }
 
        template<typename PutPlaybackConfigurationRequestT = Model::PutPlaybackConfigurationRequest>
        void PutPlaybackConfigurationAsync(const PutPlaybackConfigurationRequestT& request, const PutPlaybackConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::PutPlaybackConfiguration, request, handler, context);
        }
 
        virtual Model::StartChannelOutcome StartChannel(const Model::StartChannelRequest& request) const;
 
        template<typename StartChannelRequestT = Model::StartChannelRequest>
        Model::StartChannelOutcomeCallable StartChannelCallable(const StartChannelRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::StartChannel, request);
        }
 
        template<typename StartChannelRequestT = Model::StartChannelRequest>
        void StartChannelAsync(const StartChannelRequestT& request, const StartChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::StartChannel, request, handler, context);
        }
 
        virtual Model::StopChannelOutcome StopChannel(const Model::StopChannelRequest& request) const;
 
        template<typename StopChannelRequestT = Model::StopChannelRequest>
        Model::StopChannelOutcomeCallable StopChannelCallable(const StopChannelRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::StopChannel, request);
        }
 
        template<typename StopChannelRequestT = Model::StopChannelRequest>
        void StopChannelAsync(const StopChannelRequestT& request, const StopChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::StopChannel, 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(&MediaTailorClient::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(&MediaTailorClient::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(&MediaTailorClient::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(&MediaTailorClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateChannelOutcome UpdateChannel(const Model::UpdateChannelRequest& request) const;
 
        template<typename UpdateChannelRequestT = Model::UpdateChannelRequest>
        Model::UpdateChannelOutcomeCallable UpdateChannelCallable(const UpdateChannelRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::UpdateChannel, request);
        }
 
        template<typename UpdateChannelRequestT = Model::UpdateChannelRequest>
        void UpdateChannelAsync(const UpdateChannelRequestT& request, const UpdateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::UpdateChannel, request, handler, context);
        }
 
        virtual Model::UpdateLiveSourceOutcome UpdateLiveSource(const Model::UpdateLiveSourceRequest& request) const;
 
        template<typename UpdateLiveSourceRequestT = Model::UpdateLiveSourceRequest>
        Model::UpdateLiveSourceOutcomeCallable UpdateLiveSourceCallable(const UpdateLiveSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::UpdateLiveSource, request);
        }
 
        template<typename UpdateLiveSourceRequestT = Model::UpdateLiveSourceRequest>
        void UpdateLiveSourceAsync(const UpdateLiveSourceRequestT& request, const UpdateLiveSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::UpdateLiveSource, request, handler, context);
        }
 
        virtual Model::UpdateProgramOutcome UpdateProgram(const Model::UpdateProgramRequest& request) const;
 
        template<typename UpdateProgramRequestT = Model::UpdateProgramRequest>
        Model::UpdateProgramOutcomeCallable UpdateProgramCallable(const UpdateProgramRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::UpdateProgram, request);
        }
 
        template<typename UpdateProgramRequestT = Model::UpdateProgramRequest>
        void UpdateProgramAsync(const UpdateProgramRequestT& request, const UpdateProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::UpdateProgram, request, handler, context);
        }
 
        virtual Model::UpdateSourceLocationOutcome UpdateSourceLocation(const Model::UpdateSourceLocationRequest& request) const;
 
        template<typename UpdateSourceLocationRequestT = Model::UpdateSourceLocationRequest>
        Model::UpdateSourceLocationOutcomeCallable UpdateSourceLocationCallable(const UpdateSourceLocationRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::UpdateSourceLocation, request);
        }
 
        template<typename UpdateSourceLocationRequestT = Model::UpdateSourceLocationRequest>
        void UpdateSourceLocationAsync(const UpdateSourceLocationRequestT& request, const UpdateSourceLocationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::UpdateSourceLocation, request, handler, context);
        }
 
        virtual Model::UpdateVodSourceOutcome UpdateVodSource(const Model::UpdateVodSourceRequest& request) const;
 
        template<typename UpdateVodSourceRequestT = Model::UpdateVodSourceRequest>
        Model::UpdateVodSourceOutcomeCallable UpdateVodSourceCallable(const UpdateVodSourceRequestT& request) const
        {
            return SubmitCallable(&MediaTailorClient::UpdateVodSource, request);
        }
 
        template<typename UpdateVodSourceRequestT = Model::UpdateVodSourceRequest>
        void UpdateVodSourceAsync(const UpdateVodSourceRequestT& request, const UpdateVodSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaTailorClient::UpdateVodSource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MediaTailorEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaTailorClient>;
      void init(const MediaTailorClientConfiguration& clientConfiguration);
 
      MediaTailorClientConfiguration m_clientConfiguration;
      std::shared_ptr<MediaTailorEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MediaTailor
} // namespace Aws