WorkSpacesClient.h

 
#pragma once
#include <aws/workspaces/WorkSpaces_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/workspaces/WorkSpacesServiceClientModel.h>
 
namespace Aws
{
namespace WorkSpaces
{
  class AWS_WORKSPACES_API WorkSpacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<WorkSpacesClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef WorkSpacesClientConfiguration ClientConfigurationType;
      typedef WorkSpacesEndpointProvider EndpointProviderType;
 
        WorkSpacesClient(const Aws::WorkSpaces::WorkSpacesClientConfiguration& clientConfiguration = Aws::WorkSpaces::WorkSpacesClientConfiguration(),
                         std::shared_ptr<WorkSpacesEndpointProviderBase> endpointProvider = nullptr);
 
        WorkSpacesClient(const Aws::Auth::AWSCredentials& credentials,
                         std::shared_ptr<WorkSpacesEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::WorkSpaces::WorkSpacesClientConfiguration& clientConfiguration = Aws::WorkSpaces::WorkSpacesClientConfiguration());
 
        WorkSpacesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         std::shared_ptr<WorkSpacesEndpointProviderBase> endpointProvider = nullptr,
                         const Aws::WorkSpaces::WorkSpacesClientConfiguration& clientConfiguration = Aws::WorkSpaces::WorkSpacesClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        WorkSpacesClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WorkSpacesClient(const Aws::Auth::AWSCredentials& credentials,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        WorkSpacesClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                         const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~WorkSpacesClient();
 
        virtual Model::AcceptAccountLinkInvitationOutcome AcceptAccountLinkInvitation(const Model::AcceptAccountLinkInvitationRequest& request) const;
 
        template<typename AcceptAccountLinkInvitationRequestT = Model::AcceptAccountLinkInvitationRequest>
        Model::AcceptAccountLinkInvitationOutcomeCallable AcceptAccountLinkInvitationCallable(const AcceptAccountLinkInvitationRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::AcceptAccountLinkInvitation, request);
        }
 
        template<typename AcceptAccountLinkInvitationRequestT = Model::AcceptAccountLinkInvitationRequest>
        void AcceptAccountLinkInvitationAsync(const AcceptAccountLinkInvitationRequestT& request, const AcceptAccountLinkInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::AcceptAccountLinkInvitation, request, handler, context);
        }
 
        virtual Model::AssociateConnectionAliasOutcome AssociateConnectionAlias(const Model::AssociateConnectionAliasRequest& request) const;
 
