WorkDocsClient.h

 
#pragma once
#include <aws/workdocs/WorkDocs_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/workdocs/WorkDocsServiceClientModel.h>
 
namespace Aws
{
namespace WorkDocs
{
  class AWS_WORKDOCS_API WorkDocsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<WorkDocsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef WorkDocsClientConfiguration ClientConfigurationType;
      typedef WorkDocsEndpointProvider EndpointProviderType;
 
        WorkDocsClient(const Aws::WorkDocs::WorkDocsClientConfiguration& clientConfiguration = Aws::WorkDocs::WorkDocsClientConfiguration(),
                       std::shared_ptr<WorkDocsEndpointProviderBase> endpointProvider = nullptr);
 
        WorkDocsClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<WorkDocsEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::WorkDocs::WorkDocsClientConfiguration& clientConfiguration = Aws::WorkDocs::WorkDocsClientConfiguration());
 
        WorkDocsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<WorkDocsEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::WorkDocs::WorkDocsClientConfiguration& clientConfiguration = Aws::WorkDocs::WorkDocsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        WorkDocsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WorkDocsClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WorkDocsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~WorkDocsClient();
 
        virtual Model::AbortDocumentVersionUploadOutcome AbortDocumentVersionUpload(const Model::AbortDocumentVersionUploadRequest& request) const;
 
