MediaLiveClient.h

 
#pragma once
#include <aws/medialive/MediaLive_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/medialive/MediaLiveServiceClientModel.h>
 
namespace Aws
{
namespace MediaLive
{
  class AWS_MEDIALIVE_API MediaLiveClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<MediaLiveClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef MediaLiveClientConfiguration ClientConfigurationType;
      typedef MediaLiveEndpointProvider EndpointProviderType;
 
        MediaLiveClient(const Aws::MediaLive::MediaLiveClientConfiguration& clientConfiguration = Aws::MediaLive::MediaLiveClientConfiguration(),
                        std::shared_ptr<MediaLiveEndpointProviderBase> endpointProvider = nullptr);
 
        MediaLiveClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<MediaLiveEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::MediaLive::MediaLiveClientConfiguration& clientConfiguration = Aws::MediaLive::MediaLiveClientConfiguration());
 
        MediaLiveClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<MediaLiveEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::MediaLive::MediaLiveClientConfiguration& clientConfiguration = Aws::MediaLive::MediaLiveClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        MediaLiveClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaLiveClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        MediaLiveClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~MediaLiveClient();
 
        virtual Model::AcceptInputDeviceTransferOutcome AcceptInputDeviceTransfer(const Model::AcceptInputDeviceTransferRequest& request) const;
 
