QAppsClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/qapps/QAppsPaginationBase.h>
#include <aws/qapps/QAppsServiceClientModel.h>
#include <aws/qapps/QAppsWaiter.h>
#include <aws/qapps/QApps_EXPORTS.h>
 
namespace Aws {
namespace QApps {
class AWS_QAPPS_API QAppsClient : public Aws::Client::AWSJsonClient,
                                  public Aws::Client::ClientWithAsyncTemplateMethods<QAppsClient>,
                                  public QAppsPaginationBase<QAppsClient>,
                                  public QAppsWaiter<QAppsClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef QAppsClientConfiguration ClientConfigurationType;
  typedef QAppsEndpointProvider EndpointProviderType;
 
  QAppsClient(const Aws::QApps::QAppsClientConfiguration& clientConfiguration = Aws::QApps::QAppsClientConfiguration(),
              std::shared_ptr<QAppsEndpointProviderBase> endpointProvider = nullptr);
 
  QAppsClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<QAppsEndpointProviderBase> endpointProvider = nullptr,
              const Aws::QApps::QAppsClientConfiguration& clientConfiguration = Aws::QApps::QAppsClientConfiguration());
 
  QAppsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              std::shared_ptr<QAppsEndpointProviderBase> endpointProvider = nullptr,
              const Aws::QApps::QAppsClientConfiguration& clientConfiguration = Aws::QApps::QAppsClientConfiguration());
 
  /* Legacy constructors due deprecation */
  QAppsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  QAppsClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  QAppsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
              const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~QAppsClient();
 
  virtual Model::AssociateLibraryItemReviewOutcome AssociateLibraryItemReview(
      const Model::AssociateLibraryItemReviewRequest& request) const;
 
  template <typename AssociateLibraryItemReviewRequestT = Model::AssociateLibraryItemReviewRequest>
  Model::AssociateLibraryItemReviewOutcomeCallable AssociateLibraryItemReviewCallable(
      const AssociateLibraryItemReviewRequestT& request) const {
    return SubmitCallable(&QAppsClient::AssociateLibraryItemReview, request);
  }
 
  template <typename AssociateLibraryItemReviewRequestT = Model::AssociateLibraryItemReviewRequest>
  void AssociateLibraryItemReviewAsync(const AssociateLibraryItemReviewRequestT& request,
                                       const AssociateLibraryItemReviewResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::AssociateLibraryItemReview, request, handler, context);
  }
 
  virtual Model::AssociateQAppWithUserOutcome AssociateQAppWithUser(const Model::AssociateQAppWithUserRequest& request) const;
 
  template <typename AssociateQAppWithUserRequestT = Model::AssociateQAppWithUserRequest>
  Model::AssociateQAppWithUserOutcomeCallable AssociateQAppWithUserCallable(const AssociateQAppWithUserRequestT& request) const {
    return SubmitCallable(&QAppsClient::AssociateQAppWithUser, request);
  }
 
  template <typename AssociateQAppWithUserRequestT = Model::AssociateQAppWithUserRequest>
  void AssociateQAppWithUserAsync(const AssociateQAppWithUserRequestT& request, const AssociateQAppWithUserResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::AssociateQAppWithUser, request, handler, context);
  }
 
  virtual Model::BatchCreateCategoryOutcome BatchCreateCategory(const Model::BatchCreateCategoryRequest& request) const;
 
  template <typename BatchCreateCategoryRequestT = Model::BatchCreateCategoryRequest>
  Model::BatchCreateCategoryOutcomeCallable BatchCreateCategoryCallable(const BatchCreateCategoryRequestT& request) const {
    return SubmitCallable(&QAppsClient::BatchCreateCategory, request);
  }
 
  template <typename BatchCreateCategoryRequestT = Model::BatchCreateCategoryRequest>
  void BatchCreateCategoryAsync(const BatchCreateCategoryRequestT& request, const BatchCreateCategoryResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::BatchCreateCategory, request, handler, context);
  }
 
  virtual Model::BatchDeleteCategoryOutcome BatchDeleteCategory(const Model::BatchDeleteCategoryRequest& request) const;
 
  template <typename BatchDeleteCategoryRequestT = Model::BatchDeleteCategoryRequest>
  Model::BatchDeleteCategoryOutcomeCallable BatchDeleteCategoryCallable(const BatchDeleteCategoryRequestT& request) const {
    return SubmitCallable(&QAppsClient::BatchDeleteCategory, request);
  }
 
  template <typename BatchDeleteCategoryRequestT = Model::BatchDeleteCategoryRequest>
  void BatchDeleteCategoryAsync(const BatchDeleteCategoryRequestT& request, const BatchDeleteCategoryResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::BatchDeleteCategory, request, handler, context);
  }
 
  virtual Model::BatchUpdateCategoryOutcome BatchUpdateCategory(const Model::BatchUpdateCategoryRequest& request) const;
 
  template <typename BatchUpdateCategoryRequestT = Model::BatchUpdateCategoryRequest>
  Model::BatchUpdateCategoryOutcomeCallable BatchUpdateCategoryCallable(const BatchUpdateCategoryRequestT& request) const {
    return SubmitCallable(&QAppsClient::BatchUpdateCategory, request);
  }
 
  template <typename BatchUpdateCategoryRequestT = Model::BatchUpdateCategoryRequest>
  void BatchUpdateCategoryAsync(const BatchUpdateCategoryRequestT& request, const BatchUpdateCategoryResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::BatchUpdateCategory, request, handler, context);
  }
 
  virtual Model::CreateLibraryItemOutcome CreateLibraryItem(const Model::CreateLibraryItemRequest& request) const;
 
  template <typename CreateLibraryItemRequestT = Model::CreateLibraryItemRequest>
  Model::CreateLibraryItemOutcomeCallable CreateLibraryItemCallable(const CreateLibraryItemRequestT& request) const {
    return SubmitCallable(&QAppsClient::CreateLibraryItem, request);
  }
 
  template <typename CreateLibraryItemRequestT = Model::CreateLibraryItemRequest>
  void CreateLibraryItemAsync(const CreateLibraryItemRequestT& request, const CreateLibraryItemResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::CreateLibraryItem, request, handler, context);
  }
 
  virtual Model::CreatePresignedUrlOutcome CreatePresignedUrl(const Model::CreatePresignedUrlRequest& request) const;
 
  template <typename CreatePresignedUrlRequestT = Model::CreatePresignedUrlRequest>
  Model::CreatePresignedUrlOutcomeCallable CreatePresignedUrlCallable(const CreatePresignedUrlRequestT& request) const {
    return SubmitCallable(&QAppsClient::CreatePresignedUrl, request);
  }
 
  template <typename CreatePresignedUrlRequestT = Model::CreatePresignedUrlRequest>
  void CreatePresignedUrlAsync(const CreatePresignedUrlRequestT& request, const CreatePresignedUrlResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::CreatePresignedUrl, request, handler, context);
  }
 
  virtual Model::CreateQAppOutcome CreateQApp(const Model::CreateQAppRequest& request) const;
 
  template <typename CreateQAppRequestT = Model::CreateQAppRequest>
  Model::CreateQAppOutcomeCallable CreateQAppCallable(const CreateQAppRequestT& request) const {
    return SubmitCallable(&QAppsClient::CreateQApp, request);
  }
 
  template <typename CreateQAppRequestT = Model::CreateQAppRequest>
  void CreateQAppAsync(const CreateQAppRequestT& request, const CreateQAppResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::CreateQApp, request, handler, context);
  }
 
  virtual Model::DeleteLibraryItemOutcome DeleteLibraryItem(const Model::DeleteLibraryItemRequest& request) const;
 
  template <typename DeleteLibraryItemRequestT = Model::DeleteLibraryItemRequest>
  Model::DeleteLibraryItemOutcomeCallable DeleteLibraryItemCallable(const DeleteLibraryItemRequestT& request) const {
    return SubmitCallable(&QAppsClient::DeleteLibraryItem, request);
  }
 
  template <typename DeleteLibraryItemRequestT = Model::DeleteLibraryItemRequest>
  void DeleteLibraryItemAsync(const DeleteLibraryItemRequestT& request, const DeleteLibraryItemResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::DeleteLibraryItem, request, handler, context);
  }
 
  virtual Model::DeleteQAppOutcome DeleteQApp(const Model::DeleteQAppRequest& request) const;
 
  template <typename DeleteQAppRequestT = Model::DeleteQAppRequest>
  Model::DeleteQAppOutcomeCallable DeleteQAppCallable(const DeleteQAppRequestT& request) const {
    return SubmitCallable(&QAppsClient::DeleteQApp, request);
  }
 
  template <typename DeleteQAppRequestT = Model::DeleteQAppRequest>
  void DeleteQAppAsync(const DeleteQAppRequestT& request, const DeleteQAppResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::DeleteQApp, request, handler, context);
  }
 
  virtual Model::DescribeQAppPermissionsOutcome DescribeQAppPermissions(const Model::DescribeQAppPermissionsRequest& request) const;
 
  template <typename DescribeQAppPermissionsRequestT = Model::DescribeQAppPermissionsRequest>
  Model::DescribeQAppPermissionsOutcomeCallable DescribeQAppPermissionsCallable(const DescribeQAppPermissionsRequestT& request) const {
    return SubmitCallable(&QAppsClient::DescribeQAppPermissions, request);
  }
 
  template <typename DescribeQAppPermissionsRequestT = Model::DescribeQAppPermissionsRequest>
  void DescribeQAppPermissionsAsync(const DescribeQAppPermissionsRequestT& request,
                                    const DescribeQAppPermissionsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::DescribeQAppPermissions, request, handler, context);
  }
 
  virtual Model::DisassociateLibraryItemReviewOutcome DisassociateLibraryItemReview(
      const Model::DisassociateLibraryItemReviewRequest& request) const;
 
  template <typename DisassociateLibraryItemReviewRequestT = Model::DisassociateLibraryItemReviewRequest>
  Model::DisassociateLibraryItemReviewOutcomeCallable DisassociateLibraryItemReviewCallable(
      const DisassociateLibraryItemReviewRequestT& request) const {
    return SubmitCallable(&QAppsClient::DisassociateLibraryItemReview, request);
  }
 
  template <typename DisassociateLibraryItemReviewRequestT = Model::DisassociateLibraryItemReviewRequest>
  void DisassociateLibraryItemReviewAsync(const DisassociateLibraryItemReviewRequestT& request,
                                          const DisassociateLibraryItemReviewResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::DisassociateLibraryItemReview, request, handler, context);
  }
 
  virtual Model::DisassociateQAppFromUserOutcome DisassociateQAppFromUser(const Model::DisassociateQAppFromUserRequest& request) const;
 
  template <typename DisassociateQAppFromUserRequestT = Model::DisassociateQAppFromUserRequest>
  Model::DisassociateQAppFromUserOutcomeCallable DisassociateQAppFromUserCallable(const DisassociateQAppFromUserRequestT& request) const {
    return SubmitCallable(&QAppsClient::DisassociateQAppFromUser, request);
  }
 
  template <typename DisassociateQAppFromUserRequestT = Model::DisassociateQAppFromUserRequest>
  void DisassociateQAppFromUserAsync(const DisassociateQAppFromUserRequestT& request,
                                     const DisassociateQAppFromUserResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::DisassociateQAppFromUser, request, handler, context);
  }
 
  virtual Model::ExportQAppSessionDataOutcome ExportQAppSessionData(const Model::ExportQAppSessionDataRequest& request) const;
 
  template <typename ExportQAppSessionDataRequestT = Model::ExportQAppSessionDataRequest>
  Model::ExportQAppSessionDataOutcomeCallable ExportQAppSessionDataCallable(const ExportQAppSessionDataRequestT& request) const {
    return SubmitCallable(&QAppsClient::ExportQAppSessionData, request);
  }
 
  template <typename ExportQAppSessionDataRequestT = Model::ExportQAppSessionDataRequest>
  void ExportQAppSessionDataAsync(const ExportQAppSessionDataRequestT& request, const ExportQAppSessionDataResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::ExportQAppSessionData, request, handler, context);
  }
 
  virtual Model::GetLibraryItemOutcome GetLibraryItem(const Model::GetLibraryItemRequest& request) const;
 
  template <typename GetLibraryItemRequestT = Model::GetLibraryItemRequest>
  Model::GetLibraryItemOutcomeCallable GetLibraryItemCallable(const GetLibraryItemRequestT& request) const {
    return SubmitCallable(&QAppsClient::GetLibraryItem, request);
  }
 
  template <typename GetLibraryItemRequestT = Model::GetLibraryItemRequest>
  void GetLibraryItemAsync(const GetLibraryItemRequestT& request, const GetLibraryItemResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::GetLibraryItem, request, handler, context);
  }
 
  virtual Model::GetQAppOutcome GetQApp(const Model::GetQAppRequest& request) const;
 
  template <typename GetQAppRequestT = Model::GetQAppRequest>
  Model::GetQAppOutcomeCallable GetQAppCallable(const GetQAppRequestT& request) const {
    return SubmitCallable(&QAppsClient::GetQApp, request);
  }
 
  template <typename GetQAppRequestT = Model::GetQAppRequest>
  void GetQAppAsync(const GetQAppRequestT& request, const GetQAppResponseReceivedHandler& handler,
                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::GetQApp, request, handler, context);
  }
 
  virtual Model::GetQAppSessionOutcome GetQAppSession(const Model::GetQAppSessionRequest& request) const;
 
  template <typename GetQAppSessionRequestT = Model::GetQAppSessionRequest>
  Model::GetQAppSessionOutcomeCallable GetQAppSessionCallable(const GetQAppSessionRequestT& request) const {
    return SubmitCallable(&QAppsClient::GetQAppSession, request);
  }
 
  template <typename GetQAppSessionRequestT = Model::GetQAppSessionRequest>
  void GetQAppSessionAsync(const GetQAppSessionRequestT& request, const GetQAppSessionResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::GetQAppSession, request, handler, context);
  }
 
  virtual Model::GetQAppSessionMetadataOutcome GetQAppSessionMetadata(const Model::GetQAppSessionMetadataRequest& request) const;
 
  template <typename GetQAppSessionMetadataRequestT = Model::GetQAppSessionMetadataRequest>
  Model::GetQAppSessionMetadataOutcomeCallable GetQAppSessionMetadataCallable(const GetQAppSessionMetadataRequestT& request) const {
    return SubmitCallable(&QAppsClient::GetQAppSessionMetadata, request);
  }
 
  template <typename GetQAppSessionMetadataRequestT = Model::GetQAppSessionMetadataRequest>
  void GetQAppSessionMetadataAsync(const GetQAppSessionMetadataRequestT& request,
                                   const GetQAppSessionMetadataResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::GetQAppSessionMetadata, request, handler, context);
  }
 
  virtual Model::ImportDocumentOutcome ImportDocument(const Model::ImportDocumentRequest& request) const;
 
  template <typename ImportDocumentRequestT = Model::ImportDocumentRequest>
  Model::ImportDocumentOutcomeCallable ImportDocumentCallable(const ImportDocumentRequestT& request) const {
    return SubmitCallable(&QAppsClient::ImportDocument, request);
  }
 
  template <typename ImportDocumentRequestT = Model::ImportDocumentRequest>
  void ImportDocumentAsync(const ImportDocumentRequestT& request, const ImportDocumentResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::ImportDocument, request, handler, context);
  }
 
  virtual Model::ListCategoriesOutcome ListCategories(const Model::ListCategoriesRequest& request) const;
 
  template <typename ListCategoriesRequestT = Model::ListCategoriesRequest>
  Model::ListCategoriesOutcomeCallable ListCategoriesCallable(const ListCategoriesRequestT& request) const {
    return SubmitCallable(&QAppsClient::ListCategories, request);
  }
 
  template <typename ListCategoriesRequestT = Model::ListCategoriesRequest>
  void ListCategoriesAsync(const ListCategoriesRequestT& request, const ListCategoriesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::ListCategories, request, handler, context);
  }
 
  virtual Model::ListLibraryItemsOutcome ListLibraryItems(const Model::ListLibraryItemsRequest& request) const;
 
  template <typename ListLibraryItemsRequestT = Model::ListLibraryItemsRequest>
  Model::ListLibraryItemsOutcomeCallable ListLibraryItemsCallable(const ListLibraryItemsRequestT& request) const {
    return SubmitCallable(&QAppsClient::ListLibraryItems, request);
  }
 
  template <typename ListLibraryItemsRequestT = Model::ListLibraryItemsRequest>
  void ListLibraryItemsAsync(const ListLibraryItemsRequestT& request, const ListLibraryItemsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::ListLibraryItems, request, handler, context);
  }
 
  virtual Model::ListQAppSessionDataOutcome ListQAppSessionData(const Model::ListQAppSessionDataRequest& request) const;
 
  template <typename ListQAppSessionDataRequestT = Model::ListQAppSessionDataRequest>
  Model::ListQAppSessionDataOutcomeCallable ListQAppSessionDataCallable(const ListQAppSessionDataRequestT& request) const {
    return SubmitCallable(&QAppsClient::ListQAppSessionData, request);
  }
 
  template <typename ListQAppSessionDataRequestT = Model::ListQAppSessionDataRequest>
  void ListQAppSessionDataAsync(const ListQAppSessionDataRequestT& request, const ListQAppSessionDataResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::ListQAppSessionData, request, handler, context);
  }
 
  virtual Model::ListQAppsOutcome ListQApps(const Model::ListQAppsRequest& request) const;
 
  template <typename ListQAppsRequestT = Model::ListQAppsRequest>
  Model::ListQAppsOutcomeCallable ListQAppsCallable(const ListQAppsRequestT& request) const {
    return SubmitCallable(&QAppsClient::ListQApps, request);
  }
 
  template <typename ListQAppsRequestT = Model::ListQAppsRequest>
  void ListQAppsAsync(const ListQAppsRequestT& request, const ListQAppsResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::ListQApps, 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(&QAppsClient::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(&QAppsClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::PredictQAppOutcome PredictQApp(const Model::PredictQAppRequest& request) const;
 
  template <typename PredictQAppRequestT = Model::PredictQAppRequest>
  Model::PredictQAppOutcomeCallable PredictQAppCallable(const PredictQAppRequestT& request) const {
    return SubmitCallable(&QAppsClient::PredictQApp, request);
  }
 
  template <typename PredictQAppRequestT = Model::PredictQAppRequest>
  void PredictQAppAsync(const PredictQAppRequestT& request, const PredictQAppResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::PredictQApp, request, handler, context);
  }
 
  virtual Model::StartQAppSessionOutcome StartQAppSession(const Model::StartQAppSessionRequest& request) const;
 
  template <typename StartQAppSessionRequestT = Model::StartQAppSessionRequest>
  Model::StartQAppSessionOutcomeCallable StartQAppSessionCallable(const StartQAppSessionRequestT& request) const {
    return SubmitCallable(&QAppsClient::StartQAppSession, request);
  }
 
  template <typename StartQAppSessionRequestT = Model::StartQAppSessionRequest>
  void StartQAppSessionAsync(const StartQAppSessionRequestT& request, const StartQAppSessionResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::StartQAppSession, request, handler, context);
  }
 
  virtual Model::StopQAppSessionOutcome StopQAppSession(const Model::StopQAppSessionRequest& request) const;
 
  template <typename StopQAppSessionRequestT = Model::StopQAppSessionRequest>
  Model::StopQAppSessionOutcomeCallable StopQAppSessionCallable(const StopQAppSessionRequestT& request) const {
    return SubmitCallable(&QAppsClient::StopQAppSession, request);
  }
 
  template <typename StopQAppSessionRequestT = Model::StopQAppSessionRequest>
  void StopQAppSessionAsync(const StopQAppSessionRequestT& request, const StopQAppSessionResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::StopQAppSession, 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(&QAppsClient::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(&QAppsClient::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(&QAppsClient::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(&QAppsClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateLibraryItemOutcome UpdateLibraryItem(const Model::UpdateLibraryItemRequest& request) const;
 
  template <typename UpdateLibraryItemRequestT = Model::UpdateLibraryItemRequest>
  Model::UpdateLibraryItemOutcomeCallable UpdateLibraryItemCallable(const UpdateLibraryItemRequestT& request) const {
    return SubmitCallable(&QAppsClient::UpdateLibraryItem, request);
  }
 
  template <typename UpdateLibraryItemRequestT = Model::UpdateLibraryItemRequest>
  void UpdateLibraryItemAsync(const UpdateLibraryItemRequestT& request, const UpdateLibraryItemResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::UpdateLibraryItem, request, handler, context);
  }
 
  virtual Model::UpdateLibraryItemMetadataOutcome UpdateLibraryItemMetadata(const Model::UpdateLibraryItemMetadataRequest& request) const;
 
  template <typename UpdateLibraryItemMetadataRequestT = Model::UpdateLibraryItemMetadataRequest>
  Model::UpdateLibraryItemMetadataOutcomeCallable UpdateLibraryItemMetadataCallable(
      const UpdateLibraryItemMetadataRequestT& request) const {
    return SubmitCallable(&QAppsClient::UpdateLibraryItemMetadata, request);
  }
 
  template <typename UpdateLibraryItemMetadataRequestT = Model::UpdateLibraryItemMetadataRequest>
  void UpdateLibraryItemMetadataAsync(const UpdateLibraryItemMetadataRequestT& request,
                                      const UpdateLibraryItemMetadataResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::UpdateLibraryItemMetadata, request, handler, context);
  }
 
  virtual Model::UpdateQAppOutcome UpdateQApp(const Model::UpdateQAppRequest& request) const;
 
  template <typename UpdateQAppRequestT = Model::UpdateQAppRequest>
  Model::UpdateQAppOutcomeCallable UpdateQAppCallable(const UpdateQAppRequestT& request) const {
    return SubmitCallable(&QAppsClient::UpdateQApp, request);
  }
 
  template <typename UpdateQAppRequestT = Model::UpdateQAppRequest>
  void UpdateQAppAsync(const UpdateQAppRequestT& request, const UpdateQAppResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::UpdateQApp, request, handler, context);
  }
 
  virtual Model::UpdateQAppPermissionsOutcome UpdateQAppPermissions(const Model::UpdateQAppPermissionsRequest& request) const;
 
  template <typename UpdateQAppPermissionsRequestT = Model::UpdateQAppPermissionsRequest>
  Model::UpdateQAppPermissionsOutcomeCallable UpdateQAppPermissionsCallable(const UpdateQAppPermissionsRequestT& request) const {
    return SubmitCallable(&QAppsClient::UpdateQAppPermissions, request);
  }
 
  template <typename UpdateQAppPermissionsRequestT = Model::UpdateQAppPermissionsRequest>
  void UpdateQAppPermissionsAsync(const UpdateQAppPermissionsRequestT& request, const UpdateQAppPermissionsResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::UpdateQAppPermissions, request, handler, context);
  }
 
  virtual Model::UpdateQAppSessionOutcome UpdateQAppSession(const Model::UpdateQAppSessionRequest& request) const;
 
  template <typename UpdateQAppSessionRequestT = Model::UpdateQAppSessionRequest>
  Model::UpdateQAppSessionOutcomeCallable UpdateQAppSessionCallable(const UpdateQAppSessionRequestT& request) const {
    return SubmitCallable(&QAppsClient::UpdateQAppSession, request);
  }
 
  template <typename UpdateQAppSessionRequestT = Model::UpdateQAppSessionRequest>
  void UpdateQAppSessionAsync(const UpdateQAppSessionRequestT& request, const UpdateQAppSessionResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::UpdateQAppSession, request, handler, context);
  }
 
  virtual Model::UpdateQAppSessionMetadataOutcome UpdateQAppSessionMetadata(const Model::UpdateQAppSessionMetadataRequest& request) const;
 
  template <typename UpdateQAppSessionMetadataRequestT = Model::UpdateQAppSessionMetadataRequest>
  Model::UpdateQAppSessionMetadataOutcomeCallable UpdateQAppSessionMetadataCallable(
      const UpdateQAppSessionMetadataRequestT& request) const {
    return SubmitCallable(&QAppsClient::UpdateQAppSessionMetadata, request);
  }
 
  template <typename UpdateQAppSessionMetadataRequestT = Model::UpdateQAppSessionMetadataRequest>
  void UpdateQAppSessionMetadataAsync(const UpdateQAppSessionMetadataRequestT& request,
                                      const UpdateQAppSessionMetadataResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&QAppsClient::UpdateQAppSessionMetadata, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<QAppsEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<QAppsClient>;
  void init(const QAppsClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, QAppsError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  QAppsClientConfiguration m_clientConfiguration;
  std::shared_ptr<QAppsEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace QApps
}  // namespace Aws