/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace WorkSpaces { /** * Amazon WorkSpaces Service

Amazon WorkSpaces enables you * to provision virtual, cloud-based Microsoft Windows or Amazon Linux desktops for * your users, known as WorkSpaces. WorkSpaces eliminates the need to * procure and deploy hardware or install complex software. You can quickly add or * remove users as your needs change. Users can access their virtual desktops from * multiple devices or web browsers.

This API Reference provides detailed * information about the actions, data types, parameters, and errors of the * WorkSpaces service. For more information about the supported Amazon Web Services * Regions, endpoints, and service quotas of the Amazon WorkSpaces service, see WorkSpaces * endpoints and quotas in the Amazon Web Services General * Reference.

You can also manage your WorkSpaces resources using the * WorkSpaces console, Command Line Interface (CLI), and SDKs. For more information * about administering WorkSpaces, see the Amazon * WorkSpaces Administration Guide. For more information about using the Amazon * WorkSpaces client application or web browser to access provisioned WorkSpaces, * see the Amazon * WorkSpaces User Guide. For more information about using the CLI to manage * your WorkSpaces resources, see the WorkSpaces * section of the CLI Reference.

*/ class AWS_WORKSPACES_API WorkSpacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef WorkSpacesClientConfiguration ClientConfigurationType; typedef WorkSpacesEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WorkSpacesClient(const Aws::WorkSpaces::WorkSpacesClientConfiguration& clientConfiguration = Aws::WorkSpaces::WorkSpacesClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WorkSpacesClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::WorkSpaces::WorkSpacesClientConfiguration& clientConfiguration = Aws::WorkSpaces::WorkSpacesClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ WorkSpacesClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::WorkSpaces::WorkSpacesClientConfiguration& clientConfiguration = Aws::WorkSpaces::WorkSpacesClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WorkSpacesClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ WorkSpacesClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ WorkSpacesClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~WorkSpacesClient(); /** *

Associates the specified connection alias with the specified directory to * enable cross-Region redirection. For more information, see * Cross-Region Redirection for Amazon WorkSpaces.

Before * performing this operation, call * DescribeConnectionAliases to make sure that the current state of the * connection alias is CREATED.

See Also:

AWS * API Reference

*/ virtual Model::AssociateConnectionAliasOutcome AssociateConnectionAlias(const Model::AssociateConnectionAliasRequest& request) const; /** * A Callable wrapper for AssociateConnectionAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateConnectionAliasOutcomeCallable AssociateConnectionAliasCallable(const AssociateConnectionAliasRequestT& request) const { return SubmitCallable(&WorkSpacesClient::AssociateConnectionAlias, request); } /** * An Async wrapper for AssociateConnectionAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateConnectionAliasAsync(const AssociateConnectionAliasRequestT& request, const AssociateConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::AssociateConnectionAlias, request, handler, context); } /** *

Associates the specified IP access control group with the specified * directory.

See Also:

AWS * API Reference

*/ virtual Model::AssociateIpGroupsOutcome AssociateIpGroups(const Model::AssociateIpGroupsRequest& request) const; /** * A Callable wrapper for AssociateIpGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateIpGroupsOutcomeCallable AssociateIpGroupsCallable(const AssociateIpGroupsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::AssociateIpGroups, request); } /** * An Async wrapper for AssociateIpGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateIpGroupsAsync(const AssociateIpGroupsRequestT& request, const AssociateIpGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::AssociateIpGroups, request, handler, context); } /** *

Adds one or more rules to the specified IP access control group.

This * action gives users permission to access their WorkSpaces from the CIDR address * ranges specified in the rules.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeIpRulesOutcome AuthorizeIpRules(const Model::AuthorizeIpRulesRequest& request) const; /** * A Callable wrapper for AuthorizeIpRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeIpRulesOutcomeCallable AuthorizeIpRulesCallable(const AuthorizeIpRulesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::AuthorizeIpRules, request); } /** * An Async wrapper for AuthorizeIpRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeIpRulesAsync(const AuthorizeIpRulesRequestT& request, const AuthorizeIpRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::AuthorizeIpRules, request, handler, context); } /** *

Copies the specified image from the specified Region to the current Region. * For more information about copying images, see * Copy a Custom WorkSpaces Image.

In the China (Ningxia) Region, you * can copy images only within the same Region.

In Amazon Web Services * GovCloud (US), to copy images to and from other Regions, contact Amazon Web * Services Support.

Before copying a shared image, be sure to * verify that it has been shared from the correct Amazon Web Services account. To * determine if an image has been shared and to see the ID of the Amazon Web * Services account that owns an image, use the DescribeWorkSpaceImages * and DescribeWorkspaceImagePermissions * API operations.

See Also:

AWS * API Reference

*/ virtual Model::CopyWorkspaceImageOutcome CopyWorkspaceImage(const Model::CopyWorkspaceImageRequest& request) const; /** * A Callable wrapper for CopyWorkspaceImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyWorkspaceImageOutcomeCallable CopyWorkspaceImageCallable(const CopyWorkspaceImageRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CopyWorkspaceImage, request); } /** * An Async wrapper for CopyWorkspaceImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyWorkspaceImageAsync(const CopyWorkspaceImageRequestT& request, const CopyWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CopyWorkspaceImage, request, handler, context); } /** *

Creates a client-add-in for Amazon Connect within a directory. You can create * only one Amazon Connect client add-in within a directory.

This client * add-in allows WorkSpaces users to seamlessly connect to Amazon * Connect.

See Also:

AWS * API Reference

*/ virtual Model::CreateConnectClientAddInOutcome CreateConnectClientAddIn(const Model::CreateConnectClientAddInRequest& request) const; /** * A Callable wrapper for CreateConnectClientAddIn that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateConnectClientAddInOutcomeCallable CreateConnectClientAddInCallable(const CreateConnectClientAddInRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateConnectClientAddIn, request); } /** * An Async wrapper for CreateConnectClientAddIn that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateConnectClientAddInAsync(const CreateConnectClientAddInRequestT& request, const CreateConnectClientAddInResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateConnectClientAddIn, request, handler, context); } /** *

Creates the specified connection alias for use with cross-Region redirection. * For more information, see * Cross-Region Redirection for Amazon WorkSpaces.

See Also:

* AWS * API Reference

*/ virtual Model::CreateConnectionAliasOutcome CreateConnectionAlias(const Model::CreateConnectionAliasRequest& request) const; /** * A Callable wrapper for CreateConnectionAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateConnectionAliasOutcomeCallable CreateConnectionAliasCallable(const CreateConnectionAliasRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateConnectionAlias, request); } /** * An Async wrapper for CreateConnectionAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateConnectionAliasAsync(const CreateConnectionAliasRequestT& request, const CreateConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateConnectionAlias, request, handler, context); } /** *

Creates an IP access control group.

An IP access control group * provides you with the ability to control the IP addresses from which users are * allowed to access their WorkSpaces. To specify the CIDR address ranges, add * rules to your IP access control group and then associate the group with your * directory. You can add rules when you create the group or at any time using * AuthorizeIpRules.

There is a default IP access control group * associated with your directory. If you don't associate an IP access control * group with your directory, the default group is used. The default group includes * a default rule that allows users to access their WorkSpaces from anywhere. You * cannot modify the default IP access control group for your * directory.

See Also:

AWS * API Reference

*/ virtual Model::CreateIpGroupOutcome CreateIpGroup(const Model::CreateIpGroupRequest& request) const; /** * A Callable wrapper for CreateIpGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateIpGroupOutcomeCallable CreateIpGroupCallable(const CreateIpGroupRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateIpGroup, request); } /** * An Async wrapper for CreateIpGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateIpGroupAsync(const CreateIpGroupRequestT& request, const CreateIpGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateIpGroup, request, handler, context); } /** *

Creates a standby WorkSpace in a secondary Region.

See Also:

* AWS * API Reference

*/ virtual Model::CreateStandbyWorkspacesOutcome CreateStandbyWorkspaces(const Model::CreateStandbyWorkspacesRequest& request) const; /** * A Callable wrapper for CreateStandbyWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStandbyWorkspacesOutcomeCallable CreateStandbyWorkspacesCallable(const CreateStandbyWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateStandbyWorkspaces, request); } /** * An Async wrapper for CreateStandbyWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStandbyWorkspacesAsync(const CreateStandbyWorkspacesRequestT& request, const CreateStandbyWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateStandbyWorkspaces, request, handler, context); } /** *

Creates the specified tags for the specified WorkSpaces * resource.

See Also:

AWS * API Reference

*/ virtual Model::CreateTagsOutcome CreateTags(const Model::CreateTagsRequest& request) const; /** * A Callable wrapper for CreateTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTagsOutcomeCallable CreateTagsCallable(const CreateTagsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateTags, request); } /** * An Async wrapper for CreateTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTagsAsync(const CreateTagsRequestT& request, const CreateTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateTags, request, handler, context); } /** *

Creates a new updated WorkSpace image based on the specified source image. * The new updated WorkSpace image has the latest drivers and other updates * required by the Amazon WorkSpaces components.

To determine which * WorkSpace images need to be updated with the latest Amazon WorkSpaces * requirements, use * DescribeWorkspaceImages.

  • Only Windows 10, Windows * Server 2016, and Windows Server 2019 WorkSpace images can be programmatically * updated at this time.

  • Microsoft Windows updates and other * application updates are not included in the update process.

  • *

    The source WorkSpace image is not deleted. You can delete the source image * after you've verified your new updated image and created a new bundle.

    *

See Also:

AWS * API Reference

*/ virtual Model::CreateUpdatedWorkspaceImageOutcome CreateUpdatedWorkspaceImage(const Model::CreateUpdatedWorkspaceImageRequest& request) const; /** * A Callable wrapper for CreateUpdatedWorkspaceImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUpdatedWorkspaceImageOutcomeCallable CreateUpdatedWorkspaceImageCallable(const CreateUpdatedWorkspaceImageRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateUpdatedWorkspaceImage, request); } /** * An Async wrapper for CreateUpdatedWorkspaceImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUpdatedWorkspaceImageAsync(const CreateUpdatedWorkspaceImageRequestT& request, const CreateUpdatedWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateUpdatedWorkspaceImage, request, handler, context); } /** *

Creates the specified WorkSpace bundle. For more information about creating * WorkSpace bundles, see * Create a Custom WorkSpaces Image and Bundle.

See Also:

AWS * API Reference

*/ virtual Model::CreateWorkspaceBundleOutcome CreateWorkspaceBundle(const Model::CreateWorkspaceBundleRequest& request) const; /** * A Callable wrapper for CreateWorkspaceBundle that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWorkspaceBundleOutcomeCallable CreateWorkspaceBundleCallable(const CreateWorkspaceBundleRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateWorkspaceBundle, request); } /** * An Async wrapper for CreateWorkspaceBundle that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWorkspaceBundleAsync(const CreateWorkspaceBundleRequestT& request, const CreateWorkspaceBundleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateWorkspaceBundle, request, handler, context); } /** *

Creates a new WorkSpace image from an existing WorkSpace.

See * Also:

AWS * API Reference

*/ virtual Model::CreateWorkspaceImageOutcome CreateWorkspaceImage(const Model::CreateWorkspaceImageRequest& request) const; /** * A Callable wrapper for CreateWorkspaceImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWorkspaceImageOutcomeCallable CreateWorkspaceImageCallable(const CreateWorkspaceImageRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateWorkspaceImage, request); } /** * An Async wrapper for CreateWorkspaceImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWorkspaceImageAsync(const CreateWorkspaceImageRequestT& request, const CreateWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateWorkspaceImage, request, handler, context); } /** *

Creates one or more WorkSpaces.

This operation is asynchronous and * returns before the WorkSpaces are created.

The MANUAL * running mode value is only supported by Amazon WorkSpaces Core. Contact your * account team to be allow-listed to use this value. For more information, see Amazon WorkSpaces Core.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateWorkspacesOutcome CreateWorkspaces(const Model::CreateWorkspacesRequest& request) const; /** * A Callable wrapper for CreateWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateWorkspacesOutcomeCallable CreateWorkspacesCallable(const CreateWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::CreateWorkspaces, request); } /** * An Async wrapper for CreateWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateWorkspacesAsync(const CreateWorkspacesRequestT& request, const CreateWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::CreateWorkspaces, request, handler, context); } /** *

Deletes customized client branding. Client branding allows you to customize * your WorkSpace's client login portal. You can tailor your login portal company * logo, the support email address, support link, link to reset password, and a * custom message for users trying to sign in.

After you delete your * customized client branding, your login portal reverts to the default client * branding.

See Also:

AWS * API Reference

*/ virtual Model::DeleteClientBrandingOutcome DeleteClientBranding(const Model::DeleteClientBrandingRequest& request) const; /** * A Callable wrapper for DeleteClientBranding that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteClientBrandingOutcomeCallable DeleteClientBrandingCallable(const DeleteClientBrandingRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeleteClientBranding, request); } /** * An Async wrapper for DeleteClientBranding that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteClientBrandingAsync(const DeleteClientBrandingRequestT& request, const DeleteClientBrandingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeleteClientBranding, request, handler, context); } /** *

Deletes a client-add-in for Amazon Connect that is configured within a * directory.

See Also:

AWS * API Reference

*/ virtual Model::DeleteConnectClientAddInOutcome DeleteConnectClientAddIn(const Model::DeleteConnectClientAddInRequest& request) const; /** * A Callable wrapper for DeleteConnectClientAddIn that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConnectClientAddInOutcomeCallable DeleteConnectClientAddInCallable(const DeleteConnectClientAddInRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeleteConnectClientAddIn, request); } /** * An Async wrapper for DeleteConnectClientAddIn that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConnectClientAddInAsync(const DeleteConnectClientAddInRequestT& request, const DeleteConnectClientAddInResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeleteConnectClientAddIn, request, handler, context); } /** *

Deletes the specified connection alias. For more information, see * Cross-Region Redirection for Amazon WorkSpaces.

If * you will no longer be using a fully qualified domain name (FQDN) as the * registration code for your WorkSpaces users, you must take certain precautions * to prevent potential security issues. For more information, see * Security Considerations if You Stop Using Cross-Region Redirection.

*

To delete a connection alias that has been shared, the * shared account must first disassociate the connection alias from any directories * it has been associated with. Then you must unshare the connection alias from the * account it has been shared with. You can delete a connection alias only after it * is no longer shared with any accounts or associated with any directories.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteConnectionAliasOutcome DeleteConnectionAlias(const Model::DeleteConnectionAliasRequest& request) const; /** * A Callable wrapper for DeleteConnectionAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteConnectionAliasOutcomeCallable DeleteConnectionAliasCallable(const DeleteConnectionAliasRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeleteConnectionAlias, request); } /** * An Async wrapper for DeleteConnectionAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteConnectionAliasAsync(const DeleteConnectionAliasRequestT& request, const DeleteConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeleteConnectionAlias, request, handler, context); } /** *

Deletes the specified IP access control group.

You cannot delete an IP * access control group that is associated with a directory.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteIpGroupOutcome DeleteIpGroup(const Model::DeleteIpGroupRequest& request) const; /** * A Callable wrapper for DeleteIpGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteIpGroupOutcomeCallable DeleteIpGroupCallable(const DeleteIpGroupRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeleteIpGroup, request); } /** * An Async wrapper for DeleteIpGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteIpGroupAsync(const DeleteIpGroupRequestT& request, const DeleteIpGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeleteIpGroup, request, handler, context); } /** *

Deletes the specified tags from the specified WorkSpaces * resource.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTagsOutcome DeleteTags(const Model::DeleteTagsRequest& request) const; /** * A Callable wrapper for DeleteTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTagsOutcomeCallable DeleteTagsCallable(const DeleteTagsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeleteTags, request); } /** * An Async wrapper for DeleteTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTagsAsync(const DeleteTagsRequestT& request, const DeleteTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeleteTags, request, handler, context); } /** *

Deletes the specified WorkSpace bundle. For more information about deleting * WorkSpace bundles, see * Delete a Custom WorkSpaces Bundle or Image.

See Also:

AWS * API Reference

*/ virtual Model::DeleteWorkspaceBundleOutcome DeleteWorkspaceBundle(const Model::DeleteWorkspaceBundleRequest& request) const; /** * A Callable wrapper for DeleteWorkspaceBundle that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteWorkspaceBundleOutcomeCallable DeleteWorkspaceBundleCallable(const DeleteWorkspaceBundleRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeleteWorkspaceBundle, request); } /** * An Async wrapper for DeleteWorkspaceBundle that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteWorkspaceBundleAsync(const DeleteWorkspaceBundleRequestT& request, const DeleteWorkspaceBundleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeleteWorkspaceBundle, request, handler, context); } /** *

Deletes the specified image from your account. To delete an image, you must * first delete any bundles that are associated with the image and unshare the * image if it is shared with other accounts.

See Also:

AWS * API Reference

*/ virtual Model::DeleteWorkspaceImageOutcome DeleteWorkspaceImage(const Model::DeleteWorkspaceImageRequest& request) const; /** * A Callable wrapper for DeleteWorkspaceImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteWorkspaceImageOutcomeCallable DeleteWorkspaceImageCallable(const DeleteWorkspaceImageRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeleteWorkspaceImage, request); } /** * An Async wrapper for DeleteWorkspaceImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteWorkspaceImageAsync(const DeleteWorkspaceImageRequestT& request, const DeleteWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeleteWorkspaceImage, request, handler, context); } /** *

Deregisters the specified directory. This operation is asynchronous and * returns before the WorkSpace directory is deregistered. If any WorkSpaces are * registered to this directory, you must remove them before you can deregister the * directory.

Simple AD and AD Connector are made available to you * free of charge to use with WorkSpaces. If there are no WorkSpaces being used * with your Simple AD or AD Connector directory for 30 consecutive days, this * directory will be automatically deregistered for use with Amazon WorkSpaces, and * you will be charged for this directory as per the Directory Service pricing * terms.

To delete empty directories, see * Delete the Directory for Your WorkSpaces. If you delete your Simple AD or AD * Connector directory, you can always create a new one when you want to start * using WorkSpaces again.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterWorkspaceDirectoryOutcome DeregisterWorkspaceDirectory(const Model::DeregisterWorkspaceDirectoryRequest& request) const; /** * A Callable wrapper for DeregisterWorkspaceDirectory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterWorkspaceDirectoryOutcomeCallable DeregisterWorkspaceDirectoryCallable(const DeregisterWorkspaceDirectoryRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DeregisterWorkspaceDirectory, request); } /** * An Async wrapper for DeregisterWorkspaceDirectory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterWorkspaceDirectoryAsync(const DeregisterWorkspaceDirectoryRequestT& request, const DeregisterWorkspaceDirectoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DeregisterWorkspaceDirectory, request, handler, context); } /** *

Retrieves a list that describes the configuration of Bring Your Own License * (BYOL) for the specified account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountOutcome DescribeAccount(const Model::DescribeAccountRequest& request) const; /** * A Callable wrapper for DescribeAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountOutcomeCallable DescribeAccountCallable(const DescribeAccountRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeAccount, request); } /** * An Async wrapper for DescribeAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountAsync(const DescribeAccountRequestT& request, const DescribeAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeAccount, request, handler, context); } /** *

Retrieves a list that describes modifications to the configuration of Bring * Your Own License (BYOL) for the specified account.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountModificationsOutcome DescribeAccountModifications(const Model::DescribeAccountModificationsRequest& request) const; /** * A Callable wrapper for DescribeAccountModifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountModificationsOutcomeCallable DescribeAccountModificationsCallable(const DescribeAccountModificationsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeAccountModifications, request); } /** * An Async wrapper for DescribeAccountModifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountModificationsAsync(const DescribeAccountModificationsRequestT& request, const DescribeAccountModificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeAccountModifications, request, handler, context); } /** *

Describes the specified client branding. Client branding allows you to * customize the log in page of various device types for your users. You can add * your company logo, the support email address, support link, link to reset * password, and a custom message for users trying to sign in.

Only * device types that have branding information configured will be shown in the * response.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClientBrandingOutcome DescribeClientBranding(const Model::DescribeClientBrandingRequest& request) const; /** * A Callable wrapper for DescribeClientBranding that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClientBrandingOutcomeCallable DescribeClientBrandingCallable(const DescribeClientBrandingRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeClientBranding, request); } /** * An Async wrapper for DescribeClientBranding that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClientBrandingAsync(const DescribeClientBrandingRequestT& request, const DescribeClientBrandingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeClientBranding, request, handler, context); } /** *

Retrieves a list that describes one or more specified Amazon WorkSpaces * clients.

See Also:

AWS * API Reference

*/ virtual Model::DescribeClientPropertiesOutcome DescribeClientProperties(const Model::DescribeClientPropertiesRequest& request) const; /** * A Callable wrapper for DescribeClientProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeClientPropertiesOutcomeCallable DescribeClientPropertiesCallable(const DescribeClientPropertiesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeClientProperties, request); } /** * An Async wrapper for DescribeClientProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeClientPropertiesAsync(const DescribeClientPropertiesRequestT& request, const DescribeClientPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeClientProperties, request, handler, context); } /** *

Retrieves a list of Amazon Connect client add-ins that have been * created.

See Also:

AWS * API Reference

*/ virtual Model::DescribeConnectClientAddInsOutcome DescribeConnectClientAddIns(const Model::DescribeConnectClientAddInsRequest& request) const; /** * A Callable wrapper for DescribeConnectClientAddIns that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConnectClientAddInsOutcomeCallable DescribeConnectClientAddInsCallable(const DescribeConnectClientAddInsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeConnectClientAddIns, request); } /** * An Async wrapper for DescribeConnectClientAddIns that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConnectClientAddInsAsync(const DescribeConnectClientAddInsRequestT& request, const DescribeConnectClientAddInsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeConnectClientAddIns, request, handler, context); } /** *

Describes the permissions that the owner of a connection alias has granted to * another Amazon Web Services account for the specified connection alias. For more * information, see * Cross-Region Redirection for Amazon WorkSpaces.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeConnectionAliasPermissionsOutcome DescribeConnectionAliasPermissions(const Model::DescribeConnectionAliasPermissionsRequest& request) const; /** * A Callable wrapper for DescribeConnectionAliasPermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConnectionAliasPermissionsOutcomeCallable DescribeConnectionAliasPermissionsCallable(const DescribeConnectionAliasPermissionsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeConnectionAliasPermissions, request); } /** * An Async wrapper for DescribeConnectionAliasPermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConnectionAliasPermissionsAsync(const DescribeConnectionAliasPermissionsRequestT& request, const DescribeConnectionAliasPermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeConnectionAliasPermissions, request, handler, context); } /** *

Retrieves a list that describes the connection aliases used for cross-Region * redirection. For more information, see * Cross-Region Redirection for Amazon WorkSpaces.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeConnectionAliasesOutcome DescribeConnectionAliases(const Model::DescribeConnectionAliasesRequest& request) const; /** * A Callable wrapper for DescribeConnectionAliases that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeConnectionAliasesOutcomeCallable DescribeConnectionAliasesCallable(const DescribeConnectionAliasesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeConnectionAliases, request); } /** * An Async wrapper for DescribeConnectionAliases that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeConnectionAliasesAsync(const DescribeConnectionAliasesRequestT& request, const DescribeConnectionAliasesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeConnectionAliases, request, handler, context); } /** *

Describes one or more of your IP access control groups.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeIpGroupsOutcome DescribeIpGroups(const Model::DescribeIpGroupsRequest& request) const; /** * A Callable wrapper for DescribeIpGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeIpGroupsOutcomeCallable DescribeIpGroupsCallable(const DescribeIpGroupsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeIpGroups, request); } /** * An Async wrapper for DescribeIpGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeIpGroupsAsync(const DescribeIpGroupsRequestT& request, const DescribeIpGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeIpGroups, request, handler, context); } /** *

Describes the specified tags for the specified WorkSpaces * resource.

See Also:

AWS * API Reference

*/ virtual Model::DescribeTagsOutcome DescribeTags(const Model::DescribeTagsRequest& request) const; /** * A Callable wrapper for DescribeTags that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeTagsOutcomeCallable DescribeTagsCallable(const DescribeTagsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeTags, request); } /** * An Async wrapper for DescribeTags that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeTagsAsync(const DescribeTagsRequestT& request, const DescribeTagsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeTags, request, handler, context); } /** *

Retrieves a list that describes the available WorkSpace bundles.

You * can filter the results using either bundle ID or owner, but not * both.

See Also:

AWS * API Reference

*/ virtual Model::DescribeWorkspaceBundlesOutcome DescribeWorkspaceBundles(const Model::DescribeWorkspaceBundlesRequest& request) const; /** * A Callable wrapper for DescribeWorkspaceBundles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkspaceBundlesOutcomeCallable DescribeWorkspaceBundlesCallable(const DescribeWorkspaceBundlesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceBundles, request); } /** * An Async wrapper for DescribeWorkspaceBundles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkspaceBundlesAsync(const DescribeWorkspaceBundlesRequestT& request, const DescribeWorkspaceBundlesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceBundles, request, handler, context); } /** *

Describes the available directories that are registered with Amazon * WorkSpaces.

See Also:

AWS * API Reference

*/ virtual Model::DescribeWorkspaceDirectoriesOutcome DescribeWorkspaceDirectories(const Model::DescribeWorkspaceDirectoriesRequest& request) const; /** * A Callable wrapper for DescribeWorkspaceDirectories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkspaceDirectoriesOutcomeCallable DescribeWorkspaceDirectoriesCallable(const DescribeWorkspaceDirectoriesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceDirectories, request); } /** * An Async wrapper for DescribeWorkspaceDirectories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkspaceDirectoriesAsync(const DescribeWorkspaceDirectoriesRequestT& request, const DescribeWorkspaceDirectoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceDirectories, request, handler, context); } /** *

Describes the permissions that the owner of an image has granted to other * Amazon Web Services accounts for an image.

See Also:

AWS * API Reference

*/ virtual Model::DescribeWorkspaceImagePermissionsOutcome DescribeWorkspaceImagePermissions(const Model::DescribeWorkspaceImagePermissionsRequest& request) const; /** * A Callable wrapper for DescribeWorkspaceImagePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkspaceImagePermissionsOutcomeCallable DescribeWorkspaceImagePermissionsCallable(const DescribeWorkspaceImagePermissionsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceImagePermissions, request); } /** * An Async wrapper for DescribeWorkspaceImagePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkspaceImagePermissionsAsync(const DescribeWorkspaceImagePermissionsRequestT& request, const DescribeWorkspaceImagePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceImagePermissions, request, handler, context); } /** *

Retrieves a list that describes one or more specified images, if the image * identifiers are provided. Otherwise, all images in the account are described. *

See Also:

AWS * API Reference

*/ virtual Model::DescribeWorkspaceImagesOutcome DescribeWorkspaceImages(const Model::DescribeWorkspaceImagesRequest& request) const; /** * A Callable wrapper for DescribeWorkspaceImages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkspaceImagesOutcomeCallable DescribeWorkspaceImagesCallable(const DescribeWorkspaceImagesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceImages, request); } /** * An Async wrapper for DescribeWorkspaceImages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkspaceImagesAsync(const DescribeWorkspaceImagesRequestT& request, const DescribeWorkspaceImagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceImages, request, handler, context); } /** *

Describes the snapshots for the specified WorkSpace.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeWorkspaceSnapshotsOutcome DescribeWorkspaceSnapshots(const Model::DescribeWorkspaceSnapshotsRequest& request) const; /** * A Callable wrapper for DescribeWorkspaceSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkspaceSnapshotsOutcomeCallable DescribeWorkspaceSnapshotsCallable(const DescribeWorkspaceSnapshotsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeWorkspaceSnapshots, request); } /** * An Async wrapper for DescribeWorkspaceSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkspaceSnapshotsAsync(const DescribeWorkspaceSnapshotsRequestT& request, const DescribeWorkspaceSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeWorkspaceSnapshots, request, handler, context); } /** *

Describes the specified WorkSpaces.

You can filter the results by * using the bundle identifier, directory identifier, or owner, but you can specify * only one filter at a time.

See Also:

AWS * API Reference

*/ virtual Model::DescribeWorkspacesOutcome DescribeWorkspaces(const Model::DescribeWorkspacesRequest& request) const; /** * A Callable wrapper for DescribeWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkspacesOutcomeCallable DescribeWorkspacesCallable(const DescribeWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeWorkspaces, request); } /** * An Async wrapper for DescribeWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkspacesAsync(const DescribeWorkspacesRequestT& request, const DescribeWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeWorkspaces, request, handler, context); } /** *

Describes the connection status of the specified WorkSpaces.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeWorkspacesConnectionStatusOutcome DescribeWorkspacesConnectionStatus(const Model::DescribeWorkspacesConnectionStatusRequest& request) const; /** * A Callable wrapper for DescribeWorkspacesConnectionStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeWorkspacesConnectionStatusOutcomeCallable DescribeWorkspacesConnectionStatusCallable(const DescribeWorkspacesConnectionStatusRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DescribeWorkspacesConnectionStatus, request); } /** * An Async wrapper for DescribeWorkspacesConnectionStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeWorkspacesConnectionStatusAsync(const DescribeWorkspacesConnectionStatusRequestT& request, const DescribeWorkspacesConnectionStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DescribeWorkspacesConnectionStatus, request, handler, context); } /** *

Disassociates a connection alias from a directory. Disassociating a * connection alias disables cross-Region redirection between two directories in * different Regions. For more information, see * Cross-Region Redirection for Amazon WorkSpaces.

Before * performing this operation, call * DescribeConnectionAliases to make sure that the current state of the * connection alias is CREATED.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateConnectionAliasOutcome DisassociateConnectionAlias(const Model::DisassociateConnectionAliasRequest& request) const; /** * A Callable wrapper for DisassociateConnectionAlias that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateConnectionAliasOutcomeCallable DisassociateConnectionAliasCallable(const DisassociateConnectionAliasRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DisassociateConnectionAlias, request); } /** * An Async wrapper for DisassociateConnectionAlias that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateConnectionAliasAsync(const DisassociateConnectionAliasRequestT& request, const DisassociateConnectionAliasResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DisassociateConnectionAlias, request, handler, context); } /** *

Disassociates the specified IP access control group from the specified * directory.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateIpGroupsOutcome DisassociateIpGroups(const Model::DisassociateIpGroupsRequest& request) const; /** * A Callable wrapper for DisassociateIpGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateIpGroupsOutcomeCallable DisassociateIpGroupsCallable(const DisassociateIpGroupsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::DisassociateIpGroups, request); } /** * An Async wrapper for DisassociateIpGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateIpGroupsAsync(const DisassociateIpGroupsRequestT& request, const DisassociateIpGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::DisassociateIpGroups, request, handler, context); } /** *

Imports client branding. Client branding allows you to customize your * WorkSpace's client login portal. You can tailor your login portal company logo, * the support email address, support link, link to reset password, and a custom * message for users trying to sign in.

After you import client branding, * the default branding experience for the specified platform type is replaced with * the imported experience

  • You must specify at least one * platform type when importing client branding.

  • You can import * up to 6 MB of data with each request. If your request exceeds this limit, you * can import client branding for different platform types using separate * requests.

  • In each platform type, the SupportEmail * and SupportLink parameters are mutually exclusive. You can specify * only one parameter for each platform type, but not both.

  • *

    Imported data can take up to a minute to appear in the WorkSpaces client.

    *

See Also:

AWS * API Reference

*/ virtual Model::ImportClientBrandingOutcome ImportClientBranding(const Model::ImportClientBrandingRequest& request) const; /** * A Callable wrapper for ImportClientBranding that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportClientBrandingOutcomeCallable ImportClientBrandingCallable(const ImportClientBrandingRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ImportClientBranding, request); } /** * An Async wrapper for ImportClientBranding that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportClientBrandingAsync(const ImportClientBrandingRequestT& request, const ImportClientBrandingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ImportClientBranding, request, handler, context); } /** *

Imports the specified Windows 10 or 11 Bring Your Own License (BYOL) image * into Amazon WorkSpaces. The image must be an already licensed Amazon EC2 image * that is in your Amazon Web Services account, and you must own the image. For * more information about creating BYOL images, see * Bring Your Own Windows Desktop Licenses.

See Also:

AWS * API Reference

*/ virtual Model::ImportWorkspaceImageOutcome ImportWorkspaceImage(const Model::ImportWorkspaceImageRequest& request) const; /** * A Callable wrapper for ImportWorkspaceImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ImportWorkspaceImageOutcomeCallable ImportWorkspaceImageCallable(const ImportWorkspaceImageRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ImportWorkspaceImage, request); } /** * An Async wrapper for ImportWorkspaceImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ImportWorkspaceImageAsync(const ImportWorkspaceImageRequestT& request, const ImportWorkspaceImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ImportWorkspaceImage, request, handler, context); } /** *

Retrieves a list of IP address ranges, specified as IPv4 CIDR blocks, that * you can use for the network management interface when you enable Bring Your Own * License (BYOL).

This operation can be run only by Amazon Web Services * accounts that are enabled for BYOL. If your account isn't enabled for BYOL, * you'll receive an AccessDeniedException error.

The * management network interface is connected to a secure Amazon WorkSpaces * management network. It is used for interactive streaming of the WorkSpace * desktop to Amazon WorkSpaces clients, and to allow Amazon WorkSpaces to manage * the WorkSpace.

See Also:

AWS * API Reference

*/ virtual Model::ListAvailableManagementCidrRangesOutcome ListAvailableManagementCidrRanges(const Model::ListAvailableManagementCidrRangesRequest& request) const; /** * A Callable wrapper for ListAvailableManagementCidrRanges that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAvailableManagementCidrRangesOutcomeCallable ListAvailableManagementCidrRangesCallable(const ListAvailableManagementCidrRangesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ListAvailableManagementCidrRanges, request); } /** * An Async wrapper for ListAvailableManagementCidrRanges that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAvailableManagementCidrRangesAsync(const ListAvailableManagementCidrRangesRequestT& request, const ListAvailableManagementCidrRangesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ListAvailableManagementCidrRanges, request, handler, context); } /** *

Migrates a WorkSpace from one operating system or bundle type to another, * while retaining the data on the user volume.

The migration process * recreates the WorkSpace by using a new root volume from the target bundle image * and the user volume from the last available snapshot of the original WorkSpace. * During migration, the original D:\Users\%USERNAME% user profile * folder is renamed to D:\Users\%USERNAME%MMddyyTHHmmss%.NotMigrated. * A new D:\Users\%USERNAME%\ folder is generated by the new OS. * Certain files in the old user profile are moved to the new user profile.

*

For available migration scenarios, details about what happens during * migration, and best practices, see Migrate * a WorkSpace.

See Also:

AWS * API Reference

*/ virtual Model::MigrateWorkspaceOutcome MigrateWorkspace(const Model::MigrateWorkspaceRequest& request) const; /** * A Callable wrapper for MigrateWorkspace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::MigrateWorkspaceOutcomeCallable MigrateWorkspaceCallable(const MigrateWorkspaceRequestT& request) const { return SubmitCallable(&WorkSpacesClient::MigrateWorkspace, request); } /** * An Async wrapper for MigrateWorkspace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void MigrateWorkspaceAsync(const MigrateWorkspaceRequestT& request, const MigrateWorkspaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::MigrateWorkspace, request, handler, context); } /** *

Modifies the configuration of Bring Your Own License (BYOL) for the specified * account.

See Also:

AWS * API Reference

*/ virtual Model::ModifyAccountOutcome ModifyAccount(const Model::ModifyAccountRequest& request) const; /** * A Callable wrapper for ModifyAccount that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyAccountOutcomeCallable ModifyAccountCallable(const ModifyAccountRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifyAccount, request); } /** * An Async wrapper for ModifyAccount that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyAccountAsync(const ModifyAccountRequestT& request, const ModifyAccountResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifyAccount, request, handler, context); } /** *

Modifies the properties of the certificate-based authentication you want to * use with your WorkSpaces.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCertificateBasedAuthPropertiesOutcome ModifyCertificateBasedAuthProperties(const Model::ModifyCertificateBasedAuthPropertiesRequest& request) const; /** * A Callable wrapper for ModifyCertificateBasedAuthProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCertificateBasedAuthPropertiesOutcomeCallable ModifyCertificateBasedAuthPropertiesCallable(const ModifyCertificateBasedAuthPropertiesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifyCertificateBasedAuthProperties, request); } /** * An Async wrapper for ModifyCertificateBasedAuthProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCertificateBasedAuthPropertiesAsync(const ModifyCertificateBasedAuthPropertiesRequestT& request, const ModifyCertificateBasedAuthPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifyCertificateBasedAuthProperties, request, handler, context); } /** *

Modifies the properties of the specified Amazon WorkSpaces * clients.

See Also:

AWS * API Reference

*/ virtual Model::ModifyClientPropertiesOutcome ModifyClientProperties(const Model::ModifyClientPropertiesRequest& request) const; /** * A Callable wrapper for ModifyClientProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyClientPropertiesOutcomeCallable ModifyClientPropertiesCallable(const ModifyClientPropertiesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifyClientProperties, request); } /** * An Async wrapper for ModifyClientProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyClientPropertiesAsync(const ModifyClientPropertiesRequestT& request, const ModifyClientPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifyClientProperties, request, handler, context); } /** *

Modifies multiple properties related to SAML 2.0 authentication, including * the enablement status, user access URL, and relay state parameter name that are * used for configuring federation with an SAML 2.0 identity * provider.

See Also:

AWS * API Reference

*/ virtual Model::ModifySamlPropertiesOutcome ModifySamlProperties(const Model::ModifySamlPropertiesRequest& request) const; /** * A Callable wrapper for ModifySamlProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySamlPropertiesOutcomeCallable ModifySamlPropertiesCallable(const ModifySamlPropertiesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifySamlProperties, request); } /** * An Async wrapper for ModifySamlProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySamlPropertiesAsync(const ModifySamlPropertiesRequestT& request, const ModifySamlPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifySamlProperties, request, handler, context); } /** *

Modifies the self-service WorkSpace management capabilities for your users. * For more information, see Enable * Self-Service WorkSpace Management Capabilities for Your Users.

See * Also:

AWS * API Reference

*/ virtual Model::ModifySelfservicePermissionsOutcome ModifySelfservicePermissions(const Model::ModifySelfservicePermissionsRequest& request) const; /** * A Callable wrapper for ModifySelfservicePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifySelfservicePermissionsOutcomeCallable ModifySelfservicePermissionsCallable(const ModifySelfservicePermissionsRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifySelfservicePermissions, request); } /** * An Async wrapper for ModifySelfservicePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifySelfservicePermissionsAsync(const ModifySelfservicePermissionsRequestT& request, const ModifySelfservicePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifySelfservicePermissions, request, handler, context); } /** *

Specifies which devices and operating systems users can use to access their * WorkSpaces. For more information, see * Control Device Access.

See Also:

AWS * API Reference

*/ virtual Model::ModifyWorkspaceAccessPropertiesOutcome ModifyWorkspaceAccessProperties(const Model::ModifyWorkspaceAccessPropertiesRequest& request) const; /** * A Callable wrapper for ModifyWorkspaceAccessProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyWorkspaceAccessPropertiesOutcomeCallable ModifyWorkspaceAccessPropertiesCallable(const ModifyWorkspaceAccessPropertiesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceAccessProperties, request); } /** * An Async wrapper for ModifyWorkspaceAccessProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyWorkspaceAccessPropertiesAsync(const ModifyWorkspaceAccessPropertiesRequestT& request, const ModifyWorkspaceAccessPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceAccessProperties, request, handler, context); } /** *

Modify the default properties used to create WorkSpaces.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyWorkspaceCreationPropertiesOutcome ModifyWorkspaceCreationProperties(const Model::ModifyWorkspaceCreationPropertiesRequest& request) const; /** * A Callable wrapper for ModifyWorkspaceCreationProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyWorkspaceCreationPropertiesOutcomeCallable ModifyWorkspaceCreationPropertiesCallable(const ModifyWorkspaceCreationPropertiesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceCreationProperties, request); } /** * An Async wrapper for ModifyWorkspaceCreationProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyWorkspaceCreationPropertiesAsync(const ModifyWorkspaceCreationPropertiesRequestT& request, const ModifyWorkspaceCreationPropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceCreationProperties, request, handler, context); } /** *

Modifies the specified WorkSpace properties. For important information about * how to modify the size of the root and user volumes, see * Modify a WorkSpace.

The MANUAL running mode * value is only supported by Amazon WorkSpaces Core. Contact your account team to * be allow-listed to use this value. For more information, see Amazon WorkSpaces Core.

*

See Also:

AWS * API Reference

*/ virtual Model::ModifyWorkspacePropertiesOutcome ModifyWorkspaceProperties(const Model::ModifyWorkspacePropertiesRequest& request) const; /** * A Callable wrapper for ModifyWorkspaceProperties that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyWorkspacePropertiesOutcomeCallable ModifyWorkspacePropertiesCallable(const ModifyWorkspacePropertiesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceProperties, request); } /** * An Async wrapper for ModifyWorkspaceProperties that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyWorkspacePropertiesAsync(const ModifyWorkspacePropertiesRequestT& request, const ModifyWorkspacePropertiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceProperties, request, handler, context); } /** *

Sets the state of the specified WorkSpace.

To maintain a WorkSpace * without being interrupted, set the WorkSpace state to * ADMIN_MAINTENANCE. WorkSpaces in this state do not respond to * requests to reboot, stop, start, rebuild, or restore. An AutoStop WorkSpace in * this state is not stopped. Users cannot log into a WorkSpace in the * ADMIN_MAINTENANCE state.

See Also:

AWS * API Reference

*/ virtual Model::ModifyWorkspaceStateOutcome ModifyWorkspaceState(const Model::ModifyWorkspaceStateRequest& request) const; /** * A Callable wrapper for ModifyWorkspaceState that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyWorkspaceStateOutcomeCallable ModifyWorkspaceStateCallable(const ModifyWorkspaceStateRequestT& request) const { return SubmitCallable(&WorkSpacesClient::ModifyWorkspaceState, request); } /** * An Async wrapper for ModifyWorkspaceState that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyWorkspaceStateAsync(const ModifyWorkspaceStateRequestT& request, const ModifyWorkspaceStateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::ModifyWorkspaceState, request, handler, context); } /** *

Reboots the specified WorkSpaces.

You cannot reboot a WorkSpace unless * its state is AVAILABLE or UNHEALTHY.

This * operation is asynchronous and returns before the WorkSpaces have * rebooted.

See Also:

AWS * API Reference

*/ virtual Model::RebootWorkspacesOutcome RebootWorkspaces(const Model::RebootWorkspacesRequest& request) const; /** * A Callable wrapper for RebootWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootWorkspacesOutcomeCallable RebootWorkspacesCallable(const RebootWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::RebootWorkspaces, request); } /** * An Async wrapper for RebootWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootWorkspacesAsync(const RebootWorkspacesRequestT& request, const RebootWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::RebootWorkspaces, request, handler, context); } /** *

Rebuilds the specified WorkSpace.

You cannot rebuild a WorkSpace * unless its state is AVAILABLE, ERROR, * UNHEALTHY, STOPPED, or REBOOTING.

*

Rebuilding a WorkSpace is a potentially destructive action that can result in * the loss of data. For more information, see Rebuild * a WorkSpace.

This operation is asynchronous and returns before the * WorkSpaces have been completely rebuilt.

See Also:

AWS * API Reference

*/ virtual Model::RebuildWorkspacesOutcome RebuildWorkspaces(const Model::RebuildWorkspacesRequest& request) const; /** * A Callable wrapper for RebuildWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebuildWorkspacesOutcomeCallable RebuildWorkspacesCallable(const RebuildWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::RebuildWorkspaces, request); } /** * An Async wrapper for RebuildWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebuildWorkspacesAsync(const RebuildWorkspacesRequestT& request, const RebuildWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::RebuildWorkspaces, request, handler, context); } /** *

Registers the specified directory. This operation is asynchronous and returns * before the WorkSpace directory is registered. If this is the first time you are * registering a directory, you will need to create the workspaces_DefaultRole role * before you can register a directory. For more information, see * Creating the workspaces_DefaultRole Role.

See Also:

AWS * API Reference

*/ virtual Model::RegisterWorkspaceDirectoryOutcome RegisterWorkspaceDirectory(const Model::RegisterWorkspaceDirectoryRequest& request) const; /** * A Callable wrapper for RegisterWorkspaceDirectory that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterWorkspaceDirectoryOutcomeCallable RegisterWorkspaceDirectoryCallable(const RegisterWorkspaceDirectoryRequestT& request) const { return SubmitCallable(&WorkSpacesClient::RegisterWorkspaceDirectory, request); } /** * An Async wrapper for RegisterWorkspaceDirectory that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterWorkspaceDirectoryAsync(const RegisterWorkspaceDirectoryRequestT& request, const RegisterWorkspaceDirectoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::RegisterWorkspaceDirectory, request, handler, context); } /** *

Restores the specified WorkSpace to its last known healthy state.

You * cannot restore a WorkSpace unless its state is AVAILABLE, * ERROR, UNHEALTHY, or STOPPED.

*

Restoring a WorkSpace is a potentially destructive action that can result in * the loss of data. For more information, see Restore * a WorkSpace.

This operation is asynchronous and returns before the * WorkSpace is completely restored.

See Also:

AWS * API Reference

*/ virtual Model::RestoreWorkspaceOutcome RestoreWorkspace(const Model::RestoreWorkspaceRequest& request) const; /** * A Callable wrapper for RestoreWorkspace that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreWorkspaceOutcomeCallable RestoreWorkspaceCallable(const RestoreWorkspaceRequestT& request) const { return SubmitCallable(&WorkSpacesClient::RestoreWorkspace, request); } /** * An Async wrapper for RestoreWorkspace that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreWorkspaceAsync(const RestoreWorkspaceRequestT& request, const RestoreWorkspaceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::RestoreWorkspace, request, handler, context); } /** *

Removes one or more rules from the specified IP access control * group.

See Also:

AWS * API Reference

*/ virtual Model::RevokeIpRulesOutcome RevokeIpRules(const Model::RevokeIpRulesRequest& request) const; /** * A Callable wrapper for RevokeIpRules that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeIpRulesOutcomeCallable RevokeIpRulesCallable(const RevokeIpRulesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::RevokeIpRules, request); } /** * An Async wrapper for RevokeIpRules that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeIpRulesAsync(const RevokeIpRulesRequestT& request, const RevokeIpRulesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::RevokeIpRules, request, handler, context); } /** *

Starts the specified WorkSpaces.

You cannot start a WorkSpace unless * it has a running mode of AutoStop and a state of * STOPPED.

See Also:

AWS * API Reference

*/ virtual Model::StartWorkspacesOutcome StartWorkspaces(const Model::StartWorkspacesRequest& request) const; /** * A Callable wrapper for StartWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartWorkspacesOutcomeCallable StartWorkspacesCallable(const StartWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::StartWorkspaces, request); } /** * An Async wrapper for StartWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartWorkspacesAsync(const StartWorkspacesRequestT& request, const StartWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::StartWorkspaces, request, handler, context); } /** *

Stops the specified WorkSpaces.

You cannot stop a WorkSpace unless it * has a running mode of AutoStop and a state of * AVAILABLE, IMPAIRED, UNHEALTHY, or * ERROR.

See Also:

AWS * API Reference

*/ virtual Model::StopWorkspacesOutcome StopWorkspaces(const Model::StopWorkspacesRequest& request) const; /** * A Callable wrapper for StopWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopWorkspacesOutcomeCallable StopWorkspacesCallable(const StopWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::StopWorkspaces, request); } /** * An Async wrapper for StopWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopWorkspacesAsync(const StopWorkspacesRequestT& request, const StopWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::StopWorkspaces, request, handler, context); } /** *

Terminates the specified WorkSpaces.

Terminating a * WorkSpace is a permanent action and cannot be undone. The user's data is * destroyed. If you need to archive any user data, contact Amazon Web Services * Support before terminating the WorkSpace.

You can terminate * a WorkSpace that is in any state except SUSPENDED.

This * operation is asynchronous and returns before the WorkSpaces have been completely * terminated. After a WorkSpace is terminated, the TERMINATED state * is returned only briefly before the WorkSpace directory metadata is cleaned up, * so this state is rarely returned. To confirm that a WorkSpace is terminated, * check for the WorkSpace ID by using * DescribeWorkSpaces. If the WorkSpace ID isn't returned, then the WorkSpace * has been successfully terminated.

Simple AD and AD Connector are * made available to you free of charge to use with WorkSpaces. If there are no * WorkSpaces being used with your Simple AD or AD Connector directory for 30 * consecutive days, this directory will be automatically deregistered for use with * Amazon WorkSpaces, and you will be charged for this directory as per the Directory Service pricing * terms.

To delete empty directories, see * Delete the Directory for Your WorkSpaces. If you delete your Simple AD or AD * Connector directory, you can always create a new one when you want to start * using WorkSpaces again.

See Also:

AWS * API Reference

*/ virtual Model::TerminateWorkspacesOutcome TerminateWorkspaces(const Model::TerminateWorkspacesRequest& request) const; /** * A Callable wrapper for TerminateWorkspaces that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TerminateWorkspacesOutcomeCallable TerminateWorkspacesCallable(const TerminateWorkspacesRequestT& request) const { return SubmitCallable(&WorkSpacesClient::TerminateWorkspaces, request); } /** * An Async wrapper for TerminateWorkspaces that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TerminateWorkspacesAsync(const TerminateWorkspacesRequestT& request, const TerminateWorkspacesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::TerminateWorkspaces, request, handler, context); } /** *

Updates a Amazon Connect client add-in. Use this action to update the name * and endpoint URL of a Amazon Connect client add-in.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateConnectClientAddInOutcome UpdateConnectClientAddIn(const Model::UpdateConnectClientAddInRequest& request) const; /** * A Callable wrapper for UpdateConnectClientAddIn that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateConnectClientAddInOutcomeCallable UpdateConnectClientAddInCallable(const UpdateConnectClientAddInRequestT& request) const { return SubmitCallable(&WorkSpacesClient::UpdateConnectClientAddIn, request); } /** * An Async wrapper for UpdateConnectClientAddIn that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateConnectClientAddInAsync(const UpdateConnectClientAddInRequestT& request, const UpdateConnectClientAddInResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::UpdateConnectClientAddIn, request, handler, context); } /** *

Shares or unshares a connection alias with one account by specifying whether * that account has permission to associate the connection alias with a directory. * If the association permission is granted, the connection alias is shared with * that account. If the association permission is revoked, the connection alias is * unshared with the account. For more information, see * Cross-Region Redirection for Amazon WorkSpaces.

  • *

    Before performing this operation, call * DescribeConnectionAliases to make sure that the current state of the * connection alias is CREATED.

  • To delete a * connection alias that has been shared, the shared account must first * disassociate the connection alias from any directories it has been associated * with. Then you must unshare the connection alias from the account it has been * shared with. You can delete a connection alias only after it is no longer shared * with any accounts or associated with any directories.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateConnectionAliasPermissionOutcome UpdateConnectionAliasPermission(const Model::UpdateConnectionAliasPermissionRequest& request) const; /** * A Callable wrapper for UpdateConnectionAliasPermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateConnectionAliasPermissionOutcomeCallable UpdateConnectionAliasPermissionCallable(const UpdateConnectionAliasPermissionRequestT& request) const { return SubmitCallable(&WorkSpacesClient::UpdateConnectionAliasPermission, request); } /** * An Async wrapper for UpdateConnectionAliasPermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateConnectionAliasPermissionAsync(const UpdateConnectionAliasPermissionRequestT& request, const UpdateConnectionAliasPermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::UpdateConnectionAliasPermission, request, handler, context); } /** *

Replaces the current rules of the specified IP access control group with the * specified rules.

See Also:

AWS * API Reference

*/ virtual Model::UpdateRulesOfIpGroupOutcome UpdateRulesOfIpGroup(const Model::UpdateRulesOfIpGroupRequest& request) const; /** * A Callable wrapper for UpdateRulesOfIpGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateRulesOfIpGroupOutcomeCallable UpdateRulesOfIpGroupCallable(const UpdateRulesOfIpGroupRequestT& request) const { return SubmitCallable(&WorkSpacesClient::UpdateRulesOfIpGroup, request); } /** * An Async wrapper for UpdateRulesOfIpGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateRulesOfIpGroupAsync(const UpdateRulesOfIpGroupRequestT& request, const UpdateRulesOfIpGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::UpdateRulesOfIpGroup, request, handler, context); } /** *

Updates a WorkSpace bundle with a new image. For more information about * updating WorkSpace bundles, see * Update a Custom WorkSpaces Bundle.

Existing WorkSpaces * aren't automatically updated when you update the bundle that they're based on. * To update existing WorkSpaces that are based on a bundle that you've updated, * you must either rebuild the WorkSpaces or delete and recreate them.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateWorkspaceBundleOutcome UpdateWorkspaceBundle(const Model::UpdateWorkspaceBundleRequest& request) const; /** * A Callable wrapper for UpdateWorkspaceBundle that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateWorkspaceBundleOutcomeCallable UpdateWorkspaceBundleCallable(const UpdateWorkspaceBundleRequestT& request) const { return SubmitCallable(&WorkSpacesClient::UpdateWorkspaceBundle, request); } /** * An Async wrapper for UpdateWorkspaceBundle that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateWorkspaceBundleAsync(const UpdateWorkspaceBundleRequestT& request, const UpdateWorkspaceBundleResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::UpdateWorkspaceBundle, request, handler, context); } /** *

Shares or unshares an image with one account in the same Amazon Web Services * Region by specifying whether that account has permission to copy the image. If * the copy image permission is granted, the image is shared with that account. If * the copy image permission is revoked, the image is unshared with the * account.

After an image has been shared, the recipient account can copy * the image to other Regions as needed.

In the China (Ningxia) Region, you * can copy images only within the same Region.

In Amazon Web Services * GovCloud (US), to copy images to and from other Regions, contact Amazon Web * Services Support.

For more information about sharing images, see * Share or Unshare a Custom WorkSpaces Image.

  • To * delete an image that has been shared, you must unshare the image before you * delete it.

  • Sharing Bring Your Own License (BYOL) images across * Amazon Web Services accounts isn't supported at this time in Amazon Web Services * GovCloud (US). To share BYOL images across accounts in Amazon Web Services * GovCloud (US), contact Amazon Web Services Support.

*

See Also:

AWS * API Reference

*/ virtual Model::UpdateWorkspaceImagePermissionOutcome UpdateWorkspaceImagePermission(const Model::UpdateWorkspaceImagePermissionRequest& request) const; /** * A Callable wrapper for UpdateWorkspaceImagePermission that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateWorkspaceImagePermissionOutcomeCallable UpdateWorkspaceImagePermissionCallable(const UpdateWorkspaceImagePermissionRequestT& request) const { return SubmitCallable(&WorkSpacesClient::UpdateWorkspaceImagePermission, request); } /** * An Async wrapper for UpdateWorkspaceImagePermission that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateWorkspaceImagePermissionAsync(const UpdateWorkspaceImagePermissionRequestT& request, const UpdateWorkspaceImagePermissionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&WorkSpacesClient::UpdateWorkspaceImagePermission, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const WorkSpacesClientConfiguration& clientConfiguration); WorkSpacesClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace WorkSpaces } // namespace Aws