        template<typename AssociateConnectionAliasRequestT = Model::AssociateConnectionAliasRequest>
        Model::AssociateConnectionAliasOutcomeCallable AssociateConnectionAliasCallable(const AssociateConnectionAliasRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::AssociateConnectionAlias, request);
        }
 
        template<typename AssociateConnectionAliasRequestT = Model::AssociateConnectionAliasRequest>
        void AssociateConnectionAliasAsync(const AssociateConnectionAliasRequestT& request, const AssociateConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::AssociateConnectionAlias, request, handler, context);
        }
 
        virtual Model::AssociateIpGroupsOutcome AssociateIpGroups(const Model::AssociateIpGroupsRequest& request) const;
 
        template<typename AssociateIpGroupsRequestT = Model::AssociateIpGroupsRequest>
        Model::AssociateIpGroupsOutcomeCallable AssociateIpGroupsCallable(const AssociateIpGroupsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::AssociateIpGroups, request);
        }
 
        template<typename AssociateIpGroupsRequestT = Model::AssociateIpGroupsRequest>
        void AssociateIpGroupsAsync(const AssociateIpGroupsRequestT& request, const AssociateIpGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::AssociateIpGroups, request, handler, context);
        }
 
        virtual Model::AssociateWorkspaceApplicationOutcome AssociateWorkspaceApplication(const Model::AssociateWorkspaceApplicationRequest& request) const;
 
        template<typename AssociateWorkspaceApplicationRequestT = Model::AssociateWorkspaceApplicationRequest>
        Model::AssociateWorkspaceApplicationOutcomeCallable AssociateWorkspaceApplicationCallable(const AssociateWorkspaceApplicationRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::AssociateWorkspaceApplication, request);
        }
 
        template<typename AssociateWorkspaceApplicationRequestT = Model::AssociateWorkspaceApplicationRequest>
        void AssociateWorkspaceApplicationAsync(const AssociateWorkspaceApplicationRequestT& request, const AssociateWorkspaceApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::AssociateWorkspaceApplication, request, handler, context);
        }
 
        virtual Model::AuthorizeIpRulesOutcome AuthorizeIpRules(const Model::AuthorizeIpRulesRequest& request) const;
 
        template<typename AuthorizeIpRulesRequestT = Model::AuthorizeIpRulesRequest>
        Model::AuthorizeIpRulesOutcomeCallable AuthorizeIpRulesCallable(const AuthorizeIpRulesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::AuthorizeIpRules, request);
        }
 
        template<typename AuthorizeIpRulesRequestT = Model::AuthorizeIpRulesRequest>
        void AuthorizeIpRulesAsync(const AuthorizeIpRulesRequestT& request, const AuthorizeIpRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::AuthorizeIpRules, request, handler, context);
        }
 
        virtual Model::CopyWorkspaceImageOutcome CopyWorkspaceImage(const Model::CopyWorkspaceImageRequest& request) const;
 
        template<typename CopyWorkspaceImageRequestT = Model::CopyWorkspaceImageRequest>
        Model::CopyWorkspaceImageOutcomeCallable CopyWorkspaceImageCallable(const CopyWorkspaceImageRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CopyWorkspaceImage, request);
        }
 
        template<typename CopyWorkspaceImageRequestT = Model::CopyWorkspaceImageRequest>
        void CopyWorkspaceImageAsync(const CopyWorkspaceImageRequestT& request, const CopyWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CopyWorkspaceImage, request, handler, context);
        }
 
        virtual Model::CreateAccountLinkInvitationOutcome CreateAccountLinkInvitation(const Model::CreateAccountLinkInvitationRequest& request) const;
 
        template<typename CreateAccountLinkInvitationRequestT = Model::CreateAccountLinkInvitationRequest>
        Model::CreateAccountLinkInvitationOutcomeCallable CreateAccountLinkInvitationCallable(const CreateAccountLinkInvitationRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateAccountLinkInvitation, request);
        }
 
        template<typename CreateAccountLinkInvitationRequestT = Model::CreateAccountLinkInvitationRequest>
        void CreateAccountLinkInvitationAsync(const CreateAccountLinkInvitationRequestT& request, const CreateAccountLinkInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateAccountLinkInvitation, request, handler, context);
        }
 
        virtual Model::CreateConnectClientAddInOutcome CreateConnectClientAddIn(const Model::CreateConnectClientAddInRequest& request) const;
 
        template<typename CreateConnectClientAddInRequestT = Model::CreateConnectClientAddInRequest>
        Model::CreateConnectClientAddInOutcomeCallable CreateConnectClientAddInCallable(const CreateConnectClientAddInRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateConnectClientAddIn, request);
        }
 
        template<typename CreateConnectClientAddInRequestT = Model::CreateConnectClientAddInRequest>
        void CreateConnectClientAddInAsync(const CreateConnectClientAddInRequestT& request, const CreateConnectClientAddInResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateConnectClientAddIn, request, handler, context);
        }
 
        virtual Model::CreateConnectionAliasOutcome CreateConnectionAlias(const Model::CreateConnectionAliasRequest& request) const;
 
        template<typename CreateConnectionAliasRequestT = Model::CreateConnectionAliasRequest>
        Model::CreateConnectionAliasOutcomeCallable CreateConnectionAliasCallable(const CreateConnectionAliasRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateConnectionAlias, request);
        }
 
        template<typename CreateConnectionAliasRequestT = Model::CreateConnectionAliasRequest>
        void CreateConnectionAliasAsync(const CreateConnectionAliasRequestT& request, const CreateConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateConnectionAlias, request, handler, context);
        }
 
        virtual Model::CreateIpGroupOutcome CreateIpGroup(const Model::CreateIpGroupRequest& request) const;
 
        template<typename CreateIpGroupRequestT = Model::CreateIpGroupRequest>
        Model::CreateIpGroupOutcomeCallable CreateIpGroupCallable(const CreateIpGroupRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateIpGroup, request);
        }
 
        template<typename CreateIpGroupRequestT = Model::CreateIpGroupRequest>
        void CreateIpGroupAsync(const CreateIpGroupRequestT& request, const CreateIpGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateIpGroup, request, handler, context);
        }
 
        virtual Model::CreateStandbyWorkspacesOutcome CreateStandbyWorkspaces(const Model::CreateStandbyWorkspacesRequest& request) const;
 
        template<typename CreateStandbyWorkspacesRequestT = Model::CreateStandbyWorkspacesRequest>
        Model::CreateStandbyWorkspacesOutcomeCallable CreateStandbyWorkspacesCallable(const CreateStandbyWorkspacesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateStandbyWorkspaces, request);
        }
 
        template<typename CreateStandbyWorkspacesRequestT = Model::CreateStandbyWorkspacesRequest>
        void CreateStandbyWorkspacesAsync(const CreateStandbyWorkspacesRequestT& request, const CreateStandbyWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateStandbyWorkspaces, request, handler, context);
        }
 
        virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const;
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateTags, request);
        }
 
        template<typename CreateTagsRequestT = Model::CreateTagsRequest>
        void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateTags, request, handler, context);
        }
 
        virtual Model::CreateUpdatedWorkspaceImageOutcome CreateUpdatedWorkspaceImage(const Model::CreateUpdatedWorkspaceImageRequest& request) const;
 
        template<typename CreateUpdatedWorkspaceImageRequestT = Model::CreateUpdatedWorkspaceImageRequest>
        Model::CreateUpdatedWorkspaceImageOutcomeCallable CreateUpdatedWorkspaceImageCallable(const CreateUpdatedWorkspaceImageRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateUpdatedWorkspaceImage, request);
        }
 
        template<typename CreateUpdatedWorkspaceImageRequestT = Model::CreateUpdatedWorkspaceImageRequest>
        void CreateUpdatedWorkspaceImageAsync(const CreateUpdatedWorkspaceImageRequestT& request, const CreateUpdatedWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateUpdatedWorkspaceImage, request, handler, context);
        }
 
        virtual Model::CreateWorkspaceBundleOutcome CreateWorkspaceBundle(const Model::CreateWorkspaceBundleRequest& request) const;
 
        template<typename CreateWorkspaceBundleRequestT = Model::CreateWorkspaceBundleRequest>
        Model::CreateWorkspaceBundleOutcomeCallable CreateWorkspaceBundleCallable(const CreateWorkspaceBundleRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateWorkspaceBundle, request);
        }
 
        template<typename CreateWorkspaceBundleRequestT = Model::CreateWorkspaceBundleRequest>
        void CreateWorkspaceBundleAsync(const CreateWorkspaceBundleRequestT& request, const CreateWorkspaceBundleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateWorkspaceBundle, request, handler, context);
        }
 
        virtual Model::CreateWorkspaceImageOutcome CreateWorkspaceImage(const Model::CreateWorkspaceImageRequest& request) const;
 
        template<typename CreateWorkspaceImageRequestT = Model::CreateWorkspaceImageRequest>
        Model::CreateWorkspaceImageOutcomeCallable CreateWorkspaceImageCallable(const CreateWorkspaceImageRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateWorkspaceImage, request);
        }
 
        template<typename CreateWorkspaceImageRequestT = Model::CreateWorkspaceImageRequest>
        void CreateWorkspaceImageAsync(const CreateWorkspaceImageRequestT& request, const CreateWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateWorkspaceImage, request, handler, context);
        }
 
        virtual Model::CreateWorkspacesOutcome CreateWorkspaces(const Model::CreateWorkspacesRequest& request) const;
 
        template<typename CreateWorkspacesRequestT = Model::CreateWorkspacesRequest>
        Model::CreateWorkspacesOutcomeCallable CreateWorkspacesCallable(const CreateWorkspacesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateWorkspaces, request);
        }
 
        template<typename CreateWorkspacesRequestT = Model::CreateWorkspacesRequest>
        void CreateWorkspacesAsync(const CreateWorkspacesRequestT& request, const CreateWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateWorkspaces, request, handler, context);
        }
 
        virtual Model::CreateWorkspacesPoolOutcome CreateWorkspacesPool(const Model::CreateWorkspacesPoolRequest& request) const;
 
        template<typename CreateWorkspacesPoolRequestT = Model::CreateWorkspacesPoolRequest>
        Model::CreateWorkspacesPoolOutcomeCallable CreateWorkspacesPoolCallable(const CreateWorkspacesPoolRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::CreateWorkspacesPool, request);
        }
 
        template<typename CreateWorkspacesPoolRequestT = Model::CreateWorkspacesPoolRequest>
        void CreateWorkspacesPoolAsync(const CreateWorkspacesPoolRequestT& request, const CreateWorkspacesPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::CreateWorkspacesPool, request, handler, context);
        }
 
        virtual Model::DeleteAccountLinkInvitationOutcome DeleteAccountLinkInvitation(const Model::DeleteAccountLinkInvitationRequest& request) const;
 
        template<typename DeleteAccountLinkInvitationRequestT = Model::DeleteAccountLinkInvitationRequest>
        Model::DeleteAccountLinkInvitationOutcomeCallable DeleteAccountLinkInvitationCallable(const DeleteAccountLinkInvitationRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteAccountLinkInvitation, request);
        }
 
        template<typename DeleteAccountLinkInvitationRequestT = Model::DeleteAccountLinkInvitationRequest>
        void DeleteAccountLinkInvitationAsync(const DeleteAccountLinkInvitationRequestT& request, const DeleteAccountLinkInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteAccountLinkInvitation, request, handler, context);
        }
 
        virtual Model::DeleteClientBrandingOutcome DeleteClientBranding(const Model::DeleteClientBrandingRequest& request) const;
 
        template<typename DeleteClientBrandingRequestT = Model::DeleteClientBrandingRequest>
        Model::DeleteClientBrandingOutcomeCallable DeleteClientBrandingCallable(const DeleteClientBrandingRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteClientBranding, request);
        }
 
        template<typename DeleteClientBrandingRequestT = Model::DeleteClientBrandingRequest>
        void DeleteClientBrandingAsync(const DeleteClientBrandingRequestT& request, const DeleteClientBrandingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteClientBranding, request, handler, context);
        }
 
        virtual Model::DeleteConnectClientAddInOutcome DeleteConnectClientAddIn(const Model::DeleteConnectClientAddInRequest& request) const;
 
        template<typename DeleteConnectClientAddInRequestT = Model::DeleteConnectClientAddInRequest>
        Model::DeleteConnectClientAddInOutcomeCallable DeleteConnectClientAddInCallable(const DeleteConnectClientAddInRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteConnectClientAddIn, request);
        }
 
        template<typename DeleteConnectClientAddInRequestT = Model::DeleteConnectClientAddInRequest>
        void DeleteConnectClientAddInAsync(const DeleteConnectClientAddInRequestT& request, const DeleteConnectClientAddInResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteConnectClientAddIn, request, handler, context);
        }
 
        virtual Model::DeleteConnectionAliasOutcome DeleteConnectionAlias(const Model::DeleteConnectionAliasRequest& request) const;
 
        template<typename DeleteConnectionAliasRequestT = Model::DeleteConnectionAliasRequest>
        Model::DeleteConnectionAliasOutcomeCallable DeleteConnectionAliasCallable(const DeleteConnectionAliasRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteConnectionAlias, request);
        }
 
        template<typename DeleteConnectionAliasRequestT = Model::DeleteConnectionAliasRequest>
        void DeleteConnectionAliasAsync(const DeleteConnectionAliasRequestT& request, const DeleteConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteConnectionAlias, request, handler, context);
        }
 
        virtual Model::DeleteIpGroupOutcome DeleteIpGroup(const Model::DeleteIpGroupRequest& request) const;
 
        template<typename DeleteIpGroupRequestT = Model::DeleteIpGroupRequest>
        Model::DeleteIpGroupOutcomeCallable DeleteIpGroupCallable(const DeleteIpGroupRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteIpGroup, request);
        }
 
        template<typename DeleteIpGroupRequestT = Model::DeleteIpGroupRequest>
        void DeleteIpGroupAsync(const DeleteIpGroupRequestT& request, const DeleteIpGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteIpGroup, request, handler, context);
        }
 
        virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const;
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteTags, request);
        }
 
        template<typename DeleteTagsRequestT = Model::DeleteTagsRequest>
        void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteTags, request, handler, context);
        }
 
        virtual Model::DeleteWorkspaceBundleOutcome DeleteWorkspaceBundle(const Model::DeleteWorkspaceBundleRequest& request = {}) const;
 
        template<typename DeleteWorkspaceBundleRequestT = Model::DeleteWorkspaceBundleRequest>
        Model::DeleteWorkspaceBundleOutcomeCallable DeleteWorkspaceBundleCallable(const DeleteWorkspaceBundleRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteWorkspaceBundle, request);
        }
 
        template<typename DeleteWorkspaceBundleRequestT = Model::DeleteWorkspaceBundleRequest>
        void DeleteWorkspaceBundleAsync(const DeleteWorkspaceBundleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeleteWorkspaceBundleRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteWorkspaceBundle, request, handler, context);
        }
 
        virtual Model::DeleteWorkspaceImageOutcome DeleteWorkspaceImage(const Model::DeleteWorkspaceImageRequest& request) const;
 
        template<typename DeleteWorkspaceImageRequestT = Model::DeleteWorkspaceImageRequest>
        Model::DeleteWorkspaceImageOutcomeCallable DeleteWorkspaceImageCallable(const DeleteWorkspaceImageRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeleteWorkspaceImage, request);
        }
 
        template<typename DeleteWorkspaceImageRequestT = Model::DeleteWorkspaceImageRequest>
        void DeleteWorkspaceImageAsync(const DeleteWorkspaceImageRequestT& request, const DeleteWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeleteWorkspaceImage, request, handler, context);
        }
 
        virtual Model::DeployWorkspaceApplicationsOutcome DeployWorkspaceApplications(const Model::DeployWorkspaceApplicationsRequest& request) const;
 
        template<typename DeployWorkspaceApplicationsRequestT = Model::DeployWorkspaceApplicationsRequest>
        Model::DeployWorkspaceApplicationsOutcomeCallable DeployWorkspaceApplicationsCallable(const DeployWorkspaceApplicationsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeployWorkspaceApplications, request);
        }
 
        template<typename DeployWorkspaceApplicationsRequestT = Model::DeployWorkspaceApplicationsRequest>
        void DeployWorkspaceApplicationsAsync(const DeployWorkspaceApplicationsRequestT& request, const DeployWorkspaceApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeployWorkspaceApplications, request, handler, context);
        }
 
        virtual Model::DeregisterWorkspaceDirectoryOutcome DeregisterWorkspaceDirectory(const Model::DeregisterWorkspaceDirectoryRequest& request) const;
 
        template<typename DeregisterWorkspaceDirectoryRequestT = Model::DeregisterWorkspaceDirectoryRequest>
        Model::DeregisterWorkspaceDirectoryOutcomeCallable DeregisterWorkspaceDirectoryCallable(const DeregisterWorkspaceDirectoryRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DeregisterWorkspaceDirectory, request);
        }
 
        template<typename DeregisterWorkspaceDirectoryRequestT = Model::DeregisterWorkspaceDirectoryRequest>
        void DeregisterWorkspaceDirectoryAsync(const DeregisterWorkspaceDirectoryRequestT& request, const DeregisterWorkspaceDirectoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DeregisterWorkspaceDirectory, request, handler, context);
        }
 
        virtual Model::DescribeAccountOutcome DescribeAccount(const Model::DescribeAccountRequest& request = {}) const;
 
        template<typename DescribeAccountRequestT = Model::DescribeAccountRequest>
        Model::DescribeAccountOutcomeCallable DescribeAccountCallable(const DescribeAccountRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeAccount, request);
        }
 
        template<typename DescribeAccountRequestT = Model::DescribeAccountRequest>
        void DescribeAccountAsync(const DescribeAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeAccount, request, handler, context);
        }
 
        virtual Model::DescribeAccountModificationsOutcome DescribeAccountModifications(const Model::DescribeAccountModificationsRequest& request = {}) const;
 
        template<typename DescribeAccountModificationsRequestT = Model::DescribeAccountModificationsRequest>
        Model::DescribeAccountModificationsOutcomeCallable DescribeAccountModificationsCallable(const DescribeAccountModificationsRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeAccountModifications, request);
        }
 
        template<typename DescribeAccountModificationsRequestT = Model::DescribeAccountModificationsRequest>
        void DescribeAccountModificationsAsync(const DescribeAccountModificationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeAccountModificationsRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeAccountModifications, request, handler, context);
        }
 
        virtual Model::DescribeApplicationAssociationsOutcome DescribeApplicationAssociations(const Model::DescribeApplicationAssociationsRequest& request) const;
 
        template<typename DescribeApplicationAssociationsRequestT = Model::DescribeApplicationAssociationsRequest>
        Model::DescribeApplicationAssociationsOutcomeCallable DescribeApplicationAssociationsCallable(const DescribeApplicationAssociationsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeApplicationAssociations, request);
        }
 
        template<typename DescribeApplicationAssociationsRequestT = Model::DescribeApplicationAssociationsRequest>
        void DescribeApplicationAssociationsAsync(const DescribeApplicationAssociationsRequestT& request, const DescribeApplicationAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeApplicationAssociations, request, handler, context);
        }
 
        virtual Model::DescribeApplicationsOutcome DescribeApplications(const Model::DescribeApplicationsRequest& request = {}) const;
 
        template<typename DescribeApplicationsRequestT = Model::DescribeApplicationsRequest>
        Model::DescribeApplicationsOutcomeCallable DescribeApplicationsCallable(const DescribeApplicationsRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeApplications, request);
        }
 
        template<typename DescribeApplicationsRequestT = Model::DescribeApplicationsRequest>
        void DescribeApplicationsAsync(const DescribeApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeApplicationsRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeApplications, request, handler, context);
        }
 
        virtual Model::DescribeBundleAssociationsOutcome DescribeBundleAssociations(const Model::DescribeBundleAssociationsRequest& request) const;
 
        template<typename DescribeBundleAssociationsRequestT = Model::DescribeBundleAssociationsRequest>
        Model::DescribeBundleAssociationsOutcomeCallable DescribeBundleAssociationsCallable(const DescribeBundleAssociationsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeBundleAssociations, request);
        }
 
        template<typename DescribeBundleAssociationsRequestT = Model::DescribeBundleAssociationsRequest>
        void DescribeBundleAssociationsAsync(const DescribeBundleAssociationsRequestT& request, const DescribeBundleAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeBundleAssociations, request, handler, context);
        }
 
        virtual Model::DescribeClientBrandingOutcome DescribeClientBranding(const Model::DescribeClientBrandingRequest& request) const;
 
        template<typename DescribeClientBrandingRequestT = Model::DescribeClientBrandingRequest>
        Model::DescribeClientBrandingOutcomeCallable DescribeClientBrandingCallable(const DescribeClientBrandingRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeClientBranding, request);
        }
 
        template<typename DescribeClientBrandingRequestT = Model::DescribeClientBrandingRequest>
        void DescribeClientBrandingAsync(const DescribeClientBrandingRequestT& request, const DescribeClientBrandingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeClientBranding, request, handler, context);
        }
 
        virtual Model::DescribeClientPropertiesOutcome DescribeClientProperties(const Model::DescribeClientPropertiesRequest& request) const;
 
        template<typename DescribeClientPropertiesRequestT = Model::DescribeClientPropertiesRequest>
        Model::DescribeClientPropertiesOutcomeCallable DescribeClientPropertiesCallable(const DescribeClientPropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeClientProperties, request);
        }
 
        template<typename DescribeClientPropertiesRequestT = Model::DescribeClientPropertiesRequest>
        void DescribeClientPropertiesAsync(const DescribeClientPropertiesRequestT& request, const DescribeClientPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeClientProperties, request, handler, context);
        }
 
        virtual Model::DescribeConnectClientAddInsOutcome DescribeConnectClientAddIns(const Model::DescribeConnectClientAddInsRequest& request) const;
 
        template<typename DescribeConnectClientAddInsRequestT = Model::DescribeConnectClientAddInsRequest>
        Model::DescribeConnectClientAddInsOutcomeCallable DescribeConnectClientAddInsCallable(const DescribeConnectClientAddInsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeConnectClientAddIns, request);
        }
 
        template<typename DescribeConnectClientAddInsRequestT = Model::DescribeConnectClientAddInsRequest>
        void DescribeConnectClientAddInsAsync(const DescribeConnectClientAddInsRequestT& request, const DescribeConnectClientAddInsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeConnectClientAddIns, request, handler, context);
        }
 
        virtual Model::DescribeConnectionAliasPermissionsOutcome DescribeConnectionAliasPermissions(const Model::DescribeConnectionAliasPermissionsRequest& request) const;
 
        template<typename DescribeConnectionAliasPermissionsRequestT = Model::DescribeConnectionAliasPermissionsRequest>
        Model::DescribeConnectionAliasPermissionsOutcomeCallable DescribeConnectionAliasPermissionsCallable(const DescribeConnectionAliasPermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeConnectionAliasPermissions, request);
        }
 
        template<typename DescribeConnectionAliasPermissionsRequestT = Model::DescribeConnectionAliasPermissionsRequest>
        void DescribeConnectionAliasPermissionsAsync(const DescribeConnectionAliasPermissionsRequestT& request, const DescribeConnectionAliasPermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeConnectionAliasPermissions, request, handler, context);
        }
 
        virtual Model::DescribeConnectionAliasesOutcome DescribeConnectionAliases(const Model::DescribeConnectionAliasesRequest& request = {}) const;
 
        template<typename DescribeConnectionAliasesRequestT = Model::DescribeConnectionAliasesRequest>
        Model::DescribeConnectionAliasesOutcomeCallable DescribeConnectionAliasesCallable(const DescribeConnectionAliasesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeConnectionAliases, request);
        }
 
        template<typename DescribeConnectionAliasesRequestT = Model::DescribeConnectionAliasesRequest>
        void DescribeConnectionAliasesAsync(const DescribeConnectionAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeConnectionAliasesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeConnectionAliases, request, handler, context);
        }
 
        virtual Model::DescribeImageAssociationsOutcome DescribeImageAssociations(const Model::DescribeImageAssociationsRequest& request) const;
 
        template<typename DescribeImageAssociationsRequestT = Model::DescribeImageAssociationsRequest>
        Model::DescribeImageAssociationsOutcomeCallable DescribeImageAssociationsCallable(const DescribeImageAssociationsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeImageAssociations, request);
        }
 
        template<typename DescribeImageAssociationsRequestT = Model::DescribeImageAssociationsRequest>
        void DescribeImageAssociationsAsync(const DescribeImageAssociationsRequestT& request, const DescribeImageAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeImageAssociations, request, handler, context);
        }
 
        virtual Model::DescribeIpGroupsOutcome DescribeIpGroups(const Model::DescribeIpGroupsRequest& request = {}) const;
 
        template<typename DescribeIpGroupsRequestT = Model::DescribeIpGroupsRequest>
        Model::DescribeIpGroupsOutcomeCallable DescribeIpGroupsCallable(const DescribeIpGroupsRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeIpGroups, request);
        }
 
        template<typename DescribeIpGroupsRequestT = Model::DescribeIpGroupsRequest>
        void DescribeIpGroupsAsync(const DescribeIpGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeIpGroupsRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeIpGroups, request, handler, context);
        }
 
        virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const;
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeTags, request);
        }
 
        template<typename DescribeTagsRequestT = Model::DescribeTagsRequest>
        void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeTags, request, handler, context);
        }
 
        virtual Model::DescribeWorkspaceAssociationsOutcome DescribeWorkspaceAssociations(const Model::DescribeWorkspaceAssociationsRequest& request) const;
 
        template<typename DescribeWorkspaceAssociationsRequestT = Model::DescribeWorkspaceAssociationsRequest>
        Model::DescribeWorkspaceAssociationsOutcomeCallable DescribeWorkspaceAssociationsCallable(const DescribeWorkspaceAssociationsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceAssociations, request);
        }
 
        template<typename DescribeWorkspaceAssociationsRequestT = Model::DescribeWorkspaceAssociationsRequest>
        void DescribeWorkspaceAssociationsAsync(const DescribeWorkspaceAssociationsRequestT& request, const DescribeWorkspaceAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceAssociations, request, handler, context);
        }
 
        virtual Model::DescribeWorkspaceBundlesOutcome DescribeWorkspaceBundles(const Model::DescribeWorkspaceBundlesRequest& request = {}) const;
 
        template<typename DescribeWorkspaceBundlesRequestT = Model::DescribeWorkspaceBundlesRequest>
        Model::DescribeWorkspaceBundlesOutcomeCallable DescribeWorkspaceBundlesCallable(const DescribeWorkspaceBundlesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceBundles, request);
        }
 
        template<typename DescribeWorkspaceBundlesRequestT = Model::DescribeWorkspaceBundlesRequest>
        void DescribeWorkspaceBundlesAsync(const DescribeWorkspaceBundlesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeWorkspaceBundlesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceBundles, request, handler, context);
        }
 
        virtual Model::DescribeWorkspaceDirectoriesOutcome DescribeWorkspaceDirectories(const Model::DescribeWorkspaceDirectoriesRequest& request = {}) const;
 
        template<typename DescribeWorkspaceDirectoriesRequestT = Model::DescribeWorkspaceDirectoriesRequest>
        Model::DescribeWorkspaceDirectoriesOutcomeCallable DescribeWorkspaceDirectoriesCallable(const DescribeWorkspaceDirectoriesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceDirectories, request);
        }
 
        template<typename DescribeWorkspaceDirectoriesRequestT = Model::DescribeWorkspaceDirectoriesRequest>
        void DescribeWorkspaceDirectoriesAsync(const DescribeWorkspaceDirectoriesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeWorkspaceDirectoriesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceDirectories, request, handler, context);
        }
 
        virtual Model::DescribeWorkspaceImagePermissionsOutcome DescribeWorkspaceImagePermissions(const Model::DescribeWorkspaceImagePermissionsRequest& request) const;
 
        template<typename DescribeWorkspaceImagePermissionsRequestT = Model::DescribeWorkspaceImagePermissionsRequest>
        Model::DescribeWorkspaceImagePermissionsOutcomeCallable DescribeWorkspaceImagePermissionsCallable(const DescribeWorkspaceImagePermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceImagePermissions, request);
        }
 
        template<typename DescribeWorkspaceImagePermissionsRequestT = Model::DescribeWorkspaceImagePermissionsRequest>
        void DescribeWorkspaceImagePermissionsAsync(const DescribeWorkspaceImagePermissionsRequestT& request, const DescribeWorkspaceImagePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceImagePermissions, request, handler, context);
        }
 
        virtual Model::DescribeWorkspaceImagesOutcome DescribeWorkspaceImages(const Model::DescribeWorkspaceImagesRequest& request = {}) const;
 
        template<typename DescribeWorkspaceImagesRequestT = Model::DescribeWorkspaceImagesRequest>
        Model::DescribeWorkspaceImagesOutcomeCallable DescribeWorkspaceImagesCallable(const DescribeWorkspaceImagesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceImages, request);
        }
 
        template<typename DescribeWorkspaceImagesRequestT = Model::DescribeWorkspaceImagesRequest>
        void DescribeWorkspaceImagesAsync(const DescribeWorkspaceImagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeWorkspaceImagesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceImages, request, handler, context);
        }
 
        virtual Model::DescribeWorkspaceSnapshotsOutcome DescribeWorkspaceSnapshots(const Model::DescribeWorkspaceSnapshotsRequest& request) const;
 
        template<typename DescribeWorkspaceSnapshotsRequestT = Model::DescribeWorkspaceSnapshotsRequest>
        Model::DescribeWorkspaceSnapshotsOutcomeCallable DescribeWorkspaceSnapshotsCallable(const DescribeWorkspaceSnapshotsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceSnapshots, request);
        }
 
        template<typename DescribeWorkspaceSnapshotsRequestT = Model::DescribeWorkspaceSnapshotsRequest>
        void DescribeWorkspaceSnapshotsAsync(const DescribeWorkspaceSnapshotsRequestT& request, const DescribeWorkspaceSnapshotsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceSnapshots, request, handler, context);
        }
 
        virtual Model::DescribeWorkspacesOutcome DescribeWorkspaces(const Model::DescribeWorkspacesRequest& request = {}) const;
 
        template<typename DescribeWorkspacesRequestT = Model::DescribeWorkspacesRequest>
        Model::DescribeWorkspacesOutcomeCallable DescribeWorkspacesCallable(const DescribeWorkspacesRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspaces, request);
        }
 
        template<typename DescribeWorkspacesRequestT = Model::DescribeWorkspacesRequest>
        void DescribeWorkspacesAsync(const DescribeWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeWorkspacesRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspaces, request, handler, context);
        }
 
        virtual Model::DescribeWorkspacesConnectionStatusOutcome DescribeWorkspacesConnectionStatus(const Model::DescribeWorkspacesConnectionStatusRequest& request = {}) const;
 
        template<typename DescribeWorkspacesConnectionStatusRequestT = Model::DescribeWorkspacesConnectionStatusRequest>
        Model::DescribeWorkspacesConnectionStatusOutcomeCallable DescribeWorkspacesConnectionStatusCallable(const DescribeWorkspacesConnectionStatusRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspacesConnectionStatus, request);
        }
 
        template<typename DescribeWorkspacesConnectionStatusRequestT = Model::DescribeWorkspacesConnectionStatusRequest>
        void DescribeWorkspacesConnectionStatusAsync(const DescribeWorkspacesConnectionStatusResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeWorkspacesConnectionStatusRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspacesConnectionStatus, request, handler, context);
        }
 
        virtual Model::DescribeWorkspacesPoolSessionsOutcome DescribeWorkspacesPoolSessions(const Model::DescribeWorkspacesPoolSessionsRequest& request) const;
 
        template<typename DescribeWorkspacesPoolSessionsRequestT = Model::DescribeWorkspacesPoolSessionsRequest>
        Model::DescribeWorkspacesPoolSessionsOutcomeCallable DescribeWorkspacesPoolSessionsCallable(const DescribeWorkspacesPoolSessionsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspacesPoolSessions, request);
        }
 
        template<typename DescribeWorkspacesPoolSessionsRequestT = Model::DescribeWorkspacesPoolSessionsRequest>
        void DescribeWorkspacesPoolSessionsAsync(const DescribeWorkspacesPoolSessionsRequestT& request, const DescribeWorkspacesPoolSessionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspacesPoolSessions, request, handler, context);
        }
 
        virtual Model::DescribeWorkspacesPoolsOutcome DescribeWorkspacesPools(const Model::DescribeWorkspacesPoolsRequest& request = {}) const;
 
        template<typename DescribeWorkspacesPoolsRequestT = Model::DescribeWorkspacesPoolsRequest>
        Model::DescribeWorkspacesPoolsOutcomeCallable DescribeWorkspacesPoolsCallable(const DescribeWorkspacesPoolsRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::DescribeWorkspacesPools, request);
        }
 
        template<typename DescribeWorkspacesPoolsRequestT = Model::DescribeWorkspacesPoolsRequest>
        void DescribeWorkspacesPoolsAsync(const DescribeWorkspacesPoolsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DescribeWorkspacesPoolsRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::DescribeWorkspacesPools, request, handler, context);
        }
 
        virtual Model::DisassociateConnectionAliasOutcome DisassociateConnectionAlias(const Model::DisassociateConnectionAliasRequest& request) const;
 
        template<typename DisassociateConnectionAliasRequestT = Model::DisassociateConnectionAliasRequest>
        Model::DisassociateConnectionAliasOutcomeCallable DisassociateConnectionAliasCallable(const DisassociateConnectionAliasRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DisassociateConnectionAlias, request);
        }
 
        template<typename DisassociateConnectionAliasRequestT = Model::DisassociateConnectionAliasRequest>
        void DisassociateConnectionAliasAsync(const DisassociateConnectionAliasRequestT& request, const DisassociateConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DisassociateConnectionAlias, request, handler, context);
        }
 
        virtual Model::DisassociateIpGroupsOutcome DisassociateIpGroups(const Model::DisassociateIpGroupsRequest& request) const;
 
        template<typename DisassociateIpGroupsRequestT = Model::DisassociateIpGroupsRequest>
        Model::DisassociateIpGroupsOutcomeCallable DisassociateIpGroupsCallable(const DisassociateIpGroupsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DisassociateIpGroups, request);
        }
 
        template<typename DisassociateIpGroupsRequestT = Model::DisassociateIpGroupsRequest>
        void DisassociateIpGroupsAsync(const DisassociateIpGroupsRequestT& request, const DisassociateIpGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DisassociateIpGroups, request, handler, context);
        }
 
        virtual Model::DisassociateWorkspaceApplicationOutcome DisassociateWorkspaceApplication(const Model::DisassociateWorkspaceApplicationRequest& request) const;
 
        template<typename DisassociateWorkspaceApplicationRequestT = Model::DisassociateWorkspaceApplicationRequest>
        Model::DisassociateWorkspaceApplicationOutcomeCallable DisassociateWorkspaceApplicationCallable(const DisassociateWorkspaceApplicationRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::DisassociateWorkspaceApplication, request);
        }
 
        template<typename DisassociateWorkspaceApplicationRequestT = Model::DisassociateWorkspaceApplicationRequest>
        void DisassociateWorkspaceApplicationAsync(const DisassociateWorkspaceApplicationRequestT& request, const DisassociateWorkspaceApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::DisassociateWorkspaceApplication, request, handler, context);
        }
 
        virtual Model::GetAccountLinkOutcome GetAccountLink(const Model::GetAccountLinkRequest& request = {}) const;
 
        template<typename GetAccountLinkRequestT = Model::GetAccountLinkRequest>
        Model::GetAccountLinkOutcomeCallable GetAccountLinkCallable(const GetAccountLinkRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::GetAccountLink, request);
        }
 
        template<typename GetAccountLinkRequestT = Model::GetAccountLinkRequest>
        void GetAccountLinkAsync(const GetAccountLinkResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountLinkRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::GetAccountLink, request, handler, context);
        }
 
        virtual Model::ImportClientBrandingOutcome ImportClientBranding(const Model::ImportClientBrandingRequest& request) const;
 
        template<typename ImportClientBrandingRequestT = Model::ImportClientBrandingRequest>
        Model::ImportClientBrandingOutcomeCallable ImportClientBrandingCallable(const ImportClientBrandingRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ImportClientBranding, request);
        }
 
        template<typename ImportClientBrandingRequestT = Model::ImportClientBrandingRequest>
        void ImportClientBrandingAsync(const ImportClientBrandingRequestT& request, const ImportClientBrandingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ImportClientBranding, request, handler, context);
        }
 
        virtual Model::ImportWorkspaceImageOutcome ImportWorkspaceImage(const Model::ImportWorkspaceImageRequest& request) const;
 
        template<typename ImportWorkspaceImageRequestT = Model::ImportWorkspaceImageRequest>
        Model::ImportWorkspaceImageOutcomeCallable ImportWorkspaceImageCallable(const ImportWorkspaceImageRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ImportWorkspaceImage, request);
        }
 
        template<typename ImportWorkspaceImageRequestT = Model::ImportWorkspaceImageRequest>
        void ImportWorkspaceImageAsync(const ImportWorkspaceImageRequestT& request, const ImportWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ImportWorkspaceImage, request, handler, context);
        }
 
        virtual Model::ListAccountLinksOutcome ListAccountLinks(const Model::ListAccountLinksRequest& request = {}) const;
 
        template<typename ListAccountLinksRequestT = Model::ListAccountLinksRequest>
        Model::ListAccountLinksOutcomeCallable ListAccountLinksCallable(const ListAccountLinksRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::ListAccountLinks, request);
        }
 
        template<typename ListAccountLinksRequestT = Model::ListAccountLinksRequest>
        void ListAccountLinksAsync(const ListAccountLinksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccountLinksRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::ListAccountLinks, request, handler, context);
        }
 
        virtual Model::ListAvailableManagementCidrRangesOutcome ListAvailableManagementCidrRanges(const Model::ListAvailableManagementCidrRangesRequest& request) const;
 
        template<typename ListAvailableManagementCidrRangesRequestT = Model::ListAvailableManagementCidrRangesRequest>
        Model::ListAvailableManagementCidrRangesOutcomeCallable ListAvailableManagementCidrRangesCallable(const ListAvailableManagementCidrRangesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ListAvailableManagementCidrRanges, request);
        }
 
        template<typename ListAvailableManagementCidrRangesRequestT = Model::ListAvailableManagementCidrRangesRequest>
        void ListAvailableManagementCidrRangesAsync(const ListAvailableManagementCidrRangesRequestT& request, const ListAvailableManagementCidrRangesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ListAvailableManagementCidrRanges, request, handler, context);
        }
 
        virtual Model::MigrateWorkspaceOutcome MigrateWorkspace(const Model::MigrateWorkspaceRequest& request) const;
 
        template<typename MigrateWorkspaceRequestT = Model::MigrateWorkspaceRequest>
        Model::MigrateWorkspaceOutcomeCallable MigrateWorkspaceCallable(const MigrateWorkspaceRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::MigrateWorkspace, request);
        }
 
        template<typename MigrateWorkspaceRequestT = Model::MigrateWorkspaceRequest>
        void MigrateWorkspaceAsync(const MigrateWorkspaceRequestT& request, const MigrateWorkspaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::MigrateWorkspace, request, handler, context);
        }
 
        virtual Model::ModifyAccountOutcome ModifyAccount(const Model::ModifyAccountRequest& request = {}) const;
 
        template<typename ModifyAccountRequestT = Model::ModifyAccountRequest>
        Model::ModifyAccountOutcomeCallable ModifyAccountCallable(const ModifyAccountRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyAccount, request);
        }
 
        template<typename ModifyAccountRequestT = Model::ModifyAccountRequest>
        void ModifyAccountAsync(const ModifyAccountResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ModifyAccountRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyAccount, request, handler, context);
        }
 
        virtual Model::ModifyCertificateBasedAuthPropertiesOutcome ModifyCertificateBasedAuthProperties(const Model::ModifyCertificateBasedAuthPropertiesRequest& request) const;
 
        template<typename ModifyCertificateBasedAuthPropertiesRequestT = Model::ModifyCertificateBasedAuthPropertiesRequest>
        Model::ModifyCertificateBasedAuthPropertiesOutcomeCallable ModifyCertificateBasedAuthPropertiesCallable(const ModifyCertificateBasedAuthPropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyCertificateBasedAuthProperties, request);
        }
 
        template<typename ModifyCertificateBasedAuthPropertiesRequestT = Model::ModifyCertificateBasedAuthPropertiesRequest>
        void ModifyCertificateBasedAuthPropertiesAsync(const ModifyCertificateBasedAuthPropertiesRequestT& request, const ModifyCertificateBasedAuthPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyCertificateBasedAuthProperties, request, handler, context);
        }
 
        virtual Model::ModifyClientPropertiesOutcome ModifyClientProperties(const Model::ModifyClientPropertiesRequest& request) const;
 
        template<typename ModifyClientPropertiesRequestT = Model::ModifyClientPropertiesRequest>
        Model::ModifyClientPropertiesOutcomeCallable ModifyClientPropertiesCallable(const ModifyClientPropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyClientProperties, request);
        }
 
        template<typename ModifyClientPropertiesRequestT = Model::ModifyClientPropertiesRequest>
        void ModifyClientPropertiesAsync(const ModifyClientPropertiesRequestT& request, const ModifyClientPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyClientProperties, request, handler, context);
        }
 
        virtual Model::ModifySamlPropertiesOutcome ModifySamlProperties(const Model::ModifySamlPropertiesRequest& request) const;
 
        template<typename ModifySamlPropertiesRequestT = Model::ModifySamlPropertiesRequest>
        Model::ModifySamlPropertiesOutcomeCallable ModifySamlPropertiesCallable(const ModifySamlPropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifySamlProperties, request);
        }
 
        template<typename ModifySamlPropertiesRequestT = Model::ModifySamlPropertiesRequest>
        void ModifySamlPropertiesAsync(const ModifySamlPropertiesRequestT& request, const ModifySamlPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifySamlProperties, request, handler, context);
        }
 
        virtual Model::ModifySelfservicePermissionsOutcome ModifySelfservicePermissions(const Model::ModifySelfservicePermissionsRequest& request) const;
 
        template<typename ModifySelfservicePermissionsRequestT = Model::ModifySelfservicePermissionsRequest>
        Model::ModifySelfservicePermissionsOutcomeCallable ModifySelfservicePermissionsCallable(const ModifySelfservicePermissionsRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifySelfservicePermissions, request);
        }
 
        template<typename ModifySelfservicePermissionsRequestT = Model::ModifySelfservicePermissionsRequest>
        void ModifySelfservicePermissionsAsync(const ModifySelfservicePermissionsRequestT& request, const ModifySelfservicePermissionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifySelfservicePermissions, request, handler, context);
        }
 
        virtual Model::ModifyStreamingPropertiesOutcome ModifyStreamingProperties(const Model::ModifyStreamingPropertiesRequest& request) const;
 
        template<typename ModifyStreamingPropertiesRequestT = Model::ModifyStreamingPropertiesRequest>
        Model::ModifyStreamingPropertiesOutcomeCallable ModifyStreamingPropertiesCallable(const ModifyStreamingPropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyStreamingProperties, request);
        }
 
        template<typename ModifyStreamingPropertiesRequestT = Model::ModifyStreamingPropertiesRequest>
        void ModifyStreamingPropertiesAsync(const ModifyStreamingPropertiesRequestT& request, const ModifyStreamingPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyStreamingProperties, request, handler, context);
        }
 
        virtual Model::ModifyWorkspaceAccessPropertiesOutcome ModifyWorkspaceAccessProperties(const Model::ModifyWorkspaceAccessPropertiesRequest& request) const;
 
        template<typename ModifyWorkspaceAccessPropertiesRequestT = Model::ModifyWorkspaceAccessPropertiesRequest>
        Model::ModifyWorkspaceAccessPropertiesOutcomeCallable ModifyWorkspaceAccessPropertiesCallable(const ModifyWorkspaceAccessPropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceAccessProperties, request);
        }
 
        template<typename ModifyWorkspaceAccessPropertiesRequestT = Model::ModifyWorkspaceAccessPropertiesRequest>
        void ModifyWorkspaceAccessPropertiesAsync(const ModifyWorkspaceAccessPropertiesRequestT& request, const ModifyWorkspaceAccessPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceAccessProperties, request, handler, context);
        }
 
        virtual Model::ModifyWorkspaceCreationPropertiesOutcome ModifyWorkspaceCreationProperties(const Model::ModifyWorkspaceCreationPropertiesRequest& request) const;
 
        template<typename ModifyWorkspaceCreationPropertiesRequestT = Model::ModifyWorkspaceCreationPropertiesRequest>
        Model::ModifyWorkspaceCreationPropertiesOutcomeCallable ModifyWorkspaceCreationPropertiesCallable(const ModifyWorkspaceCreationPropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceCreationProperties, request);
        }
 
        template<typename ModifyWorkspaceCreationPropertiesRequestT = Model::ModifyWorkspaceCreationPropertiesRequest>
        void ModifyWorkspaceCreationPropertiesAsync(const ModifyWorkspaceCreationPropertiesRequestT& request, const ModifyWorkspaceCreationPropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceCreationProperties, request, handler, context);
        }
 
        virtual Model::ModifyWorkspacePropertiesOutcome ModifyWorkspaceProperties(const Model::ModifyWorkspacePropertiesRequest& request) const;
 
        template<typename ModifyWorkspacePropertiesRequestT = Model::ModifyWorkspacePropertiesRequest>
        Model::ModifyWorkspacePropertiesOutcomeCallable ModifyWorkspacePropertiesCallable(const ModifyWorkspacePropertiesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceProperties, request);
        }
 
        template<typename ModifyWorkspacePropertiesRequestT = Model::ModifyWorkspacePropertiesRequest>
        void ModifyWorkspacePropertiesAsync(const ModifyWorkspacePropertiesRequestT& request, const ModifyWorkspacePropertiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceProperties, request, handler, context);
        }
 
        virtual Model::ModifyWorkspaceStateOutcome ModifyWorkspaceState(const Model::ModifyWorkspaceStateRequest& request) const;
 
        template<typename ModifyWorkspaceStateRequestT = Model::ModifyWorkspaceStateRequest>
        Model::ModifyWorkspaceStateOutcomeCallable ModifyWorkspaceStateCallable(const ModifyWorkspaceStateRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceState, request);
        }
 
        template<typename ModifyWorkspaceStateRequestT = Model::ModifyWorkspaceStateRequest>
        void ModifyWorkspaceStateAsync(const ModifyWorkspaceStateRequestT& request, const ModifyWorkspaceStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceState, request, handler, context);
        }
 
        virtual Model::RebootWorkspacesOutcome RebootWorkspaces(const Model::RebootWorkspacesRequest& request) const;
 
        template<typename RebootWorkspacesRequestT = Model::RebootWorkspacesRequest>
        Model::RebootWorkspacesOutcomeCallable RebootWorkspacesCallable(const RebootWorkspacesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::RebootWorkspaces, request);
        }
 
        template<typename RebootWorkspacesRequestT = Model::RebootWorkspacesRequest>
        void RebootWorkspacesAsync(const RebootWorkspacesRequestT& request, const RebootWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::RebootWorkspaces, request, handler, context);
        }
 
        virtual Model::RebuildWorkspacesOutcome RebuildWorkspaces(const Model::RebuildWorkspacesRequest& request) const;
 
        template<typename RebuildWorkspacesRequestT = Model::RebuildWorkspacesRequest>
        Model::RebuildWorkspacesOutcomeCallable RebuildWorkspacesCallable(const RebuildWorkspacesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::RebuildWorkspaces, request);
        }
 
        template<typename RebuildWorkspacesRequestT = Model::RebuildWorkspacesRequest>
        void RebuildWorkspacesAsync(const RebuildWorkspacesRequestT& request, const RebuildWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::RebuildWorkspaces, request, handler, context);
        }
 
        virtual Model::RegisterWorkspaceDirectoryOutcome RegisterWorkspaceDirectory(const Model::RegisterWorkspaceDirectoryRequest& request = {}) const;
 
        template<typename RegisterWorkspaceDirectoryRequestT = Model::RegisterWorkspaceDirectoryRequest>
        Model::RegisterWorkspaceDirectoryOutcomeCallable RegisterWorkspaceDirectoryCallable(const RegisterWorkspaceDirectoryRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::RegisterWorkspaceDirectory, request);
        }
 
        template<typename RegisterWorkspaceDirectoryRequestT = Model::RegisterWorkspaceDirectoryRequest>
        void RegisterWorkspaceDirectoryAsync(const RegisterWorkspaceDirectoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const RegisterWorkspaceDirectoryRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::RegisterWorkspaceDirectory, request, handler, context);
        }
 
        virtual Model::RejectAccountLinkInvitationOutcome RejectAccountLinkInvitation(const Model::RejectAccountLinkInvitationRequest& request) const;
 
        template<typename RejectAccountLinkInvitationRequestT = Model::RejectAccountLinkInvitationRequest>
        Model::RejectAccountLinkInvitationOutcomeCallable RejectAccountLinkInvitationCallable(const RejectAccountLinkInvitationRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::RejectAccountLinkInvitation, request);
        }
 
        template<typename RejectAccountLinkInvitationRequestT = Model::RejectAccountLinkInvitationRequest>
        void RejectAccountLinkInvitationAsync(const RejectAccountLinkInvitationRequestT& request, const RejectAccountLinkInvitationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::RejectAccountLinkInvitation, request, handler, context);
        }
 
        virtual Model::RestoreWorkspaceOutcome RestoreWorkspace(const Model::RestoreWorkspaceRequest& request) const;
 
        template<typename RestoreWorkspaceRequestT = Model::RestoreWorkspaceRequest>
        Model::RestoreWorkspaceOutcomeCallable RestoreWorkspaceCallable(const RestoreWorkspaceRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::RestoreWorkspace, request);
        }
 
        template<typename RestoreWorkspaceRequestT = Model::RestoreWorkspaceRequest>
        void RestoreWorkspaceAsync(const RestoreWorkspaceRequestT& request, const RestoreWorkspaceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::RestoreWorkspace, request, handler, context);
        }
 
        virtual Model::RevokeIpRulesOutcome RevokeIpRules(const Model::RevokeIpRulesRequest& request) const;
 
        template<typename RevokeIpRulesRequestT = Model::RevokeIpRulesRequest>
        Model::RevokeIpRulesOutcomeCallable RevokeIpRulesCallable(const RevokeIpRulesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::RevokeIpRules, request);
        }
 
        template<typename RevokeIpRulesRequestT = Model::RevokeIpRulesRequest>
        void RevokeIpRulesAsync(const RevokeIpRulesRequestT& request, const RevokeIpRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::RevokeIpRules, request, handler, context);
        }
 
        virtual Model::StartWorkspacesOutcome StartWorkspaces(const Model::StartWorkspacesRequest& request) const;
 
        template<typename StartWorkspacesRequestT = Model::StartWorkspacesRequest>
        Model::StartWorkspacesOutcomeCallable StartWorkspacesCallable(const StartWorkspacesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::StartWorkspaces, request);
        }
 
        template<typename StartWorkspacesRequestT = Model::StartWorkspacesRequest>
        void StartWorkspacesAsync(const StartWorkspacesRequestT& request, const StartWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::StartWorkspaces, request, handler, context);
        }
 
        virtual Model::StartWorkspacesPoolOutcome StartWorkspacesPool(const Model::StartWorkspacesPoolRequest& request) const;
 
        template<typename StartWorkspacesPoolRequestT = Model::StartWorkspacesPoolRequest>
        Model::StartWorkspacesPoolOutcomeCallable StartWorkspacesPoolCallable(const StartWorkspacesPoolRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::StartWorkspacesPool, request);
        }
 
        template<typename StartWorkspacesPoolRequestT = Model::StartWorkspacesPoolRequest>
        void StartWorkspacesPoolAsync(const StartWorkspacesPoolRequestT& request, const StartWorkspacesPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::StartWorkspacesPool, request, handler, context);
        }
 
        virtual Model::StopWorkspacesOutcome StopWorkspaces(const Model::StopWorkspacesRequest& request) const;
 
        template<typename StopWorkspacesRequestT = Model::StopWorkspacesRequest>
        Model::StopWorkspacesOutcomeCallable StopWorkspacesCallable(const StopWorkspacesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::StopWorkspaces, request);
        }
 
        template<typename StopWorkspacesRequestT = Model::StopWorkspacesRequest>
        void StopWorkspacesAsync(const StopWorkspacesRequestT& request, const StopWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::StopWorkspaces, request, handler, context);
        }
 
        virtual Model::StopWorkspacesPoolOutcome StopWorkspacesPool(const Model::StopWorkspacesPoolRequest& request) const;
 
        template<typename StopWorkspacesPoolRequestT = Model::StopWorkspacesPoolRequest>
        Model::StopWorkspacesPoolOutcomeCallable StopWorkspacesPoolCallable(const StopWorkspacesPoolRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::StopWorkspacesPool, request);
        }
 
        template<typename StopWorkspacesPoolRequestT = Model::StopWorkspacesPoolRequest>
        void StopWorkspacesPoolAsync(const StopWorkspacesPoolRequestT& request, const StopWorkspacesPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::StopWorkspacesPool, request, handler, context);
        }
 
        virtual Model::TerminateWorkspacesOutcome TerminateWorkspaces(const Model::TerminateWorkspacesRequest& request) const;
 
        template<typename TerminateWorkspacesRequestT = Model::TerminateWorkspacesRequest>
        Model::TerminateWorkspacesOutcomeCallable TerminateWorkspacesCallable(const TerminateWorkspacesRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::TerminateWorkspaces, request);
        }
 
        template<typename TerminateWorkspacesRequestT = Model::TerminateWorkspacesRequest>
        void TerminateWorkspacesAsync(const TerminateWorkspacesRequestT& request, const TerminateWorkspacesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::TerminateWorkspaces, request, handler, context);
        }
 
        virtual Model::TerminateWorkspacesPoolOutcome TerminateWorkspacesPool(const Model::TerminateWorkspacesPoolRequest& request) const;
 
        template<typename TerminateWorkspacesPoolRequestT = Model::TerminateWorkspacesPoolRequest>
        Model::TerminateWorkspacesPoolOutcomeCallable TerminateWorkspacesPoolCallable(const TerminateWorkspacesPoolRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::TerminateWorkspacesPool, request);
        }
 
        template<typename TerminateWorkspacesPoolRequestT = Model::TerminateWorkspacesPoolRequest>
        void TerminateWorkspacesPoolAsync(const TerminateWorkspacesPoolRequestT& request, const TerminateWorkspacesPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::TerminateWorkspacesPool, request, handler, context);
        }
 
        virtual Model::TerminateWorkspacesPoolSessionOutcome TerminateWorkspacesPoolSession(const Model::TerminateWorkspacesPoolSessionRequest& request) const;
 
        template<typename TerminateWorkspacesPoolSessionRequestT = Model::TerminateWorkspacesPoolSessionRequest>
        Model::TerminateWorkspacesPoolSessionOutcomeCallable TerminateWorkspacesPoolSessionCallable(const TerminateWorkspacesPoolSessionRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::TerminateWorkspacesPoolSession, request);
        }
 
        template<typename TerminateWorkspacesPoolSessionRequestT = Model::TerminateWorkspacesPoolSessionRequest>
        void TerminateWorkspacesPoolSessionAsync(const TerminateWorkspacesPoolSessionRequestT& request, const TerminateWorkspacesPoolSessionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::TerminateWorkspacesPoolSession, request, handler, context);
        }
 
        virtual Model::UpdateConnectClientAddInOutcome UpdateConnectClientAddIn(const Model::UpdateConnectClientAddInRequest& request) const;
 
        template<typename UpdateConnectClientAddInRequestT = Model::UpdateConnectClientAddInRequest>
        Model::UpdateConnectClientAddInOutcomeCallable UpdateConnectClientAddInCallable(const UpdateConnectClientAddInRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::UpdateConnectClientAddIn, request);
        }
 
        template<typename UpdateConnectClientAddInRequestT = Model::UpdateConnectClientAddInRequest>
        void UpdateConnectClientAddInAsync(const UpdateConnectClientAddInRequestT& request, const UpdateConnectClientAddInResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::UpdateConnectClientAddIn, request, handler, context);
        }
 
        virtual Model::UpdateConnectionAliasPermissionOutcome UpdateConnectionAliasPermission(const Model::UpdateConnectionAliasPermissionRequest& request) const;
 
        template<typename UpdateConnectionAliasPermissionRequestT = Model::UpdateConnectionAliasPermissionRequest>
        Model::UpdateConnectionAliasPermissionOutcomeCallable UpdateConnectionAliasPermissionCallable(const UpdateConnectionAliasPermissionRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::UpdateConnectionAliasPermission, request);
        }
 
        template<typename UpdateConnectionAliasPermissionRequestT = Model::UpdateConnectionAliasPermissionRequest>
        void UpdateConnectionAliasPermissionAsync(const UpdateConnectionAliasPermissionRequestT& request, const UpdateConnectionAliasPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::UpdateConnectionAliasPermission, request, handler, context);
        }
 
        virtual Model::UpdateRulesOfIpGroupOutcome UpdateRulesOfIpGroup(const Model::UpdateRulesOfIpGroupRequest& request) const;
 
        template<typename UpdateRulesOfIpGroupRequestT = Model::UpdateRulesOfIpGroupRequest>
        Model::UpdateRulesOfIpGroupOutcomeCallable UpdateRulesOfIpGroupCallable(const UpdateRulesOfIpGroupRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::UpdateRulesOfIpGroup, request);
        }
 
        template<typename UpdateRulesOfIpGroupRequestT = Model::UpdateRulesOfIpGroupRequest>
        void UpdateRulesOfIpGroupAsync(const UpdateRulesOfIpGroupRequestT& request, const UpdateRulesOfIpGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::UpdateRulesOfIpGroup, request, handler, context);
        }
 
        virtual Model::UpdateWorkspaceBundleOutcome UpdateWorkspaceBundle(const Model::UpdateWorkspaceBundleRequest& request = {}) const;
 
        template<typename UpdateWorkspaceBundleRequestT = Model::UpdateWorkspaceBundleRequest>
        Model::UpdateWorkspaceBundleOutcomeCallable UpdateWorkspaceBundleCallable(const UpdateWorkspaceBundleRequestT& request = {}) const
        {
            return SubmitCallable(&WorkSpacesClient::UpdateWorkspaceBundle, request);
        }
 
        template<typename UpdateWorkspaceBundleRequestT = Model::UpdateWorkspaceBundleRequest>
        void UpdateWorkspaceBundleAsync(const UpdateWorkspaceBundleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateWorkspaceBundleRequestT& request = {}) const
        {
            return SubmitAsync(&WorkSpacesClient::UpdateWorkspaceBundle, request, handler, context);
        }
 
        virtual Model::UpdateWorkspaceImagePermissionOutcome UpdateWorkspaceImagePermission(const Model::UpdateWorkspaceImagePermissionRequest& request) const;
 
        template<typename UpdateWorkspaceImagePermissionRequestT = Model::UpdateWorkspaceImagePermissionRequest>
        Model::UpdateWorkspaceImagePermissionOutcomeCallable UpdateWorkspaceImagePermissionCallable(const UpdateWorkspaceImagePermissionRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::UpdateWorkspaceImagePermission, request);
        }
 
        template<typename UpdateWorkspaceImagePermissionRequestT = Model::UpdateWorkspaceImagePermissionRequest>
        void UpdateWorkspaceImagePermissionAsync(const UpdateWorkspaceImagePermissionRequestT& request, const UpdateWorkspaceImagePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::UpdateWorkspaceImagePermission, request, handler, context);
        }
 
        virtual Model::UpdateWorkspacesPoolOutcome UpdateWorkspacesPool(const Model::UpdateWorkspacesPoolRequest& request) const;
 
        template<typename UpdateWorkspacesPoolRequestT = Model::UpdateWorkspacesPoolRequest>
        Model::UpdateWorkspacesPoolOutcomeCallable UpdateWorkspacesPoolCallable(const UpdateWorkspacesPoolRequestT& request) const
        {
            return SubmitCallable(&WorkSpacesClient::UpdateWorkspacesPool, request);
        }
 
        template<typename UpdateWorkspacesPoolRequestT = Model::UpdateWorkspacesPoolRequest>
        void UpdateWorkspacesPoolAsync(const UpdateWorkspacesPoolRequestT& request, const UpdateWorkspacesPoolResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&WorkSpacesClient::UpdateWorkspacesPool, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<WorkSpacesEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<WorkSpacesClient>;
      void init(const WorkSpacesClientConfiguration& clientConfiguration);
 
      WorkSpacesClientConfiguration m_clientConfiguration;
      std::shared_ptr<WorkSpacesEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace WorkSpaces
} // namespace Aws