QAppsClient.h

 
#pragma once
#include <aws/qapps/QApps_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/qapps/QAppsServiceClientModel.h>
 
namespace Aws
{
namespace QApps
{
  class AWS_QAPPS_API QAppsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<QAppsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<QAppsClient>;
      void init(const QAppsClientConfiguration& clientConfiguration);
 
      QAppsClientConfiguration m_clientConfiguration;
      std::shared_ptr<QAppsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace QApps
} // namespace Aws