MediaConnectClient.h

 
#pragma once
#include <aws/mediaconnect/MediaConnect_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/mediaconnect/MediaConnectServiceClientModel.h>
 
namespace Aws
{
namespace MediaConnect
{
  class AWS_MEDIACONNECT_API MediaConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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::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::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::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::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::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::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::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::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::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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<MediaConnectEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<MediaConnectClient>;
      void init(const MediaConnectClientConfiguration& clientConfiguration);
 
      MediaConnectClientConfiguration m_clientConfiguration;
      std::shared_ptr<MediaConnectEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace MediaConnect
} // namespace Aws