MediaConnectClient.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/mediaconnect/MediaConnectPaginationBase.h>
#include <aws/mediaconnect/MediaConnectServiceClientModel.h>
#include <aws/mediaconnect/MediaConnectWaiter.h>
#include <aws/mediaconnect/MediaConnect_EXPORTS.h>
 
namespace Aws {
namespace MediaConnect {
class AWS_MEDIACONNECT_API MediaConnectClient : public Aws::Client::AWSJsonClient,
                                                public Aws::Client::ClientWithAsyncTemplateMethods<MediaConnectClient>,
                                                public MediaConnectPaginationBase<MediaConnectClient>,
                                                public MediaConnectWaiter<MediaConnectClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef MediaConnectClientConfiguration ClientConfigurationType;
  typedef MediaConnectEndpointProvider EndpointProviderType;
 
  MediaConnectClient(
      const Aws::MediaConnect::MediaConnectClientConfiguration& clientConfiguration = Aws::MediaConnect::MediaConnectClientConfiguration(),
      std::shared_ptr<MediaConnectEndpointProviderBase> endpointProvider = nullptr);
 
  MediaConnectClient(
      const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<MediaConnectEndpointProviderBase> endpointProvider = nullptr,
      const Aws::MediaConnect::MediaConnectClientConfiguration& clientConfiguration = Aws::MediaConnect::MediaConnectClientConfiguration());
 
  MediaConnectClient(
      const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
      std::shared_ptr<MediaConnectEndpointProviderBase> endpointProvider = nullptr,
      const Aws::MediaConnect::MediaConnectClientConfiguration& clientConfiguration = Aws::MediaConnect::MediaConnectClientConfiguration());
 
  /* Legacy constructors due deprecation */
  MediaConnectClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MediaConnectClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  MediaConnectClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                     const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~MediaConnectClient();
 
  virtual Model::AddBridgeOutputsOutcome AddBridgeOutputs(const Model::AddBridgeOutputsRequest& request) const;
 
  template <typename AddBridgeOutputsRequestT = Model::AddBridgeOutputsRequest>
  Model::AddBridgeOutputsOutcomeCallable AddBridgeOutputsCallable(const AddBridgeOutputsRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::AddBridgeOutputs, request);
  }
 