        template<typename AcceptInputDeviceTransferRequestT = Model::AcceptInputDeviceTransferRequest>
        Model::AcceptInputDeviceTransferOutcomeCallable AcceptInputDeviceTransferCallable(const AcceptInputDeviceTransferRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::AcceptInputDeviceTransfer, request);
        }
 
        template<typename AcceptInputDeviceTransferRequestT = Model::AcceptInputDeviceTransferRequest>
        void AcceptInputDeviceTransferAsync(const AcceptInputDeviceTransferRequestT& request, const AcceptInputDeviceTransferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::AcceptInputDeviceTransfer, request, handler, context);
        }
 
        virtual Model::BatchDeleteOutcome BatchDelete(const Model::BatchDeleteRequest& request = {}) const;
 
        template<typename BatchDeleteRequestT = Model::BatchDeleteRequest>
        Model::BatchDeleteOutcomeCallable BatchDeleteCallable(const BatchDeleteRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::BatchDelete, request);
        }
 
        template<typename BatchDeleteRequestT = Model::BatchDeleteRequest>
        void BatchDeleteAsync(const BatchDeleteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const BatchDeleteRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::BatchDelete, request, handler, context);
        }
 
        virtual Model::BatchStartOutcome BatchStart(const Model::BatchStartRequest& request = {}) const;
 
        template<typename BatchStartRequestT = Model::BatchStartRequest>
        Model::BatchStartOutcomeCallable BatchStartCallable(const BatchStartRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::BatchStart, request);
        }
 
        template<typename BatchStartRequestT = Model::BatchStartRequest>
        void BatchStartAsync(const BatchStartResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const BatchStartRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::BatchStart, request, handler, context);
        }
 
        virtual Model::BatchStopOutcome BatchStop(const Model::BatchStopRequest& request = {}) const;
 
        template<typename BatchStopRequestT = Model::BatchStopRequest>
        Model::BatchStopOutcomeCallable BatchStopCallable(const BatchStopRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::BatchStop, request);
        }
 
        template<typename BatchStopRequestT = Model::BatchStopRequest>
        void BatchStopAsync(const BatchStopResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const BatchStopRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::BatchStop, request, handler, context);
        }
 
        virtual Model::BatchUpdateScheduleOutcome BatchUpdateSchedule(const Model::BatchUpdateScheduleRequest& request) const;
 
        template<typename BatchUpdateScheduleRequestT = Model::BatchUpdateScheduleRequest>
        Model::BatchUpdateScheduleOutcomeCallable BatchUpdateScheduleCallable(const BatchUpdateScheduleRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::BatchUpdateSchedule, request);
        }
 
        template<typename BatchUpdateScheduleRequestT = Model::BatchUpdateScheduleRequest>
        void BatchUpdateScheduleAsync(const BatchUpdateScheduleRequestT& request, const BatchUpdateScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::BatchUpdateSchedule, request, handler, context);
        }
 
        virtual Model::CancelInputDeviceTransferOutcome CancelInputDeviceTransfer(const Model::CancelInputDeviceTransferRequest& request) const;
 
        template<typename CancelInputDeviceTransferRequestT = Model::CancelInputDeviceTransferRequest>
        Model::CancelInputDeviceTransferOutcomeCallable CancelInputDeviceTransferCallable(const CancelInputDeviceTransferRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CancelInputDeviceTransfer, request);
        }
 
        template<typename CancelInputDeviceTransferRequestT = Model::CancelInputDeviceTransferRequest>
        void CancelInputDeviceTransferAsync(const CancelInputDeviceTransferRequestT& request, const CancelInputDeviceTransferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CancelInputDeviceTransfer, request, handler, context);
        }
 
        virtual Model::ClaimDeviceOutcome ClaimDevice(const Model::ClaimDeviceRequest& request = {}) const;
 
        template<typename ClaimDeviceRequestT = Model::ClaimDeviceRequest>
        Model::ClaimDeviceOutcomeCallable ClaimDeviceCallable(const ClaimDeviceRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ClaimDevice, request);
        }
 
        template<typename ClaimDeviceRequestT = Model::ClaimDeviceRequest>
        void ClaimDeviceAsync(const ClaimDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ClaimDeviceRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ClaimDevice, 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(&MediaLiveClient::CreateChannel, request);
        }
 
        template<typename CreateChannelRequestT = Model::CreateChannelRequest>
        void CreateChannelAsync(const CreateChannelResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateChannelRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::CreateChannel, request, handler, context);
        }
 
        virtual Model::CreateChannelPlacementGroupOutcome CreateChannelPlacementGroup(const Model::CreateChannelPlacementGroupRequest& request) const;
 
        template<typename CreateChannelPlacementGroupRequestT = Model::CreateChannelPlacementGroupRequest>
        Model::CreateChannelPlacementGroupOutcomeCallable CreateChannelPlacementGroupCallable(const CreateChannelPlacementGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateChannelPlacementGroup, request);
        }
 
        template<typename CreateChannelPlacementGroupRequestT = Model::CreateChannelPlacementGroupRequest>
        void CreateChannelPlacementGroupAsync(const CreateChannelPlacementGroupRequestT& request, const CreateChannelPlacementGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateChannelPlacementGroup, request, handler, context);
        }
 
        virtual Model::CreateCloudWatchAlarmTemplateOutcome CreateCloudWatchAlarmTemplate(const Model::CreateCloudWatchAlarmTemplateRequest& request) const;
 
        template<typename CreateCloudWatchAlarmTemplateRequestT = Model::CreateCloudWatchAlarmTemplateRequest>
        Model::CreateCloudWatchAlarmTemplateOutcomeCallable CreateCloudWatchAlarmTemplateCallable(const CreateCloudWatchAlarmTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateCloudWatchAlarmTemplate, request);
        }
 
        template<typename CreateCloudWatchAlarmTemplateRequestT = Model::CreateCloudWatchAlarmTemplateRequest>
        void CreateCloudWatchAlarmTemplateAsync(const CreateCloudWatchAlarmTemplateRequestT& request, const CreateCloudWatchAlarmTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateCloudWatchAlarmTemplate, request, handler, context);
        }
 
        virtual Model::CreateCloudWatchAlarmTemplateGroupOutcome CreateCloudWatchAlarmTemplateGroup(const Model::CreateCloudWatchAlarmTemplateGroupRequest& request) const;
 
        template<typename CreateCloudWatchAlarmTemplateGroupRequestT = Model::CreateCloudWatchAlarmTemplateGroupRequest>
        Model::CreateCloudWatchAlarmTemplateGroupOutcomeCallable CreateCloudWatchAlarmTemplateGroupCallable(const CreateCloudWatchAlarmTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateCloudWatchAlarmTemplateGroup, request);
        }
 
        template<typename CreateCloudWatchAlarmTemplateGroupRequestT = Model::CreateCloudWatchAlarmTemplateGroupRequest>
        void CreateCloudWatchAlarmTemplateGroupAsync(const CreateCloudWatchAlarmTemplateGroupRequestT& request, const CreateCloudWatchAlarmTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateCloudWatchAlarmTemplateGroup, request, handler, context);
        }
 
        virtual Model::CreateClusterOutcome CreateCluster(const Model::CreateClusterRequest& request = {}) const;
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        Model::CreateClusterOutcomeCallable CreateClusterCallable(const CreateClusterRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::CreateCluster, request);
        }
 
        template<typename CreateClusterRequestT = Model::CreateClusterRequest>
        void CreateClusterAsync(const CreateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateClusterRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::CreateCluster, request, handler, context);
        }
 
        virtual Model::CreateEventBridgeRuleTemplateOutcome CreateEventBridgeRuleTemplate(const Model::CreateEventBridgeRuleTemplateRequest& request) const;
 
        template<typename CreateEventBridgeRuleTemplateRequestT = Model::CreateEventBridgeRuleTemplateRequest>
        Model::CreateEventBridgeRuleTemplateOutcomeCallable CreateEventBridgeRuleTemplateCallable(const CreateEventBridgeRuleTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateEventBridgeRuleTemplate, request);
        }
 
        template<typename CreateEventBridgeRuleTemplateRequestT = Model::CreateEventBridgeRuleTemplateRequest>
        void CreateEventBridgeRuleTemplateAsync(const CreateEventBridgeRuleTemplateRequestT& request, const CreateEventBridgeRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateEventBridgeRuleTemplate, request, handler, context);
        }
 
        virtual Model::CreateEventBridgeRuleTemplateGroupOutcome CreateEventBridgeRuleTemplateGroup(const Model::CreateEventBridgeRuleTemplateGroupRequest& request) const;
 
        template<typename CreateEventBridgeRuleTemplateGroupRequestT = Model::CreateEventBridgeRuleTemplateGroupRequest>
        Model::CreateEventBridgeRuleTemplateGroupOutcomeCallable CreateEventBridgeRuleTemplateGroupCallable(const CreateEventBridgeRuleTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateEventBridgeRuleTemplateGroup, request);
        }
 
        template<typename CreateEventBridgeRuleTemplateGroupRequestT = Model::CreateEventBridgeRuleTemplateGroupRequest>
        void CreateEventBridgeRuleTemplateGroupAsync(const CreateEventBridgeRuleTemplateGroupRequestT& request, const CreateEventBridgeRuleTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateEventBridgeRuleTemplateGroup, request, handler, context);
        }
 
        virtual Model::CreateInputOutcome CreateInput(const Model::CreateInputRequest& request = {}) const;
 
        template<typename CreateInputRequestT = Model::CreateInputRequest>
        Model::CreateInputOutcomeCallable CreateInputCallable(const CreateInputRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::CreateInput, request);
        }
 
        template<typename CreateInputRequestT = Model::CreateInputRequest>
        void CreateInputAsync(const CreateInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateInputRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::CreateInput, request, handler, context);
        }
 
        virtual Model::CreateInputSecurityGroupOutcome CreateInputSecurityGroup(const Model::CreateInputSecurityGroupRequest& request = {}) const;
 
        template<typename CreateInputSecurityGroupRequestT = Model::CreateInputSecurityGroupRequest>
        Model::CreateInputSecurityGroupOutcomeCallable CreateInputSecurityGroupCallable(const CreateInputSecurityGroupRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::CreateInputSecurityGroup, request);
        }
 
        template<typename CreateInputSecurityGroupRequestT = Model::CreateInputSecurityGroupRequest>
        void CreateInputSecurityGroupAsync(const CreateInputSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateInputSecurityGroupRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::CreateInputSecurityGroup, request, handler, context);
        }
 
        virtual Model::CreateMultiplexOutcome CreateMultiplex(const Model::CreateMultiplexRequest& request) const;
 
        template<typename CreateMultiplexRequestT = Model::CreateMultiplexRequest>
        Model::CreateMultiplexOutcomeCallable CreateMultiplexCallable(const CreateMultiplexRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateMultiplex, request);
        }
 
        template<typename CreateMultiplexRequestT = Model::CreateMultiplexRequest>
        void CreateMultiplexAsync(const CreateMultiplexRequestT& request, const CreateMultiplexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateMultiplex, request, handler, context);
        }
 
        virtual Model::CreateMultiplexProgramOutcome CreateMultiplexProgram(const Model::CreateMultiplexProgramRequest& request) const;
 
        template<typename CreateMultiplexProgramRequestT = Model::CreateMultiplexProgramRequest>
        Model::CreateMultiplexProgramOutcomeCallable CreateMultiplexProgramCallable(const CreateMultiplexProgramRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateMultiplexProgram, request);
        }
 
        template<typename CreateMultiplexProgramRequestT = Model::CreateMultiplexProgramRequest>
        void CreateMultiplexProgramAsync(const CreateMultiplexProgramRequestT& request, const CreateMultiplexProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateMultiplexProgram, request, handler, context);
        }
 
        virtual Model::CreateNetworkOutcome CreateNetwork(const Model::CreateNetworkRequest& request = {}) const;
 
        template<typename CreateNetworkRequestT = Model::CreateNetworkRequest>
        Model::CreateNetworkOutcomeCallable CreateNetworkCallable(const CreateNetworkRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::CreateNetwork, request);
        }
 
        template<typename CreateNetworkRequestT = Model::CreateNetworkRequest>
        void CreateNetworkAsync(const CreateNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateNetworkRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::CreateNetwork, request, handler, context);
        }
 
        virtual Model::CreateNodeOutcome CreateNode(const Model::CreateNodeRequest& request) const;
 
        template<typename CreateNodeRequestT = Model::CreateNodeRequest>
        Model::CreateNodeOutcomeCallable CreateNodeCallable(const CreateNodeRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateNode, request);
        }
 
        template<typename CreateNodeRequestT = Model::CreateNodeRequest>
        void CreateNodeAsync(const CreateNodeRequestT& request, const CreateNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateNode, request, handler, context);
        }
 
        virtual Model::CreateNodeRegistrationScriptOutcome CreateNodeRegistrationScript(const Model::CreateNodeRegistrationScriptRequest& request) const;
 
        template<typename CreateNodeRegistrationScriptRequestT = Model::CreateNodeRegistrationScriptRequest>
        Model::CreateNodeRegistrationScriptOutcomeCallable CreateNodeRegistrationScriptCallable(const CreateNodeRegistrationScriptRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateNodeRegistrationScript, request);
        }
 
        template<typename CreateNodeRegistrationScriptRequestT = Model::CreateNodeRegistrationScriptRequest>
        void CreateNodeRegistrationScriptAsync(const CreateNodeRegistrationScriptRequestT& request, const CreateNodeRegistrationScriptResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateNodeRegistrationScript, request, handler, context);
        }
 
        virtual Model::CreatePartnerInputOutcome CreatePartnerInput(const Model::CreatePartnerInputRequest& request) const;
 
        template<typename CreatePartnerInputRequestT = Model::CreatePartnerInputRequest>
        Model::CreatePartnerInputOutcomeCallable CreatePartnerInputCallable(const CreatePartnerInputRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreatePartnerInput, request);
        }
 
        template<typename CreatePartnerInputRequestT = Model::CreatePartnerInputRequest>
        void CreatePartnerInputAsync(const CreatePartnerInputRequestT& request, const CreatePartnerInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreatePartnerInput, request, handler, context);
        }
 
        virtual Model::CreateSdiSourceOutcome CreateSdiSource(const Model::CreateSdiSourceRequest& request = {}) const;
 
        template<typename CreateSdiSourceRequestT = Model::CreateSdiSourceRequest>
        Model::CreateSdiSourceOutcomeCallable CreateSdiSourceCallable(const CreateSdiSourceRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::CreateSdiSource, request);
        }
 
        template<typename CreateSdiSourceRequestT = Model::CreateSdiSourceRequest>
        void CreateSdiSourceAsync(const CreateSdiSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateSdiSourceRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::CreateSdiSource, request, handler, context);
        }
 
        virtual Model::CreateSignalMapOutcome CreateSignalMap(const Model::CreateSignalMapRequest& request) const;
 
        template<typename CreateSignalMapRequestT = Model::CreateSignalMapRequest>
        Model::CreateSignalMapOutcomeCallable CreateSignalMapCallable(const CreateSignalMapRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateSignalMap, request);
        }
 
        template<typename CreateSignalMapRequestT = Model::CreateSignalMapRequest>
        void CreateSignalMapAsync(const CreateSignalMapRequestT& request, const CreateSignalMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateSignalMap, request, handler, context);
        }
 
        virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const;
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::CreateTags, request);
        }
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::CreateTags, 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(&MediaLiveClient::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(&MediaLiveClient::DeleteChannel, request, handler, context);
        }
 
        virtual Model::DeleteChannelPlacementGroupOutcome DeleteChannelPlacementGroup(const Model::DeleteChannelPlacementGroupRequest& request) const;
 
        template<typename DeleteChannelPlacementGroupRequestT = Model::DeleteChannelPlacementGroupRequest>
        Model::DeleteChannelPlacementGroupOutcomeCallable DeleteChannelPlacementGroupCallable(const DeleteChannelPlacementGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteChannelPlacementGroup, request);
        }
 
        template<typename DeleteChannelPlacementGroupRequestT = Model::DeleteChannelPlacementGroupRequest>
        void DeleteChannelPlacementGroupAsync(const DeleteChannelPlacementGroupRequestT& request, const DeleteChannelPlacementGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteChannelPlacementGroup, request, handler, context);
        }
 
        virtual Model::DeleteCloudWatchAlarmTemplateOutcome DeleteCloudWatchAlarmTemplate(const Model::DeleteCloudWatchAlarmTemplateRequest& request) const;
 
        template<typename DeleteCloudWatchAlarmTemplateRequestT = Model::DeleteCloudWatchAlarmTemplateRequest>
        Model::DeleteCloudWatchAlarmTemplateOutcomeCallable DeleteCloudWatchAlarmTemplateCallable(const DeleteCloudWatchAlarmTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteCloudWatchAlarmTemplate, request);
        }
 
        template<typename DeleteCloudWatchAlarmTemplateRequestT = Model::DeleteCloudWatchAlarmTemplateRequest>
        void DeleteCloudWatchAlarmTemplateAsync(const DeleteCloudWatchAlarmTemplateRequestT& request, const DeleteCloudWatchAlarmTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteCloudWatchAlarmTemplate, request, handler, context);
        }
 
        virtual Model::DeleteCloudWatchAlarmTemplateGroupOutcome DeleteCloudWatchAlarmTemplateGroup(const Model::DeleteCloudWatchAlarmTemplateGroupRequest& request) const;
 
        template<typename DeleteCloudWatchAlarmTemplateGroupRequestT = Model::DeleteCloudWatchAlarmTemplateGroupRequest>
        Model::DeleteCloudWatchAlarmTemplateGroupOutcomeCallable DeleteCloudWatchAlarmTemplateGroupCallable(const DeleteCloudWatchAlarmTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteCloudWatchAlarmTemplateGroup, request);
        }
 
        template<typename DeleteCloudWatchAlarmTemplateGroupRequestT = Model::DeleteCloudWatchAlarmTemplateGroupRequest>
        void DeleteCloudWatchAlarmTemplateGroupAsync(const DeleteCloudWatchAlarmTemplateGroupRequestT& request, const DeleteCloudWatchAlarmTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteCloudWatchAlarmTemplateGroup, request, handler, context);
        }
 
        virtual Model::DeleteClusterOutcome DeleteCluster(const Model::DeleteClusterRequest& request) const;
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        Model::DeleteClusterOutcomeCallable DeleteClusterCallable(const DeleteClusterRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteCluster, request);
        }
 
        template<typename DeleteClusterRequestT = Model::DeleteClusterRequest>
        void DeleteClusterAsync(const DeleteClusterRequestT& request, const DeleteClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteCluster, request, handler, context);
        }
 
        virtual Model::DeleteEventBridgeRuleTemplateOutcome DeleteEventBridgeRuleTemplate(const Model::DeleteEventBridgeRuleTemplateRequest& request) const;
 
        template<typename DeleteEventBridgeRuleTemplateRequestT = Model::DeleteEventBridgeRuleTemplateRequest>
        Model::DeleteEventBridgeRuleTemplateOutcomeCallable DeleteEventBridgeRuleTemplateCallable(const DeleteEventBridgeRuleTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteEventBridgeRuleTemplate, request);
        }
 
        template<typename DeleteEventBridgeRuleTemplateRequestT = Model::DeleteEventBridgeRuleTemplateRequest>
        void DeleteEventBridgeRuleTemplateAsync(const DeleteEventBridgeRuleTemplateRequestT& request, const DeleteEventBridgeRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteEventBridgeRuleTemplate, request, handler, context);
        }
 
        virtual Model::DeleteEventBridgeRuleTemplateGroupOutcome DeleteEventBridgeRuleTemplateGroup(const Model::DeleteEventBridgeRuleTemplateGroupRequest& request) const;
 
        template<typename DeleteEventBridgeRuleTemplateGroupRequestT = Model::DeleteEventBridgeRuleTemplateGroupRequest>
        Model::DeleteEventBridgeRuleTemplateGroupOutcomeCallable DeleteEventBridgeRuleTemplateGroupCallable(const DeleteEventBridgeRuleTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteEventBridgeRuleTemplateGroup, request);
        }
 
        template<typename DeleteEventBridgeRuleTemplateGroupRequestT = Model::DeleteEventBridgeRuleTemplateGroupRequest>
        void DeleteEventBridgeRuleTemplateGroupAsync(const DeleteEventBridgeRuleTemplateGroupRequestT& request, const DeleteEventBridgeRuleTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteEventBridgeRuleTemplateGroup, request, handler, context);
        }
 
        virtual Model::DeleteInputOutcome DeleteInput(const Model::DeleteInputRequest& request) const;
 
        template<typename DeleteInputRequestT = Model::DeleteInputRequest>
        Model::DeleteInputOutcomeCallable DeleteInputCallable(const DeleteInputRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteInput, request);
        }
 
        template<typename DeleteInputRequestT = Model::DeleteInputRequest>
        void DeleteInputAsync(const DeleteInputRequestT& request, const DeleteInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteInput, request, handler, context);
        }
 
        virtual Model::DeleteInputSecurityGroupOutcome DeleteInputSecurityGroup(const Model::DeleteInputSecurityGroupRequest& request) const;
 
        template<typename DeleteInputSecurityGroupRequestT = Model::DeleteInputSecurityGroupRequest>
        Model::DeleteInputSecurityGroupOutcomeCallable DeleteInputSecurityGroupCallable(const DeleteInputSecurityGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteInputSecurityGroup, request);
        }
 
        template<typename DeleteInputSecurityGroupRequestT = Model::DeleteInputSecurityGroupRequest>
        void DeleteInputSecurityGroupAsync(const DeleteInputSecurityGroupRequestT& request, const DeleteInputSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteInputSecurityGroup, request, handler, context);
        }
 
        virtual Model::DeleteMultiplexOutcome DeleteMultiplex(const Model::DeleteMultiplexRequest& request) const;
 
        template<typename DeleteMultiplexRequestT = Model::DeleteMultiplexRequest>
        Model::DeleteMultiplexOutcomeCallable DeleteMultiplexCallable(const DeleteMultiplexRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteMultiplex, request);
        }
 
        template<typename DeleteMultiplexRequestT = Model::DeleteMultiplexRequest>
        void DeleteMultiplexAsync(const DeleteMultiplexRequestT& request, const DeleteMultiplexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteMultiplex, request, handler, context);
        }
 
        virtual Model::DeleteMultiplexProgramOutcome DeleteMultiplexProgram(const Model::DeleteMultiplexProgramRequest& request) const;
 
        template<typename DeleteMultiplexProgramRequestT = Model::DeleteMultiplexProgramRequest>
        Model::DeleteMultiplexProgramOutcomeCallable DeleteMultiplexProgramCallable(const DeleteMultiplexProgramRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteMultiplexProgram, request);
        }
 
        template<typename DeleteMultiplexProgramRequestT = Model::DeleteMultiplexProgramRequest>
        void DeleteMultiplexProgramAsync(const DeleteMultiplexProgramRequestT& request, const DeleteMultiplexProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteMultiplexProgram, request, handler, context);
        }
 
        virtual Model::DeleteNetworkOutcome DeleteNetwork(const Model::DeleteNetworkRequest& request) const;
 
        template<typename DeleteNetworkRequestT = Model::DeleteNetworkRequest>
        Model::DeleteNetworkOutcomeCallable DeleteNetworkCallable(const DeleteNetworkRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteNetwork, request);
        }
 
        template<typename DeleteNetworkRequestT = Model::DeleteNetworkRequest>
        void DeleteNetworkAsync(const DeleteNetworkRequestT& request, const DeleteNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteNetwork, request, handler, context);
        }
 
        virtual Model::DeleteNodeOutcome DeleteNode(const Model::DeleteNodeRequest& request) const;
 
        template<typename DeleteNodeRequestT = Model::DeleteNodeRequest>
        Model::DeleteNodeOutcomeCallable DeleteNodeCallable(const DeleteNodeRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteNode, request);
        }
 
        template<typename DeleteNodeRequestT = Model::DeleteNodeRequest>
        void DeleteNodeAsync(const DeleteNodeRequestT& request, const DeleteNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteNode, request, handler, context);
        }
 
        virtual Model::DeleteReservationOutcome DeleteReservation(const Model::DeleteReservationRequest& request) const;
 
        template<typename DeleteReservationRequestT = Model::DeleteReservationRequest>
        Model::DeleteReservationOutcomeCallable DeleteReservationCallable(const DeleteReservationRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteReservation, request);
        }
 
        template<typename DeleteReservationRequestT = Model::DeleteReservationRequest>
        void DeleteReservationAsync(const DeleteReservationRequestT& request, const DeleteReservationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteReservation, request, handler, context);
        }
 
        virtual Model::DeleteScheduleOutcome DeleteSchedule(const Model::DeleteScheduleRequest& request) const;
 
        template<typename DeleteScheduleRequestT = Model::DeleteScheduleRequest>
        Model::DeleteScheduleOutcomeCallable DeleteScheduleCallable(const DeleteScheduleRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteSchedule, request);
        }
 
        template<typename DeleteScheduleRequestT = Model::DeleteScheduleRequest>
        void DeleteScheduleAsync(const DeleteScheduleRequestT& request, const DeleteScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteSchedule, request, handler, context);
        }
 
        virtual Model::DeleteSdiSourceOutcome DeleteSdiSource(const Model::DeleteSdiSourceRequest& request) const;
 
        template<typename DeleteSdiSourceRequestT = Model::DeleteSdiSourceRequest>
        Model::DeleteSdiSourceOutcomeCallable DeleteSdiSourceCallable(const DeleteSdiSourceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteSdiSource, request);
        }
 
        template<typename DeleteSdiSourceRequestT = Model::DeleteSdiSourceRequest>
        void DeleteSdiSourceAsync(const DeleteSdiSourceRequestT& request, const DeleteSdiSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteSdiSource, request, handler, context);
        }
 
        virtual Model::DeleteSignalMapOutcome DeleteSignalMap(const Model::DeleteSignalMapRequest& request) const;
 
        template<typename DeleteSignalMapRequestT = Model::DeleteSignalMapRequest>
        Model::DeleteSignalMapOutcomeCallable DeleteSignalMapCallable(const DeleteSignalMapRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteSignalMap, request);
        }
 
        template<typename DeleteSignalMapRequestT = Model::DeleteSignalMapRequest>
        void DeleteSignalMapAsync(const DeleteSignalMapRequestT& request, const DeleteSignalMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteSignalMap, request, handler, context);
        }
 
        virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DeleteTags, request);
        }
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DeleteTags, request, handler, context);
        }
 
        virtual Model::DescribeAccountConfigurationOutcome DescribeAccountConfiguration(const Model::DescribeAccountConfigurationRequest& request = {}) const;
 
        template<typename DescribeAccountConfigurationRequestT = Model::DescribeAccountConfigurationRequest>
        Model::DescribeAccountConfigurationOutcomeCallable DescribeAccountConfigurationCallable(const DescribeAccountConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeAccountConfiguration, request);
        }
 
        template<typename DescribeAccountConfigurationRequestT = Model::DescribeAccountConfigurationRequest>
        void DescribeAccountConfigurationAsync(const DescribeAccountConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeAccountConfiguration, 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(&MediaLiveClient::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(&MediaLiveClient::DescribeChannel, request, handler, context);
        }
 
        virtual Model::DescribeChannelPlacementGroupOutcome DescribeChannelPlacementGroup(const Model::DescribeChannelPlacementGroupRequest& request) const;
 
        template<typename DescribeChannelPlacementGroupRequestT = Model::DescribeChannelPlacementGroupRequest>
        Model::DescribeChannelPlacementGroupOutcomeCallable DescribeChannelPlacementGroupCallable(const DescribeChannelPlacementGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeChannelPlacementGroup, request);
        }
 
        template<typename DescribeChannelPlacementGroupRequestT = Model::DescribeChannelPlacementGroupRequest>
        void DescribeChannelPlacementGroupAsync(const DescribeChannelPlacementGroupRequestT& request, const DescribeChannelPlacementGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeChannelPlacementGroup, request, handler, context);
        }
 
        virtual Model::DescribeClusterOutcome DescribeCluster(const Model::DescribeClusterRequest& request) const;
 
        template<typename DescribeClusterRequestT = Model::DescribeClusterRequest>
        Model::DescribeClusterOutcomeCallable DescribeClusterCallable(const DescribeClusterRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeCluster, request);
        }
 
        template<typename DescribeClusterRequestT = Model::DescribeClusterRequest>
        void DescribeClusterAsync(const DescribeClusterRequestT& request, const DescribeClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeCluster, request, handler, context);
        }
 
        virtual Model::DescribeInputOutcome DescribeInput(const Model::DescribeInputRequest& request) const;
 
        template<typename DescribeInputRequestT = Model::DescribeInputRequest>
        Model::DescribeInputOutcomeCallable DescribeInputCallable(const DescribeInputRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeInput, request);
        }
 
        template<typename DescribeInputRequestT = Model::DescribeInputRequest>
        void DescribeInputAsync(const DescribeInputRequestT& request, const DescribeInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeInput, request, handler, context);
        }
 
        virtual Model::DescribeInputDeviceOutcome DescribeInputDevice(const Model::DescribeInputDeviceRequest& request) const;
 
        template<typename DescribeInputDeviceRequestT = Model::DescribeInputDeviceRequest>
        Model::DescribeInputDeviceOutcomeCallable DescribeInputDeviceCallable(const DescribeInputDeviceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeInputDevice, request);
        }
 
        template<typename DescribeInputDeviceRequestT = Model::DescribeInputDeviceRequest>
        void DescribeInputDeviceAsync(const DescribeInputDeviceRequestT& request, const DescribeInputDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeInputDevice, request, handler, context);
        }
 
        virtual Model::DescribeInputDeviceThumbnailOutcome DescribeInputDeviceThumbnail(const Model::DescribeInputDeviceThumbnailRequest& request) const;
 
        template<typename DescribeInputDeviceThumbnailRequestT = Model::DescribeInputDeviceThumbnailRequest>
        Model::DescribeInputDeviceThumbnailOutcomeCallable DescribeInputDeviceThumbnailCallable(const DescribeInputDeviceThumbnailRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeInputDeviceThumbnail, request);
        }
 
        template<typename DescribeInputDeviceThumbnailRequestT = Model::DescribeInputDeviceThumbnailRequest>
        void DescribeInputDeviceThumbnailAsync(const DescribeInputDeviceThumbnailRequestT& request, const DescribeInputDeviceThumbnailResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeInputDeviceThumbnail, request, handler, context);
        }
 
        virtual Model::DescribeInputSecurityGroupOutcome DescribeInputSecurityGroup(const Model::DescribeInputSecurityGroupRequest& request) const;
 
        template<typename DescribeInputSecurityGroupRequestT = Model::DescribeInputSecurityGroupRequest>
        Model::DescribeInputSecurityGroupOutcomeCallable DescribeInputSecurityGroupCallable(const DescribeInputSecurityGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeInputSecurityGroup, request);
        }
 
        template<typename DescribeInputSecurityGroupRequestT = Model::DescribeInputSecurityGroupRequest>
        void DescribeInputSecurityGroupAsync(const DescribeInputSecurityGroupRequestT& request, const DescribeInputSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeInputSecurityGroup, request, handler, context);
        }
 
        virtual Model::DescribeMultiplexOutcome DescribeMultiplex(const Model::DescribeMultiplexRequest& request) const;
 
        template<typename DescribeMultiplexRequestT = Model::DescribeMultiplexRequest>
        Model::DescribeMultiplexOutcomeCallable DescribeMultiplexCallable(const DescribeMultiplexRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeMultiplex, request);
        }
 
        template<typename DescribeMultiplexRequestT = Model::DescribeMultiplexRequest>
        void DescribeMultiplexAsync(const DescribeMultiplexRequestT& request, const DescribeMultiplexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeMultiplex, request, handler, context);
        }
 
        virtual Model::DescribeMultiplexProgramOutcome DescribeMultiplexProgram(const Model::DescribeMultiplexProgramRequest& request) const;
 
        template<typename DescribeMultiplexProgramRequestT = Model::DescribeMultiplexProgramRequest>
        Model::DescribeMultiplexProgramOutcomeCallable DescribeMultiplexProgramCallable(const DescribeMultiplexProgramRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeMultiplexProgram, request);
        }
 
        template<typename DescribeMultiplexProgramRequestT = Model::DescribeMultiplexProgramRequest>
        void DescribeMultiplexProgramAsync(const DescribeMultiplexProgramRequestT& request, const DescribeMultiplexProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeMultiplexProgram, request, handler, context);
        }
 
        virtual Model::DescribeNetworkOutcome DescribeNetwork(const Model::DescribeNetworkRequest& request) const;
 
        template<typename DescribeNetworkRequestT = Model::DescribeNetworkRequest>
        Model::DescribeNetworkOutcomeCallable DescribeNetworkCallable(const DescribeNetworkRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeNetwork, request);
        }
 
        template<typename DescribeNetworkRequestT = Model::DescribeNetworkRequest>
        void DescribeNetworkAsync(const DescribeNetworkRequestT& request, const DescribeNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeNetwork, request, handler, context);
        }
 
        virtual Model::DescribeNodeOutcome DescribeNode(const Model::DescribeNodeRequest& request) const;
 
        template<typename DescribeNodeRequestT = Model::DescribeNodeRequest>
        Model::DescribeNodeOutcomeCallable DescribeNodeCallable(const DescribeNodeRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeNode, request);
        }
 
        template<typename DescribeNodeRequestT = Model::DescribeNodeRequest>
        void DescribeNodeAsync(const DescribeNodeRequestT& request, const DescribeNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeNode, request, handler, context);
        }
 
        virtual Model::DescribeOfferingOutcome DescribeOffering(const Model::DescribeOfferingRequest& request) const;
 
        template<typename DescribeOfferingRequestT = Model::DescribeOfferingRequest>
        Model::DescribeOfferingOutcomeCallable DescribeOfferingCallable(const DescribeOfferingRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeOffering, request);
        }
 
        template<typename DescribeOfferingRequestT = Model::DescribeOfferingRequest>
        void DescribeOfferingAsync(const DescribeOfferingRequestT& request, const DescribeOfferingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeOffering, request, handler, context);
        }
 
        virtual Model::DescribeReservationOutcome DescribeReservation(const Model::DescribeReservationRequest& request) const;
 
        template<typename DescribeReservationRequestT = Model::DescribeReservationRequest>
        Model::DescribeReservationOutcomeCallable DescribeReservationCallable(const DescribeReservationRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeReservation, request);
        }
 
        template<typename DescribeReservationRequestT = Model::DescribeReservationRequest>
        void DescribeReservationAsync(const DescribeReservationRequestT& request, const DescribeReservationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeReservation, request, handler, context);
        }
 
        virtual Model::DescribeScheduleOutcome DescribeSchedule(const Model::DescribeScheduleRequest& request) const;
 
        template<typename DescribeScheduleRequestT = Model::DescribeScheduleRequest>
        Model::DescribeScheduleOutcomeCallable DescribeScheduleCallable(const DescribeScheduleRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeSchedule, request);
        }
 
        template<typename DescribeScheduleRequestT = Model::DescribeScheduleRequest>
        void DescribeScheduleAsync(const DescribeScheduleRequestT& request, const DescribeScheduleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeSchedule, request, handler, context);
        }
 
        virtual Model::DescribeSdiSourceOutcome DescribeSdiSource(const Model::DescribeSdiSourceRequest& request) const;
 
        template<typename DescribeSdiSourceRequestT = Model::DescribeSdiSourceRequest>
        Model::DescribeSdiSourceOutcomeCallable DescribeSdiSourceCallable(const DescribeSdiSourceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeSdiSource, request);
        }
 
        template<typename DescribeSdiSourceRequestT = Model::DescribeSdiSourceRequest>
        void DescribeSdiSourceAsync(const DescribeSdiSourceRequestT& request, const DescribeSdiSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeSdiSource, request, handler, context);
        }
 
        virtual Model::DescribeThumbnailsOutcome DescribeThumbnails(const Model::DescribeThumbnailsRequest& request) const;
 
        template<typename DescribeThumbnailsRequestT = Model::DescribeThumbnailsRequest>
        Model::DescribeThumbnailsOutcomeCallable DescribeThumbnailsCallable(const DescribeThumbnailsRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::DescribeThumbnails, request);
        }
 
        template<typename DescribeThumbnailsRequestT = Model::DescribeThumbnailsRequest>
        void DescribeThumbnailsAsync(const DescribeThumbnailsRequestT& request, const DescribeThumbnailsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::DescribeThumbnails, request, handler, context);
        }
 
        virtual Model::GetCloudWatchAlarmTemplateOutcome GetCloudWatchAlarmTemplate(const Model::GetCloudWatchAlarmTemplateRequest& request) const;
 
        template<typename GetCloudWatchAlarmTemplateRequestT = Model::GetCloudWatchAlarmTemplateRequest>
        Model::GetCloudWatchAlarmTemplateOutcomeCallable GetCloudWatchAlarmTemplateCallable(const GetCloudWatchAlarmTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::GetCloudWatchAlarmTemplate, request);
        }
 
        template<typename GetCloudWatchAlarmTemplateRequestT = Model::GetCloudWatchAlarmTemplateRequest>
        void GetCloudWatchAlarmTemplateAsync(const GetCloudWatchAlarmTemplateRequestT& request, const GetCloudWatchAlarmTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::GetCloudWatchAlarmTemplate, request, handler, context);
        }
 
        virtual Model::GetCloudWatchAlarmTemplateGroupOutcome GetCloudWatchAlarmTemplateGroup(const Model::GetCloudWatchAlarmTemplateGroupRequest& request) const;
 
        template<typename GetCloudWatchAlarmTemplateGroupRequestT = Model::GetCloudWatchAlarmTemplateGroupRequest>
        Model::GetCloudWatchAlarmTemplateGroupOutcomeCallable GetCloudWatchAlarmTemplateGroupCallable(const GetCloudWatchAlarmTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::GetCloudWatchAlarmTemplateGroup, request);
        }
 
        template<typename GetCloudWatchAlarmTemplateGroupRequestT = Model::GetCloudWatchAlarmTemplateGroupRequest>
        void GetCloudWatchAlarmTemplateGroupAsync(const GetCloudWatchAlarmTemplateGroupRequestT& request, const GetCloudWatchAlarmTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::GetCloudWatchAlarmTemplateGroup, request, handler, context);
        }
 
        virtual Model::GetEventBridgeRuleTemplateOutcome GetEventBridgeRuleTemplate(const Model::GetEventBridgeRuleTemplateRequest& request) const;
 
        template<typename GetEventBridgeRuleTemplateRequestT = Model::GetEventBridgeRuleTemplateRequest>
        Model::GetEventBridgeRuleTemplateOutcomeCallable GetEventBridgeRuleTemplateCallable(const GetEventBridgeRuleTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::GetEventBridgeRuleTemplate, request);
        }
 
        template<typename GetEventBridgeRuleTemplateRequestT = Model::GetEventBridgeRuleTemplateRequest>
        void GetEventBridgeRuleTemplateAsync(const GetEventBridgeRuleTemplateRequestT& request, const GetEventBridgeRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::GetEventBridgeRuleTemplate, request, handler, context);
        }
 
        virtual Model::GetEventBridgeRuleTemplateGroupOutcome GetEventBridgeRuleTemplateGroup(const Model::GetEventBridgeRuleTemplateGroupRequest& request) const;
 
        template<typename GetEventBridgeRuleTemplateGroupRequestT = Model::GetEventBridgeRuleTemplateGroupRequest>
        Model::GetEventBridgeRuleTemplateGroupOutcomeCallable GetEventBridgeRuleTemplateGroupCallable(const GetEventBridgeRuleTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::GetEventBridgeRuleTemplateGroup, request);
        }
 
        template<typename GetEventBridgeRuleTemplateGroupRequestT = Model::GetEventBridgeRuleTemplateGroupRequest>
        void GetEventBridgeRuleTemplateGroupAsync(const GetEventBridgeRuleTemplateGroupRequestT& request, const GetEventBridgeRuleTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::GetEventBridgeRuleTemplateGroup, request, handler, context);
        }
 
        virtual Model::GetSignalMapOutcome GetSignalMap(const Model::GetSignalMapRequest& request) const;
 
        template<typename GetSignalMapRequestT = Model::GetSignalMapRequest>
        Model::GetSignalMapOutcomeCallable GetSignalMapCallable(const GetSignalMapRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::GetSignalMap, request);
        }
 
        template<typename GetSignalMapRequestT = Model::GetSignalMapRequest>
        void GetSignalMapAsync(const GetSignalMapRequestT& request, const GetSignalMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::GetSignalMap, request, handler, context);
        }
 
        virtual Model::ListChannelPlacementGroupsOutcome ListChannelPlacementGroups(const Model::ListChannelPlacementGroupsRequest& request) const;
 
        template<typename ListChannelPlacementGroupsRequestT = Model::ListChannelPlacementGroupsRequest>
        Model::ListChannelPlacementGroupsOutcomeCallable ListChannelPlacementGroupsCallable(const ListChannelPlacementGroupsRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::ListChannelPlacementGroups, request);
        }
 
        template<typename ListChannelPlacementGroupsRequestT = Model::ListChannelPlacementGroupsRequest>
        void ListChannelPlacementGroupsAsync(const ListChannelPlacementGroupsRequestT& request, const ListChannelPlacementGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::ListChannelPlacementGroups, 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(&MediaLiveClient::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(&MediaLiveClient::ListChannels, request, handler, context);
        }
 
        virtual Model::ListCloudWatchAlarmTemplateGroupsOutcome ListCloudWatchAlarmTemplateGroups(const Model::ListCloudWatchAlarmTemplateGroupsRequest& request = {}) const;
 
        template<typename ListCloudWatchAlarmTemplateGroupsRequestT = Model::ListCloudWatchAlarmTemplateGroupsRequest>
        Model::ListCloudWatchAlarmTemplateGroupsOutcomeCallable ListCloudWatchAlarmTemplateGroupsCallable(const ListCloudWatchAlarmTemplateGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListCloudWatchAlarmTemplateGroups, request);
        }
 
        template<typename ListCloudWatchAlarmTemplateGroupsRequestT = Model::ListCloudWatchAlarmTemplateGroupsRequest>
        void ListCloudWatchAlarmTemplateGroupsAsync(const ListCloudWatchAlarmTemplateGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCloudWatchAlarmTemplateGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListCloudWatchAlarmTemplateGroups, request, handler, context);
        }
 
        virtual Model::ListCloudWatchAlarmTemplatesOutcome ListCloudWatchAlarmTemplates(const Model::ListCloudWatchAlarmTemplatesRequest& request = {}) const;
 
        template<typename ListCloudWatchAlarmTemplatesRequestT = Model::ListCloudWatchAlarmTemplatesRequest>
        Model::ListCloudWatchAlarmTemplatesOutcomeCallable ListCloudWatchAlarmTemplatesCallable(const ListCloudWatchAlarmTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListCloudWatchAlarmTemplates, request);
        }
 
        template<typename ListCloudWatchAlarmTemplatesRequestT = Model::ListCloudWatchAlarmTemplatesRequest>
        void ListCloudWatchAlarmTemplatesAsync(const ListCloudWatchAlarmTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListCloudWatchAlarmTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListCloudWatchAlarmTemplates, request, handler, context);
        }
 
        virtual Model::ListClustersOutcome ListClusters(const Model::ListClustersRequest& request = {}) const;
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        Model::ListClustersOutcomeCallable ListClustersCallable(const ListClustersRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListClusters, request);
        }
 
        template<typename ListClustersRequestT = Model::ListClustersRequest>
        void ListClustersAsync(const ListClustersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListClustersRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListClusters, request, handler, context);
        }
 
        virtual Model::ListEventBridgeRuleTemplateGroupsOutcome ListEventBridgeRuleTemplateGroups(const Model::ListEventBridgeRuleTemplateGroupsRequest& request = {}) const;
 
        template<typename ListEventBridgeRuleTemplateGroupsRequestT = Model::ListEventBridgeRuleTemplateGroupsRequest>
        Model::ListEventBridgeRuleTemplateGroupsOutcomeCallable ListEventBridgeRuleTemplateGroupsCallable(const ListEventBridgeRuleTemplateGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListEventBridgeRuleTemplateGroups, request);
        }
 
        template<typename ListEventBridgeRuleTemplateGroupsRequestT = Model::ListEventBridgeRuleTemplateGroupsRequest>
        void ListEventBridgeRuleTemplateGroupsAsync(const ListEventBridgeRuleTemplateGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEventBridgeRuleTemplateGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListEventBridgeRuleTemplateGroups, request, handler, context);
        }
 
        virtual Model::ListEventBridgeRuleTemplatesOutcome ListEventBridgeRuleTemplates(const Model::ListEventBridgeRuleTemplatesRequest& request = {}) const;
 
        template<typename ListEventBridgeRuleTemplatesRequestT = Model::ListEventBridgeRuleTemplatesRequest>
        Model::ListEventBridgeRuleTemplatesOutcomeCallable ListEventBridgeRuleTemplatesCallable(const ListEventBridgeRuleTemplatesRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListEventBridgeRuleTemplates, request);
        }
 
        template<typename ListEventBridgeRuleTemplatesRequestT = Model::ListEventBridgeRuleTemplatesRequest>
        void ListEventBridgeRuleTemplatesAsync(const ListEventBridgeRuleTemplatesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListEventBridgeRuleTemplatesRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListEventBridgeRuleTemplates, request, handler, context);
        }
 
        virtual Model::ListInputDeviceTransfersOutcome ListInputDeviceTransfers(const Model::ListInputDeviceTransfersRequest& request) const;
 
        template<typename ListInputDeviceTransfersRequestT = Model::ListInputDeviceTransfersRequest>
        Model::ListInputDeviceTransfersOutcomeCallable ListInputDeviceTransfersCallable(const ListInputDeviceTransfersRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::ListInputDeviceTransfers, request);
        }
 
        template<typename ListInputDeviceTransfersRequestT = Model::ListInputDeviceTransfersRequest>
        void ListInputDeviceTransfersAsync(const ListInputDeviceTransfersRequestT& request, const ListInputDeviceTransfersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::ListInputDeviceTransfers, request, handler, context);
        }
 
        virtual Model::ListInputDevicesOutcome ListInputDevices(const Model::ListInputDevicesRequest& request = {}) const;
 
        template<typename ListInputDevicesRequestT = Model::ListInputDevicesRequest>
        Model::ListInputDevicesOutcomeCallable ListInputDevicesCallable(const ListInputDevicesRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListInputDevices, request);
        }
 
        template<typename ListInputDevicesRequestT = Model::ListInputDevicesRequest>
        void ListInputDevicesAsync(const ListInputDevicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInputDevicesRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListInputDevices, request, handler, context);
        }
 
        virtual Model::ListInputSecurityGroupsOutcome ListInputSecurityGroups(const Model::ListInputSecurityGroupsRequest& request = {}) const;
 
        template<typename ListInputSecurityGroupsRequestT = Model::ListInputSecurityGroupsRequest>
        Model::ListInputSecurityGroupsOutcomeCallable ListInputSecurityGroupsCallable(const ListInputSecurityGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListInputSecurityGroups, request);
        }
 
        template<typename ListInputSecurityGroupsRequestT = Model::ListInputSecurityGroupsRequest>
        void ListInputSecurityGroupsAsync(const ListInputSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInputSecurityGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListInputSecurityGroups, request, handler, context);
        }
 
        virtual Model::ListInputsOutcome ListInputs(const Model::ListInputsRequest& request = {}) const;
 
        template<typename ListInputsRequestT = Model::ListInputsRequest>
        Model::ListInputsOutcomeCallable ListInputsCallable(const ListInputsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListInputs, request);
        }
 
        template<typename ListInputsRequestT = Model::ListInputsRequest>
        void ListInputsAsync(const ListInputsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInputsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListInputs, request, handler, context);
        }
 
        virtual Model::ListMultiplexProgramsOutcome ListMultiplexPrograms(const Model::ListMultiplexProgramsRequest& request) const;
 
        template<typename ListMultiplexProgramsRequestT = Model::ListMultiplexProgramsRequest>
        Model::ListMultiplexProgramsOutcomeCallable ListMultiplexProgramsCallable(const ListMultiplexProgramsRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::ListMultiplexPrograms, request);
        }
 
        template<typename ListMultiplexProgramsRequestT = Model::ListMultiplexProgramsRequest>
        void ListMultiplexProgramsAsync(const ListMultiplexProgramsRequestT& request, const ListMultiplexProgramsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::ListMultiplexPrograms, request, handler, context);
        }
 
        virtual Model::ListMultiplexesOutcome ListMultiplexes(const Model::ListMultiplexesRequest& request = {}) const;
 
        template<typename ListMultiplexesRequestT = Model::ListMultiplexesRequest>
        Model::ListMultiplexesOutcomeCallable ListMultiplexesCallable(const ListMultiplexesRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListMultiplexes, request);
        }
 
        template<typename ListMultiplexesRequestT = Model::ListMultiplexesRequest>
        void ListMultiplexesAsync(const ListMultiplexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListMultiplexesRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListMultiplexes, request, handler, context);
        }
 
        virtual Model::ListNetworksOutcome ListNetworks(const Model::ListNetworksRequest& request = {}) const;
 
        template<typename ListNetworksRequestT = Model::ListNetworksRequest>
        Model::ListNetworksOutcomeCallable ListNetworksCallable(const ListNetworksRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListNetworks, request);
        }
 
        template<typename ListNetworksRequestT = Model::ListNetworksRequest>
        void ListNetworksAsync(const ListNetworksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListNetworksRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListNetworks, request, handler, context);
        }
 
        virtual Model::ListNodesOutcome ListNodes(const Model::ListNodesRequest& request) const;
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        Model::ListNodesOutcomeCallable ListNodesCallable(const ListNodesRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::ListNodes, request);
        }
 
        template<typename ListNodesRequestT = Model::ListNodesRequest>
        void ListNodesAsync(const ListNodesRequestT& request, const ListNodesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::ListNodes, request, handler, context);
        }
 
        virtual Model::ListOfferingsOutcome ListOfferings(const Model::ListOfferingsRequest& request = {}) const;
 
        template<typename ListOfferingsRequestT = Model::ListOfferingsRequest>
        Model::ListOfferingsOutcomeCallable ListOfferingsCallable(const ListOfferingsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListOfferings, request);
        }
 
        template<typename ListOfferingsRequestT = Model::ListOfferingsRequest>
        void ListOfferingsAsync(const ListOfferingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListOfferingsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListOfferings, request, handler, context);
        }
 
        virtual Model::ListReservationsOutcome ListReservations(const Model::ListReservationsRequest& request = {}) const;
 
        template<typename ListReservationsRequestT = Model::ListReservationsRequest>
        Model::ListReservationsOutcomeCallable ListReservationsCallable(const ListReservationsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListReservations, request);
        }
 
        template<typename ListReservationsRequestT = Model::ListReservationsRequest>
        void ListReservationsAsync(const ListReservationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReservationsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListReservations, request, handler, context);
        }
 
        virtual Model::ListSdiSourcesOutcome ListSdiSources(const Model::ListSdiSourcesRequest& request = {}) const;
 
        template<typename ListSdiSourcesRequestT = Model::ListSdiSourcesRequest>
        Model::ListSdiSourcesOutcomeCallable ListSdiSourcesCallable(const ListSdiSourcesRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListSdiSources, request);
        }
 
        template<typename ListSdiSourcesRequestT = Model::ListSdiSourcesRequest>
        void ListSdiSourcesAsync(const ListSdiSourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSdiSourcesRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListSdiSources, request, handler, context);
        }
 
        virtual Model::ListSignalMapsOutcome ListSignalMaps(const Model::ListSignalMapsRequest& request = {}) const;
 
        template<typename ListSignalMapsRequestT = Model::ListSignalMapsRequest>
        Model::ListSignalMapsOutcomeCallable ListSignalMapsCallable(const ListSignalMapsRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::ListSignalMaps, request);
        }
 
        template<typename ListSignalMapsRequestT = Model::ListSignalMapsRequest>
        void ListSignalMapsAsync(const ListSignalMapsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSignalMapsRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::ListSignalMaps, 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(&MediaLiveClient::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(&MediaLiveClient::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(&MediaLiveClient::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(&MediaLiveClient::ListVersions, request, handler, context);
        }
 
        virtual Model::PurchaseOfferingOutcome PurchaseOffering(const Model::PurchaseOfferingRequest& request) const;
 
        template<typename PurchaseOfferingRequestT = Model::PurchaseOfferingRequest>
        Model::PurchaseOfferingOutcomeCallable PurchaseOfferingCallable(const PurchaseOfferingRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::PurchaseOffering, request);
        }
 
        template<typename PurchaseOfferingRequestT = Model::PurchaseOfferingRequest>
        void PurchaseOfferingAsync(const PurchaseOfferingRequestT& request, const PurchaseOfferingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::PurchaseOffering, request, handler, context);
        }
 
        virtual Model::RebootInputDeviceOutcome RebootInputDevice(const Model::RebootInputDeviceRequest& request) const;
 
        template<typename RebootInputDeviceRequestT = Model::RebootInputDeviceRequest>
        Model::RebootInputDeviceOutcomeCallable RebootInputDeviceCallable(const RebootInputDeviceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::RebootInputDevice, request);
        }
 
        template<typename RebootInputDeviceRequestT = Model::RebootInputDeviceRequest>
        void RebootInputDeviceAsync(const RebootInputDeviceRequestT& request, const RebootInputDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::RebootInputDevice, request, handler, context);
        }
 
        virtual Model::RejectInputDeviceTransferOutcome RejectInputDeviceTransfer(const Model::RejectInputDeviceTransferRequest& request) const;
 
        template<typename RejectInputDeviceTransferRequestT = Model::RejectInputDeviceTransferRequest>
        Model::RejectInputDeviceTransferOutcomeCallable RejectInputDeviceTransferCallable(const RejectInputDeviceTransferRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::RejectInputDeviceTransfer, request);
        }
 
        template<typename RejectInputDeviceTransferRequestT = Model::RejectInputDeviceTransferRequest>
        void RejectInputDeviceTransferAsync(const RejectInputDeviceTransferRequestT& request, const RejectInputDeviceTransferResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::RejectInputDeviceTransfer, request, handler, context);
        }
 
        virtual Model::RestartChannelPipelinesOutcome RestartChannelPipelines(const Model::RestartChannelPipelinesRequest& request) const;
 
        template<typename RestartChannelPipelinesRequestT = Model::RestartChannelPipelinesRequest>
        Model::RestartChannelPipelinesOutcomeCallable RestartChannelPipelinesCallable(const RestartChannelPipelinesRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::RestartChannelPipelines, request);
        }
 
        template<typename RestartChannelPipelinesRequestT = Model::RestartChannelPipelinesRequest>
        void RestartChannelPipelinesAsync(const RestartChannelPipelinesRequestT& request, const RestartChannelPipelinesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::RestartChannelPipelines, 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(&MediaLiveClient::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(&MediaLiveClient::StartChannel, request, handler, context);
        }
 
        virtual Model::StartDeleteMonitorDeploymentOutcome StartDeleteMonitorDeployment(const Model::StartDeleteMonitorDeploymentRequest& request) const;
 
        template<typename StartDeleteMonitorDeploymentRequestT = Model::StartDeleteMonitorDeploymentRequest>
        Model::StartDeleteMonitorDeploymentOutcomeCallable StartDeleteMonitorDeploymentCallable(const StartDeleteMonitorDeploymentRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StartDeleteMonitorDeployment, request);
        }
 
        template<typename StartDeleteMonitorDeploymentRequestT = Model::StartDeleteMonitorDeploymentRequest>
        void StartDeleteMonitorDeploymentAsync(const StartDeleteMonitorDeploymentRequestT& request, const StartDeleteMonitorDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StartDeleteMonitorDeployment, request, handler, context);
        }
 
        virtual Model::StartInputDeviceOutcome StartInputDevice(const Model::StartInputDeviceRequest& request) const;
 
        template<typename StartInputDeviceRequestT = Model::StartInputDeviceRequest>
        Model::StartInputDeviceOutcomeCallable StartInputDeviceCallable(const StartInputDeviceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StartInputDevice, request);
        }
 
        template<typename StartInputDeviceRequestT = Model::StartInputDeviceRequest>
        void StartInputDeviceAsync(const StartInputDeviceRequestT& request, const StartInputDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StartInputDevice, request, handler, context);
        }
 
        virtual Model::StartInputDeviceMaintenanceWindowOutcome StartInputDeviceMaintenanceWindow(const Model::StartInputDeviceMaintenanceWindowRequest& request) const;
 
        template<typename StartInputDeviceMaintenanceWindowRequestT = Model::StartInputDeviceMaintenanceWindowRequest>
        Model::StartInputDeviceMaintenanceWindowOutcomeCallable StartInputDeviceMaintenanceWindowCallable(const StartInputDeviceMaintenanceWindowRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StartInputDeviceMaintenanceWindow, request);
        }
 
        template<typename StartInputDeviceMaintenanceWindowRequestT = Model::StartInputDeviceMaintenanceWindowRequest>
        void StartInputDeviceMaintenanceWindowAsync(const StartInputDeviceMaintenanceWindowRequestT& request, const StartInputDeviceMaintenanceWindowResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StartInputDeviceMaintenanceWindow, request, handler, context);
        }
 
        virtual Model::StartMonitorDeploymentOutcome StartMonitorDeployment(const Model::StartMonitorDeploymentRequest& request) const;
 
        template<typename StartMonitorDeploymentRequestT = Model::StartMonitorDeploymentRequest>
        Model::StartMonitorDeploymentOutcomeCallable StartMonitorDeploymentCallable(const StartMonitorDeploymentRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StartMonitorDeployment, request);
        }
 
        template<typename StartMonitorDeploymentRequestT = Model::StartMonitorDeploymentRequest>
        void StartMonitorDeploymentAsync(const StartMonitorDeploymentRequestT& request, const StartMonitorDeploymentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StartMonitorDeployment, request, handler, context);
        }
 
        virtual Model::StartMultiplexOutcome StartMultiplex(const Model::StartMultiplexRequest& request) const;
 
        template<typename StartMultiplexRequestT = Model::StartMultiplexRequest>
        Model::StartMultiplexOutcomeCallable StartMultiplexCallable(const StartMultiplexRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StartMultiplex, request);
        }
 
        template<typename StartMultiplexRequestT = Model::StartMultiplexRequest>
        void StartMultiplexAsync(const StartMultiplexRequestT& request, const StartMultiplexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StartMultiplex, request, handler, context);
        }
 
        virtual Model::StartUpdateSignalMapOutcome StartUpdateSignalMap(const Model::StartUpdateSignalMapRequest& request) const;
 
        template<typename StartUpdateSignalMapRequestT = Model::StartUpdateSignalMapRequest>
        Model::StartUpdateSignalMapOutcomeCallable StartUpdateSignalMapCallable(const StartUpdateSignalMapRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StartUpdateSignalMap, request);
        }
 
        template<typename StartUpdateSignalMapRequestT = Model::StartUpdateSignalMapRequest>
        void StartUpdateSignalMapAsync(const StartUpdateSignalMapRequestT& request, const StartUpdateSignalMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StartUpdateSignalMap, 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(&MediaLiveClient::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(&MediaLiveClient::StopChannel, request, handler, context);
        }
 
        virtual Model::StopInputDeviceOutcome StopInputDevice(const Model::StopInputDeviceRequest& request) const;
 
        template<typename StopInputDeviceRequestT = Model::StopInputDeviceRequest>
        Model::StopInputDeviceOutcomeCallable StopInputDeviceCallable(const StopInputDeviceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StopInputDevice, request);
        }
 
        template<typename StopInputDeviceRequestT = Model::StopInputDeviceRequest>
        void StopInputDeviceAsync(const StopInputDeviceRequestT& request, const StopInputDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StopInputDevice, request, handler, context);
        }
 
        virtual Model::StopMultiplexOutcome StopMultiplex(const Model::StopMultiplexRequest& request) const;
 
        template<typename StopMultiplexRequestT = Model::StopMultiplexRequest>
        Model::StopMultiplexOutcomeCallable StopMultiplexCallable(const StopMultiplexRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::StopMultiplex, request);
        }
 
        template<typename StopMultiplexRequestT = Model::StopMultiplexRequest>
        void StopMultiplexAsync(const StopMultiplexRequestT& request, const StopMultiplexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::StopMultiplex, request, handler, context);
        }
 
        virtual Model::TransferInputDeviceOutcome TransferInputDevice(const Model::TransferInputDeviceRequest& request) const;
 
        template<typename TransferInputDeviceRequestT = Model::TransferInputDeviceRequest>
        Model::TransferInputDeviceOutcomeCallable TransferInputDeviceCallable(const TransferInputDeviceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::TransferInputDevice, request);
        }
 
        template<typename TransferInputDeviceRequestT = Model::TransferInputDeviceRequest>
        void TransferInputDeviceAsync(const TransferInputDeviceRequestT& request, const TransferInputDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::TransferInputDevice, request, handler, context);
        }
 
        virtual Model::UpdateAccountConfigurationOutcome UpdateAccountConfiguration(const Model::UpdateAccountConfigurationRequest& request = {}) const;
 
        template<typename UpdateAccountConfigurationRequestT = Model::UpdateAccountConfigurationRequest>
        Model::UpdateAccountConfigurationOutcomeCallable UpdateAccountConfigurationCallable(const UpdateAccountConfigurationRequestT& request = {}) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateAccountConfiguration, request);
        }
 
        template<typename UpdateAccountConfigurationRequestT = Model::UpdateAccountConfigurationRequest>
        void UpdateAccountConfigurationAsync(const UpdateAccountConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateAccountConfigurationRequestT& request = {}) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateAccountConfiguration, 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(&MediaLiveClient::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(&MediaLiveClient::UpdateChannel, request, handler, context);
        }
 
        virtual Model::UpdateChannelClassOutcome UpdateChannelClass(const Model::UpdateChannelClassRequest& request) const;
 
        template<typename UpdateChannelClassRequestT = Model::UpdateChannelClassRequest>
        Model::UpdateChannelClassOutcomeCallable UpdateChannelClassCallable(const UpdateChannelClassRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateChannelClass, request);
        }
 
        template<typename UpdateChannelClassRequestT = Model::UpdateChannelClassRequest>
        void UpdateChannelClassAsync(const UpdateChannelClassRequestT& request, const UpdateChannelClassResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateChannelClass, request, handler, context);
        }
 
        virtual Model::UpdateChannelPlacementGroupOutcome UpdateChannelPlacementGroup(const Model::UpdateChannelPlacementGroupRequest& request) const;
 
        template<typename UpdateChannelPlacementGroupRequestT = Model::UpdateChannelPlacementGroupRequest>
        Model::UpdateChannelPlacementGroupOutcomeCallable UpdateChannelPlacementGroupCallable(const UpdateChannelPlacementGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateChannelPlacementGroup, request);
        }
 
        template<typename UpdateChannelPlacementGroupRequestT = Model::UpdateChannelPlacementGroupRequest>
        void UpdateChannelPlacementGroupAsync(const UpdateChannelPlacementGroupRequestT& request, const UpdateChannelPlacementGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateChannelPlacementGroup, request, handler, context);
        }
 
        virtual Model::UpdateCloudWatchAlarmTemplateOutcome UpdateCloudWatchAlarmTemplate(const Model::UpdateCloudWatchAlarmTemplateRequest& request) const;
 
        template<typename UpdateCloudWatchAlarmTemplateRequestT = Model::UpdateCloudWatchAlarmTemplateRequest>
        Model::UpdateCloudWatchAlarmTemplateOutcomeCallable UpdateCloudWatchAlarmTemplateCallable(const UpdateCloudWatchAlarmTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateCloudWatchAlarmTemplate, request);
        }
 
        template<typename UpdateCloudWatchAlarmTemplateRequestT = Model::UpdateCloudWatchAlarmTemplateRequest>
        void UpdateCloudWatchAlarmTemplateAsync(const UpdateCloudWatchAlarmTemplateRequestT& request, const UpdateCloudWatchAlarmTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateCloudWatchAlarmTemplate, request, handler, context);
        }
 
        virtual Model::UpdateCloudWatchAlarmTemplateGroupOutcome UpdateCloudWatchAlarmTemplateGroup(const Model::UpdateCloudWatchAlarmTemplateGroupRequest& request) const;
 
        template<typename UpdateCloudWatchAlarmTemplateGroupRequestT = Model::UpdateCloudWatchAlarmTemplateGroupRequest>
        Model::UpdateCloudWatchAlarmTemplateGroupOutcomeCallable UpdateCloudWatchAlarmTemplateGroupCallable(const UpdateCloudWatchAlarmTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateCloudWatchAlarmTemplateGroup, request);
        }
 
        template<typename UpdateCloudWatchAlarmTemplateGroupRequestT = Model::UpdateCloudWatchAlarmTemplateGroupRequest>
        void UpdateCloudWatchAlarmTemplateGroupAsync(const UpdateCloudWatchAlarmTemplateGroupRequestT& request, const UpdateCloudWatchAlarmTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateCloudWatchAlarmTemplateGroup, request, handler, context);
        }
 
        virtual Model::UpdateClusterOutcome UpdateCluster(const Model::UpdateClusterRequest& request) const;
 
        template<typename UpdateClusterRequestT = Model::UpdateClusterRequest>
        Model::UpdateClusterOutcomeCallable UpdateClusterCallable(const UpdateClusterRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateCluster, request);
        }
 
        template<typename UpdateClusterRequestT = Model::UpdateClusterRequest>
        void UpdateClusterAsync(const UpdateClusterRequestT& request, const UpdateClusterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateCluster, request, handler, context);
        }
 
        virtual Model::UpdateEventBridgeRuleTemplateOutcome UpdateEventBridgeRuleTemplate(const Model::UpdateEventBridgeRuleTemplateRequest& request) const;
 
        template<typename UpdateEventBridgeRuleTemplateRequestT = Model::UpdateEventBridgeRuleTemplateRequest>
        Model::UpdateEventBridgeRuleTemplateOutcomeCallable UpdateEventBridgeRuleTemplateCallable(const UpdateEventBridgeRuleTemplateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateEventBridgeRuleTemplate, request);
        }
 
        template<typename UpdateEventBridgeRuleTemplateRequestT = Model::UpdateEventBridgeRuleTemplateRequest>
        void UpdateEventBridgeRuleTemplateAsync(const UpdateEventBridgeRuleTemplateRequestT& request, const UpdateEventBridgeRuleTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateEventBridgeRuleTemplate, request, handler, context);
        }
 
        virtual Model::UpdateEventBridgeRuleTemplateGroupOutcome UpdateEventBridgeRuleTemplateGroup(const Model::UpdateEventBridgeRuleTemplateGroupRequest& request) const;
 
        template<typename UpdateEventBridgeRuleTemplateGroupRequestT = Model::UpdateEventBridgeRuleTemplateGroupRequest>
        Model::UpdateEventBridgeRuleTemplateGroupOutcomeCallable UpdateEventBridgeRuleTemplateGroupCallable(const UpdateEventBridgeRuleTemplateGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateEventBridgeRuleTemplateGroup, request);
        }
 
        template<typename UpdateEventBridgeRuleTemplateGroupRequestT = Model::UpdateEventBridgeRuleTemplateGroupRequest>
        void UpdateEventBridgeRuleTemplateGroupAsync(const UpdateEventBridgeRuleTemplateGroupRequestT& request, const UpdateEventBridgeRuleTemplateGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateEventBridgeRuleTemplateGroup, request, handler, context);
        }
 
        virtual Model::UpdateInputOutcome UpdateInput(const Model::UpdateInputRequest& request) const;
 
        template<typename UpdateInputRequestT = Model::UpdateInputRequest>
        Model::UpdateInputOutcomeCallable UpdateInputCallable(const UpdateInputRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateInput, request);
        }
 
        template<typename UpdateInputRequestT = Model::UpdateInputRequest>
        void UpdateInputAsync(const UpdateInputRequestT& request, const UpdateInputResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateInput, request, handler, context);
        }
 
        virtual Model::UpdateInputDeviceOutcome UpdateInputDevice(const Model::UpdateInputDeviceRequest& request) const;
 
        template<typename UpdateInputDeviceRequestT = Model::UpdateInputDeviceRequest>
        Model::UpdateInputDeviceOutcomeCallable UpdateInputDeviceCallable(const UpdateInputDeviceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateInputDevice, request);
        }
 
        template<typename UpdateInputDeviceRequestT = Model::UpdateInputDeviceRequest>
        void UpdateInputDeviceAsync(const UpdateInputDeviceRequestT& request, const UpdateInputDeviceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateInputDevice, request, handler, context);
        }
 
        virtual Model::UpdateInputSecurityGroupOutcome UpdateInputSecurityGroup(const Model::UpdateInputSecurityGroupRequest& request) const;
 
        template<typename UpdateInputSecurityGroupRequestT = Model::UpdateInputSecurityGroupRequest>
        Model::UpdateInputSecurityGroupOutcomeCallable UpdateInputSecurityGroupCallable(const UpdateInputSecurityGroupRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateInputSecurityGroup, request);
        }
 
        template<typename UpdateInputSecurityGroupRequestT = Model::UpdateInputSecurityGroupRequest>
        void UpdateInputSecurityGroupAsync(const UpdateInputSecurityGroupRequestT& request, const UpdateInputSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateInputSecurityGroup, request, handler, context);
        }
 
        virtual Model::UpdateMultiplexOutcome UpdateMultiplex(const Model::UpdateMultiplexRequest& request) const;
 
        template<typename UpdateMultiplexRequestT = Model::UpdateMultiplexRequest>
        Model::UpdateMultiplexOutcomeCallable UpdateMultiplexCallable(const UpdateMultiplexRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateMultiplex, request);
        }
 
        template<typename UpdateMultiplexRequestT = Model::UpdateMultiplexRequest>
        void UpdateMultiplexAsync(const UpdateMultiplexRequestT& request, const UpdateMultiplexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateMultiplex, request, handler, context);
        }
 
        virtual Model::UpdateMultiplexProgramOutcome UpdateMultiplexProgram(const Model::UpdateMultiplexProgramRequest& request) const;
 
        template<typename UpdateMultiplexProgramRequestT = Model::UpdateMultiplexProgramRequest>
        Model::UpdateMultiplexProgramOutcomeCallable UpdateMultiplexProgramCallable(const UpdateMultiplexProgramRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateMultiplexProgram, request);
        }
 
        template<typename UpdateMultiplexProgramRequestT = Model::UpdateMultiplexProgramRequest>
        void UpdateMultiplexProgramAsync(const UpdateMultiplexProgramRequestT& request, const UpdateMultiplexProgramResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateMultiplexProgram, request, handler, context);
        }
 
        virtual Model::UpdateNetworkOutcome UpdateNetwork(const Model::UpdateNetworkRequest& request) const;
 
        template<typename UpdateNetworkRequestT = Model::UpdateNetworkRequest>
        Model::UpdateNetworkOutcomeCallable UpdateNetworkCallable(const UpdateNetworkRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateNetwork, request);
        }
 
        template<typename UpdateNetworkRequestT = Model::UpdateNetworkRequest>
        void UpdateNetworkAsync(const UpdateNetworkRequestT& request, const UpdateNetworkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateNetwork, request, handler, context);
        }
 
        virtual Model::UpdateNodeOutcome UpdateNode(const Model::UpdateNodeRequest& request) const;
 
        template<typename UpdateNodeRequestT = Model::UpdateNodeRequest>
        Model::UpdateNodeOutcomeCallable UpdateNodeCallable(const UpdateNodeRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateNode, request);
        }
 
        template<typename UpdateNodeRequestT = Model::UpdateNodeRequest>
        void UpdateNodeAsync(const UpdateNodeRequestT& request, const UpdateNodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateNode, request, handler, context);
        }
 
        virtual Model::UpdateNodeStateOutcome UpdateNodeState(const Model::UpdateNodeStateRequest& request) const;
 
        template<typename UpdateNodeStateRequestT = Model::UpdateNodeStateRequest>
        Model::UpdateNodeStateOutcomeCallable UpdateNodeStateCallable(const UpdateNodeStateRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateNodeState, request);
        }
 
        template<typename UpdateNodeStateRequestT = Model::UpdateNodeStateRequest>
        void UpdateNodeStateAsync(const UpdateNodeStateRequestT& request, const UpdateNodeStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateNodeState, request, handler, context);
        }
 
        virtual Model::UpdateReservationOutcome UpdateReservation(const Model::UpdateReservationRequest& request) const;
 
        template<typename UpdateReservationRequestT = Model::UpdateReservationRequest>
        Model::UpdateReservationOutcomeCallable UpdateReservationCallable(const UpdateReservationRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateReservation, request);
        }
 
        template<typename UpdateReservationRequestT = Model::UpdateReservationRequest>
        void UpdateReservationAsync(const UpdateReservationRequestT& request, const UpdateReservationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateReservation, request, handler, context);
        }
 
        virtual Model::UpdateSdiSourceOutcome UpdateSdiSource(const Model::UpdateSdiSourceRequest& request) const;
 
        template<typename UpdateSdiSourceRequestT = Model::UpdateSdiSourceRequest>
        Model::UpdateSdiSourceOutcomeCallable UpdateSdiSourceCallable(const UpdateSdiSourceRequestT& request) const
        {
            return SubmitCallable(&MediaLiveClient::UpdateSdiSource, request);
        }
 
        template<typename UpdateSdiSourceRequestT = Model::UpdateSdiSourceRequest>
        void UpdateSdiSourceAsync(const UpdateSdiSourceRequestT& request, const UpdateSdiSourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&MediaLiveClient::UpdateSdiSource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MediaLiveEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaLiveClient>;
      void init(const MediaLiveClientConfiguration& clientConfiguration);
 
      MediaLiveClientConfiguration m_clientConfiguration;
      std::shared_ptr<MediaLiveEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MediaLive
} // namespace Aws