AppFabricClient.h

 
#pragma once
#include <aws/appfabric/AppFabricPaginationBase.h>
#include <aws/appfabric/AppFabricServiceClientModel.h>
#include <aws/appfabric/AppFabric_EXPORTS.h>
#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>
 
namespace Aws {
namespace AppFabric {
class AWS_APPFABRIC_API AppFabricClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<AppFabricClient>,
                                          public AppFabricPaginationBase<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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