MediaLiveClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/medialive/MediaLivePaginationBase.h>
#include <aws/medialive/MediaLiveServiceClientModel.h>
#include <aws/medialive/MediaLive_EXPORTS.h>
 
namespace Aws {
namespace MediaLive {
class AWS_MEDIALIVE_API MediaLiveClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<MediaLiveClient>,
                                          public MediaLivePaginationBase<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::ListAlertsOutcome ListAlerts(const Model::ListAlertsRequest& request) const;
 
  template <typename ListAlertsRequestT = Model::ListAlertsRequest>
  Model::ListAlertsOutcomeCallable ListAlertsCallable(const ListAlertsRequestT& request) const {
    return SubmitCallable(&MediaLiveClient::ListAlerts, request);
  }
 
  template <typename ListAlertsRequestT = Model::ListAlertsRequest>
  void ListAlertsAsync(const ListAlertsRequestT& request, const ListAlertsResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaLiveClient::ListAlerts, 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::ListClusterAlertsOutcome ListClusterAlerts(const Model::ListClusterAlertsRequest& request) const;
 
  template <typename ListClusterAlertsRequestT = Model::ListClusterAlertsRequest>
  Model::ListClusterAlertsOutcomeCallable ListClusterAlertsCallable(const ListClusterAlertsRequestT& request) const {
    return SubmitCallable(&MediaLiveClient::ListClusterAlerts, request);
  }
 
  template <typename ListClusterAlertsRequestT = Model::ListClusterAlertsRequest>
  void ListClusterAlertsAsync(const ListClusterAlertsRequestT& request, const ListClusterAlertsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaLiveClient::ListClusterAlerts, 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::ListMultiplexAlertsOutcome ListMultiplexAlerts(const Model::ListMultiplexAlertsRequest& request) const;
 
  template <typename ListMultiplexAlertsRequestT = Model::ListMultiplexAlertsRequest>
  Model::ListMultiplexAlertsOutcomeCallable ListMultiplexAlertsCallable(const ListMultiplexAlertsRequestT& request) const {
    return SubmitCallable(&MediaLiveClient::ListMultiplexAlerts, request);
  }
 
  template <typename ListMultiplexAlertsRequestT = Model::ListMultiplexAlertsRequest>
  void ListMultiplexAlertsAsync(const ListMultiplexAlertsRequestT& request, const ListMultiplexAlertsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaLiveClient::ListMultiplexAlerts, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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