/** * 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 AppStream { /** * Amazon AppStream 2.0

This is the Amazon AppStream 2.0 * API Reference. This documentation provides descriptions and syntax for each * of the actions and data types in AppStream 2.0. AppStream 2.0 is a fully * managed, secure application streaming service that lets you stream desktop * applications to users without rewriting applications. AppStream 2.0 manages the * AWS resources that are required to host and run your applications, scales * automatically, and provides access to your users on demand.

You * can call the AppStream 2.0 API operations by using an interface VPC endpoint * (interface endpoint). For more information, see Access * AppStream 2.0 API Operations and CLI Commands Through an Interface VPC * Endpoint in the Amazon AppStream 2.0 Administration Guide.

*

To learn more about AppStream 2.0, see the following resources:

* */ class AWS_APPSTREAM_API AppStreamClient : 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 AppStreamClientConfiguration ClientConfigurationType; typedef AppStreamEndpointProvider 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. */ AppStreamClient(const Aws::AppStream::AppStreamClientConfiguration& clientConfiguration = Aws::AppStream::AppStreamClientConfiguration(), 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. */ AppStreamClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::AppStream::AppStreamClientConfiguration& clientConfiguration = Aws::AppStream::AppStreamClientConfiguration()); /** * 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 */ AppStreamClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::AppStream::AppStreamClientConfiguration& clientConfiguration = Aws::AppStream::AppStreamClientConfiguration()); /* 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. */ AppStreamClient(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. */ AppStreamClient(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 */ AppStreamClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~AppStreamClient(); /** *

Associates the specified app block builder with the specified app * block.

See Also:

AWS * API Reference

*/ virtual Model::AssociateAppBlockBuilderAppBlockOutcome AssociateAppBlockBuilderAppBlock(const Model::AssociateAppBlockBuilderAppBlockRequest& request) const; /** * A Callable wrapper for AssociateAppBlockBuilderAppBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateAppBlockBuilderAppBlockOutcomeCallable AssociateAppBlockBuilderAppBlockCallable(const AssociateAppBlockBuilderAppBlockRequestT& request) const { return SubmitCallable(&AppStreamClient::AssociateAppBlockBuilderAppBlock, request); } /** * An Async wrapper for AssociateAppBlockBuilderAppBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateAppBlockBuilderAppBlockAsync(const AssociateAppBlockBuilderAppBlockRequestT& request, const AssociateAppBlockBuilderAppBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::AssociateAppBlockBuilderAppBlock, request, handler, context); } /** *

Associates the specified application with the specified fleet. This is only * supported for Elastic fleets.

See Also:

AWS * API Reference

*/ virtual Model::AssociateApplicationFleetOutcome AssociateApplicationFleet(const Model::AssociateApplicationFleetRequest& request) const; /** * A Callable wrapper for AssociateApplicationFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateApplicationFleetOutcomeCallable AssociateApplicationFleetCallable(const AssociateApplicationFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::AssociateApplicationFleet, request); } /** * An Async wrapper for AssociateApplicationFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateApplicationFleetAsync(const AssociateApplicationFleetRequestT& request, const AssociateApplicationFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::AssociateApplicationFleet, request, handler, context); } /** *

Associates an application to entitle.

See Also:

AWS * API Reference

*/ virtual Model::AssociateApplicationToEntitlementOutcome AssociateApplicationToEntitlement(const Model::AssociateApplicationToEntitlementRequest& request) const; /** * A Callable wrapper for AssociateApplicationToEntitlement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateApplicationToEntitlementOutcomeCallable AssociateApplicationToEntitlementCallable(const AssociateApplicationToEntitlementRequestT& request) const { return SubmitCallable(&AppStreamClient::AssociateApplicationToEntitlement, request); } /** * An Async wrapper for AssociateApplicationToEntitlement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateApplicationToEntitlementAsync(const AssociateApplicationToEntitlementRequestT& request, const AssociateApplicationToEntitlementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::AssociateApplicationToEntitlement, request, handler, context); } /** *

Associates the specified fleet with the specified stack.

See * Also:

AWS * API Reference

*/ virtual Model::AssociateFleetOutcome AssociateFleet(const Model::AssociateFleetRequest& request) const; /** * A Callable wrapper for AssociateFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AssociateFleetOutcomeCallable AssociateFleetCallable(const AssociateFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::AssociateFleet, request); } /** * An Async wrapper for AssociateFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AssociateFleetAsync(const AssociateFleetRequestT& request, const AssociateFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::AssociateFleet, request, handler, context); } /** *

Associates the specified users with the specified stacks. Users in a user * pool cannot be assigned to stacks with fleets that are joined to an Active * Directory domain.

See Also:

AWS * API Reference

*/ virtual Model::BatchAssociateUserStackOutcome BatchAssociateUserStack(const Model::BatchAssociateUserStackRequest& request) const; /** * A Callable wrapper for BatchAssociateUserStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchAssociateUserStackOutcomeCallable BatchAssociateUserStackCallable(const BatchAssociateUserStackRequestT& request) const { return SubmitCallable(&AppStreamClient::BatchAssociateUserStack, request); } /** * An Async wrapper for BatchAssociateUserStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchAssociateUserStackAsync(const BatchAssociateUserStackRequestT& request, const BatchAssociateUserStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::BatchAssociateUserStack, request, handler, context); } /** *

Disassociates the specified users from the specified stacks.

See * Also:

AWS * API Reference

*/ virtual Model::BatchDisassociateUserStackOutcome BatchDisassociateUserStack(const Model::BatchDisassociateUserStackRequest& request) const; /** * A Callable wrapper for BatchDisassociateUserStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BatchDisassociateUserStackOutcomeCallable BatchDisassociateUserStackCallable(const BatchDisassociateUserStackRequestT& request) const { return SubmitCallable(&AppStreamClient::BatchDisassociateUserStack, request); } /** * An Async wrapper for BatchDisassociateUserStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BatchDisassociateUserStackAsync(const BatchDisassociateUserStackRequestT& request, const BatchDisassociateUserStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::BatchDisassociateUserStack, request, handler, context); } /** *

Copies the image within the same region or to a new region within the same * AWS account. Note that any tags you added to the image will not be * copied.

See Also:

AWS * API Reference

*/ virtual Model::CopyImageOutcome CopyImage(const Model::CopyImageRequest& request) const; /** * A Callable wrapper for CopyImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyImageOutcomeCallable CopyImageCallable(const CopyImageRequestT& request) const { return SubmitCallable(&AppStreamClient::CopyImage, request); } /** * An Async wrapper for CopyImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyImageAsync(const CopyImageRequestT& request, const CopyImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CopyImage, request, handler, context); } /** *

Creates an app block.

App blocks are an Amazon AppStream 2.0 resource * that stores the details about the virtual hard disk in an S3 bucket. It also * stores the setup script with details about how to mount the virtual hard disk. * The virtual hard disk includes the application binaries and other files * necessary to launch your applications. Multiple applications can be assigned to * a single app block.

This is only supported for Elastic * fleets.

See Also:

AWS * API Reference

*/ virtual Model::CreateAppBlockOutcome CreateAppBlock(const Model::CreateAppBlockRequest& request) const; /** * A Callable wrapper for CreateAppBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAppBlockOutcomeCallable CreateAppBlockCallable(const CreateAppBlockRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateAppBlock, request); } /** * An Async wrapper for CreateAppBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAppBlockAsync(const CreateAppBlockRequestT& request, const CreateAppBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateAppBlock, request, handler, context); } /** *

Creates an app block builder.

See Also:

AWS * API Reference

*/ virtual Model::CreateAppBlockBuilderOutcome CreateAppBlockBuilder(const Model::CreateAppBlockBuilderRequest& request) const; /** * A Callable wrapper for CreateAppBlockBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAppBlockBuilderOutcomeCallable CreateAppBlockBuilderCallable(const CreateAppBlockBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateAppBlockBuilder, request); } /** * An Async wrapper for CreateAppBlockBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAppBlockBuilderAsync(const CreateAppBlockBuilderRequestT& request, const CreateAppBlockBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateAppBlockBuilder, request, handler, context); } /** *

Creates a URL to start a create app block builder streaming * session.

See Also:

AWS * API Reference

*/ virtual Model::CreateAppBlockBuilderStreamingURLOutcome CreateAppBlockBuilderStreamingURL(const Model::CreateAppBlockBuilderStreamingURLRequest& request) const; /** * A Callable wrapper for CreateAppBlockBuilderStreamingURL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateAppBlockBuilderStreamingURLOutcomeCallable CreateAppBlockBuilderStreamingURLCallable(const CreateAppBlockBuilderStreamingURLRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateAppBlockBuilderStreamingURL, request); } /** * An Async wrapper for CreateAppBlockBuilderStreamingURL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateAppBlockBuilderStreamingURLAsync(const CreateAppBlockBuilderStreamingURLRequestT& request, const CreateAppBlockBuilderStreamingURLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateAppBlockBuilderStreamingURL, request, handler, context); } /** *

Creates an application.

Applications are an Amazon AppStream 2.0 * resource that stores the details about how to launch applications on Elastic * fleet streaming instances. An application consists of the launch details, icon, * and display name. Applications are associated with an app block that contains * the application binaries and other files. The applications assigned to an * Elastic fleet are the applications users can launch.

This is only * supported for Elastic fleets.

See Also:

AWS * API Reference

*/ virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const; /** * A Callable wrapper for CreateApplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateApplication, request); } /** * An Async wrapper for CreateApplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateApplication, request, handler, context); } /** *

Creates a Directory Config object in AppStream 2.0. This object includes the * configuration information required to join fleets and image builders to * Microsoft Active Directory domains.

See Also:

AWS * API Reference

*/ virtual Model::CreateDirectoryConfigOutcome CreateDirectoryConfig(const Model::CreateDirectoryConfigRequest& request) const; /** * A Callable wrapper for CreateDirectoryConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDirectoryConfigOutcomeCallable CreateDirectoryConfigCallable(const CreateDirectoryConfigRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateDirectoryConfig, request); } /** * An Async wrapper for CreateDirectoryConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDirectoryConfigAsync(const CreateDirectoryConfigRequestT& request, const CreateDirectoryConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateDirectoryConfig, request, handler, context); } /** *

Creates a new entitlement. Entitlements control access to specific * applications within a stack, based on user attributes. Entitlements apply to * SAML 2.0 federated user identities. Amazon AppStream 2.0 user pool and streaming * URL users are entitled to all applications in a stack. Entitlements don't apply * to the desktop stream view application, or to applications managed by a dynamic * app provider using the Dynamic Application Framework.

See Also:

* AWS * API Reference

*/ virtual Model::CreateEntitlementOutcome CreateEntitlement(const Model::CreateEntitlementRequest& request) const; /** * A Callable wrapper for CreateEntitlement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEntitlementOutcomeCallable CreateEntitlementCallable(const CreateEntitlementRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateEntitlement, request); } /** * An Async wrapper for CreateEntitlement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEntitlementAsync(const CreateEntitlementRequestT& request, const CreateEntitlementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateEntitlement, request, handler, context); } /** *

Creates a fleet. A fleet consists of streaming instances that your users * access for their applications and desktops.

See Also:

AWS * API Reference

*/ virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const; /** * A Callable wrapper for CreateFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateFleet, request); } /** * An Async wrapper for CreateFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateFleet, request, handler, context); } /** *

Creates an image builder. An image builder is a virtual machine that is used * to create an image.

The initial state of the builder is * PENDING. When it is ready, the state is * RUNNING.

See Also:

AWS * API Reference

*/ virtual Model::CreateImageBuilderOutcome CreateImageBuilder(const Model::CreateImageBuilderRequest& request) const; /** * A Callable wrapper for CreateImageBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateImageBuilderOutcomeCallable CreateImageBuilderCallable(const CreateImageBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateImageBuilder, request); } /** * An Async wrapper for CreateImageBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateImageBuilderAsync(const CreateImageBuilderRequestT& request, const CreateImageBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateImageBuilder, request, handler, context); } /** *

Creates a URL to start an image builder streaming session.

See * Also:

AWS * API Reference

*/ virtual Model::CreateImageBuilderStreamingURLOutcome CreateImageBuilderStreamingURL(const Model::CreateImageBuilderStreamingURLRequest& request) const; /** * A Callable wrapper for CreateImageBuilderStreamingURL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateImageBuilderStreamingURLOutcomeCallable CreateImageBuilderStreamingURLCallable(const CreateImageBuilderStreamingURLRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateImageBuilderStreamingURL, request); } /** * An Async wrapper for CreateImageBuilderStreamingURL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateImageBuilderStreamingURLAsync(const CreateImageBuilderStreamingURLRequestT& request, const CreateImageBuilderStreamingURLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateImageBuilderStreamingURL, request, handler, context); } /** *

Creates a stack to start streaming applications to users. A stack consists of * an associated fleet, user access policies, and storage configurations. *

See Also:

AWS * API Reference

*/ virtual Model::CreateStackOutcome CreateStack(const Model::CreateStackRequest& request) const; /** * A Callable wrapper for CreateStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStackOutcomeCallable CreateStackCallable(const CreateStackRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateStack, request); } /** * An Async wrapper for CreateStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStackAsync(const CreateStackRequestT& request, const CreateStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateStack, request, handler, context); } /** *

Creates a temporary URL to start an AppStream 2.0 streaming session for the * specified user. A streaming URL enables application streaming to be tested * without user setup.

See Also:

AWS * API Reference

*/ virtual Model::CreateStreamingURLOutcome CreateStreamingURL(const Model::CreateStreamingURLRequest& request) const; /** * A Callable wrapper for CreateStreamingURL that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateStreamingURLOutcomeCallable CreateStreamingURLCallable(const CreateStreamingURLRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateStreamingURL, request); } /** * An Async wrapper for CreateStreamingURL that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateStreamingURLAsync(const CreateStreamingURLRequestT& request, const CreateStreamingURLResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateStreamingURL, request, handler, context); } /** *

Creates a new image with the latest Windows operating system updates, driver * updates, and AppStream 2.0 agent software.

For more information, see the * "Update an Image by Using Managed AppStream 2.0 Image Updates" section in Administer * Your AppStream 2.0 Images, in the Amazon AppStream 2.0 Administration * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateUpdatedImageOutcome CreateUpdatedImage(const Model::CreateUpdatedImageRequest& request) const; /** * A Callable wrapper for CreateUpdatedImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUpdatedImageOutcomeCallable CreateUpdatedImageCallable(const CreateUpdatedImageRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateUpdatedImage, request); } /** * An Async wrapper for CreateUpdatedImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUpdatedImageAsync(const CreateUpdatedImageRequestT& request, const CreateUpdatedImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateUpdatedImage, request, handler, context); } /** *

Creates a usage report subscription. Usage reports are generated * daily.

See Also:

AWS * API Reference

*/ virtual Model::CreateUsageReportSubscriptionOutcome CreateUsageReportSubscription(const Model::CreateUsageReportSubscriptionRequest& request) const; /** * A Callable wrapper for CreateUsageReportSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUsageReportSubscriptionOutcomeCallable CreateUsageReportSubscriptionCallable(const CreateUsageReportSubscriptionRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateUsageReportSubscription, request); } /** * An Async wrapper for CreateUsageReportSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUsageReportSubscriptionAsync(const CreateUsageReportSubscriptionRequestT& request, const CreateUsageReportSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateUsageReportSubscription, request, handler, context); } /** *

Creates a new user in the user pool.

See Also:

AWS * API Reference

*/ virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const; /** * A Callable wrapper for CreateUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const { return SubmitCallable(&AppStreamClient::CreateUser, request); } /** * An Async wrapper for CreateUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::CreateUser, request, handler, context); } /** *

Deletes an app block.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAppBlockOutcome DeleteAppBlock(const Model::DeleteAppBlockRequest& request) const; /** * A Callable wrapper for DeleteAppBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAppBlockOutcomeCallable DeleteAppBlockCallable(const DeleteAppBlockRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteAppBlock, request); } /** * An Async wrapper for DeleteAppBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAppBlockAsync(const DeleteAppBlockRequestT& request, const DeleteAppBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteAppBlock, request, handler, context); } /** *

Deletes an app block builder.

An app block builder can only be deleted * when it has no association with an app block.

See Also:

AWS * API Reference

*/ virtual Model::DeleteAppBlockBuilderOutcome DeleteAppBlockBuilder(const Model::DeleteAppBlockBuilderRequest& request) const; /** * A Callable wrapper for DeleteAppBlockBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteAppBlockBuilderOutcomeCallable DeleteAppBlockBuilderCallable(const DeleteAppBlockBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteAppBlockBuilder, request); } /** * An Async wrapper for DeleteAppBlockBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteAppBlockBuilderAsync(const DeleteAppBlockBuilderRequestT& request, const DeleteAppBlockBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteAppBlockBuilder, request, handler, context); } /** *

Deletes an application.

See Also:

AWS * API Reference

*/ virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const; /** * A Callable wrapper for DeleteApplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteApplication, request); } /** * An Async wrapper for DeleteApplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteApplication, request, handler, context); } /** *

Deletes the specified Directory Config object from AppStream 2.0. This object * includes the information required to join streaming instances to an Active * Directory domain.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDirectoryConfigOutcome DeleteDirectoryConfig(const Model::DeleteDirectoryConfigRequest& request) const; /** * A Callable wrapper for DeleteDirectoryConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDirectoryConfigOutcomeCallable DeleteDirectoryConfigCallable(const DeleteDirectoryConfigRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteDirectoryConfig, request); } /** * An Async wrapper for DeleteDirectoryConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDirectoryConfigAsync(const DeleteDirectoryConfigRequestT& request, const DeleteDirectoryConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteDirectoryConfig, request, handler, context); } /** *

Deletes the specified entitlement.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEntitlementOutcome DeleteEntitlement(const Model::DeleteEntitlementRequest& request) const; /** * A Callable wrapper for DeleteEntitlement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEntitlementOutcomeCallable DeleteEntitlementCallable(const DeleteEntitlementRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteEntitlement, request); } /** * An Async wrapper for DeleteEntitlement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEntitlementAsync(const DeleteEntitlementRequestT& request, const DeleteEntitlementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteEntitlement, request, handler, context); } /** *

Deletes the specified fleet.

See Also:

AWS * API Reference

*/ virtual Model::DeleteFleetOutcome DeleteFleet(const Model::DeleteFleetRequest& request) const; /** * A Callable wrapper for DeleteFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteFleetOutcomeCallable DeleteFleetCallable(const DeleteFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteFleet, request); } /** * An Async wrapper for DeleteFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteFleetAsync(const DeleteFleetRequestT& request, const DeleteFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteFleet, request, handler, context); } /** *

Deletes the specified image. You cannot delete an image when it is in use. * After you delete an image, you cannot provision new capacity using the * image.

See Also:

AWS * API Reference

*/ virtual Model::DeleteImageOutcome DeleteImage(const Model::DeleteImageRequest& request) const; /** * A Callable wrapper for DeleteImage that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteImageOutcomeCallable DeleteImageCallable(const DeleteImageRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteImage, request); } /** * An Async wrapper for DeleteImage that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteImageAsync(const DeleteImageRequestT& request, const DeleteImageResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteImage, request, handler, context); } /** *

Deletes the specified image builder and releases the capacity.

See * Also:

AWS * API Reference

*/ virtual Model::DeleteImageBuilderOutcome DeleteImageBuilder(const Model::DeleteImageBuilderRequest& request) const; /** * A Callable wrapper for DeleteImageBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteImageBuilderOutcomeCallable DeleteImageBuilderCallable(const DeleteImageBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteImageBuilder, request); } /** * An Async wrapper for DeleteImageBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteImageBuilderAsync(const DeleteImageBuilderRequestT& request, const DeleteImageBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteImageBuilder, request, handler, context); } /** *

Deletes permissions for the specified private image. After you delete * permissions for an image, AWS accounts to which you previously granted these * permissions can no longer use the image.

See Also:

AWS * API Reference

*/ virtual Model::DeleteImagePermissionsOutcome DeleteImagePermissions(const Model::DeleteImagePermissionsRequest& request) const; /** * A Callable wrapper for DeleteImagePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteImagePermissionsOutcomeCallable DeleteImagePermissionsCallable(const DeleteImagePermissionsRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteImagePermissions, request); } /** * An Async wrapper for DeleteImagePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteImagePermissionsAsync(const DeleteImagePermissionsRequestT& request, const DeleteImagePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteImagePermissions, request, handler, context); } /** *

Deletes the specified stack. After the stack is deleted, the application * streaming environment provided by the stack is no longer available to users. * Also, any reservations made for application streaming sessions for the stack are * released.

See Also:

AWS * API Reference

*/ virtual Model::DeleteStackOutcome DeleteStack(const Model::DeleteStackRequest& request) const; /** * A Callable wrapper for DeleteStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteStackOutcomeCallable DeleteStackCallable(const DeleteStackRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteStack, request); } /** * An Async wrapper for DeleteStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteStackAsync(const DeleteStackRequestT& request, const DeleteStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteStack, request, handler, context); } /** *

Disables usage report generation.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUsageReportSubscriptionOutcome DeleteUsageReportSubscription(const Model::DeleteUsageReportSubscriptionRequest& request) const; /** * A Callable wrapper for DeleteUsageReportSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUsageReportSubscriptionOutcomeCallable DeleteUsageReportSubscriptionCallable(const DeleteUsageReportSubscriptionRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteUsageReportSubscription, request); } /** * An Async wrapper for DeleteUsageReportSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUsageReportSubscriptionAsync(const DeleteUsageReportSubscriptionRequestT& request, const DeleteUsageReportSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteUsageReportSubscription, request, handler, context); } /** *

Deletes a user from the user pool.

See Also:

AWS * API Reference

*/ virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const; /** * A Callable wrapper for DeleteUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const { return SubmitCallable(&AppStreamClient::DeleteUser, request); } /** * An Async wrapper for DeleteUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DeleteUser, request, handler, context); } /** *

Retrieves a list that describes one or more app block builder * associations.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAppBlockBuilderAppBlockAssociationsOutcome DescribeAppBlockBuilderAppBlockAssociations(const Model::DescribeAppBlockBuilderAppBlockAssociationsRequest& request) const; /** * A Callable wrapper for DescribeAppBlockBuilderAppBlockAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAppBlockBuilderAppBlockAssociationsOutcomeCallable DescribeAppBlockBuilderAppBlockAssociationsCallable(const DescribeAppBlockBuilderAppBlockAssociationsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeAppBlockBuilderAppBlockAssociations, request); } /** * An Async wrapper for DescribeAppBlockBuilderAppBlockAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAppBlockBuilderAppBlockAssociationsAsync(const DescribeAppBlockBuilderAppBlockAssociationsRequestT& request, const DescribeAppBlockBuilderAppBlockAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeAppBlockBuilderAppBlockAssociations, request, handler, context); } /** *

Retrieves a list that describes one or more app block builders.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAppBlockBuildersOutcome DescribeAppBlockBuilders(const Model::DescribeAppBlockBuildersRequest& request) const; /** * A Callable wrapper for DescribeAppBlockBuilders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAppBlockBuildersOutcomeCallable DescribeAppBlockBuildersCallable(const DescribeAppBlockBuildersRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeAppBlockBuilders, request); } /** * An Async wrapper for DescribeAppBlockBuilders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAppBlockBuildersAsync(const DescribeAppBlockBuildersRequestT& request, const DescribeAppBlockBuildersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeAppBlockBuilders, request, handler, context); } /** *

Retrieves a list that describes one or more app blocks.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeAppBlocksOutcome DescribeAppBlocks(const Model::DescribeAppBlocksRequest& request) const; /** * A Callable wrapper for DescribeAppBlocks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAppBlocksOutcomeCallable DescribeAppBlocksCallable(const DescribeAppBlocksRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeAppBlocks, request); } /** * An Async wrapper for DescribeAppBlocks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAppBlocksAsync(const DescribeAppBlocksRequestT& request, const DescribeAppBlocksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeAppBlocks, request, handler, context); } /** *

Retrieves a list that describes one or more application fleet associations. * Either ApplicationArn or FleetName must be specified.

See Also:

* AWS * API Reference

*/ virtual Model::DescribeApplicationFleetAssociationsOutcome DescribeApplicationFleetAssociations(const Model::DescribeApplicationFleetAssociationsRequest& request) const; /** * A Callable wrapper for DescribeApplicationFleetAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeApplicationFleetAssociationsOutcomeCallable DescribeApplicationFleetAssociationsCallable(const DescribeApplicationFleetAssociationsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeApplicationFleetAssociations, request); } /** * An Async wrapper for DescribeApplicationFleetAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeApplicationFleetAssociationsAsync(const DescribeApplicationFleetAssociationsRequestT& request, const DescribeApplicationFleetAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeApplicationFleetAssociations, request, handler, context); } /** *

Retrieves a list that describes one or more applications.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeApplicationsOutcome DescribeApplications(const Model::DescribeApplicationsRequest& request) const; /** * A Callable wrapper for DescribeApplications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeApplicationsOutcomeCallable DescribeApplicationsCallable(const DescribeApplicationsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeApplications, request); } /** * An Async wrapper for DescribeApplications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeApplicationsAsync(const DescribeApplicationsRequestT& request, const DescribeApplicationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeApplications, request, handler, context); } /** *

Retrieves a list that describes one or more specified Directory Config * objects for AppStream 2.0, if the names for these objects are provided. * Otherwise, all Directory Config objects in the account are described. These * objects include the configuration information required to join fleets and image * builders to Microsoft Active Directory domains.

Although the response * syntax in this topic includes the account password, this password is not * returned in the actual response.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDirectoryConfigsOutcome DescribeDirectoryConfigs(const Model::DescribeDirectoryConfigsRequest& request) const; /** * A Callable wrapper for DescribeDirectoryConfigs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDirectoryConfigsOutcomeCallable DescribeDirectoryConfigsCallable(const DescribeDirectoryConfigsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeDirectoryConfigs, request); } /** * An Async wrapper for DescribeDirectoryConfigs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDirectoryConfigsAsync(const DescribeDirectoryConfigsRequestT& request, const DescribeDirectoryConfigsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeDirectoryConfigs, request, handler, context); } /** *

Retrieves a list that describes one of more entitlements.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeEntitlementsOutcome DescribeEntitlements(const Model::DescribeEntitlementsRequest& request) const; /** * A Callable wrapper for DescribeEntitlements that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEntitlementsOutcomeCallable DescribeEntitlementsCallable(const DescribeEntitlementsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeEntitlements, request); } /** * An Async wrapper for DescribeEntitlements that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEntitlementsAsync(const DescribeEntitlementsRequestT& request, const DescribeEntitlementsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeEntitlements, request, handler, context); } /** *

Retrieves a list that describes one or more specified fleets, if the fleet * names are provided. Otherwise, all fleets in the account are * described.

See Also:

AWS * API Reference

*/ virtual Model::DescribeFleetsOutcome DescribeFleets(const Model::DescribeFleetsRequest& request) const; /** * A Callable wrapper for DescribeFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeFleetsOutcomeCallable DescribeFleetsCallable(const DescribeFleetsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeFleets, request); } /** * An Async wrapper for DescribeFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeFleetsAsync(const DescribeFleetsRequestT& request, const DescribeFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeFleets, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::DescribeImageBuildersOutcome DescribeImageBuilders(const Model::DescribeImageBuildersRequest& request) const; /** * A Callable wrapper for DescribeImageBuilders that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImageBuildersOutcomeCallable DescribeImageBuildersCallable(const DescribeImageBuildersRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeImageBuilders, request); } /** * An Async wrapper for DescribeImageBuilders that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImageBuildersAsync(const DescribeImageBuildersRequestT& request, const DescribeImageBuildersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeImageBuilders, request, handler, context); } /** *

Retrieves a list that describes the permissions for shared AWS account IDs on * a private image that you own.

See Also:

AWS * API Reference

*/ virtual Model::DescribeImagePermissionsOutcome DescribeImagePermissions(const Model::DescribeImagePermissionsRequest& request) const; /** * A Callable wrapper for DescribeImagePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImagePermissionsOutcomeCallable DescribeImagePermissionsCallable(const DescribeImagePermissionsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeImagePermissions, request); } /** * An Async wrapper for DescribeImagePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImagePermissionsAsync(const DescribeImagePermissionsRequestT& request, const DescribeImagePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeImagePermissions, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::DescribeImagesOutcome DescribeImages(const Model::DescribeImagesRequest& request) const; /** * A Callable wrapper for DescribeImages that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeImagesOutcomeCallable DescribeImagesCallable(const DescribeImagesRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeImages, request); } /** * An Async wrapper for DescribeImages that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeImagesAsync(const DescribeImagesRequestT& request, const DescribeImagesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeImages, request, handler, context); } /** *

Retrieves a list that describes the streaming sessions for a specified stack * and fleet. If a UserId is provided for the stack and fleet, only streaming * sessions for that user are described. If an authentication type is not provided, * the default is to authenticate users using a streaming URL.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeSessionsOutcome DescribeSessions(const Model::DescribeSessionsRequest& request) const; /** * A Callable wrapper for DescribeSessions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSessionsOutcomeCallable DescribeSessionsCallable(const DescribeSessionsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeSessions, request); } /** * An Async wrapper for DescribeSessions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSessionsAsync(const DescribeSessionsRequestT& request, const DescribeSessionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeSessions, request, handler, context); } /** *

Retrieves a list that describes one or more specified stacks, if the stack * names are provided. Otherwise, all stacks in the account are * described.

See Also:

AWS * API Reference

*/ virtual Model::DescribeStacksOutcome DescribeStacks(const Model::DescribeStacksRequest& request) const; /** * A Callable wrapper for DescribeStacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeStacksOutcomeCallable DescribeStacksCallable(const DescribeStacksRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeStacks, request); } /** * An Async wrapper for DescribeStacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeStacksAsync(const DescribeStacksRequestT& request, const DescribeStacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeStacks, request, handler, context); } /** *

Retrieves a list that describes one or more usage report * subscriptions.

See Also:

AWS * API Reference

*/ virtual Model::DescribeUsageReportSubscriptionsOutcome DescribeUsageReportSubscriptions(const Model::DescribeUsageReportSubscriptionsRequest& request) const; /** * A Callable wrapper for DescribeUsageReportSubscriptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUsageReportSubscriptionsOutcomeCallable DescribeUsageReportSubscriptionsCallable(const DescribeUsageReportSubscriptionsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeUsageReportSubscriptions, request); } /** * An Async wrapper for DescribeUsageReportSubscriptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUsageReportSubscriptionsAsync(const DescribeUsageReportSubscriptionsRequestT& request, const DescribeUsageReportSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeUsageReportSubscriptions, request, handler, context); } /** *

Retrieves a list that describes the UserStackAssociation objects. You must * specify either or both of the following:

  • The stack name

    *

  • The user name (email address of the user associated with the * stack) and the authentication type for the user

See * Also:

AWS * API Reference

*/ virtual Model::DescribeUserStackAssociationsOutcome DescribeUserStackAssociations(const Model::DescribeUserStackAssociationsRequest& request) const; /** * A Callable wrapper for DescribeUserStackAssociations that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUserStackAssociationsOutcomeCallable DescribeUserStackAssociationsCallable(const DescribeUserStackAssociationsRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeUserStackAssociations, request); } /** * An Async wrapper for DescribeUserStackAssociations that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUserStackAssociationsAsync(const DescribeUserStackAssociationsRequestT& request, const DescribeUserStackAssociationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeUserStackAssociations, request, handler, context); } /** *

Retrieves a list that describes one or more specified users in the user * pool.

See Also:

AWS * API Reference

*/ virtual Model::DescribeUsersOutcome DescribeUsers(const Model::DescribeUsersRequest& request) const; /** * A Callable wrapper for DescribeUsers that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeUsersOutcomeCallable DescribeUsersCallable(const DescribeUsersRequestT& request) const { return SubmitCallable(&AppStreamClient::DescribeUsers, request); } /** * An Async wrapper for DescribeUsers that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeUsersAsync(const DescribeUsersRequestT& request, const DescribeUsersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DescribeUsers, request, handler, context); } /** *

Disables the specified user in the user pool. Users can't sign in to * AppStream 2.0 until they are re-enabled. This action does not delete the user. *

See Also:

AWS * API Reference

*/ virtual Model::DisableUserOutcome DisableUser(const Model::DisableUserRequest& request) const; /** * A Callable wrapper for DisableUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisableUserOutcomeCallable DisableUserCallable(const DisableUserRequestT& request) const { return SubmitCallable(&AppStreamClient::DisableUser, request); } /** * An Async wrapper for DisableUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisableUserAsync(const DisableUserRequestT& request, const DisableUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DisableUser, request, handler, context); } /** *

Disassociates a specified app block builder from a specified app * block.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateAppBlockBuilderAppBlockOutcome DisassociateAppBlockBuilderAppBlock(const Model::DisassociateAppBlockBuilderAppBlockRequest& request) const; /** * A Callable wrapper for DisassociateAppBlockBuilderAppBlock that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateAppBlockBuilderAppBlockOutcomeCallable DisassociateAppBlockBuilderAppBlockCallable(const DisassociateAppBlockBuilderAppBlockRequestT& request) const { return SubmitCallable(&AppStreamClient::DisassociateAppBlockBuilderAppBlock, request); } /** * An Async wrapper for DisassociateAppBlockBuilderAppBlock that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateAppBlockBuilderAppBlockAsync(const DisassociateAppBlockBuilderAppBlockRequestT& request, const DisassociateAppBlockBuilderAppBlockResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DisassociateAppBlockBuilderAppBlock, request, handler, context); } /** *

Disassociates the specified application from the fleet.

See * Also:

AWS * API Reference

*/ virtual Model::DisassociateApplicationFleetOutcome DisassociateApplicationFleet(const Model::DisassociateApplicationFleetRequest& request) const; /** * A Callable wrapper for DisassociateApplicationFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateApplicationFleetOutcomeCallable DisassociateApplicationFleetCallable(const DisassociateApplicationFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::DisassociateApplicationFleet, request); } /** * An Async wrapper for DisassociateApplicationFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateApplicationFleetAsync(const DisassociateApplicationFleetRequestT& request, const DisassociateApplicationFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DisassociateApplicationFleet, request, handler, context); } /** *

Deletes the specified application from the specified * entitlement.

See Also:

AWS * API Reference

*/ virtual Model::DisassociateApplicationFromEntitlementOutcome DisassociateApplicationFromEntitlement(const Model::DisassociateApplicationFromEntitlementRequest& request) const; /** * A Callable wrapper for DisassociateApplicationFromEntitlement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateApplicationFromEntitlementOutcomeCallable DisassociateApplicationFromEntitlementCallable(const DisassociateApplicationFromEntitlementRequestT& request) const { return SubmitCallable(&AppStreamClient::DisassociateApplicationFromEntitlement, request); } /** * An Async wrapper for DisassociateApplicationFromEntitlement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateApplicationFromEntitlementAsync(const DisassociateApplicationFromEntitlementRequestT& request, const DisassociateApplicationFromEntitlementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DisassociateApplicationFromEntitlement, request, handler, context); } /** *

Disassociates the specified fleet from the specified stack.

See * Also:

AWS * API Reference

*/ virtual Model::DisassociateFleetOutcome DisassociateFleet(const Model::DisassociateFleetRequest& request) const; /** * A Callable wrapper for DisassociateFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DisassociateFleetOutcomeCallable DisassociateFleetCallable(const DisassociateFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::DisassociateFleet, request); } /** * An Async wrapper for DisassociateFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DisassociateFleetAsync(const DisassociateFleetRequestT& request, const DisassociateFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::DisassociateFleet, request, handler, context); } /** *

Enables a user in the user pool. After being enabled, users can sign in to * AppStream 2.0 and open applications from the stacks to which they are * assigned.

See Also:

AWS * API Reference

*/ virtual Model::EnableUserOutcome EnableUser(const Model::EnableUserRequest& request) const; /** * A Callable wrapper for EnableUser that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::EnableUserOutcomeCallable EnableUserCallable(const EnableUserRequestT& request) const { return SubmitCallable(&AppStreamClient::EnableUser, request); } /** * An Async wrapper for EnableUser that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void EnableUserAsync(const EnableUserRequestT& request, const EnableUserResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::EnableUser, request, handler, context); } /** *

Immediately stops the specified streaming session.

See Also:

* AWS * API Reference

*/ virtual Model::ExpireSessionOutcome ExpireSession(const Model::ExpireSessionRequest& request) const; /** * A Callable wrapper for ExpireSession that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ExpireSessionOutcomeCallable ExpireSessionCallable(const ExpireSessionRequestT& request) const { return SubmitCallable(&AppStreamClient::ExpireSession, request); } /** * An Async wrapper for ExpireSession that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ExpireSessionAsync(const ExpireSessionRequestT& request, const ExpireSessionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::ExpireSession, request, handler, context); } /** *

Retrieves the name of the fleet that is associated with the specified * stack.

See Also:

AWS * API Reference

*/ virtual Model::ListAssociatedFleetsOutcome ListAssociatedFleets(const Model::ListAssociatedFleetsRequest& request) const; /** * A Callable wrapper for ListAssociatedFleets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssociatedFleetsOutcomeCallable ListAssociatedFleetsCallable(const ListAssociatedFleetsRequestT& request) const { return SubmitCallable(&AppStreamClient::ListAssociatedFleets, request); } /** * An Async wrapper for ListAssociatedFleets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssociatedFleetsAsync(const ListAssociatedFleetsRequestT& request, const ListAssociatedFleetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::ListAssociatedFleets, request, handler, context); } /** *

Retrieves the name of the stack with which the specified fleet is * associated.

See Also:

AWS * API Reference

*/ virtual Model::ListAssociatedStacksOutcome ListAssociatedStacks(const Model::ListAssociatedStacksRequest& request) const; /** * A Callable wrapper for ListAssociatedStacks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListAssociatedStacksOutcomeCallable ListAssociatedStacksCallable(const ListAssociatedStacksRequestT& request) const { return SubmitCallable(&AppStreamClient::ListAssociatedStacks, request); } /** * An Async wrapper for ListAssociatedStacks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListAssociatedStacksAsync(const ListAssociatedStacksRequestT& request, const ListAssociatedStacksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::ListAssociatedStacks, request, handler, context); } /** *

Retrieves a list of entitled applications.

See Also:

AWS * API Reference

*/ virtual Model::ListEntitledApplicationsOutcome ListEntitledApplications(const Model::ListEntitledApplicationsRequest& request) const; /** * A Callable wrapper for ListEntitledApplications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEntitledApplicationsOutcomeCallable ListEntitledApplicationsCallable(const ListEntitledApplicationsRequestT& request) const { return SubmitCallable(&AppStreamClient::ListEntitledApplications, request); } /** * An Async wrapper for ListEntitledApplications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEntitledApplicationsAsync(const ListEntitledApplicationsRequestT& request, const ListEntitledApplicationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::ListEntitledApplications, request, handler, context); } /** *

Retrieves a list of all tags for the specified AppStream 2.0 resource. You * can tag AppStream 2.0 image builders, images, fleets, and stacks.

For * more information about tags, see Tagging * Your Resources in the Amazon AppStream 2.0 Administration * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&AppStreamClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::ListTagsForResource, request, handler, context); } /** *

Starts an app block builder.

An app block builder can only be started * when it's associated with an app block.

Starting an app block builder * starts a new instance, which is equivalent to an elastic fleet instance with * application builder assistance functionality.

See Also:

AWS * API Reference

*/ virtual Model::StartAppBlockBuilderOutcome StartAppBlockBuilder(const Model::StartAppBlockBuilderRequest& request) const; /** * A Callable wrapper for StartAppBlockBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartAppBlockBuilderOutcomeCallable StartAppBlockBuilderCallable(const StartAppBlockBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::StartAppBlockBuilder, request); } /** * An Async wrapper for StartAppBlockBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartAppBlockBuilderAsync(const StartAppBlockBuilderRequestT& request, const StartAppBlockBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::StartAppBlockBuilder, request, handler, context); } /** *

Starts the specified fleet.

See Also:

AWS * API Reference

*/ virtual Model::StartFleetOutcome StartFleet(const Model::StartFleetRequest& request) const; /** * A Callable wrapper for StartFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartFleetOutcomeCallable StartFleetCallable(const StartFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::StartFleet, request); } /** * An Async wrapper for StartFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartFleetAsync(const StartFleetRequestT& request, const StartFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::StartFleet, request, handler, context); } /** *

Starts the specified image builder.

See Also:

AWS * API Reference

*/ virtual Model::StartImageBuilderOutcome StartImageBuilder(const Model::StartImageBuilderRequest& request) const; /** * A Callable wrapper for StartImageBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartImageBuilderOutcomeCallable StartImageBuilderCallable(const StartImageBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::StartImageBuilder, request); } /** * An Async wrapper for StartImageBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartImageBuilderAsync(const StartImageBuilderRequestT& request, const StartImageBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::StartImageBuilder, request, handler, context); } /** *

Stops an app block builder.

Stopping an app block builder terminates * the instance, and the instance state is not persisted.

See Also:

* AWS * API Reference

*/ virtual Model::StopAppBlockBuilderOutcome StopAppBlockBuilder(const Model::StopAppBlockBuilderRequest& request) const; /** * A Callable wrapper for StopAppBlockBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopAppBlockBuilderOutcomeCallable StopAppBlockBuilderCallable(const StopAppBlockBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::StopAppBlockBuilder, request); } /** * An Async wrapper for StopAppBlockBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopAppBlockBuilderAsync(const StopAppBlockBuilderRequestT& request, const StopAppBlockBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::StopAppBlockBuilder, request, handler, context); } /** *

Stops the specified fleet.

See Also:

AWS * API Reference

*/ virtual Model::StopFleetOutcome StopFleet(const Model::StopFleetRequest& request) const; /** * A Callable wrapper for StopFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopFleetOutcomeCallable StopFleetCallable(const StopFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::StopFleet, request); } /** * An Async wrapper for StopFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopFleetAsync(const StopFleetRequestT& request, const StopFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::StopFleet, request, handler, context); } /** *

Stops the specified image builder.

See Also:

AWS * API Reference

*/ virtual Model::StopImageBuilderOutcome StopImageBuilder(const Model::StopImageBuilderRequest& request) const; /** * A Callable wrapper for StopImageBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopImageBuilderOutcomeCallable StopImageBuilderCallable(const StopImageBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::StopImageBuilder, request); } /** * An Async wrapper for StopImageBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopImageBuilderAsync(const StopImageBuilderRequestT& request, const StopImageBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::StopImageBuilder, request, handler, context); } /** *

Adds or overwrites one or more tags for the specified AppStream 2.0 resource. * You can tag AppStream 2.0 image builders, images, fleets, and stacks.

*

Each tag consists of a key and an optional value. If a resource already has a * tag with the same key, this operation updates its value.

To list the * current tags for your resources, use ListTagsForResource. To disassociate * tags from your resources, use UntagResource.

For more information * about tags, see Tagging * Your Resources in the Amazon AppStream 2.0 Administration * Guide.

See Also:

AWS * API Reference

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&AppStreamClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::TagResource, request, handler, context); } /** *

Disassociates one or more specified tags from the specified AppStream 2.0 * resource.

To list the current tags for your resources, use * ListTagsForResource.

For more information about tags, see Tagging * Your Resources in the Amazon AppStream 2.0 Administration * Guide.

See Also:

AWS * API Reference

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&AppStreamClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UntagResource, request, handler, context); } /** *

Updates an app block builder.

If the app block builder is in the * STARTING or STOPPING state, you can't update it. If * the app block builder is in the RUNNING state, you can only update * the DisplayName and Description. If the app block builder is in the * STOPPED state, you can update any attribute except the * Name.

See Also:

AWS * API Reference

*/ virtual Model::UpdateAppBlockBuilderOutcome UpdateAppBlockBuilder(const Model::UpdateAppBlockBuilderRequest& request) const; /** * A Callable wrapper for UpdateAppBlockBuilder that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAppBlockBuilderOutcomeCallable UpdateAppBlockBuilderCallable(const UpdateAppBlockBuilderRequestT& request) const { return SubmitCallable(&AppStreamClient::UpdateAppBlockBuilder, request); } /** * An Async wrapper for UpdateAppBlockBuilder that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAppBlockBuilderAsync(const UpdateAppBlockBuilderRequestT& request, const UpdateAppBlockBuilderResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UpdateAppBlockBuilder, request, handler, context); } /** *

Updates the specified application.

See Also:

AWS * API Reference

*/ virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const; /** * A Callable wrapper for UpdateApplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const { return SubmitCallable(&AppStreamClient::UpdateApplication, request); } /** * An Async wrapper for UpdateApplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UpdateApplication, request, handler, context); } /** *

Updates the specified Directory Config object in AppStream 2.0. This object * includes the configuration information required to join fleets and image * builders to Microsoft Active Directory domains.

See Also:

AWS * API Reference

*/ virtual Model::UpdateDirectoryConfigOutcome UpdateDirectoryConfig(const Model::UpdateDirectoryConfigRequest& request) const; /** * A Callable wrapper for UpdateDirectoryConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateDirectoryConfigOutcomeCallable UpdateDirectoryConfigCallable(const UpdateDirectoryConfigRequestT& request) const { return SubmitCallable(&AppStreamClient::UpdateDirectoryConfig, request); } /** * An Async wrapper for UpdateDirectoryConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateDirectoryConfigAsync(const UpdateDirectoryConfigRequestT& request, const UpdateDirectoryConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UpdateDirectoryConfig, request, handler, context); } /** *

Updates the specified entitlement.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEntitlementOutcome UpdateEntitlement(const Model::UpdateEntitlementRequest& request) const; /** * A Callable wrapper for UpdateEntitlement that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEntitlementOutcomeCallable UpdateEntitlementCallable(const UpdateEntitlementRequestT& request) const { return SubmitCallable(&AppStreamClient::UpdateEntitlement, request); } /** * An Async wrapper for UpdateEntitlement that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEntitlementAsync(const UpdateEntitlementRequestT& request, const UpdateEntitlementResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UpdateEntitlement, request, handler, context); } /** *

Updates the specified fleet.

If the fleet is in the * STOPPED state, you can update any attribute except the fleet * name.

If the fleet is in the RUNNING state, you can update * the following based on the fleet type:

  • Always-On and On-Demand * fleet types

    You can update the DisplayName, * ComputeCapacity, ImageARN, ImageName, * IdleDisconnectTimeoutInSeconds, and * DisconnectTimeoutInSeconds attributes.

  • Elastic * fleet type

    You can update the DisplayName, * IdleDisconnectTimeoutInSeconds, * DisconnectTimeoutInSeconds, MaxConcurrentSessions, * SessionScriptS3Location and UsbDeviceFilterStrings * attributes.

If the fleet is in the STARTING or * STOPPED state, you can't update it.

See Also:

AWS * API Reference

*/ virtual Model::UpdateFleetOutcome UpdateFleet(const Model::UpdateFleetRequest& request) const; /** * A Callable wrapper for UpdateFleet that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateFleetOutcomeCallable UpdateFleetCallable(const UpdateFleetRequestT& request) const { return SubmitCallable(&AppStreamClient::UpdateFleet, request); } /** * An Async wrapper for UpdateFleet that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateFleetAsync(const UpdateFleetRequestT& request, const UpdateFleetResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UpdateFleet, request, handler, context); } /** *

Adds or updates permissions for the specified private image.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateImagePermissionsOutcome UpdateImagePermissions(const Model::UpdateImagePermissionsRequest& request) const; /** * A Callable wrapper for UpdateImagePermissions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateImagePermissionsOutcomeCallable UpdateImagePermissionsCallable(const UpdateImagePermissionsRequestT& request) const { return SubmitCallable(&AppStreamClient::UpdateImagePermissions, request); } /** * An Async wrapper for UpdateImagePermissions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateImagePermissionsAsync(const UpdateImagePermissionsRequestT& request, const UpdateImagePermissionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UpdateImagePermissions, request, handler, context); } /** *

Updates the specified fields for the specified stack.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateStackOutcome UpdateStack(const Model::UpdateStackRequest& request) const; /** * A Callable wrapper for UpdateStack that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateStackOutcomeCallable UpdateStackCallable(const UpdateStackRequestT& request) const { return SubmitCallable(&AppStreamClient::UpdateStack, request); } /** * An Async wrapper for UpdateStack that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateStackAsync(const UpdateStackRequestT& request, const UpdateStackResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&AppStreamClient::UpdateStack, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const AppStreamClientConfiguration& clientConfiguration); AppStreamClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace AppStream } // namespace Aws