AppFabricClient.h

 
#pragma once
#include <aws/appfabric/AppFabric_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/appfabric/AppFabricServiceClientModel.h>
 
namespace Aws
{
namespace AppFabric
{
  class AWS_APPFABRIC_API AppFabricClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<AppFabricClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef AppFabricClientConfiguration ClientConfigurationType;
      typedef AppFabricEndpointProvider EndpointProviderType;
 
        AppFabricClient(const Aws::AppFabric::AppFabricClientConfiguration& clientConfiguration = Aws::AppFabric::AppFabricClientConfiguration(),
                        std::shared_ptr<AppFabricEndpointProviderBase> endpointProvider = nullptr);
 
        AppFabricClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<AppFabricEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::AppFabric::AppFabricClientConfiguration& clientConfiguration = Aws::AppFabric::AppFabricClientConfiguration());
 
        AppFabricClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<AppFabricEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::AppFabric::AppFabricClientConfiguration& clientConfiguration = Aws::AppFabric::AppFabricClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        AppFabricClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppFabricClient(const Aws::Auth::AWSCredentials& credentials,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        AppFabricClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~AppFabricClient();
 
        virtual Model::BatchGetUserAccessTasksOutcome BatchGetUserAccessTasks(const Model::BatchGetUserAccessTasksRequest& request) const;
 
        template<typename BatchGetUserAccessTasksRequestT = Model::BatchGetUserAccessTasksRequest>
        Model::BatchGetUserAccessTasksOutcomeCallable BatchGetUserAccessTasksCallable(const BatchGetUserAccessTasksRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::BatchGetUserAccessTasks, request);
        }
 