  template <typename AddBridgeOutputsRequestT = Model::AddBridgeOutputsRequest>
  void AddBridgeOutputsAsync(const AddBridgeOutputsRequestT& request, const AddBridgeOutputsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::AddBridgeOutputs, request, handler, context);
  }
 
  virtual Model::AddBridgeSourcesOutcome AddBridgeSources(const Model::AddBridgeSourcesRequest& request) const;
 
  template <typename AddBridgeSourcesRequestT = Model::AddBridgeSourcesRequest>
  Model::AddBridgeSourcesOutcomeCallable AddBridgeSourcesCallable(const AddBridgeSourcesRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::AddBridgeSources, request);
  }
 
  template <typename AddBridgeSourcesRequestT = Model::AddBridgeSourcesRequest>
  void AddBridgeSourcesAsync(const AddBridgeSourcesRequestT& request, const AddBridgeSourcesResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::AddBridgeSources, request, handler, context);
  }
 
  virtual Model::AddFlowMediaStreamsOutcome AddFlowMediaStreams(const Model::AddFlowMediaStreamsRequest& request) const;
 
  template <typename AddFlowMediaStreamsRequestT = Model::AddFlowMediaStreamsRequest>
  Model::AddFlowMediaStreamsOutcomeCallable AddFlowMediaStreamsCallable(const AddFlowMediaStreamsRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::AddFlowMediaStreams, request);
  }
 
  template <typename AddFlowMediaStreamsRequestT = Model::AddFlowMediaStreamsRequest>
  void AddFlowMediaStreamsAsync(const AddFlowMediaStreamsRequestT& request, const AddFlowMediaStreamsResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::AddFlowMediaStreams, request, handler, context);
  }
 
  virtual Model::AddFlowOutputsOutcome AddFlowOutputs(const Model::AddFlowOutputsRequest& request) const;
 
  template <typename AddFlowOutputsRequestT = Model::AddFlowOutputsRequest>
  Model::AddFlowOutputsOutcomeCallable AddFlowOutputsCallable(const AddFlowOutputsRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::AddFlowOutputs, request);
  }
 
  template <typename AddFlowOutputsRequestT = Model::AddFlowOutputsRequest>
  void AddFlowOutputsAsync(const AddFlowOutputsRequestT& request, const AddFlowOutputsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::AddFlowOutputs, request, handler, context);
  }
 
  virtual Model::AddFlowSourcesOutcome AddFlowSources(const Model::AddFlowSourcesRequest& request) const;
 
  template <typename AddFlowSourcesRequestT = Model::AddFlowSourcesRequest>
  Model::AddFlowSourcesOutcomeCallable AddFlowSourcesCallable(const AddFlowSourcesRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::AddFlowSources, request);
  }
 
  template <typename AddFlowSourcesRequestT = Model::AddFlowSourcesRequest>
  void AddFlowSourcesAsync(const AddFlowSourcesRequestT& request, const AddFlowSourcesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::AddFlowSources, request, handler, context);
  }
 
  virtual Model::AddFlowVpcInterfacesOutcome AddFlowVpcInterfaces(const Model::AddFlowVpcInterfacesRequest& request) const;
 
  template <typename AddFlowVpcInterfacesRequestT = Model::AddFlowVpcInterfacesRequest>
  Model::AddFlowVpcInterfacesOutcomeCallable AddFlowVpcInterfacesCallable(const AddFlowVpcInterfacesRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::AddFlowVpcInterfaces, request);
  }
 
  template <typename AddFlowVpcInterfacesRequestT = Model::AddFlowVpcInterfacesRequest>
  void AddFlowVpcInterfacesAsync(const AddFlowVpcInterfacesRequestT& request, const AddFlowVpcInterfacesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::AddFlowVpcInterfaces, request, handler, context);
  }
 
  virtual Model::BatchGetRouterInputOutcome BatchGetRouterInput(const Model::BatchGetRouterInputRequest& request) const;
 
  template <typename BatchGetRouterInputRequestT = Model::BatchGetRouterInputRequest>
  Model::BatchGetRouterInputOutcomeCallable BatchGetRouterInputCallable(const BatchGetRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::BatchGetRouterInput, request);
  }
 
  template <typename BatchGetRouterInputRequestT = Model::BatchGetRouterInputRequest>
  void BatchGetRouterInputAsync(const BatchGetRouterInputRequestT& request, const BatchGetRouterInputResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::BatchGetRouterInput, request, handler, context);
  }
 
  virtual Model::BatchGetRouterNetworkInterfaceOutcome BatchGetRouterNetworkInterface(
      const Model::BatchGetRouterNetworkInterfaceRequest& request) const;
 
  template <typename BatchGetRouterNetworkInterfaceRequestT = Model::BatchGetRouterNetworkInterfaceRequest>
  Model::BatchGetRouterNetworkInterfaceOutcomeCallable BatchGetRouterNetworkInterfaceCallable(
      const BatchGetRouterNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::BatchGetRouterNetworkInterface, request);
  }
 
  template <typename BatchGetRouterNetworkInterfaceRequestT = Model::BatchGetRouterNetworkInterfaceRequest>
  void BatchGetRouterNetworkInterfaceAsync(const BatchGetRouterNetworkInterfaceRequestT& request,
                                           const BatchGetRouterNetworkInterfaceResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::BatchGetRouterNetworkInterface, request, handler, context);
  }
 
  virtual Model::BatchGetRouterOutputOutcome BatchGetRouterOutput(const Model::BatchGetRouterOutputRequest& request) const;
 
  template <typename BatchGetRouterOutputRequestT = Model::BatchGetRouterOutputRequest>
  Model::BatchGetRouterOutputOutcomeCallable BatchGetRouterOutputCallable(const BatchGetRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::BatchGetRouterOutput, request);
  }
 
  template <typename BatchGetRouterOutputRequestT = Model::BatchGetRouterOutputRequest>
  void BatchGetRouterOutputAsync(const BatchGetRouterOutputRequestT& request, const BatchGetRouterOutputResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::BatchGetRouterOutput, request, handler, context);
  }
 
  virtual Model::CreateBridgeOutcome CreateBridge(const Model::CreateBridgeRequest& request) const;
 
  template <typename CreateBridgeRequestT = Model::CreateBridgeRequest>
  Model::CreateBridgeOutcomeCallable CreateBridgeCallable(const CreateBridgeRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::CreateBridge, request);
  }
 
  template <typename CreateBridgeRequestT = Model::CreateBridgeRequest>
  void CreateBridgeAsync(const CreateBridgeRequestT& request, const CreateBridgeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::CreateBridge, request, handler, context);
  }
 
  virtual Model::CreateFlowOutcome CreateFlow(const Model::CreateFlowRequest& request) const;
 
  template <typename CreateFlowRequestT = Model::CreateFlowRequest>
  Model::CreateFlowOutcomeCallable CreateFlowCallable(const CreateFlowRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::CreateFlow, request);
  }
 
  template <typename CreateFlowRequestT = Model::CreateFlowRequest>
  void CreateFlowAsync(const CreateFlowRequestT& request, const CreateFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::CreateFlow, request, handler, context);
  }
 
  virtual Model::CreateGatewayOutcome CreateGateway(const Model::CreateGatewayRequest& request) const;
 
  template <typename CreateGatewayRequestT = Model::CreateGatewayRequest>
  Model::CreateGatewayOutcomeCallable CreateGatewayCallable(const CreateGatewayRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::CreateGateway, request);
  }
 
  template <typename CreateGatewayRequestT = Model::CreateGatewayRequest>
  void CreateGatewayAsync(const CreateGatewayRequestT& request, const CreateGatewayResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::CreateGateway, request, handler, context);
  }
 
  virtual Model::CreateRouterInputOutcome CreateRouterInput(const Model::CreateRouterInputRequest& request) const;
 
  template <typename CreateRouterInputRequestT = Model::CreateRouterInputRequest>
  Model::CreateRouterInputOutcomeCallable CreateRouterInputCallable(const CreateRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::CreateRouterInput, request);
  }
 
  template <typename CreateRouterInputRequestT = Model::CreateRouterInputRequest>
  void CreateRouterInputAsync(const CreateRouterInputRequestT& request, const CreateRouterInputResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::CreateRouterInput, request, handler, context);
  }
 
  virtual Model::CreateRouterNetworkInterfaceOutcome CreateRouterNetworkInterface(
      const Model::CreateRouterNetworkInterfaceRequest& request) const;
 
  template <typename CreateRouterNetworkInterfaceRequestT = Model::CreateRouterNetworkInterfaceRequest>
  Model::CreateRouterNetworkInterfaceOutcomeCallable CreateRouterNetworkInterfaceCallable(
      const CreateRouterNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::CreateRouterNetworkInterface, request);
  }
 
  template <typename CreateRouterNetworkInterfaceRequestT = Model::CreateRouterNetworkInterfaceRequest>
  void CreateRouterNetworkInterfaceAsync(const CreateRouterNetworkInterfaceRequestT& request,
                                         const CreateRouterNetworkInterfaceResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::CreateRouterNetworkInterface, request, handler, context);
  }
 
  virtual Model::CreateRouterOutputOutcome CreateRouterOutput(const Model::CreateRouterOutputRequest& request) const;
 
  template <typename CreateRouterOutputRequestT = Model::CreateRouterOutputRequest>
  Model::CreateRouterOutputOutcomeCallable CreateRouterOutputCallable(const CreateRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::CreateRouterOutput, request);
  }
 
  template <typename CreateRouterOutputRequestT = Model::CreateRouterOutputRequest>
  void CreateRouterOutputAsync(const CreateRouterOutputRequestT& request, const CreateRouterOutputResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::CreateRouterOutput, request, handler, context);
  }
 
  virtual Model::DeleteBridgeOutcome DeleteBridge(const Model::DeleteBridgeRequest& request) const;
 
  template <typename DeleteBridgeRequestT = Model::DeleteBridgeRequest>
  Model::DeleteBridgeOutcomeCallable DeleteBridgeCallable(const DeleteBridgeRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DeleteBridge, request);
  }
 
  template <typename DeleteBridgeRequestT = Model::DeleteBridgeRequest>
  void DeleteBridgeAsync(const DeleteBridgeRequestT& request, const DeleteBridgeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DeleteBridge, request, handler, context);
  }
 
  virtual Model::DeleteFlowOutcome DeleteFlow(const Model::DeleteFlowRequest& request) const;
 
  template <typename DeleteFlowRequestT = Model::DeleteFlowRequest>
  Model::DeleteFlowOutcomeCallable DeleteFlowCallable(const DeleteFlowRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DeleteFlow, request);
  }
 
  template <typename DeleteFlowRequestT = Model::DeleteFlowRequest>
  void DeleteFlowAsync(const DeleteFlowRequestT& request, const DeleteFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DeleteFlow, request, handler, context);
  }
 
  virtual Model::DeleteGatewayOutcome DeleteGateway(const Model::DeleteGatewayRequest& request) const;
 
  template <typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
  Model::DeleteGatewayOutcomeCallable DeleteGatewayCallable(const DeleteGatewayRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DeleteGateway, request);
  }
 
  template <typename DeleteGatewayRequestT = Model::DeleteGatewayRequest>
  void DeleteGatewayAsync(const DeleteGatewayRequestT& request, const DeleteGatewayResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DeleteGateway, request, handler, context);
  }
 
  virtual Model::DeleteRouterInputOutcome DeleteRouterInput(const Model::DeleteRouterInputRequest& request) const;
 
  template <typename DeleteRouterInputRequestT = Model::DeleteRouterInputRequest>
  Model::DeleteRouterInputOutcomeCallable DeleteRouterInputCallable(const DeleteRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DeleteRouterInput, request);
  }
 
  template <typename DeleteRouterInputRequestT = Model::DeleteRouterInputRequest>
  void DeleteRouterInputAsync(const DeleteRouterInputRequestT& request, const DeleteRouterInputResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DeleteRouterInput, request, handler, context);
  }
 
  virtual Model::DeleteRouterNetworkInterfaceOutcome DeleteRouterNetworkInterface(
      const Model::DeleteRouterNetworkInterfaceRequest& request) const;
 
  template <typename DeleteRouterNetworkInterfaceRequestT = Model::DeleteRouterNetworkInterfaceRequest>
  Model::DeleteRouterNetworkInterfaceOutcomeCallable DeleteRouterNetworkInterfaceCallable(
      const DeleteRouterNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DeleteRouterNetworkInterface, request);
  }
 
  template <typename DeleteRouterNetworkInterfaceRequestT = Model::DeleteRouterNetworkInterfaceRequest>
  void DeleteRouterNetworkInterfaceAsync(const DeleteRouterNetworkInterfaceRequestT& request,
                                         const DeleteRouterNetworkInterfaceResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DeleteRouterNetworkInterface, request, handler, context);
  }
 
  virtual Model::DeleteRouterOutputOutcome DeleteRouterOutput(const Model::DeleteRouterOutputRequest& request) const;
 
  template <typename DeleteRouterOutputRequestT = Model::DeleteRouterOutputRequest>
  Model::DeleteRouterOutputOutcomeCallable DeleteRouterOutputCallable(const DeleteRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DeleteRouterOutput, request);
  }
 
  template <typename DeleteRouterOutputRequestT = Model::DeleteRouterOutputRequest>
  void DeleteRouterOutputAsync(const DeleteRouterOutputRequestT& request, const DeleteRouterOutputResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DeleteRouterOutput, request, handler, context);
  }
 
  virtual Model::DeregisterGatewayInstanceOutcome DeregisterGatewayInstance(const Model::DeregisterGatewayInstanceRequest& request) const;
 
  template <typename DeregisterGatewayInstanceRequestT = Model::DeregisterGatewayInstanceRequest>
  Model::DeregisterGatewayInstanceOutcomeCallable DeregisterGatewayInstanceCallable(
      const DeregisterGatewayInstanceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DeregisterGatewayInstance, request);
  }
 
  template <typename DeregisterGatewayInstanceRequestT = Model::DeregisterGatewayInstanceRequest>
  void DeregisterGatewayInstanceAsync(const DeregisterGatewayInstanceRequestT& request,
                                      const DeregisterGatewayInstanceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DeregisterGatewayInstance, request, handler, context);
  }
 
  virtual Model::DescribeBridgeOutcome DescribeBridge(const Model::DescribeBridgeRequest& request) const;
 
  template <typename DescribeBridgeRequestT = Model::DescribeBridgeRequest>
  Model::DescribeBridgeOutcomeCallable DescribeBridgeCallable(const DescribeBridgeRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DescribeBridge, request);
  }
 
  template <typename DescribeBridgeRequestT = Model::DescribeBridgeRequest>
  void DescribeBridgeAsync(const DescribeBridgeRequestT& request, const DescribeBridgeResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DescribeBridge, request, handler, context);
  }
 
  virtual Model::DescribeFlowOutcome DescribeFlow(const Model::DescribeFlowRequest& request) const;
 
  template <typename DescribeFlowRequestT = Model::DescribeFlowRequest>
  Model::DescribeFlowOutcomeCallable DescribeFlowCallable(const DescribeFlowRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DescribeFlow, request);
  }
 
  template <typename DescribeFlowRequestT = Model::DescribeFlowRequest>
  void DescribeFlowAsync(const DescribeFlowRequestT& request, const DescribeFlowResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DescribeFlow, request, handler, context);
  }
 
  virtual Model::DescribeFlowSourceMetadataOutcome DescribeFlowSourceMetadata(
      const Model::DescribeFlowSourceMetadataRequest& request) const;
 
  template <typename DescribeFlowSourceMetadataRequestT = Model::DescribeFlowSourceMetadataRequest>
  Model::DescribeFlowSourceMetadataOutcomeCallable DescribeFlowSourceMetadataCallable(
      const DescribeFlowSourceMetadataRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DescribeFlowSourceMetadata, request);
  }
 
  template <typename DescribeFlowSourceMetadataRequestT = Model::DescribeFlowSourceMetadataRequest>
  void DescribeFlowSourceMetadataAsync(const DescribeFlowSourceMetadataRequestT& request,
                                       const DescribeFlowSourceMetadataResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DescribeFlowSourceMetadata, request, handler, context);
  }
 
  virtual Model::DescribeFlowSourceThumbnailOutcome DescribeFlowSourceThumbnail(
      const Model::DescribeFlowSourceThumbnailRequest& request) const;
 
  template <typename DescribeFlowSourceThumbnailRequestT = Model::DescribeFlowSourceThumbnailRequest>
  Model::DescribeFlowSourceThumbnailOutcomeCallable DescribeFlowSourceThumbnailCallable(
      const DescribeFlowSourceThumbnailRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DescribeFlowSourceThumbnail, request);
  }
 
  template <typename DescribeFlowSourceThumbnailRequestT = Model::DescribeFlowSourceThumbnailRequest>
  void DescribeFlowSourceThumbnailAsync(const DescribeFlowSourceThumbnailRequestT& request,
                                        const DescribeFlowSourceThumbnailResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DescribeFlowSourceThumbnail, request, handler, context);
  }
 
  virtual Model::DescribeGatewayOutcome DescribeGateway(const Model::DescribeGatewayRequest& request) const;
 
  template <typename DescribeGatewayRequestT = Model::DescribeGatewayRequest>
  Model::DescribeGatewayOutcomeCallable DescribeGatewayCallable(const DescribeGatewayRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DescribeGateway, request);
  }
 
  template <typename DescribeGatewayRequestT = Model::DescribeGatewayRequest>
  void DescribeGatewayAsync(const DescribeGatewayRequestT& request, const DescribeGatewayResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DescribeGateway, request, handler, context);
  }
 
  virtual Model::DescribeGatewayInstanceOutcome DescribeGatewayInstance(const Model::DescribeGatewayInstanceRequest& request) const;
 
  template <typename DescribeGatewayInstanceRequestT = Model::DescribeGatewayInstanceRequest>
  Model::DescribeGatewayInstanceOutcomeCallable DescribeGatewayInstanceCallable(const DescribeGatewayInstanceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::DescribeGatewayInstance, request);
  }
 
  template <typename DescribeGatewayInstanceRequestT = Model::DescribeGatewayInstanceRequest>
  void DescribeGatewayInstanceAsync(const DescribeGatewayInstanceRequestT& request,
                                    const DescribeGatewayInstanceResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::DescribeGatewayInstance, 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(&MediaConnectClient::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(&MediaConnectClient::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(&MediaConnectClient::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(&MediaConnectClient::DescribeReservation, request, handler, context);
  }
 
  virtual Model::GetRouterInputOutcome GetRouterInput(const Model::GetRouterInputRequest& request) const;
 
  template <typename GetRouterInputRequestT = Model::GetRouterInputRequest>
  Model::GetRouterInputOutcomeCallable GetRouterInputCallable(const GetRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::GetRouterInput, request);
  }
 
  template <typename GetRouterInputRequestT = Model::GetRouterInputRequest>
  void GetRouterInputAsync(const GetRouterInputRequestT& request, const GetRouterInputResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::GetRouterInput, request, handler, context);
  }
 
  virtual Model::GetRouterInputSourceMetadataOutcome GetRouterInputSourceMetadata(
      const Model::GetRouterInputSourceMetadataRequest& request) const;
 
  template <typename GetRouterInputSourceMetadataRequestT = Model::GetRouterInputSourceMetadataRequest>
  Model::GetRouterInputSourceMetadataOutcomeCallable GetRouterInputSourceMetadataCallable(
      const GetRouterInputSourceMetadataRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::GetRouterInputSourceMetadata, request);
  }
 
  template <typename GetRouterInputSourceMetadataRequestT = Model::GetRouterInputSourceMetadataRequest>
  void GetRouterInputSourceMetadataAsync(const GetRouterInputSourceMetadataRequestT& request,
                                         const GetRouterInputSourceMetadataResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::GetRouterInputSourceMetadata, request, handler, context);
  }
 
  virtual Model::GetRouterInputThumbnailOutcome GetRouterInputThumbnail(const Model::GetRouterInputThumbnailRequest& request) const;
 
  template <typename GetRouterInputThumbnailRequestT = Model::GetRouterInputThumbnailRequest>
  Model::GetRouterInputThumbnailOutcomeCallable GetRouterInputThumbnailCallable(const GetRouterInputThumbnailRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::GetRouterInputThumbnail, request);
  }
 
  template <typename GetRouterInputThumbnailRequestT = Model::GetRouterInputThumbnailRequest>
  void GetRouterInputThumbnailAsync(const GetRouterInputThumbnailRequestT& request,
                                    const GetRouterInputThumbnailResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::GetRouterInputThumbnail, request, handler, context);
  }
 
  virtual Model::GetRouterNetworkInterfaceOutcome GetRouterNetworkInterface(const Model::GetRouterNetworkInterfaceRequest& request) const;
 
  template <typename GetRouterNetworkInterfaceRequestT = Model::GetRouterNetworkInterfaceRequest>
  Model::GetRouterNetworkInterfaceOutcomeCallable GetRouterNetworkInterfaceCallable(
      const GetRouterNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::GetRouterNetworkInterface, request);
  }
 
  template <typename GetRouterNetworkInterfaceRequestT = Model::GetRouterNetworkInterfaceRequest>
  void GetRouterNetworkInterfaceAsync(const GetRouterNetworkInterfaceRequestT& request,
                                      const GetRouterNetworkInterfaceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::GetRouterNetworkInterface, request, handler, context);
  }
 
  virtual Model::GetRouterOutputOutcome GetRouterOutput(const Model::GetRouterOutputRequest& request) const;
 
  template <typename GetRouterOutputRequestT = Model::GetRouterOutputRequest>
  Model::GetRouterOutputOutcomeCallable GetRouterOutputCallable(const GetRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::GetRouterOutput, request);
  }
 
  template <typename GetRouterOutputRequestT = Model::GetRouterOutputRequest>
  void GetRouterOutputAsync(const GetRouterOutputRequestT& request, const GetRouterOutputResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::GetRouterOutput, request, handler, context);
  }
 
  virtual Model::GrantFlowEntitlementsOutcome GrantFlowEntitlements(const Model::GrantFlowEntitlementsRequest& request) const;
 
  template <typename GrantFlowEntitlementsRequestT = Model::GrantFlowEntitlementsRequest>
  Model::GrantFlowEntitlementsOutcomeCallable GrantFlowEntitlementsCallable(const GrantFlowEntitlementsRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::GrantFlowEntitlements, request);
  }
 
  template <typename GrantFlowEntitlementsRequestT = Model::GrantFlowEntitlementsRequest>
  void GrantFlowEntitlementsAsync(const GrantFlowEntitlementsRequestT& request, const GrantFlowEntitlementsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::GrantFlowEntitlements, request, handler, context);
  }
 
  virtual Model::ListBridgesOutcome ListBridges(const Model::ListBridgesRequest& request = {}) const;
 
  template <typename ListBridgesRequestT = Model::ListBridgesRequest>
  Model::ListBridgesOutcomeCallable ListBridgesCallable(const ListBridgesRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListBridges, request);
  }
 
  template <typename ListBridgesRequestT = Model::ListBridgesRequest>
  void ListBridgesAsync(const ListBridgesResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const ListBridgesRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListBridges, request, handler, context);
  }
 
  virtual Model::ListEntitlementsOutcome ListEntitlements(const Model::ListEntitlementsRequest& request = {}) const;
 
  template <typename ListEntitlementsRequestT = Model::ListEntitlementsRequest>
  Model::ListEntitlementsOutcomeCallable ListEntitlementsCallable(const ListEntitlementsRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListEntitlements, request);
  }
 
  template <typename ListEntitlementsRequestT = Model::ListEntitlementsRequest>
  void ListEntitlementsAsync(const ListEntitlementsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListEntitlementsRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListEntitlements, request, handler, context);
  }
 
  virtual Model::ListFlowsOutcome ListFlows(const Model::ListFlowsRequest& request = {}) const;
 
  template <typename ListFlowsRequestT = Model::ListFlowsRequest>
  Model::ListFlowsOutcomeCallable ListFlowsCallable(const ListFlowsRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListFlows, request);
  }
 
  template <typename ListFlowsRequestT = Model::ListFlowsRequest>
  void ListFlowsAsync(const ListFlowsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                      const ListFlowsRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListFlows, request, handler, context);
  }
 
  virtual Model::ListGatewayInstancesOutcome ListGatewayInstances(const Model::ListGatewayInstancesRequest& request = {}) const;
 
  template <typename ListGatewayInstancesRequestT = Model::ListGatewayInstancesRequest>
  Model::ListGatewayInstancesOutcomeCallable ListGatewayInstancesCallable(const ListGatewayInstancesRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListGatewayInstances, request);
  }
 
  template <typename ListGatewayInstancesRequestT = Model::ListGatewayInstancesRequest>
  void ListGatewayInstancesAsync(const ListGatewayInstancesResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListGatewayInstancesRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListGatewayInstances, request, handler, context);
  }
 
  virtual Model::ListGatewaysOutcome ListGateways(const Model::ListGatewaysRequest& request = {}) const;
 
  template <typename ListGatewaysRequestT = Model::ListGatewaysRequest>
  Model::ListGatewaysOutcomeCallable ListGatewaysCallable(const ListGatewaysRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListGateways, request);
  }
 
  template <typename ListGatewaysRequestT = Model::ListGatewaysRequest>
  void ListGatewaysAsync(const ListGatewaysResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                         const ListGatewaysRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListGateways, 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(&MediaConnectClient::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(&MediaConnectClient::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(&MediaConnectClient::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(&MediaConnectClient::ListReservations, request, handler, context);
  }
 
  virtual Model::ListRouterInputsOutcome ListRouterInputs(const Model::ListRouterInputsRequest& request = {}) const;
 
  template <typename ListRouterInputsRequestT = Model::ListRouterInputsRequest>
  Model::ListRouterInputsOutcomeCallable ListRouterInputsCallable(const ListRouterInputsRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListRouterInputs, request);
  }
 
  template <typename ListRouterInputsRequestT = Model::ListRouterInputsRequest>
  void ListRouterInputsAsync(const ListRouterInputsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListRouterInputsRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListRouterInputs, request, handler, context);
  }
 
  virtual Model::ListRouterNetworkInterfacesOutcome ListRouterNetworkInterfaces(
      const Model::ListRouterNetworkInterfacesRequest& request = {}) const;
 
  template <typename ListRouterNetworkInterfacesRequestT = Model::ListRouterNetworkInterfacesRequest>
  Model::ListRouterNetworkInterfacesOutcomeCallable ListRouterNetworkInterfacesCallable(
      const ListRouterNetworkInterfacesRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListRouterNetworkInterfaces, request);
  }
 
  template <typename ListRouterNetworkInterfacesRequestT = Model::ListRouterNetworkInterfacesRequest>
  void ListRouterNetworkInterfacesAsync(const ListRouterNetworkInterfacesResponseReceivedHandler& handler,
                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                        const ListRouterNetworkInterfacesRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListRouterNetworkInterfaces, request, handler, context);
  }
 
  virtual Model::ListRouterOutputsOutcome ListRouterOutputs(const Model::ListRouterOutputsRequest& request = {}) const;
 
  template <typename ListRouterOutputsRequestT = Model::ListRouterOutputsRequest>
  Model::ListRouterOutputsOutcomeCallable ListRouterOutputsCallable(const ListRouterOutputsRequestT& request = {}) const {
    return SubmitCallable(&MediaConnectClient::ListRouterOutputs, request);
  }
 
  template <typename ListRouterOutputsRequestT = Model::ListRouterOutputsRequest>
  void ListRouterOutputsAsync(const ListRouterOutputsResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListRouterOutputsRequestT& request = {}) const {
    return SubmitAsync(&MediaConnectClient::ListRouterOutputs, request, handler, context);
  }
 
  virtual Model::ListTagsForGlobalResourceOutcome ListTagsForGlobalResource(const Model::ListTagsForGlobalResourceRequest& request) const;
 
  template <typename ListTagsForGlobalResourceRequestT = Model::ListTagsForGlobalResourceRequest>
  Model::ListTagsForGlobalResourceOutcomeCallable ListTagsForGlobalResourceCallable(
      const ListTagsForGlobalResourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::ListTagsForGlobalResource, request);
  }
 
  template <typename ListTagsForGlobalResourceRequestT = Model::ListTagsForGlobalResourceRequest>
  void ListTagsForGlobalResourceAsync(const ListTagsForGlobalResourceRequestT& request,
                                      const ListTagsForGlobalResourceResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::ListTagsForGlobalResource, 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(&MediaConnectClient::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(&MediaConnectClient::ListTagsForResource, 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(&MediaConnectClient::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(&MediaConnectClient::PurchaseOffering, request, handler, context);
  }
 
  virtual Model::RemoveBridgeOutputOutcome RemoveBridgeOutput(const Model::RemoveBridgeOutputRequest& request) const;
 
  template <typename RemoveBridgeOutputRequestT = Model::RemoveBridgeOutputRequest>
  Model::RemoveBridgeOutputOutcomeCallable RemoveBridgeOutputCallable(const RemoveBridgeOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RemoveBridgeOutput, request);
  }
 
  template <typename RemoveBridgeOutputRequestT = Model::RemoveBridgeOutputRequest>
  void RemoveBridgeOutputAsync(const RemoveBridgeOutputRequestT& request, const RemoveBridgeOutputResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RemoveBridgeOutput, request, handler, context);
  }
 
  virtual Model::RemoveBridgeSourceOutcome RemoveBridgeSource(const Model::RemoveBridgeSourceRequest& request) const;
 
  template <typename RemoveBridgeSourceRequestT = Model::RemoveBridgeSourceRequest>
  Model::RemoveBridgeSourceOutcomeCallable RemoveBridgeSourceCallable(const RemoveBridgeSourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RemoveBridgeSource, request);
  }
 
  template <typename RemoveBridgeSourceRequestT = Model::RemoveBridgeSourceRequest>
  void RemoveBridgeSourceAsync(const RemoveBridgeSourceRequestT& request, const RemoveBridgeSourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RemoveBridgeSource, request, handler, context);
  }
 
  virtual Model::RemoveFlowMediaStreamOutcome RemoveFlowMediaStream(const Model::RemoveFlowMediaStreamRequest& request) const;
 
  template <typename RemoveFlowMediaStreamRequestT = Model::RemoveFlowMediaStreamRequest>
  Model::RemoveFlowMediaStreamOutcomeCallable RemoveFlowMediaStreamCallable(const RemoveFlowMediaStreamRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RemoveFlowMediaStream, request);
  }
 
  template <typename RemoveFlowMediaStreamRequestT = Model::RemoveFlowMediaStreamRequest>
  void RemoveFlowMediaStreamAsync(const RemoveFlowMediaStreamRequestT& request, const RemoveFlowMediaStreamResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RemoveFlowMediaStream, request, handler, context);
  }
 
  virtual Model::RemoveFlowOutputOutcome RemoveFlowOutput(const Model::RemoveFlowOutputRequest& request) const;
 
  template <typename RemoveFlowOutputRequestT = Model::RemoveFlowOutputRequest>
  Model::RemoveFlowOutputOutcomeCallable RemoveFlowOutputCallable(const RemoveFlowOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RemoveFlowOutput, request);
  }
 
  template <typename RemoveFlowOutputRequestT = Model::RemoveFlowOutputRequest>
  void RemoveFlowOutputAsync(const RemoveFlowOutputRequestT& request, const RemoveFlowOutputResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RemoveFlowOutput, request, handler, context);
  }
 
  virtual Model::RemoveFlowSourceOutcome RemoveFlowSource(const Model::RemoveFlowSourceRequest& request) const;
 
  template <typename RemoveFlowSourceRequestT = Model::RemoveFlowSourceRequest>
  Model::RemoveFlowSourceOutcomeCallable RemoveFlowSourceCallable(const RemoveFlowSourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RemoveFlowSource, request);
  }
 
  template <typename RemoveFlowSourceRequestT = Model::RemoveFlowSourceRequest>
  void RemoveFlowSourceAsync(const RemoveFlowSourceRequestT& request, const RemoveFlowSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RemoveFlowSource, request, handler, context);
  }
 
  virtual Model::RemoveFlowVpcInterfaceOutcome RemoveFlowVpcInterface(const Model::RemoveFlowVpcInterfaceRequest& request) const;
 
  template <typename RemoveFlowVpcInterfaceRequestT = Model::RemoveFlowVpcInterfaceRequest>
  Model::RemoveFlowVpcInterfaceOutcomeCallable RemoveFlowVpcInterfaceCallable(const RemoveFlowVpcInterfaceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RemoveFlowVpcInterface, request);
  }
 
  template <typename RemoveFlowVpcInterfaceRequestT = Model::RemoveFlowVpcInterfaceRequest>
  void RemoveFlowVpcInterfaceAsync(const RemoveFlowVpcInterfaceRequestT& request,
                                   const RemoveFlowVpcInterfaceResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RemoveFlowVpcInterface, request, handler, context);
  }
 
  virtual Model::RestartRouterInputOutcome RestartRouterInput(const Model::RestartRouterInputRequest& request) const;
 
  template <typename RestartRouterInputRequestT = Model::RestartRouterInputRequest>
  Model::RestartRouterInputOutcomeCallable RestartRouterInputCallable(const RestartRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RestartRouterInput, request);
  }
 
  template <typename RestartRouterInputRequestT = Model::RestartRouterInputRequest>
  void RestartRouterInputAsync(const RestartRouterInputRequestT& request, const RestartRouterInputResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RestartRouterInput, request, handler, context);
  }
 
  virtual Model::RestartRouterOutputOutcome RestartRouterOutput(const Model::RestartRouterOutputRequest& request) const;
 
  template <typename RestartRouterOutputRequestT = Model::RestartRouterOutputRequest>
  Model::RestartRouterOutputOutcomeCallable RestartRouterOutputCallable(const RestartRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RestartRouterOutput, request);
  }
 
  template <typename RestartRouterOutputRequestT = Model::RestartRouterOutputRequest>
  void RestartRouterOutputAsync(const RestartRouterOutputRequestT& request, const RestartRouterOutputResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RestartRouterOutput, request, handler, context);
  }
 
  virtual Model::RevokeFlowEntitlementOutcome RevokeFlowEntitlement(const Model::RevokeFlowEntitlementRequest& request) const;
 
  template <typename RevokeFlowEntitlementRequestT = Model::RevokeFlowEntitlementRequest>
  Model::RevokeFlowEntitlementOutcomeCallable RevokeFlowEntitlementCallable(const RevokeFlowEntitlementRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::RevokeFlowEntitlement, request);
  }
 
  template <typename RevokeFlowEntitlementRequestT = Model::RevokeFlowEntitlementRequest>
  void RevokeFlowEntitlementAsync(const RevokeFlowEntitlementRequestT& request, const RevokeFlowEntitlementResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::RevokeFlowEntitlement, request, handler, context);
  }
 
  virtual Model::StartFlowOutcome StartFlow(const Model::StartFlowRequest& request) const;
 
  template <typename StartFlowRequestT = Model::StartFlowRequest>
  Model::StartFlowOutcomeCallable StartFlowCallable(const StartFlowRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::StartFlow, request);
  }
 
  template <typename StartFlowRequestT = Model::StartFlowRequest>
  void StartFlowAsync(const StartFlowRequestT& request, const StartFlowResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::StartFlow, request, handler, context);
  }
 
  virtual Model::StartRouterInputOutcome StartRouterInput(const Model::StartRouterInputRequest& request) const;
 
  template <typename StartRouterInputRequestT = Model::StartRouterInputRequest>
  Model::StartRouterInputOutcomeCallable StartRouterInputCallable(const StartRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::StartRouterInput, request);
  }
 
  template <typename StartRouterInputRequestT = Model::StartRouterInputRequest>
  void StartRouterInputAsync(const StartRouterInputRequestT& request, const StartRouterInputResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::StartRouterInput, request, handler, context);
  }
 
  virtual Model::StartRouterOutputOutcome StartRouterOutput(const Model::StartRouterOutputRequest& request) const;
 
  template <typename StartRouterOutputRequestT = Model::StartRouterOutputRequest>
  Model::StartRouterOutputOutcomeCallable StartRouterOutputCallable(const StartRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::StartRouterOutput, request);
  }
 
  template <typename StartRouterOutputRequestT = Model::StartRouterOutputRequest>
  void StartRouterOutputAsync(const StartRouterOutputRequestT& request, const StartRouterOutputResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::StartRouterOutput, request, handler, context);
  }
 
  virtual Model::StopFlowOutcome StopFlow(const Model::StopFlowRequest& request) const;
 
  template <typename StopFlowRequestT = Model::StopFlowRequest>
  Model::StopFlowOutcomeCallable StopFlowCallable(const StopFlowRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::StopFlow, request);
  }
 
  template <typename StopFlowRequestT = Model::StopFlowRequest>
  void StopFlowAsync(const StopFlowRequestT& request, const StopFlowResponseReceivedHandler& handler,
                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::StopFlow, request, handler, context);
  }
 
  virtual Model::StopRouterInputOutcome StopRouterInput(const Model::StopRouterInputRequest& request) const;
 
  template <typename StopRouterInputRequestT = Model::StopRouterInputRequest>
  Model::StopRouterInputOutcomeCallable StopRouterInputCallable(const StopRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::StopRouterInput, request);
  }
 
  template <typename StopRouterInputRequestT = Model::StopRouterInputRequest>
  void StopRouterInputAsync(const StopRouterInputRequestT& request, const StopRouterInputResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::StopRouterInput, request, handler, context);
  }
 
  virtual Model::StopRouterOutputOutcome StopRouterOutput(const Model::StopRouterOutputRequest& request) const;
 
  template <typename StopRouterOutputRequestT = Model::StopRouterOutputRequest>
  Model::StopRouterOutputOutcomeCallable StopRouterOutputCallable(const StopRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::StopRouterOutput, request);
  }
 
  template <typename StopRouterOutputRequestT = Model::StopRouterOutputRequest>
  void StopRouterOutputAsync(const StopRouterOutputRequestT& request, const StopRouterOutputResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::StopRouterOutput, request, handler, context);
  }
 
  virtual Model::TagGlobalResourceOutcome TagGlobalResource(const Model::TagGlobalResourceRequest& request) const;
 
  template <typename TagGlobalResourceRequestT = Model::TagGlobalResourceRequest>
  Model::TagGlobalResourceOutcomeCallable TagGlobalResourceCallable(const TagGlobalResourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::TagGlobalResource, request);
  }
 
  template <typename TagGlobalResourceRequestT = Model::TagGlobalResourceRequest>
  void TagGlobalResourceAsync(const TagGlobalResourceRequestT& request, const TagGlobalResourceResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::TagGlobalResource, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::TagResource, request, handler, context);
  }
 
  virtual Model::TakeRouterInputOutcome TakeRouterInput(const Model::TakeRouterInputRequest& request) const;
 
  template <typename TakeRouterInputRequestT = Model::TakeRouterInputRequest>
  Model::TakeRouterInputOutcomeCallable TakeRouterInputCallable(const TakeRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::TakeRouterInput, request);
  }
 
  template <typename TakeRouterInputRequestT = Model::TakeRouterInputRequest>
  void TakeRouterInputAsync(const TakeRouterInputRequestT& request, const TakeRouterInputResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::TakeRouterInput, request, handler, context);
  }
 
  virtual Model::UntagGlobalResourceOutcome UntagGlobalResource(const Model::UntagGlobalResourceRequest& request) const;
 
  template <typename UntagGlobalResourceRequestT = Model::UntagGlobalResourceRequest>
  Model::UntagGlobalResourceOutcomeCallable UntagGlobalResourceCallable(const UntagGlobalResourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UntagGlobalResource, request);
  }
 
  template <typename UntagGlobalResourceRequestT = Model::UntagGlobalResourceRequest>
  void UntagGlobalResourceAsync(const UntagGlobalResourceRequestT& request, const UntagGlobalResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UntagGlobalResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateBridgeOutcome UpdateBridge(const Model::UpdateBridgeRequest& request) const;
 
  template <typename UpdateBridgeRequestT = Model::UpdateBridgeRequest>
  Model::UpdateBridgeOutcomeCallable UpdateBridgeCallable(const UpdateBridgeRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateBridge, request);
  }
 
  template <typename UpdateBridgeRequestT = Model::UpdateBridgeRequest>
  void UpdateBridgeAsync(const UpdateBridgeRequestT& request, const UpdateBridgeResponseReceivedHandler& handler,
                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateBridge, request, handler, context);
  }
 
  virtual Model::UpdateBridgeOutputOutcome UpdateBridgeOutput(const Model::UpdateBridgeOutputRequest& request) const;
 
  template <typename UpdateBridgeOutputRequestT = Model::UpdateBridgeOutputRequest>
  Model::UpdateBridgeOutputOutcomeCallable UpdateBridgeOutputCallable(const UpdateBridgeOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateBridgeOutput, request);
  }
 
  template <typename UpdateBridgeOutputRequestT = Model::UpdateBridgeOutputRequest>
  void UpdateBridgeOutputAsync(const UpdateBridgeOutputRequestT& request, const UpdateBridgeOutputResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateBridgeOutput, request, handler, context);
  }
 
  virtual Model::UpdateBridgeSourceOutcome UpdateBridgeSource(const Model::UpdateBridgeSourceRequest& request) const;
 
  template <typename UpdateBridgeSourceRequestT = Model::UpdateBridgeSourceRequest>
  Model::UpdateBridgeSourceOutcomeCallable UpdateBridgeSourceCallable(const UpdateBridgeSourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateBridgeSource, request);
  }
 
  template <typename UpdateBridgeSourceRequestT = Model::UpdateBridgeSourceRequest>
  void UpdateBridgeSourceAsync(const UpdateBridgeSourceRequestT& request, const UpdateBridgeSourceResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateBridgeSource, request, handler, context);
  }
 
  virtual Model::UpdateBridgeStateOutcome UpdateBridgeState(const Model::UpdateBridgeStateRequest& request) const;
 
  template <typename UpdateBridgeStateRequestT = Model::UpdateBridgeStateRequest>
  Model::UpdateBridgeStateOutcomeCallable UpdateBridgeStateCallable(const UpdateBridgeStateRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateBridgeState, request);
  }
 
  template <typename UpdateBridgeStateRequestT = Model::UpdateBridgeStateRequest>
  void UpdateBridgeStateAsync(const UpdateBridgeStateRequestT& request, const UpdateBridgeStateResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateBridgeState, request, handler, context);
  }
 
  virtual Model::UpdateFlowOutcome UpdateFlow(const Model::UpdateFlowRequest& request) const;
 
  template <typename UpdateFlowRequestT = Model::UpdateFlowRequest>
  Model::UpdateFlowOutcomeCallable UpdateFlowCallable(const UpdateFlowRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateFlow, request);
  }
 
  template <typename UpdateFlowRequestT = Model::UpdateFlowRequest>
  void UpdateFlowAsync(const UpdateFlowRequestT& request, const UpdateFlowResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateFlow, request, handler, context);
  }
 
  virtual Model::UpdateFlowEntitlementOutcome UpdateFlowEntitlement(const Model::UpdateFlowEntitlementRequest& request) const;
 
  template <typename UpdateFlowEntitlementRequestT = Model::UpdateFlowEntitlementRequest>
  Model::UpdateFlowEntitlementOutcomeCallable UpdateFlowEntitlementCallable(const UpdateFlowEntitlementRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateFlowEntitlement, request);
  }
 
  template <typename UpdateFlowEntitlementRequestT = Model::UpdateFlowEntitlementRequest>
  void UpdateFlowEntitlementAsync(const UpdateFlowEntitlementRequestT& request, const UpdateFlowEntitlementResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateFlowEntitlement, request, handler, context);
  }
 
  virtual Model::UpdateFlowMediaStreamOutcome UpdateFlowMediaStream(const Model::UpdateFlowMediaStreamRequest& request) const;
 
  template <typename UpdateFlowMediaStreamRequestT = Model::UpdateFlowMediaStreamRequest>
  Model::UpdateFlowMediaStreamOutcomeCallable UpdateFlowMediaStreamCallable(const UpdateFlowMediaStreamRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateFlowMediaStream, request);
  }
 
  template <typename UpdateFlowMediaStreamRequestT = Model::UpdateFlowMediaStreamRequest>
  void UpdateFlowMediaStreamAsync(const UpdateFlowMediaStreamRequestT& request, const UpdateFlowMediaStreamResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateFlowMediaStream, request, handler, context);
  }
 
  virtual Model::UpdateFlowOutputOutcome UpdateFlowOutput(const Model::UpdateFlowOutputRequest& request) const;
 
  template <typename UpdateFlowOutputRequestT = Model::UpdateFlowOutputRequest>
  Model::UpdateFlowOutputOutcomeCallable UpdateFlowOutputCallable(const UpdateFlowOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateFlowOutput, request);
  }
 
  template <typename UpdateFlowOutputRequestT = Model::UpdateFlowOutputRequest>
  void UpdateFlowOutputAsync(const UpdateFlowOutputRequestT& request, const UpdateFlowOutputResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateFlowOutput, request, handler, context);
  }
 
  virtual Model::UpdateFlowSourceOutcome UpdateFlowSource(const Model::UpdateFlowSourceRequest& request) const;
 
  template <typename UpdateFlowSourceRequestT = Model::UpdateFlowSourceRequest>
  Model::UpdateFlowSourceOutcomeCallable UpdateFlowSourceCallable(const UpdateFlowSourceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateFlowSource, request);
  }
 
  template <typename UpdateFlowSourceRequestT = Model::UpdateFlowSourceRequest>
  void UpdateFlowSourceAsync(const UpdateFlowSourceRequestT& request, const UpdateFlowSourceResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateFlowSource, request, handler, context);
  }
 
  virtual Model::UpdateGatewayInstanceOutcome UpdateGatewayInstance(const Model::UpdateGatewayInstanceRequest& request) const;
 
  template <typename UpdateGatewayInstanceRequestT = Model::UpdateGatewayInstanceRequest>
  Model::UpdateGatewayInstanceOutcomeCallable UpdateGatewayInstanceCallable(const UpdateGatewayInstanceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateGatewayInstance, request);
  }
 
  template <typename UpdateGatewayInstanceRequestT = Model::UpdateGatewayInstanceRequest>
  void UpdateGatewayInstanceAsync(const UpdateGatewayInstanceRequestT& request, const UpdateGatewayInstanceResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateGatewayInstance, request, handler, context);
  }
 
  virtual Model::UpdateRouterInputOutcome UpdateRouterInput(const Model::UpdateRouterInputRequest& request) const;
 
  template <typename UpdateRouterInputRequestT = Model::UpdateRouterInputRequest>
  Model::UpdateRouterInputOutcomeCallable UpdateRouterInputCallable(const UpdateRouterInputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateRouterInput, request);
  }
 
  template <typename UpdateRouterInputRequestT = Model::UpdateRouterInputRequest>
  void UpdateRouterInputAsync(const UpdateRouterInputRequestT& request, const UpdateRouterInputResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateRouterInput, request, handler, context);
  }
 
  virtual Model::UpdateRouterNetworkInterfaceOutcome UpdateRouterNetworkInterface(
      const Model::UpdateRouterNetworkInterfaceRequest& request) const;
 
  template <typename UpdateRouterNetworkInterfaceRequestT = Model::UpdateRouterNetworkInterfaceRequest>
  Model::UpdateRouterNetworkInterfaceOutcomeCallable UpdateRouterNetworkInterfaceCallable(
      const UpdateRouterNetworkInterfaceRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateRouterNetworkInterface, request);
  }
 
  template <typename UpdateRouterNetworkInterfaceRequestT = Model::UpdateRouterNetworkInterfaceRequest>
  void UpdateRouterNetworkInterfaceAsync(const UpdateRouterNetworkInterfaceRequestT& request,
                                         const UpdateRouterNetworkInterfaceResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateRouterNetworkInterface, request, handler, context);
  }
 
  virtual Model::UpdateRouterOutputOutcome UpdateRouterOutput(const Model::UpdateRouterOutputRequest& request) const;
 
  template <typename UpdateRouterOutputRequestT = Model::UpdateRouterOutputRequest>
  Model::UpdateRouterOutputOutcomeCallable UpdateRouterOutputCallable(const UpdateRouterOutputRequestT& request) const {
    return SubmitCallable(&MediaConnectClient::UpdateRouterOutput, request);
  }
 
  template <typename UpdateRouterOutputRequestT = Model::UpdateRouterOutputRequest>
  void UpdateRouterOutputAsync(const UpdateRouterOutputRequestT& request, const UpdateRouterOutputResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&MediaConnectClient::UpdateRouterOutput, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<MediaConnectEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaConnectClient>;
  void init(const MediaConnectClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, MediaConnectError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  MediaConnectClientConfiguration m_clientConfiguration;
  std::shared_ptr<MediaConnectEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace MediaConnect
}  // namespace Aws