        template<typename AbortDocumentVersionUploadRequestT = Model::AbortDocumentVersionUploadRequest>
        Model::AbortDocumentVersionUploadOutcomeCallable AbortDocumentVersionUploadCallable(const AbortDocumentVersionUploadRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::AbortDocumentVersionUpload, request);
        }
 
        template<typename AbortDocumentVersionUploadRequestT = Model::AbortDocumentVersionUploadRequest>
        void AbortDocumentVersionUploadAsync(const AbortDocumentVersionUploadRequestT& request, const AbortDocumentVersionUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::AbortDocumentVersionUpload, request, handler, context);
        }
 
        virtual Model::ActivateUserOutcome ActivateUser(const Model::ActivateUserRequest& request) const;
 
        template<typename ActivateUserRequestT = Model::ActivateUserRequest>
        Model::ActivateUserOutcomeCallable ActivateUserCallable(const ActivateUserRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::ActivateUser, request);
        }
 
        template<typename ActivateUserRequestT = Model::ActivateUserRequest>
        void ActivateUserAsync(const ActivateUserRequestT& request, const ActivateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::ActivateUser, request, handler, context);
        }
 
        virtual Model::AddResourcePermissionsOutcome AddResourcePermissions(const Model::AddResourcePermissionsRequest& request) const;
 
        template<typename AddResourcePermissionsRequestT = Model::AddResourcePermissionsRequest>
        Model::AddResourcePermissionsOutcomeCallable AddResourcePermissionsCallable(const AddResourcePermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::AddResourcePermissions, request);
        }
 
        template<typename AddResourcePermissionsRequestT = Model::AddResourcePermissionsRequest>
        void AddResourcePermissionsAsync(const AddResourcePermissionsRequestT& request, const AddResourcePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::AddResourcePermissions, request, handler, context);
        }
 
        virtual Model::CreateCommentOutcome CreateComment(const Model::CreateCommentRequest& request) const;
 
        template<typename CreateCommentRequestT = Model::CreateCommentRequest>
        Model::CreateCommentOutcomeCallable CreateCommentCallable(const CreateCommentRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::CreateComment, request);
        }
 
        template<typename CreateCommentRequestT = Model::CreateCommentRequest>
        void CreateCommentAsync(const CreateCommentRequestT& request, const CreateCommentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::CreateComment, request, handler, context);
        }
 
        virtual Model::CreateCustomMetadataOutcome CreateCustomMetadata(const Model::CreateCustomMetadataRequest& request) const;
 
        template<typename CreateCustomMetadataRequestT = Model::CreateCustomMetadataRequest>
        Model::CreateCustomMetadataOutcomeCallable CreateCustomMetadataCallable(const CreateCustomMetadataRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::CreateCustomMetadata, request);
        }
 
        template<typename CreateCustomMetadataRequestT = Model::CreateCustomMetadataRequest>
        void CreateCustomMetadataAsync(const CreateCustomMetadataRequestT& request, const CreateCustomMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::CreateCustomMetadata, request, handler, context);
        }
 
        virtual Model::CreateFolderOutcome CreateFolder(const Model::CreateFolderRequest& request) const;
 
        template<typename CreateFolderRequestT = Model::CreateFolderRequest>
        Model::CreateFolderOutcomeCallable CreateFolderCallable(const CreateFolderRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::CreateFolder, request);
        }
 
        template<typename CreateFolderRequestT = Model::CreateFolderRequest>
        void CreateFolderAsync(const CreateFolderRequestT& request, const CreateFolderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::CreateFolder, request, handler, context);
        }
 
        virtual Model::CreateLabelsOutcome CreateLabels(const Model::CreateLabelsRequest& request) const;
 
        template<typename CreateLabelsRequestT = Model::CreateLabelsRequest>
        Model::CreateLabelsOutcomeCallable CreateLabelsCallable(const CreateLabelsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::CreateLabels, request);
        }
 
        template<typename CreateLabelsRequestT = Model::CreateLabelsRequest>
        void CreateLabelsAsync(const CreateLabelsRequestT& request, const CreateLabelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::CreateLabels, request, handler, context);
        }
 
        virtual Model::CreateNotificationSubscriptionOutcome CreateNotificationSubscription(const Model::CreateNotificationSubscriptionRequest& request) const;
 
        template<typename CreateNotificationSubscriptionRequestT = Model::CreateNotificationSubscriptionRequest>
        Model::CreateNotificationSubscriptionOutcomeCallable CreateNotificationSubscriptionCallable(const CreateNotificationSubscriptionRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::CreateNotificationSubscription, request);
        }
 
        template<typename CreateNotificationSubscriptionRequestT = Model::CreateNotificationSubscriptionRequest>
        void CreateNotificationSubscriptionAsync(const CreateNotificationSubscriptionRequestT& request, const CreateNotificationSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::CreateNotificationSubscription, request, handler, context);
        }
 
        virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::CreateUser, request);
        }
 
        template<typename CreateUserRequestT = Model::CreateUserRequest>
        void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::CreateUser, request, handler, context);
        }
 
        virtual Model::DeactivateUserOutcome DeactivateUser(const Model::DeactivateUserRequest& request) const;
 
        template<typename DeactivateUserRequestT = Model::DeactivateUserRequest>
        Model::DeactivateUserOutcomeCallable DeactivateUserCallable(const DeactivateUserRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeactivateUser, request);
        }
 
        template<typename DeactivateUserRequestT = Model::DeactivateUserRequest>
        void DeactivateUserAsync(const DeactivateUserRequestT& request, const DeactivateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeactivateUser, request, handler, context);
        }
 
        virtual Model::DeleteCommentOutcome DeleteComment(const Model::DeleteCommentRequest& request) const;
 
        template<typename DeleteCommentRequestT = Model::DeleteCommentRequest>
        Model::DeleteCommentOutcomeCallable DeleteCommentCallable(const DeleteCommentRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteComment, request);
        }
 
        template<typename DeleteCommentRequestT = Model::DeleteCommentRequest>
        void DeleteCommentAsync(const DeleteCommentRequestT& request, const DeleteCommentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteComment, request, handler, context);
        }
 
        virtual Model::DeleteCustomMetadataOutcome DeleteCustomMetadata(const Model::DeleteCustomMetadataRequest& request) const;
 
        template<typename DeleteCustomMetadataRequestT = Model::DeleteCustomMetadataRequest>
        Model::DeleteCustomMetadataOutcomeCallable DeleteCustomMetadataCallable(const DeleteCustomMetadataRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteCustomMetadata, request);
        }
 
        template<typename DeleteCustomMetadataRequestT = Model::DeleteCustomMetadataRequest>
        void DeleteCustomMetadataAsync(const DeleteCustomMetadataRequestT& request, const DeleteCustomMetadataResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteCustomMetadata, request, handler, context);
        }
 
        virtual Model::DeleteDocumentOutcome DeleteDocument(const Model::DeleteDocumentRequest& request) const;
 
        template<typename DeleteDocumentRequestT = Model::DeleteDocumentRequest>
        Model::DeleteDocumentOutcomeCallable DeleteDocumentCallable(const DeleteDocumentRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteDocument, request);
        }
 
        template<typename DeleteDocumentRequestT = Model::DeleteDocumentRequest>
        void DeleteDocumentAsync(const DeleteDocumentRequestT& request, const DeleteDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteDocument, request, handler, context);
        }
 
        virtual Model::DeleteDocumentVersionOutcome DeleteDocumentVersion(const Model::DeleteDocumentVersionRequest& request) const;
 
        template<typename DeleteDocumentVersionRequestT = Model::DeleteDocumentVersionRequest>
        Model::DeleteDocumentVersionOutcomeCallable DeleteDocumentVersionCallable(const DeleteDocumentVersionRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteDocumentVersion, request);
        }
 
        template<typename DeleteDocumentVersionRequestT = Model::DeleteDocumentVersionRequest>
        void DeleteDocumentVersionAsync(const DeleteDocumentVersionRequestT& request, const DeleteDocumentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteDocumentVersion, request, handler, context);
        }
 
        virtual Model::DeleteFolderOutcome DeleteFolder(const Model::DeleteFolderRequest& request) const;
 
        template<typename DeleteFolderRequestT = Model::DeleteFolderRequest>
        Model::DeleteFolderOutcomeCallable DeleteFolderCallable(const DeleteFolderRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteFolder, request);
        }
 
        template<typename DeleteFolderRequestT = Model::DeleteFolderRequest>
        void DeleteFolderAsync(const DeleteFolderRequestT& request, const DeleteFolderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteFolder, request, handler, context);
        }
 
        virtual Model::DeleteFolderContentsOutcome DeleteFolderContents(const Model::DeleteFolderContentsRequest& request) const;
 
        template<typename DeleteFolderContentsRequestT = Model::DeleteFolderContentsRequest>
        Model::DeleteFolderContentsOutcomeCallable DeleteFolderContentsCallable(const DeleteFolderContentsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteFolderContents, request);
        }
 
        template<typename DeleteFolderContentsRequestT = Model::DeleteFolderContentsRequest>
        void DeleteFolderContentsAsync(const DeleteFolderContentsRequestT& request, const DeleteFolderContentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteFolderContents, request, handler, context);
        }
 
        virtual Model::DeleteLabelsOutcome DeleteLabels(const Model::DeleteLabelsRequest& request) const;
 
        template<typename DeleteLabelsRequestT = Model::DeleteLabelsRequest>
        Model::DeleteLabelsOutcomeCallable DeleteLabelsCallable(const DeleteLabelsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteLabels, request);
        }
 
        template<typename DeleteLabelsRequestT = Model::DeleteLabelsRequest>
        void DeleteLabelsAsync(const DeleteLabelsRequestT& request, const DeleteLabelsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteLabels, request, handler, context);
        }
 
        virtual Model::DeleteNotificationSubscriptionOutcome DeleteNotificationSubscription(const Model::DeleteNotificationSubscriptionRequest& request) const;
 
        template<typename DeleteNotificationSubscriptionRequestT = Model::DeleteNotificationSubscriptionRequest>
        Model::DeleteNotificationSubscriptionOutcomeCallable DeleteNotificationSubscriptionCallable(const DeleteNotificationSubscriptionRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteNotificationSubscription, request);
        }
 
        template<typename DeleteNotificationSubscriptionRequestT = Model::DeleteNotificationSubscriptionRequest>
        void DeleteNotificationSubscriptionAsync(const DeleteNotificationSubscriptionRequestT& request, const DeleteNotificationSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteNotificationSubscription, request, handler, context);
        }
 
        virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DeleteUser, request);
        }
 
        template<typename DeleteUserRequestT = Model::DeleteUserRequest>
        void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DeleteUser, request, handler, context);
        }
 
        virtual Model::DescribeActivitiesOutcome DescribeActivities(const Model::DescribeActivitiesRequest& request = {}) const;
 
        template<typename DescribeActivitiesRequestT = Model::DescribeActivitiesRequest>
        Model::DescribeActivitiesOutcomeCallable DescribeActivitiesCallable(const DescribeActivitiesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeActivities, request);
        }
 
        template<typename DescribeActivitiesRequestT = Model::DescribeActivitiesRequest>
        void DescribeActivitiesAsync(const DescribeActivitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeActivitiesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeActivities, request, handler, context);
        }
 
        virtual Model::DescribeCommentsOutcome DescribeComments(const Model::DescribeCommentsRequest& request) const;
 
        template<typename DescribeCommentsRequestT = Model::DescribeCommentsRequest>
        Model::DescribeCommentsOutcomeCallable DescribeCommentsCallable(const DescribeCommentsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeComments, request);
        }
 
        template<typename DescribeCommentsRequestT = Model::DescribeCommentsRequest>
        void DescribeCommentsAsync(const DescribeCommentsRequestT& request, const DescribeCommentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeComments, request, handler, context);
        }
 
        virtual Model::DescribeDocumentVersionsOutcome DescribeDocumentVersions(const Model::DescribeDocumentVersionsRequest& request) const;
 
        template<typename DescribeDocumentVersionsRequestT = Model::DescribeDocumentVersionsRequest>
        Model::DescribeDocumentVersionsOutcomeCallable DescribeDocumentVersionsCallable(const DescribeDocumentVersionsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeDocumentVersions, request);
        }
 
        template<typename DescribeDocumentVersionsRequestT = Model::DescribeDocumentVersionsRequest>
        void DescribeDocumentVersionsAsync(const DescribeDocumentVersionsRequestT& request, const DescribeDocumentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeDocumentVersions, request, handler, context);
        }
 
        virtual Model::DescribeFolderContentsOutcome DescribeFolderContents(const Model::DescribeFolderContentsRequest& request) const;
 
        template<typename DescribeFolderContentsRequestT = Model::DescribeFolderContentsRequest>
        Model::DescribeFolderContentsOutcomeCallable DescribeFolderContentsCallable(const DescribeFolderContentsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeFolderContents, request);
        }
 
        template<typename DescribeFolderContentsRequestT = Model::DescribeFolderContentsRequest>
        void DescribeFolderContentsAsync(const DescribeFolderContentsRequestT& request, const DescribeFolderContentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeFolderContents, request, handler, context);
        }
 
        virtual Model::DescribeGroupsOutcome DescribeGroups(const Model::DescribeGroupsRequest& request) const;
 
        template<typename DescribeGroupsRequestT = Model::DescribeGroupsRequest>
        Model::DescribeGroupsOutcomeCallable DescribeGroupsCallable(const DescribeGroupsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeGroups, request);
        }
 
        template<typename DescribeGroupsRequestT = Model::DescribeGroupsRequest>
        void DescribeGroupsAsync(const DescribeGroupsRequestT& request, const DescribeGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeGroups, request, handler, context);
        }
 
        virtual Model::DescribeNotificationSubscriptionsOutcome DescribeNotificationSubscriptions(const Model::DescribeNotificationSubscriptionsRequest& request) const;
 
        template<typename DescribeNotificationSubscriptionsRequestT = Model::DescribeNotificationSubscriptionsRequest>
        Model::DescribeNotificationSubscriptionsOutcomeCallable DescribeNotificationSubscriptionsCallable(const DescribeNotificationSubscriptionsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeNotificationSubscriptions, request);
        }
 
        template<typename DescribeNotificationSubscriptionsRequestT = Model::DescribeNotificationSubscriptionsRequest>
        void DescribeNotificationSubscriptionsAsync(const DescribeNotificationSubscriptionsRequestT& request, const DescribeNotificationSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeNotificationSubscriptions, request, handler, context);
        }
 
        virtual Model::DescribeResourcePermissionsOutcome DescribeResourcePermissions(const Model::DescribeResourcePermissionsRequest& request) const;
 
        template<typename DescribeResourcePermissionsRequestT = Model::DescribeResourcePermissionsRequest>
        Model::DescribeResourcePermissionsOutcomeCallable DescribeResourcePermissionsCallable(const DescribeResourcePermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeResourcePermissions, request);
        }
 
        template<typename DescribeResourcePermissionsRequestT = Model::DescribeResourcePermissionsRequest>
        void DescribeResourcePermissionsAsync(const DescribeResourcePermissionsRequestT& request, const DescribeResourcePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeResourcePermissions, request, handler, context);
        }
 
        virtual Model::DescribeRootFoldersOutcome DescribeRootFolders(const Model::DescribeRootFoldersRequest& request) const;
 
        template<typename DescribeRootFoldersRequestT = Model::DescribeRootFoldersRequest>
        Model::DescribeRootFoldersOutcomeCallable DescribeRootFoldersCallable(const DescribeRootFoldersRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeRootFolders, request);
        }
 
        template<typename DescribeRootFoldersRequestT = Model::DescribeRootFoldersRequest>
        void DescribeRootFoldersAsync(const DescribeRootFoldersRequestT& request, const DescribeRootFoldersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeRootFolders, request, handler, context);
        }
 
        virtual Model::DescribeUsersOutcome DescribeUsers(const Model::DescribeUsersRequest& request = {}) const;
 
        template<typename DescribeUsersRequestT = Model::DescribeUsersRequest>
        Model::DescribeUsersOutcomeCallable DescribeUsersCallable(const DescribeUsersRequestT& request = {}) const
        {
            return SubmitCallable(&WorkDocsClient::DescribeUsers, request);
        }
 
        template<typename DescribeUsersRequestT = Model::DescribeUsersRequest>
        void DescribeUsersAsync(const DescribeUsersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeUsersRequestT& request = {}) const
        {
            return SubmitAsync(&WorkDocsClient::DescribeUsers, request, handler, context);
        }
 
        virtual Model::GetCurrentUserOutcome GetCurrentUser(const Model::GetCurrentUserRequest& request) const;
 
        template<typename GetCurrentUserRequestT = Model::GetCurrentUserRequest>
        Model::GetCurrentUserOutcomeCallable GetCurrentUserCallable(const GetCurrentUserRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::GetCurrentUser, request);
        }
 
        template<typename GetCurrentUserRequestT = Model::GetCurrentUserRequest>
        void GetCurrentUserAsync(const GetCurrentUserRequestT& request, const GetCurrentUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::GetCurrentUser, request, handler, context);
        }
 
        virtual Model::GetDocumentOutcome GetDocument(const Model::GetDocumentRequest& request) const;
 
        template<typename GetDocumentRequestT = Model::GetDocumentRequest>
        Model::GetDocumentOutcomeCallable GetDocumentCallable(const GetDocumentRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::GetDocument, request);
        }
 
        template<typename GetDocumentRequestT = Model::GetDocumentRequest>
        void GetDocumentAsync(const GetDocumentRequestT& request, const GetDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::GetDocument, request, handler, context);
        }
 
        virtual Model::GetDocumentPathOutcome GetDocumentPath(const Model::GetDocumentPathRequest& request) const;
 
        template<typename GetDocumentPathRequestT = Model::GetDocumentPathRequest>
        Model::GetDocumentPathOutcomeCallable GetDocumentPathCallable(const GetDocumentPathRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::GetDocumentPath, request);
        }
 
        template<typename GetDocumentPathRequestT = Model::GetDocumentPathRequest>
        void GetDocumentPathAsync(const GetDocumentPathRequestT& request, const GetDocumentPathResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::GetDocumentPath, request, handler, context);
        }
 
        virtual Model::GetDocumentVersionOutcome GetDocumentVersion(const Model::GetDocumentVersionRequest& request) const;
 
        template<typename GetDocumentVersionRequestT = Model::GetDocumentVersionRequest>
        Model::GetDocumentVersionOutcomeCallable GetDocumentVersionCallable(const GetDocumentVersionRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::GetDocumentVersion, request);
        }
 
        template<typename GetDocumentVersionRequestT = Model::GetDocumentVersionRequest>
        void GetDocumentVersionAsync(const GetDocumentVersionRequestT& request, const GetDocumentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::GetDocumentVersion, request, handler, context);
        }
 
        virtual Model::GetFolderOutcome GetFolder(const Model::GetFolderRequest& request) const;
 
        template<typename GetFolderRequestT = Model::GetFolderRequest>
        Model::GetFolderOutcomeCallable GetFolderCallable(const GetFolderRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::GetFolder, request);
        }
 
        template<typename GetFolderRequestT = Model::GetFolderRequest>
        void GetFolderAsync(const GetFolderRequestT& request, const GetFolderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::GetFolder, request, handler, context);
        }
 
        virtual Model::GetFolderPathOutcome GetFolderPath(const Model::GetFolderPathRequest& request) const;
 
        template<typename GetFolderPathRequestT = Model::GetFolderPathRequest>
        Model::GetFolderPathOutcomeCallable GetFolderPathCallable(const GetFolderPathRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::GetFolderPath, request);
        }
 
        template<typename GetFolderPathRequestT = Model::GetFolderPathRequest>
        void GetFolderPathAsync(const GetFolderPathRequestT& request, const GetFolderPathResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::GetFolderPath, request, handler, context);
        }
 
        virtual Model::GetResourcesOutcome GetResources(const Model::GetResourcesRequest& request = {}) const;
 
        template<typename GetResourcesRequestT = Model::GetResourcesRequest>
        Model::GetResourcesOutcomeCallable GetResourcesCallable(const GetResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkDocsClient::GetResources, request);
        }
 
        template<typename GetResourcesRequestT = Model::GetResourcesRequest>
        void GetResourcesAsync(const GetResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkDocsClient::GetResources, request, handler, context);
        }
 
        virtual Model::InitiateDocumentVersionUploadOutcome InitiateDocumentVersionUpload(const Model::InitiateDocumentVersionUploadRequest& request = {}) const;
 
        template<typename InitiateDocumentVersionUploadRequestT = Model::InitiateDocumentVersionUploadRequest>
        Model::InitiateDocumentVersionUploadOutcomeCallable InitiateDocumentVersionUploadCallable(const InitiateDocumentVersionUploadRequestT& request = {}) const
        {
            return SubmitCallable(&WorkDocsClient::InitiateDocumentVersionUpload, request);
        }
 
        template<typename InitiateDocumentVersionUploadRequestT = Model::InitiateDocumentVersionUploadRequest>
        void InitiateDocumentVersionUploadAsync(const InitiateDocumentVersionUploadResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const InitiateDocumentVersionUploadRequestT& request = {}) const
        {
            return SubmitAsync(&WorkDocsClient::InitiateDocumentVersionUpload, request, handler, context);
        }
 
        virtual Model::RemoveAllResourcePermissionsOutcome RemoveAllResourcePermissions(const Model::RemoveAllResourcePermissionsRequest& request) const;
 
        template<typename RemoveAllResourcePermissionsRequestT = Model::RemoveAllResourcePermissionsRequest>
        Model::RemoveAllResourcePermissionsOutcomeCallable RemoveAllResourcePermissionsCallable(const RemoveAllResourcePermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::RemoveAllResourcePermissions, request);
        }
 
        template<typename RemoveAllResourcePermissionsRequestT = Model::RemoveAllResourcePermissionsRequest>
        void RemoveAllResourcePermissionsAsync(const RemoveAllResourcePermissionsRequestT& request, const RemoveAllResourcePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::RemoveAllResourcePermissions, request, handler, context);
        }
 
        virtual Model::RemoveResourcePermissionOutcome RemoveResourcePermission(const Model::RemoveResourcePermissionRequest& request) const;
 
        template<typename RemoveResourcePermissionRequestT = Model::RemoveResourcePermissionRequest>
        Model::RemoveResourcePermissionOutcomeCallable RemoveResourcePermissionCallable(const RemoveResourcePermissionRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::RemoveResourcePermission, request);
        }
 
        template<typename RemoveResourcePermissionRequestT = Model::RemoveResourcePermissionRequest>
        void RemoveResourcePermissionAsync(const RemoveResourcePermissionRequestT& request, const RemoveResourcePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::RemoveResourcePermission, request, handler, context);
        }
 
        virtual Model::RestoreDocumentVersionsOutcome RestoreDocumentVersions(const Model::RestoreDocumentVersionsRequest& request) const;
 
        template<typename RestoreDocumentVersionsRequestT = Model::RestoreDocumentVersionsRequest>
        Model::RestoreDocumentVersionsOutcomeCallable RestoreDocumentVersionsCallable(const RestoreDocumentVersionsRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::RestoreDocumentVersions, request);
        }
 
        template<typename RestoreDocumentVersionsRequestT = Model::RestoreDocumentVersionsRequest>
        void RestoreDocumentVersionsAsync(const RestoreDocumentVersionsRequestT& request, const RestoreDocumentVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::RestoreDocumentVersions, request, handler, context);
        }
 
        virtual Model::SearchResourcesOutcome SearchResources(const Model::SearchResourcesRequest& request = {}) const;
 
        template<typename SearchResourcesRequestT = Model::SearchResourcesRequest>
        Model::SearchResourcesOutcomeCallable SearchResourcesCallable(const SearchResourcesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkDocsClient::SearchResources, request);
        }
 
        template<typename SearchResourcesRequestT = Model::SearchResourcesRequest>
        void SearchResourcesAsync(const SearchResourcesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const SearchResourcesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkDocsClient::SearchResources, request, handler, context);
        }
 
        virtual Model::UpdateDocumentOutcome UpdateDocument(const Model::UpdateDocumentRequest& request) const;
 
        template<typename UpdateDocumentRequestT = Model::UpdateDocumentRequest>
        Model::UpdateDocumentOutcomeCallable UpdateDocumentCallable(const UpdateDocumentRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::UpdateDocument, request);
        }
 
        template<typename UpdateDocumentRequestT = Model::UpdateDocumentRequest>
        void UpdateDocumentAsync(const UpdateDocumentRequestT& request, const UpdateDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::UpdateDocument, request, handler, context);
        }
 
        virtual Model::UpdateDocumentVersionOutcome UpdateDocumentVersion(const Model::UpdateDocumentVersionRequest& request) const;
 
        template<typename UpdateDocumentVersionRequestT = Model::UpdateDocumentVersionRequest>
        Model::UpdateDocumentVersionOutcomeCallable UpdateDocumentVersionCallable(const UpdateDocumentVersionRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::UpdateDocumentVersion, request);
        }
 
        template<typename UpdateDocumentVersionRequestT = Model::UpdateDocumentVersionRequest>
        void UpdateDocumentVersionAsync(const UpdateDocumentVersionRequestT& request, const UpdateDocumentVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::UpdateDocumentVersion, request, handler, context);
        }
 
        virtual Model::UpdateFolderOutcome UpdateFolder(const Model::UpdateFolderRequest& request) const;
 
        template<typename UpdateFolderRequestT = Model::UpdateFolderRequest>
        Model::UpdateFolderOutcomeCallable UpdateFolderCallable(const UpdateFolderRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::UpdateFolder, request);
        }
 
        template<typename UpdateFolderRequestT = Model::UpdateFolderRequest>
        void UpdateFolderAsync(const UpdateFolderRequestT& request, const UpdateFolderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::UpdateFolder, request, handler, context);
        }
 
        virtual Model::UpdateUserOutcome UpdateUser(const Model::UpdateUserRequest& request) const;
 
        template<typename UpdateUserRequestT = Model::UpdateUserRequest>
        Model::UpdateUserOutcomeCallable UpdateUserCallable(const UpdateUserRequestT& request) const
        {
            return SubmitCallable(&WorkDocsClient::UpdateUser, request);
        }
 
        template<typename UpdateUserRequestT = Model::UpdateUserRequest>
        void UpdateUserAsync(const UpdateUserRequestT& request, const UpdateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkDocsClient::UpdateUser, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<WorkDocsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<WorkDocsClient>;
      void init(const WorkDocsClientConfiguration& clientConfiguration);
 
      WorkDocsClientConfiguration m_clientConfiguration;
      std::shared_ptr<WorkDocsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace WorkDocs
} // namespace Aws