        template<typename BatchGetUserAccessTasksRequestT = Model::BatchGetUserAccessTasksRequest>
        void BatchGetUserAccessTasksAsync(const BatchGetUserAccessTasksRequestT& request, const BatchGetUserAccessTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::BatchGetUserAccessTasks, request, handler, context);
        }
 
        virtual Model::ConnectAppAuthorizationOutcome ConnectAppAuthorization(const Model::ConnectAppAuthorizationRequest& request) const;
 
        template<typename ConnectAppAuthorizationRequestT = Model::ConnectAppAuthorizationRequest>
        Model::ConnectAppAuthorizationOutcomeCallable ConnectAppAuthorizationCallable(const ConnectAppAuthorizationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::ConnectAppAuthorization, request);
        }
 
        template<typename ConnectAppAuthorizationRequestT = Model::ConnectAppAuthorizationRequest>
        void ConnectAppAuthorizationAsync(const ConnectAppAuthorizationRequestT& request, const ConnectAppAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::ConnectAppAuthorization, request, handler, context);
        }
 
        virtual Model::CreateAppAuthorizationOutcome CreateAppAuthorization(const Model::CreateAppAuthorizationRequest& request) const;
 
        template<typename CreateAppAuthorizationRequestT = Model::CreateAppAuthorizationRequest>
        Model::CreateAppAuthorizationOutcomeCallable CreateAppAuthorizationCallable(const CreateAppAuthorizationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::CreateAppAuthorization, request);
        }
 
        template<typename CreateAppAuthorizationRequestT = Model::CreateAppAuthorizationRequest>
        void CreateAppAuthorizationAsync(const CreateAppAuthorizationRequestT& request, const CreateAppAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::CreateAppAuthorization, request, handler, context);
        }
 
        virtual Model::CreateAppBundleOutcome CreateAppBundle(const Model::CreateAppBundleRequest& request = {}) const;
 
        template<typename CreateAppBundleRequestT = Model::CreateAppBundleRequest>
        Model::CreateAppBundleOutcomeCallable CreateAppBundleCallable(const CreateAppBundleRequestT& request = {}) const
        {
            return SubmitCallable(&AppFabricClient::CreateAppBundle, request);
        }
 
        template<typename CreateAppBundleRequestT = Model::CreateAppBundleRequest>
        void CreateAppBundleAsync(const CreateAppBundleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const CreateAppBundleRequestT& request = {}) const
        {
            return SubmitAsync(&AppFabricClient::CreateAppBundle, request, handler, context);
        }
 
        virtual Model::CreateIngestionOutcome CreateIngestion(const Model::CreateIngestionRequest& request) const;
 
        template<typename CreateIngestionRequestT = Model::CreateIngestionRequest>
        Model::CreateIngestionOutcomeCallable CreateIngestionCallable(const CreateIngestionRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::CreateIngestion, request);
        }
 
        template<typename CreateIngestionRequestT = Model::CreateIngestionRequest>
        void CreateIngestionAsync(const CreateIngestionRequestT& request, const CreateIngestionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::CreateIngestion, request, handler, context);
        }
 
        virtual Model::CreateIngestionDestinationOutcome CreateIngestionDestination(const Model::CreateIngestionDestinationRequest& request) const;
 
        template<typename CreateIngestionDestinationRequestT = Model::CreateIngestionDestinationRequest>
        Model::CreateIngestionDestinationOutcomeCallable CreateIngestionDestinationCallable(const CreateIngestionDestinationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::CreateIngestionDestination, request);
        }
 
        template<typename CreateIngestionDestinationRequestT = Model::CreateIngestionDestinationRequest>
        void CreateIngestionDestinationAsync(const CreateIngestionDestinationRequestT& request, const CreateIngestionDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::CreateIngestionDestination, request, handler, context);
        }
 
        virtual Model::DeleteAppAuthorizationOutcome DeleteAppAuthorization(const Model::DeleteAppAuthorizationRequest& request) const;
 
        template<typename DeleteAppAuthorizationRequestT = Model::DeleteAppAuthorizationRequest>
        Model::DeleteAppAuthorizationOutcomeCallable DeleteAppAuthorizationCallable(const DeleteAppAuthorizationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::DeleteAppAuthorization, request);
        }
 
        template<typename DeleteAppAuthorizationRequestT = Model::DeleteAppAuthorizationRequest>
        void DeleteAppAuthorizationAsync(const DeleteAppAuthorizationRequestT& request, const DeleteAppAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::DeleteAppAuthorization, request, handler, context);
        }
 
        virtual Model::DeleteAppBundleOutcome DeleteAppBundle(const Model::DeleteAppBundleRequest& request) const;
 
        template<typename DeleteAppBundleRequestT = Model::DeleteAppBundleRequest>
        Model::DeleteAppBundleOutcomeCallable DeleteAppBundleCallable(const DeleteAppBundleRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::DeleteAppBundle, request);
        }
 
        template<typename DeleteAppBundleRequestT = Model::DeleteAppBundleRequest>
        void DeleteAppBundleAsync(const DeleteAppBundleRequestT& request, const DeleteAppBundleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::DeleteAppBundle, request, handler, context);
        }
 
        virtual Model::DeleteIngestionOutcome DeleteIngestion(const Model::DeleteIngestionRequest& request) const;
 
        template<typename DeleteIngestionRequestT = Model::DeleteIngestionRequest>
        Model::DeleteIngestionOutcomeCallable DeleteIngestionCallable(const DeleteIngestionRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::DeleteIngestion, request);
        }
 
        template<typename DeleteIngestionRequestT = Model::DeleteIngestionRequest>
        void DeleteIngestionAsync(const DeleteIngestionRequestT& request, const DeleteIngestionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::DeleteIngestion, request, handler, context);
        }
 
        virtual Model::DeleteIngestionDestinationOutcome DeleteIngestionDestination(const Model::DeleteIngestionDestinationRequest& request) const;
 
        template<typename DeleteIngestionDestinationRequestT = Model::DeleteIngestionDestinationRequest>
        Model::DeleteIngestionDestinationOutcomeCallable DeleteIngestionDestinationCallable(const DeleteIngestionDestinationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::DeleteIngestionDestination, request);
        }
 
        template<typename DeleteIngestionDestinationRequestT = Model::DeleteIngestionDestinationRequest>
        void DeleteIngestionDestinationAsync(const DeleteIngestionDestinationRequestT& request, const DeleteIngestionDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::DeleteIngestionDestination, request, handler, context);
        }
 
        virtual Model::GetAppAuthorizationOutcome GetAppAuthorization(const Model::GetAppAuthorizationRequest& request) const;
 
        template<typename GetAppAuthorizationRequestT = Model::GetAppAuthorizationRequest>
        Model::GetAppAuthorizationOutcomeCallable GetAppAuthorizationCallable(const GetAppAuthorizationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::GetAppAuthorization, request);
        }
 
        template<typename GetAppAuthorizationRequestT = Model::GetAppAuthorizationRequest>
        void GetAppAuthorizationAsync(const GetAppAuthorizationRequestT& request, const GetAppAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::GetAppAuthorization, request, handler, context);
        }
 
        virtual Model::GetAppBundleOutcome GetAppBundle(const Model::GetAppBundleRequest& request) const;
 
        template<typename GetAppBundleRequestT = Model::GetAppBundleRequest>
        Model::GetAppBundleOutcomeCallable GetAppBundleCallable(const GetAppBundleRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::GetAppBundle, request);
        }
 
        template<typename GetAppBundleRequestT = Model::GetAppBundleRequest>
        void GetAppBundleAsync(const GetAppBundleRequestT& request, const GetAppBundleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::GetAppBundle, request, handler, context);
        }
 
        virtual Model::GetIngestionOutcome GetIngestion(const Model::GetIngestionRequest& request) const;
 
        template<typename GetIngestionRequestT = Model::GetIngestionRequest>
        Model::GetIngestionOutcomeCallable GetIngestionCallable(const GetIngestionRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::GetIngestion, request);
        }
 
        template<typename GetIngestionRequestT = Model::GetIngestionRequest>
        void GetIngestionAsync(const GetIngestionRequestT& request, const GetIngestionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::GetIngestion, request, handler, context);
        }
 
        virtual Model::GetIngestionDestinationOutcome GetIngestionDestination(const Model::GetIngestionDestinationRequest& request) const;
 
        template<typename GetIngestionDestinationRequestT = Model::GetIngestionDestinationRequest>
        Model::GetIngestionDestinationOutcomeCallable GetIngestionDestinationCallable(const GetIngestionDestinationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::GetIngestionDestination, request);
        }
 
        template<typename GetIngestionDestinationRequestT = Model::GetIngestionDestinationRequest>
        void GetIngestionDestinationAsync(const GetIngestionDestinationRequestT& request, const GetIngestionDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::GetIngestionDestination, request, handler, context);
        }
 
        virtual Model::ListAppAuthorizationsOutcome ListAppAuthorizations(const Model::ListAppAuthorizationsRequest& request) const;
 
        template<typename ListAppAuthorizationsRequestT = Model::ListAppAuthorizationsRequest>
        Model::ListAppAuthorizationsOutcomeCallable ListAppAuthorizationsCallable(const ListAppAuthorizationsRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::ListAppAuthorizations, request);
        }
 
        template<typename ListAppAuthorizationsRequestT = Model::ListAppAuthorizationsRequest>
        void ListAppAuthorizationsAsync(const ListAppAuthorizationsRequestT& request, const ListAppAuthorizationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::ListAppAuthorizations, request, handler, context);
        }
 
        virtual Model::ListAppBundlesOutcome ListAppBundles(const Model::ListAppBundlesRequest& request = {}) const;
 
        template<typename ListAppBundlesRequestT = Model::ListAppBundlesRequest>
        Model::ListAppBundlesOutcomeCallable ListAppBundlesCallable(const ListAppBundlesRequestT& request = {}) const
        {
            return SubmitCallable(&AppFabricClient::ListAppBundles, request);
        }
 
        template<typename ListAppBundlesRequestT = Model::ListAppBundlesRequest>
        void ListAppBundlesAsync(const ListAppBundlesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAppBundlesRequestT& request = {}) const
        {
            return SubmitAsync(&AppFabricClient::ListAppBundles, request, handler, context);
        }
 
        virtual Model::ListIngestionDestinationsOutcome ListIngestionDestinations(const Model::ListIngestionDestinationsRequest& request) const;
 
        template<typename ListIngestionDestinationsRequestT = Model::ListIngestionDestinationsRequest>
        Model::ListIngestionDestinationsOutcomeCallable ListIngestionDestinationsCallable(const ListIngestionDestinationsRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::ListIngestionDestinations, request);
        }
 
        template<typename ListIngestionDestinationsRequestT = Model::ListIngestionDestinationsRequest>
        void ListIngestionDestinationsAsync(const ListIngestionDestinationsRequestT& request, const ListIngestionDestinationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::ListIngestionDestinations, request, handler, context);
        }
 
        virtual Model::ListIngestionsOutcome ListIngestions(const Model::ListIngestionsRequest& request) const;
 
        template<typename ListIngestionsRequestT = Model::ListIngestionsRequest>
        Model::ListIngestionsOutcomeCallable ListIngestionsCallable(const ListIngestionsRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::ListIngestions, request);
        }
 
        template<typename ListIngestionsRequestT = Model::ListIngestionsRequest>
        void ListIngestionsAsync(const ListIngestionsRequestT& request, const ListIngestionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::ListIngestions, 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(&AppFabricClient::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(&AppFabricClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartIngestionOutcome StartIngestion(const Model::StartIngestionRequest& request) const;
 
        template<typename StartIngestionRequestT = Model::StartIngestionRequest>
        Model::StartIngestionOutcomeCallable StartIngestionCallable(const StartIngestionRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::StartIngestion, request);
        }
 
        template<typename StartIngestionRequestT = Model::StartIngestionRequest>
        void StartIngestionAsync(const StartIngestionRequestT& request, const StartIngestionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::StartIngestion, request, handler, context);
        }
 
        virtual Model::StartUserAccessTasksOutcome StartUserAccessTasks(const Model::StartUserAccessTasksRequest& request) const;
 
        template<typename StartUserAccessTasksRequestT = Model::StartUserAccessTasksRequest>
        Model::StartUserAccessTasksOutcomeCallable StartUserAccessTasksCallable(const StartUserAccessTasksRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::StartUserAccessTasks, request);
        }
 
        template<typename StartUserAccessTasksRequestT = Model::StartUserAccessTasksRequest>
        void StartUserAccessTasksAsync(const StartUserAccessTasksRequestT& request, const StartUserAccessTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::StartUserAccessTasks, request, handler, context);
        }
 
        virtual Model::StopIngestionOutcome StopIngestion(const Model::StopIngestionRequest& request) const;
 
        template<typename StopIngestionRequestT = Model::StopIngestionRequest>
        Model::StopIngestionOutcomeCallable StopIngestionCallable(const StopIngestionRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::StopIngestion, request);
        }
 
        template<typename StopIngestionRequestT = Model::StopIngestionRequest>
        void StopIngestionAsync(const StopIngestionRequestT& request, const StopIngestionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::StopIngestion, 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(&AppFabricClient::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(&AppFabricClient::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(&AppFabricClient::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(&AppFabricClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAppAuthorizationOutcome UpdateAppAuthorization(const Model::UpdateAppAuthorizationRequest& request) const;
 
        template<typename UpdateAppAuthorizationRequestT = Model::UpdateAppAuthorizationRequest>
        Model::UpdateAppAuthorizationOutcomeCallable UpdateAppAuthorizationCallable(const UpdateAppAuthorizationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::UpdateAppAuthorization, request);
        }
 
        template<typename UpdateAppAuthorizationRequestT = Model::UpdateAppAuthorizationRequest>
        void UpdateAppAuthorizationAsync(const UpdateAppAuthorizationRequestT& request, const UpdateAppAuthorizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::UpdateAppAuthorization, request, handler, context);
        }
 
        virtual Model::UpdateIngestionDestinationOutcome UpdateIngestionDestination(const Model::UpdateIngestionDestinationRequest& request) const;
 
        template<typename UpdateIngestionDestinationRequestT = Model::UpdateIngestionDestinationRequest>
        Model::UpdateIngestionDestinationOutcomeCallable UpdateIngestionDestinationCallable(const UpdateIngestionDestinationRequestT& request) const
        {
            return SubmitCallable(&AppFabricClient::UpdateIngestionDestination, request);
        }
 
        template<typename UpdateIngestionDestinationRequestT = Model::UpdateIngestionDestinationRequest>
        void UpdateIngestionDestinationAsync(const UpdateIngestionDestinationRequestT& request, const UpdateIngestionDestinationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&AppFabricClient::UpdateIngestionDestination, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<AppFabricEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<AppFabricClient>;
      void init(const AppFabricClientConfiguration& clientConfiguration);
 
      AppFabricClientConfiguration m_clientConfiguration;
      std::shared_ptr<AppFabricEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace AppFabric
} // namespace Aws