AppStreamClient.h

 
#pragma once
#include <aws/appstream/AppStreamServiceClientModel.h>
#include <aws/appstream/AppStream_EXPORTS.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
 
namespace Aws {
namespace AppStream {
class AWS_APPSTREAM_API AppStreamClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<AppStreamClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AppStreamClientConfiguration ClientConfigurationType;
  typedef AppStreamEndpointProvider EndpointProviderType;
 
  AppStreamClient(const Aws::AppStream::AppStreamClientConfiguration& clientConfiguration = Aws::AppStream::AppStreamClientConfiguration(),
                  std::shared_ptr<AppStreamEndpointProviderBase> endpointProvider = nullptr);
 
  AppStreamClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<AppStreamEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::AppStream::AppStreamClientConfiguration& clientConfiguration = Aws::AppStream::AppStreamClientConfiguration());
 
  AppStreamClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<AppStreamEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::AppStream::AppStreamClientConfiguration& clientConfiguration = Aws::AppStream::AppStreamClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AppStreamClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppStreamClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AppStreamClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AppStreamClient();
 
  virtual Model::AssociateAppBlockBuilderAppBlockOutcome AssociateAppBlockBuilderAppBlock(
      const Model::AssociateAppBlockBuilderAppBlockRequest& request) const;
 
  template <typename AssociateAppBlockBuilderAppBlockRequestT = Model::AssociateAppBlockBuilderAppBlockRequest>
  Model::AssociateAppBlockBuilderAppBlockOutcomeCallable AssociateAppBlockBuilderAppBlockCallable(
      const AssociateAppBlockBuilderAppBlockRequestT& request) const {
    return SubmitCallable(&AppStreamClient::AssociateAppBlockBuilderAppBlock, request);
  }
 
  template <typename AssociateAppBlockBuilderAppBlockRequestT = Model::AssociateAppBlockBuilderAppBlockRequest>
  void AssociateAppBlockBuilderAppBlockAsync(const AssociateAppBlockBuilderAppBlockRequestT& request,
                                             const AssociateAppBlockBuilderAppBlockResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::AssociateAppBlockBuilderAppBlock, request, handler, context);
  }
 
  virtual Model::AssociateApplicationFleetOutcome AssociateApplicationFleet(const Model::AssociateApplicationFleetRequest& request) const;
 
  template <typename AssociateApplicationFleetRequestT = Model::AssociateApplicationFleetRequest>
  Model::AssociateApplicationFleetOutcomeCallable AssociateApplicationFleetCallable(
      const AssociateApplicationFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::AssociateApplicationFleet, request);
  }
 
  template <typename AssociateApplicationFleetRequestT = Model::AssociateApplicationFleetRequest>
  void AssociateApplicationFleetAsync(const AssociateApplicationFleetRequestT& request,
                                      const AssociateApplicationFleetResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::AssociateApplicationFleet, request, handler, context);
  }
 
  virtual Model::AssociateApplicationToEntitlementOutcome AssociateApplicationToEntitlement(
      const Model::AssociateApplicationToEntitlementRequest& request) const;
 
  template <typename AssociateApplicationToEntitlementRequestT = Model::AssociateApplicationToEntitlementRequest>
  Model::AssociateApplicationToEntitlementOutcomeCallable AssociateApplicationToEntitlementCallable(
      const AssociateApplicationToEntitlementRequestT& request) const {
    return SubmitCallable(&AppStreamClient::AssociateApplicationToEntitlement, request);
  }
 
  template <typename AssociateApplicationToEntitlementRequestT = Model::AssociateApplicationToEntitlementRequest>
  void AssociateApplicationToEntitlementAsync(const AssociateApplicationToEntitlementRequestT& request,
                                              const AssociateApplicationToEntitlementResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::AssociateApplicationToEntitlement, request, handler, context);
  }
 
  virtual Model::AssociateFleetOutcome AssociateFleet(const Model::AssociateFleetRequest& request) const;
 
  template <typename AssociateFleetRequestT = Model::AssociateFleetRequest>
  Model::AssociateFleetOutcomeCallable AssociateFleetCallable(const AssociateFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::AssociateFleet, request);
  }
 
  template <typename AssociateFleetRequestT = Model::AssociateFleetRequest>
  void AssociateFleetAsync(const AssociateFleetRequestT& request, const AssociateFleetResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::AssociateFleet, request, handler, context);
  }
 
  virtual Model::AssociateSoftwareToImageBuilderOutcome AssociateSoftwareToImageBuilder(
      const Model::AssociateSoftwareToImageBuilderRequest& request) const;
 
  template <typename AssociateSoftwareToImageBuilderRequestT = Model::AssociateSoftwareToImageBuilderRequest>
  Model::AssociateSoftwareToImageBuilderOutcomeCallable AssociateSoftwareToImageBuilderCallable(
      const AssociateSoftwareToImageBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::AssociateSoftwareToImageBuilder, request);
  }
 
  template <typename AssociateSoftwareToImageBuilderRequestT = Model::AssociateSoftwareToImageBuilderRequest>
  void AssociateSoftwareToImageBuilderAsync(const AssociateSoftwareToImageBuilderRequestT& request,
                                            const AssociateSoftwareToImageBuilderResponseReceivedHandler& handler,
                                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::AssociateSoftwareToImageBuilder, request, handler, context);
  }
 
  virtual Model::BatchAssociateUserStackOutcome BatchAssociateUserStack(const Model::BatchAssociateUserStackRequest& request) const;
 
  template <typename BatchAssociateUserStackRequestT = Model::BatchAssociateUserStackRequest>
  Model::BatchAssociateUserStackOutcomeCallable BatchAssociateUserStackCallable(const BatchAssociateUserStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::BatchAssociateUserStack, request);
  }
 
  template <typename BatchAssociateUserStackRequestT = Model::BatchAssociateUserStackRequest>
  void BatchAssociateUserStackAsync(const BatchAssociateUserStackRequestT& request,
                                    const BatchAssociateUserStackResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::BatchAssociateUserStack, request, handler, context);
  }
 
  virtual Model::BatchDisassociateUserStackOutcome BatchDisassociateUserStack(
      const Model::BatchDisassociateUserStackRequest& request) const;
 
  template <typename BatchDisassociateUserStackRequestT = Model::BatchDisassociateUserStackRequest>
  Model::BatchDisassociateUserStackOutcomeCallable BatchDisassociateUserStackCallable(
      const BatchDisassociateUserStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::BatchDisassociateUserStack, request);
  }
 
  template <typename BatchDisassociateUserStackRequestT = Model::BatchDisassociateUserStackRequest>
  void BatchDisassociateUserStackAsync(const BatchDisassociateUserStackRequestT& request,
                                       const BatchDisassociateUserStackResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::BatchDisassociateUserStack, request, handler, context);
  }
 
  virtual Model::CopyImageOutcome CopyImage(const Model::CopyImageRequest& request) const;
 
  template <typename CopyImageRequestT = Model::CopyImageRequest>
  Model::CopyImageOutcomeCallable CopyImageCallable(const CopyImageRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CopyImage, request);
  }
 
  template <typename CopyImageRequestT = Model::CopyImageRequest>
  void CopyImageAsync(const CopyImageRequestT& request, const CopyImageResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CopyImage, request, handler, context);
  }
 
  virtual Model::CreateAppBlockOutcome CreateAppBlock(const Model::CreateAppBlockRequest& request) const;
 
  template <typename CreateAppBlockRequestT = Model::CreateAppBlockRequest>
  Model::CreateAppBlockOutcomeCallable CreateAppBlockCallable(const CreateAppBlockRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateAppBlock, request);
  }
 
  template <typename CreateAppBlockRequestT = Model::CreateAppBlockRequest>
  void CreateAppBlockAsync(const CreateAppBlockRequestT& request, const CreateAppBlockResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateAppBlock, request, handler, context);
  }
 
  virtual Model::CreateAppBlockBuilderOutcome CreateAppBlockBuilder(const Model::CreateAppBlockBuilderRequest& request) const;
 
  template <typename CreateAppBlockBuilderRequestT = Model::CreateAppBlockBuilderRequest>
  Model::CreateAppBlockBuilderOutcomeCallable CreateAppBlockBuilderCallable(const CreateAppBlockBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateAppBlockBuilder, request);
  }
 
  template <typename CreateAppBlockBuilderRequestT = Model::CreateAppBlockBuilderRequest>
  void CreateAppBlockBuilderAsync(const CreateAppBlockBuilderRequestT& request, const CreateAppBlockBuilderResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateAppBlockBuilder, request, handler, context);
  }
 
  virtual Model::CreateAppBlockBuilderStreamingURLOutcome CreateAppBlockBuilderStreamingURL(
      const Model::CreateAppBlockBuilderStreamingURLRequest& request) const;
 
  template <typename CreateAppBlockBuilderStreamingURLRequestT = Model::CreateAppBlockBuilderStreamingURLRequest>
  Model::CreateAppBlockBuilderStreamingURLOutcomeCallable CreateAppBlockBuilderStreamingURLCallable(
      const CreateAppBlockBuilderStreamingURLRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateAppBlockBuilderStreamingURL, request);
  }
 
  template <typename CreateAppBlockBuilderStreamingURLRequestT = Model::CreateAppBlockBuilderStreamingURLRequest>
  void CreateAppBlockBuilderStreamingURLAsync(const CreateAppBlockBuilderStreamingURLRequestT& request,
                                              const CreateAppBlockBuilderStreamingURLResponseReceivedHandler& handler,
                                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateAppBlockBuilderStreamingURL, request, handler, context);
  }
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateDirectoryConfigOutcome CreateDirectoryConfig(const Model::CreateDirectoryConfigRequest& request) const;
 
  template <typename CreateDirectoryConfigRequestT = Model::CreateDirectoryConfigRequest>
  Model::CreateDirectoryConfigOutcomeCallable CreateDirectoryConfigCallable(const CreateDirectoryConfigRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateDirectoryConfig, request);
  }
 
  template <typename CreateDirectoryConfigRequestT = Model::CreateDirectoryConfigRequest>
  void CreateDirectoryConfigAsync(const CreateDirectoryConfigRequestT& request, const CreateDirectoryConfigResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateDirectoryConfig, request, handler, context);
  }
 
  virtual Model::CreateEntitlementOutcome CreateEntitlement(const Model::CreateEntitlementRequest& request) const;
 
  template <typename CreateEntitlementRequestT = Model::CreateEntitlementRequest>
  Model::CreateEntitlementOutcomeCallable CreateEntitlementCallable(const CreateEntitlementRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateEntitlement, request);
  }
 
  template <typename CreateEntitlementRequestT = Model::CreateEntitlementRequest>
  void CreateEntitlementAsync(const CreateEntitlementRequestT& request, const CreateEntitlementResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateEntitlement, request, handler, context);
  }
 
  virtual Model::CreateExportImageTaskOutcome CreateExportImageTask(const Model::CreateExportImageTaskRequest& request) const;
 
  template <typename CreateExportImageTaskRequestT = Model::CreateExportImageTaskRequest>
  Model::CreateExportImageTaskOutcomeCallable CreateExportImageTaskCallable(const CreateExportImageTaskRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateExportImageTask, request);
  }
 
  template <typename CreateExportImageTaskRequestT = Model::CreateExportImageTaskRequest>
  void CreateExportImageTaskAsync(const CreateExportImageTaskRequestT& request, const CreateExportImageTaskResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateExportImageTask, request, handler, context);
  }
 
  virtual Model::CreateFleetOutcome CreateFleet(const Model::CreateFleetRequest& request) const;
 
  template <typename CreateFleetRequestT = Model::CreateFleetRequest>
  Model::CreateFleetOutcomeCallable CreateFleetCallable(const CreateFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateFleet, request);
  }
 
  template <typename CreateFleetRequestT = Model::CreateFleetRequest>
  void CreateFleetAsync(const CreateFleetRequestT& request, const CreateFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateFleet, request, handler, context);
  }
 
  virtual Model::CreateImageBuilderOutcome CreateImageBuilder(const Model::CreateImageBuilderRequest& request) const;
 
  template <typename CreateImageBuilderRequestT = Model::CreateImageBuilderRequest>
  Model::CreateImageBuilderOutcomeCallable CreateImageBuilderCallable(const CreateImageBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateImageBuilder, request);
  }
 
  template <typename CreateImageBuilderRequestT = Model::CreateImageBuilderRequest>
  void CreateImageBuilderAsync(const CreateImageBuilderRequestT& request, const CreateImageBuilderResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateImageBuilder, request, handler, context);
  }
 
  virtual Model::CreateImageBuilderStreamingURLOutcome CreateImageBuilderStreamingURL(
      const Model::CreateImageBuilderStreamingURLRequest& request) const;
 
  template <typename CreateImageBuilderStreamingURLRequestT = Model::CreateImageBuilderStreamingURLRequest>
  Model::CreateImageBuilderStreamingURLOutcomeCallable CreateImageBuilderStreamingURLCallable(
      const CreateImageBuilderStreamingURLRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateImageBuilderStreamingURL, request);
  }
 
  template <typename CreateImageBuilderStreamingURLRequestT = Model::CreateImageBuilderStreamingURLRequest>
  void CreateImageBuilderStreamingURLAsync(const CreateImageBuilderStreamingURLRequestT& request,
                                           const CreateImageBuilderStreamingURLResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateImageBuilderStreamingURL, request, handler, context);
  }
 
  virtual Model::CreateImportedImageOutcome CreateImportedImage(const Model::CreateImportedImageRequest& request) const;
 
  template <typename CreateImportedImageRequestT = Model::CreateImportedImageRequest>
  Model::CreateImportedImageOutcomeCallable CreateImportedImageCallable(const CreateImportedImageRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateImportedImage, request);
  }
 
  template <typename CreateImportedImageRequestT = Model::CreateImportedImageRequest>
  void CreateImportedImageAsync(const CreateImportedImageRequestT& request, const CreateImportedImageResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateImportedImage, request, handler, context);
  }
 
  virtual Model::CreateStackOutcome CreateStack(const Model::CreateStackRequest& request) const;
 
  template <typename CreateStackRequestT = Model::CreateStackRequest>
  Model::CreateStackOutcomeCallable CreateStackCallable(const CreateStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateStack, request);
  }
 
  template <typename CreateStackRequestT = Model::CreateStackRequest>
  void CreateStackAsync(const CreateStackRequestT& request, const CreateStackResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateStack, request, handler, context);
  }
 
  virtual Model::CreateStreamingURLOutcome CreateStreamingURL(const Model::CreateStreamingURLRequest& request) const;
 
  template <typename CreateStreamingURLRequestT = Model::CreateStreamingURLRequest>
  Model::CreateStreamingURLOutcomeCallable CreateStreamingURLCallable(const CreateStreamingURLRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateStreamingURL, request);
  }
 
  template <typename CreateStreamingURLRequestT = Model::CreateStreamingURLRequest>
  void CreateStreamingURLAsync(const CreateStreamingURLRequestT& request, const CreateStreamingURLResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateStreamingURL, request, handler, context);
  }
 
  virtual Model::CreateThemeForStackOutcome CreateThemeForStack(const Model::CreateThemeForStackRequest& request) const;
 
  template <typename CreateThemeForStackRequestT = Model::CreateThemeForStackRequest>
  Model::CreateThemeForStackOutcomeCallable CreateThemeForStackCallable(const CreateThemeForStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateThemeForStack, request);
  }
 
  template <typename CreateThemeForStackRequestT = Model::CreateThemeForStackRequest>
  void CreateThemeForStackAsync(const CreateThemeForStackRequestT& request, const CreateThemeForStackResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateThemeForStack, request, handler, context);
  }
 
  virtual Model::CreateUpdatedImageOutcome CreateUpdatedImage(const Model::CreateUpdatedImageRequest& request) const;
 
  template <typename CreateUpdatedImageRequestT = Model::CreateUpdatedImageRequest>
  Model::CreateUpdatedImageOutcomeCallable CreateUpdatedImageCallable(const CreateUpdatedImageRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateUpdatedImage, request);
  }
 
  template <typename CreateUpdatedImageRequestT = Model::CreateUpdatedImageRequest>
  void CreateUpdatedImageAsync(const CreateUpdatedImageRequestT& request, const CreateUpdatedImageResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateUpdatedImage, request, handler, context);
  }
 
  virtual Model::CreateUsageReportSubscriptionOutcome CreateUsageReportSubscription(
      const Model::CreateUsageReportSubscriptionRequest& request = {}) const;
 
  template <typename CreateUsageReportSubscriptionRequestT = Model::CreateUsageReportSubscriptionRequest>
  Model::CreateUsageReportSubscriptionOutcomeCallable CreateUsageReportSubscriptionCallable(
      const CreateUsageReportSubscriptionRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::CreateUsageReportSubscription, request);
  }
 
  template <typename CreateUsageReportSubscriptionRequestT = Model::CreateUsageReportSubscriptionRequest>
  void CreateUsageReportSubscriptionAsync(const CreateUsageReportSubscriptionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const CreateUsageReportSubscriptionRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::CreateUsageReportSubscription, request, handler, context);
  }
 
  virtual Model::CreateUserOutcome CreateUser(const Model::CreateUserRequest& request) const;
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  Model::CreateUserOutcomeCallable CreateUserCallable(const CreateUserRequestT& request) const {
    return SubmitCallable(&AppStreamClient::CreateUser, request);
  }
 
  template <typename CreateUserRequestT = Model::CreateUserRequest>
  void CreateUserAsync(const CreateUserRequestT& request, const CreateUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::CreateUser, request, handler, context);
  }
 
  virtual Model::DeleteAppBlockOutcome DeleteAppBlock(const Model::DeleteAppBlockRequest& request) const;
 
  template <typename DeleteAppBlockRequestT = Model::DeleteAppBlockRequest>
  Model::DeleteAppBlockOutcomeCallable DeleteAppBlockCallable(const DeleteAppBlockRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteAppBlock, request);
  }
 
  template <typename DeleteAppBlockRequestT = Model::DeleteAppBlockRequest>
  void DeleteAppBlockAsync(const DeleteAppBlockRequestT& request, const DeleteAppBlockResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteAppBlock, request, handler, context);
  }
 
  virtual Model::DeleteAppBlockBuilderOutcome DeleteAppBlockBuilder(const Model::DeleteAppBlockBuilderRequest& request) const;
 
  template <typename DeleteAppBlockBuilderRequestT = Model::DeleteAppBlockBuilderRequest>
  Model::DeleteAppBlockBuilderOutcomeCallable DeleteAppBlockBuilderCallable(const DeleteAppBlockBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteAppBlockBuilder, request);
  }
 
  template <typename DeleteAppBlockBuilderRequestT = Model::DeleteAppBlockBuilderRequest>
  void DeleteAppBlockBuilderAsync(const DeleteAppBlockBuilderRequestT& request, const DeleteAppBlockBuilderResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteAppBlockBuilder, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteDirectoryConfigOutcome DeleteDirectoryConfig(const Model::DeleteDirectoryConfigRequest& request) const;
 
  template <typename DeleteDirectoryConfigRequestT = Model::DeleteDirectoryConfigRequest>
  Model::DeleteDirectoryConfigOutcomeCallable DeleteDirectoryConfigCallable(const DeleteDirectoryConfigRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteDirectoryConfig, request);
  }
 
  template <typename DeleteDirectoryConfigRequestT = Model::DeleteDirectoryConfigRequest>
  void DeleteDirectoryConfigAsync(const DeleteDirectoryConfigRequestT& request, const DeleteDirectoryConfigResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteDirectoryConfig, request, handler, context);
  }
 
  virtual Model::DeleteEntitlementOutcome DeleteEntitlement(const Model::DeleteEntitlementRequest& request) const;
 
  template <typename DeleteEntitlementRequestT = Model::DeleteEntitlementRequest>
  Model::DeleteEntitlementOutcomeCallable DeleteEntitlementCallable(const DeleteEntitlementRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteEntitlement, request);
  }
 
  template <typename DeleteEntitlementRequestT = Model::DeleteEntitlementRequest>
  void DeleteEntitlementAsync(const DeleteEntitlementRequestT& request, const DeleteEntitlementResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteEntitlement, request, handler, context);
  }
 
  virtual Model::DeleteFleetOutcome DeleteFleet(const Model::DeleteFleetRequest& request) const;
 
  template <typename DeleteFleetRequestT = Model::DeleteFleetRequest>
  Model::DeleteFleetOutcomeCallable DeleteFleetCallable(const DeleteFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteFleet, request);
  }
 
  template <typename DeleteFleetRequestT = Model::DeleteFleetRequest>
  void DeleteFleetAsync(const DeleteFleetRequestT& request, const DeleteFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteFleet, request, handler, context);
  }
 
  virtual Model::DeleteImageOutcome DeleteImage(const Model::DeleteImageRequest& request) const;
 
  template <typename DeleteImageRequestT = Model::DeleteImageRequest>
  Model::DeleteImageOutcomeCallable DeleteImageCallable(const DeleteImageRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteImage, request);
  }
 
  template <typename DeleteImageRequestT = Model::DeleteImageRequest>
  void DeleteImageAsync(const DeleteImageRequestT& request, const DeleteImageResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteImage, request, handler, context);
  }
 
  virtual Model::DeleteImageBuilderOutcome DeleteImageBuilder(const Model::DeleteImageBuilderRequest& request) const;
 
  template <typename DeleteImageBuilderRequestT = Model::DeleteImageBuilderRequest>
  Model::DeleteImageBuilderOutcomeCallable DeleteImageBuilderCallable(const DeleteImageBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteImageBuilder, request);
  }
 
  template <typename DeleteImageBuilderRequestT = Model::DeleteImageBuilderRequest>
  void DeleteImageBuilderAsync(const DeleteImageBuilderRequestT& request, const DeleteImageBuilderResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteImageBuilder, request, handler, context);
  }
 
  virtual Model::DeleteImagePermissionsOutcome DeleteImagePermissions(const Model::DeleteImagePermissionsRequest& request) const;
 
  template <typename DeleteImagePermissionsRequestT = Model::DeleteImagePermissionsRequest>
  Model::DeleteImagePermissionsOutcomeCallable DeleteImagePermissionsCallable(const DeleteImagePermissionsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteImagePermissions, request);
  }
 
  template <typename DeleteImagePermissionsRequestT = Model::DeleteImagePermissionsRequest>
  void DeleteImagePermissionsAsync(const DeleteImagePermissionsRequestT& request,
                                   const DeleteImagePermissionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteImagePermissions, request, handler, context);
  }
 
  virtual Model::DeleteStackOutcome DeleteStack(const Model::DeleteStackRequest& request) const;
 
  template <typename DeleteStackRequestT = Model::DeleteStackRequest>
  Model::DeleteStackOutcomeCallable DeleteStackCallable(const DeleteStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteStack, request);
  }
 
  template <typename DeleteStackRequestT = Model::DeleteStackRequest>
  void DeleteStackAsync(const DeleteStackRequestT& request, const DeleteStackResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteStack, request, handler, context);
  }
 
  virtual Model::DeleteThemeForStackOutcome DeleteThemeForStack(const Model::DeleteThemeForStackRequest& request) const;
 
  template <typename DeleteThemeForStackRequestT = Model::DeleteThemeForStackRequest>
  Model::DeleteThemeForStackOutcomeCallable DeleteThemeForStackCallable(const DeleteThemeForStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteThemeForStack, request);
  }
 
  template <typename DeleteThemeForStackRequestT = Model::DeleteThemeForStackRequest>
  void DeleteThemeForStackAsync(const DeleteThemeForStackRequestT& request, const DeleteThemeForStackResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteThemeForStack, request, handler, context);
  }
 
  virtual Model::DeleteUsageReportSubscriptionOutcome DeleteUsageReportSubscription(
      const Model::DeleteUsageReportSubscriptionRequest& request = {}) const;
 
  template <typename DeleteUsageReportSubscriptionRequestT = Model::DeleteUsageReportSubscriptionRequest>
  Model::DeleteUsageReportSubscriptionOutcomeCallable DeleteUsageReportSubscriptionCallable(
      const DeleteUsageReportSubscriptionRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DeleteUsageReportSubscription, request);
  }
 
  template <typename DeleteUsageReportSubscriptionRequestT = Model::DeleteUsageReportSubscriptionRequest>
  void DeleteUsageReportSubscriptionAsync(const DeleteUsageReportSubscriptionResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DeleteUsageReportSubscriptionRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DeleteUsageReportSubscription, request, handler, context);
  }
 
  virtual Model::DeleteUserOutcome DeleteUser(const Model::DeleteUserRequest& request) const;
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  Model::DeleteUserOutcomeCallable DeleteUserCallable(const DeleteUserRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DeleteUser, request);
  }
 
  template <typename DeleteUserRequestT = Model::DeleteUserRequest>
  void DeleteUserAsync(const DeleteUserRequestT& request, const DeleteUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DeleteUser, request, handler, context);
  }
 
  virtual Model::DescribeAppBlockBuilderAppBlockAssociationsOutcome DescribeAppBlockBuilderAppBlockAssociations(
      const Model::DescribeAppBlockBuilderAppBlockAssociationsRequest& request = {}) const;
 
  template <typename DescribeAppBlockBuilderAppBlockAssociationsRequestT = Model::DescribeAppBlockBuilderAppBlockAssociationsRequest>
  Model::DescribeAppBlockBuilderAppBlockAssociationsOutcomeCallable DescribeAppBlockBuilderAppBlockAssociationsCallable(
      const DescribeAppBlockBuilderAppBlockAssociationsRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeAppBlockBuilderAppBlockAssociations, request);
  }
 
  template <typename DescribeAppBlockBuilderAppBlockAssociationsRequestT = Model::DescribeAppBlockBuilderAppBlockAssociationsRequest>
  void DescribeAppBlockBuilderAppBlockAssociationsAsync(const DescribeAppBlockBuilderAppBlockAssociationsResponseReceivedHandler& handler,
                                                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                        const DescribeAppBlockBuilderAppBlockAssociationsRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeAppBlockBuilderAppBlockAssociations, request, handler, context);
  }
 
  virtual Model::DescribeAppBlockBuildersOutcome DescribeAppBlockBuilders(const Model::DescribeAppBlockBuildersRequest& request = {}) const;
 
  template <typename DescribeAppBlockBuildersRequestT = Model::DescribeAppBlockBuildersRequest>
  Model::DescribeAppBlockBuildersOutcomeCallable DescribeAppBlockBuildersCallable(
      const DescribeAppBlockBuildersRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeAppBlockBuilders, request);
  }
 
  template <typename DescribeAppBlockBuildersRequestT = Model::DescribeAppBlockBuildersRequest>
  void DescribeAppBlockBuildersAsync(const DescribeAppBlockBuildersResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeAppBlockBuildersRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeAppBlockBuilders, request, handler, context);
  }
 
  virtual Model::DescribeAppBlocksOutcome DescribeAppBlocks(const Model::DescribeAppBlocksRequest& request = {}) const;
 
  template <typename DescribeAppBlocksRequestT = Model::DescribeAppBlocksRequest>
  Model::DescribeAppBlocksOutcomeCallable DescribeAppBlocksCallable(const DescribeAppBlocksRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeAppBlocks, request);
  }
 
  template <typename DescribeAppBlocksRequestT = Model::DescribeAppBlocksRequest>
  void DescribeAppBlocksAsync(const DescribeAppBlocksResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const DescribeAppBlocksRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeAppBlocks, request, handler, context);
  }
 
  virtual Model::DescribeAppLicenseUsageOutcome DescribeAppLicenseUsage(const Model::DescribeAppLicenseUsageRequest& request) const;
 
  template <typename DescribeAppLicenseUsageRequestT = Model::DescribeAppLicenseUsageRequest>
  Model::DescribeAppLicenseUsageOutcomeCallable DescribeAppLicenseUsageCallable(const DescribeAppLicenseUsageRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DescribeAppLicenseUsage, request);
  }
 
  template <typename DescribeAppLicenseUsageRequestT = Model::DescribeAppLicenseUsageRequest>
  void DescribeAppLicenseUsageAsync(const DescribeAppLicenseUsageRequestT& request,
                                    const DescribeAppLicenseUsageResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DescribeAppLicenseUsage, request, handler, context);
  }
 
  virtual Model::DescribeApplicationFleetAssociationsOutcome DescribeApplicationFleetAssociations(
      const Model::DescribeApplicationFleetAssociationsRequest& request = {}) const;
 
  template <typename DescribeApplicationFleetAssociationsRequestT = Model::DescribeApplicationFleetAssociationsRequest>
  Model::DescribeApplicationFleetAssociationsOutcomeCallable DescribeApplicationFleetAssociationsCallable(
      const DescribeApplicationFleetAssociationsRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeApplicationFleetAssociations, request);
  }
 
  template <typename DescribeApplicationFleetAssociationsRequestT = Model::DescribeApplicationFleetAssociationsRequest>
  void DescribeApplicationFleetAssociationsAsync(const DescribeApplicationFleetAssociationsResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                 const DescribeApplicationFleetAssociationsRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeApplicationFleetAssociations, request, handler, context);
  }
 
  virtual Model::DescribeApplicationsOutcome DescribeApplications(const Model::DescribeApplicationsRequest& request = {}) const;
 
  template <typename DescribeApplicationsRequestT = Model::DescribeApplicationsRequest>
  Model::DescribeApplicationsOutcomeCallable DescribeApplicationsCallable(const DescribeApplicationsRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeApplications, request);
  }
 
  template <typename DescribeApplicationsRequestT = Model::DescribeApplicationsRequest>
  void DescribeApplicationsAsync(const DescribeApplicationsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const DescribeApplicationsRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeApplications, request, handler, context);
  }
 
  virtual Model::DescribeDirectoryConfigsOutcome DescribeDirectoryConfigs(const Model::DescribeDirectoryConfigsRequest& request = {}) const;
 
  template <typename DescribeDirectoryConfigsRequestT = Model::DescribeDirectoryConfigsRequest>
  Model::DescribeDirectoryConfigsOutcomeCallable DescribeDirectoryConfigsCallable(
      const DescribeDirectoryConfigsRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeDirectoryConfigs, request);
  }
 
  template <typename DescribeDirectoryConfigsRequestT = Model::DescribeDirectoryConfigsRequest>
  void DescribeDirectoryConfigsAsync(const DescribeDirectoryConfigsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const DescribeDirectoryConfigsRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeDirectoryConfigs, request, handler, context);
  }
 
  virtual Model::DescribeEntitlementsOutcome DescribeEntitlements(const Model::DescribeEntitlementsRequest& request) const;
 
  template <typename DescribeEntitlementsRequestT = Model::DescribeEntitlementsRequest>
  Model::DescribeEntitlementsOutcomeCallable DescribeEntitlementsCallable(const DescribeEntitlementsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DescribeEntitlements, request);
  }
 
  template <typename DescribeEntitlementsRequestT = Model::DescribeEntitlementsRequest>
  void DescribeEntitlementsAsync(const DescribeEntitlementsRequestT& request, const DescribeEntitlementsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DescribeEntitlements, request, handler, context);
  }
 
  virtual Model::DescribeFleetsOutcome DescribeFleets(const Model::DescribeFleetsRequest& request = {}) const;
 
  template <typename DescribeFleetsRequestT = Model::DescribeFleetsRequest>
  Model::DescribeFleetsOutcomeCallable DescribeFleetsCallable(const DescribeFleetsRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeFleets, request);
  }
 
  template <typename DescribeFleetsRequestT = Model::DescribeFleetsRequest>
  void DescribeFleetsAsync(const DescribeFleetsResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeFleetsRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeFleets, request, handler, context);
  }
 
  virtual Model::DescribeImageBuildersOutcome DescribeImageBuilders(const Model::DescribeImageBuildersRequest& request = {}) const;
 
  template <typename DescribeImageBuildersRequestT = Model::DescribeImageBuildersRequest>
  Model::DescribeImageBuildersOutcomeCallable DescribeImageBuildersCallable(const DescribeImageBuildersRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeImageBuilders, request);
  }
 
  template <typename DescribeImageBuildersRequestT = Model::DescribeImageBuildersRequest>
  void DescribeImageBuildersAsync(const DescribeImageBuildersResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                  const DescribeImageBuildersRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeImageBuilders, request, handler, context);
  }
 
  virtual Model::DescribeImagePermissionsOutcome DescribeImagePermissions(const Model::DescribeImagePermissionsRequest& request) const;
 
  template <typename DescribeImagePermissionsRequestT = Model::DescribeImagePermissionsRequest>
  Model::DescribeImagePermissionsOutcomeCallable DescribeImagePermissionsCallable(const DescribeImagePermissionsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DescribeImagePermissions, request);
  }
 
  template <typename DescribeImagePermissionsRequestT = Model::DescribeImagePermissionsRequest>
  void DescribeImagePermissionsAsync(const DescribeImagePermissionsRequestT& request,
                                     const DescribeImagePermissionsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DescribeImagePermissions, request, handler, context);
  }
 
  virtual Model::DescribeImagesOutcome DescribeImages(const Model::DescribeImagesRequest& request = {}) const;
 
  template <typename DescribeImagesRequestT = Model::DescribeImagesRequest>
  Model::DescribeImagesOutcomeCallable DescribeImagesCallable(const DescribeImagesRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeImages, request);
  }
 
  template <typename DescribeImagesRequestT = Model::DescribeImagesRequest>
  void DescribeImagesAsync(const DescribeImagesResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeImagesRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeImages, request, handler, context);
  }
 
  virtual Model::DescribeSessionsOutcome DescribeSessions(const Model::DescribeSessionsRequest& request) const;
 
  template <typename DescribeSessionsRequestT = Model::DescribeSessionsRequest>
  Model::DescribeSessionsOutcomeCallable DescribeSessionsCallable(const DescribeSessionsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DescribeSessions, request);
  }
 
  template <typename DescribeSessionsRequestT = Model::DescribeSessionsRequest>
  void DescribeSessionsAsync(const DescribeSessionsRequestT& request, const DescribeSessionsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DescribeSessions, request, handler, context);
  }
 
  virtual Model::DescribeSoftwareAssociationsOutcome DescribeSoftwareAssociations(
      const Model::DescribeSoftwareAssociationsRequest& request) const;
 
  template <typename DescribeSoftwareAssociationsRequestT = Model::DescribeSoftwareAssociationsRequest>
  Model::DescribeSoftwareAssociationsOutcomeCallable DescribeSoftwareAssociationsCallable(
      const DescribeSoftwareAssociationsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DescribeSoftwareAssociations, request);
  }
 
  template <typename DescribeSoftwareAssociationsRequestT = Model::DescribeSoftwareAssociationsRequest>
  void DescribeSoftwareAssociationsAsync(const DescribeSoftwareAssociationsRequestT& request,
                                         const DescribeSoftwareAssociationsResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DescribeSoftwareAssociations, request, handler, context);
  }
 
  virtual Model::DescribeStacksOutcome DescribeStacks(const Model::DescribeStacksRequest& request = {}) const;
 
  template <typename DescribeStacksRequestT = Model::DescribeStacksRequest>
  Model::DescribeStacksOutcomeCallable DescribeStacksCallable(const DescribeStacksRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeStacks, request);
  }
 
  template <typename DescribeStacksRequestT = Model::DescribeStacksRequest>
  void DescribeStacksAsync(const DescribeStacksResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                           const DescribeStacksRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeStacks, request, handler, context);
  }
 
  virtual Model::DescribeThemeForStackOutcome DescribeThemeForStack(const Model::DescribeThemeForStackRequest& request) const;
 
  template <typename DescribeThemeForStackRequestT = Model::DescribeThemeForStackRequest>
  Model::DescribeThemeForStackOutcomeCallable DescribeThemeForStackCallable(const DescribeThemeForStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DescribeThemeForStack, request);
  }
 
  template <typename DescribeThemeForStackRequestT = Model::DescribeThemeForStackRequest>
  void DescribeThemeForStackAsync(const DescribeThemeForStackRequestT& request, const DescribeThemeForStackResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DescribeThemeForStack, request, handler, context);
  }
 
  virtual Model::DescribeUsageReportSubscriptionsOutcome DescribeUsageReportSubscriptions(
      const Model::DescribeUsageReportSubscriptionsRequest& request = {}) const;
 
  template <typename DescribeUsageReportSubscriptionsRequestT = Model::DescribeUsageReportSubscriptionsRequest>
  Model::DescribeUsageReportSubscriptionsOutcomeCallable DescribeUsageReportSubscriptionsCallable(
      const DescribeUsageReportSubscriptionsRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeUsageReportSubscriptions, request);
  }
 
  template <typename DescribeUsageReportSubscriptionsRequestT = Model::DescribeUsageReportSubscriptionsRequest>
  void DescribeUsageReportSubscriptionsAsync(const DescribeUsageReportSubscriptionsResponseReceivedHandler& handler,
                                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                             const DescribeUsageReportSubscriptionsRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeUsageReportSubscriptions, request, handler, context);
  }
 
  virtual Model::DescribeUserStackAssociationsOutcome DescribeUserStackAssociations(
      const Model::DescribeUserStackAssociationsRequest& request = {}) const;
 
  template <typename DescribeUserStackAssociationsRequestT = Model::DescribeUserStackAssociationsRequest>
  Model::DescribeUserStackAssociationsOutcomeCallable DescribeUserStackAssociationsCallable(
      const DescribeUserStackAssociationsRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::DescribeUserStackAssociations, request);
  }
 
  template <typename DescribeUserStackAssociationsRequestT = Model::DescribeUserStackAssociationsRequest>
  void DescribeUserStackAssociationsAsync(const DescribeUserStackAssociationsResponseReceivedHandler& handler,
                                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                          const DescribeUserStackAssociationsRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::DescribeUserStackAssociations, request, handler, context);
  }
 
  virtual Model::DescribeUsersOutcome DescribeUsers(const Model::DescribeUsersRequest& request) const;
 
  template <typename DescribeUsersRequestT = Model::DescribeUsersRequest>
  Model::DescribeUsersOutcomeCallable DescribeUsersCallable(const DescribeUsersRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DescribeUsers, request);
  }
 
  template <typename DescribeUsersRequestT = Model::DescribeUsersRequest>
  void DescribeUsersAsync(const DescribeUsersRequestT& request, const DescribeUsersResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DescribeUsers, request, handler, context);
  }
 
  virtual Model::DisableUserOutcome DisableUser(const Model::DisableUserRequest& request) const;
 
  template <typename DisableUserRequestT = Model::DisableUserRequest>
  Model::DisableUserOutcomeCallable DisableUserCallable(const DisableUserRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DisableUser, request);
  }
 
  template <typename DisableUserRequestT = Model::DisableUserRequest>
  void DisableUserAsync(const DisableUserRequestT& request, const DisableUserResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DisableUser, request, handler, context);
  }
 
  virtual Model::DisassociateAppBlockBuilderAppBlockOutcome DisassociateAppBlockBuilderAppBlock(
      const Model::DisassociateAppBlockBuilderAppBlockRequest& request) const;
 
  template <typename DisassociateAppBlockBuilderAppBlockRequestT = Model::DisassociateAppBlockBuilderAppBlockRequest>
  Model::DisassociateAppBlockBuilderAppBlockOutcomeCallable DisassociateAppBlockBuilderAppBlockCallable(
      const DisassociateAppBlockBuilderAppBlockRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DisassociateAppBlockBuilderAppBlock, request);
  }
 
  template <typename DisassociateAppBlockBuilderAppBlockRequestT = Model::DisassociateAppBlockBuilderAppBlockRequest>
  void DisassociateAppBlockBuilderAppBlockAsync(const DisassociateAppBlockBuilderAppBlockRequestT& request,
                                                const DisassociateAppBlockBuilderAppBlockResponseReceivedHandler& handler,
                                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DisassociateAppBlockBuilderAppBlock, request, handler, context);
  }
 
  virtual Model::DisassociateApplicationFleetOutcome DisassociateApplicationFleet(
      const Model::DisassociateApplicationFleetRequest& request) const;
 
  template <typename DisassociateApplicationFleetRequestT = Model::DisassociateApplicationFleetRequest>
  Model::DisassociateApplicationFleetOutcomeCallable DisassociateApplicationFleetCallable(
      const DisassociateApplicationFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DisassociateApplicationFleet, request);
  }
 
  template <typename DisassociateApplicationFleetRequestT = Model::DisassociateApplicationFleetRequest>
  void DisassociateApplicationFleetAsync(const DisassociateApplicationFleetRequestT& request,
                                         const DisassociateApplicationFleetResponseReceivedHandler& handler,
                                         const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DisassociateApplicationFleet, request, handler, context);
  }
 
  virtual Model::DisassociateApplicationFromEntitlementOutcome DisassociateApplicationFromEntitlement(
      const Model::DisassociateApplicationFromEntitlementRequest& request) const;
 
  template <typename DisassociateApplicationFromEntitlementRequestT = Model::DisassociateApplicationFromEntitlementRequest>
  Model::DisassociateApplicationFromEntitlementOutcomeCallable DisassociateApplicationFromEntitlementCallable(
      const DisassociateApplicationFromEntitlementRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DisassociateApplicationFromEntitlement, request);
  }
 
  template <typename DisassociateApplicationFromEntitlementRequestT = Model::DisassociateApplicationFromEntitlementRequest>
  void DisassociateApplicationFromEntitlementAsync(const DisassociateApplicationFromEntitlementRequestT& request,
                                                   const DisassociateApplicationFromEntitlementResponseReceivedHandler& handler,
                                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DisassociateApplicationFromEntitlement, request, handler, context);
  }
 
  virtual Model::DisassociateFleetOutcome DisassociateFleet(const Model::DisassociateFleetRequest& request) const;
 
  template <typename DisassociateFleetRequestT = Model::DisassociateFleetRequest>
  Model::DisassociateFleetOutcomeCallable DisassociateFleetCallable(const DisassociateFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DisassociateFleet, request);
  }
 
  template <typename DisassociateFleetRequestT = Model::DisassociateFleetRequest>
  void DisassociateFleetAsync(const DisassociateFleetRequestT& request, const DisassociateFleetResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DisassociateFleet, request, handler, context);
  }
 
  virtual Model::DisassociateSoftwareFromImageBuilderOutcome DisassociateSoftwareFromImageBuilder(
      const Model::DisassociateSoftwareFromImageBuilderRequest& request) const;
 
  template <typename DisassociateSoftwareFromImageBuilderRequestT = Model::DisassociateSoftwareFromImageBuilderRequest>
  Model::DisassociateSoftwareFromImageBuilderOutcomeCallable DisassociateSoftwareFromImageBuilderCallable(
      const DisassociateSoftwareFromImageBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::DisassociateSoftwareFromImageBuilder, request);
  }
 
  template <typename DisassociateSoftwareFromImageBuilderRequestT = Model::DisassociateSoftwareFromImageBuilderRequest>
  void DisassociateSoftwareFromImageBuilderAsync(const DisassociateSoftwareFromImageBuilderRequestT& request,
                                                 const DisassociateSoftwareFromImageBuilderResponseReceivedHandler& handler,
                                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::DisassociateSoftwareFromImageBuilder, request, handler, context);
  }
 
  virtual Model::EnableUserOutcome EnableUser(const Model::EnableUserRequest& request) const;
 
  template <typename EnableUserRequestT = Model::EnableUserRequest>
  Model::EnableUserOutcomeCallable EnableUserCallable(const EnableUserRequestT& request) const {
    return SubmitCallable(&AppStreamClient::EnableUser, request);
  }
 
  template <typename EnableUserRequestT = Model::EnableUserRequest>
  void EnableUserAsync(const EnableUserRequestT& request, const EnableUserResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::EnableUser, request, handler, context);
  }
 
  virtual Model::ExpireSessionOutcome ExpireSession(const Model::ExpireSessionRequest& request) const;
 
  template <typename ExpireSessionRequestT = Model::ExpireSessionRequest>
  Model::ExpireSessionOutcomeCallable ExpireSessionCallable(const ExpireSessionRequestT& request) const {
    return SubmitCallable(&AppStreamClient::ExpireSession, request);
  }
 
  template <typename ExpireSessionRequestT = Model::ExpireSessionRequest>
  void ExpireSessionAsync(const ExpireSessionRequestT& request, const ExpireSessionResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::ExpireSession, request, handler, context);
  }
 
  virtual Model::GetExportImageTaskOutcome GetExportImageTask(const Model::GetExportImageTaskRequest& request = {}) const;
 
  template <typename GetExportImageTaskRequestT = Model::GetExportImageTaskRequest>
  Model::GetExportImageTaskOutcomeCallable GetExportImageTaskCallable(const GetExportImageTaskRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::GetExportImageTask, request);
  }
 
  template <typename GetExportImageTaskRequestT = Model::GetExportImageTaskRequest>
  void GetExportImageTaskAsync(const GetExportImageTaskResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                               const GetExportImageTaskRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::GetExportImageTask, request, handler, context);
  }
 
  virtual Model::ListAssociatedFleetsOutcome ListAssociatedFleets(const Model::ListAssociatedFleetsRequest& request) const;
 
  template <typename ListAssociatedFleetsRequestT = Model::ListAssociatedFleetsRequest>
  Model::ListAssociatedFleetsOutcomeCallable ListAssociatedFleetsCallable(const ListAssociatedFleetsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::ListAssociatedFleets, request);
  }
 
  template <typename ListAssociatedFleetsRequestT = Model::ListAssociatedFleetsRequest>
  void ListAssociatedFleetsAsync(const ListAssociatedFleetsRequestT& request, const ListAssociatedFleetsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::ListAssociatedFleets, request, handler, context);
  }
 
  virtual Model::ListAssociatedStacksOutcome ListAssociatedStacks(const Model::ListAssociatedStacksRequest& request) const;
 
  template <typename ListAssociatedStacksRequestT = Model::ListAssociatedStacksRequest>
  Model::ListAssociatedStacksOutcomeCallable ListAssociatedStacksCallable(const ListAssociatedStacksRequestT& request) const {
    return SubmitCallable(&AppStreamClient::ListAssociatedStacks, request);
  }
 
  template <typename ListAssociatedStacksRequestT = Model::ListAssociatedStacksRequest>
  void ListAssociatedStacksAsync(const ListAssociatedStacksRequestT& request, const ListAssociatedStacksResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::ListAssociatedStacks, request, handler, context);
  }
 
  virtual Model::ListEntitledApplicationsOutcome ListEntitledApplications(const Model::ListEntitledApplicationsRequest& request) const;
 
  template <typename ListEntitledApplicationsRequestT = Model::ListEntitledApplicationsRequest>
  Model::ListEntitledApplicationsOutcomeCallable ListEntitledApplicationsCallable(const ListEntitledApplicationsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::ListEntitledApplications, request);
  }
 
  template <typename ListEntitledApplicationsRequestT = Model::ListEntitledApplicationsRequest>
  void ListEntitledApplicationsAsync(const ListEntitledApplicationsRequestT& request,
                                     const ListEntitledApplicationsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::ListEntitledApplications, request, handler, context);
  }
 
  virtual Model::ListExportImageTasksOutcome ListExportImageTasks(const Model::ListExportImageTasksRequest& request = {}) const;
 
  template <typename ListExportImageTasksRequestT = Model::ListExportImageTasksRequest>
  Model::ListExportImageTasksOutcomeCallable ListExportImageTasksCallable(const ListExportImageTasksRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::ListExportImageTasks, request);
  }
 
  template <typename ListExportImageTasksRequestT = Model::ListExportImageTasksRequest>
  void ListExportImageTasksAsync(const ListExportImageTasksResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListExportImageTasksRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::ListExportImageTasks, request, handler, context);
  }
 
  virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const;
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const {
    return SubmitCallable(&AppStreamClient::ListTagsForResource, request);
  }
 
  template <typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
  void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::StartAppBlockBuilderOutcome StartAppBlockBuilder(const Model::StartAppBlockBuilderRequest& request) const;
 
  template <typename StartAppBlockBuilderRequestT = Model::StartAppBlockBuilderRequest>
  Model::StartAppBlockBuilderOutcomeCallable StartAppBlockBuilderCallable(const StartAppBlockBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::StartAppBlockBuilder, request);
  }
 
  template <typename StartAppBlockBuilderRequestT = Model::StartAppBlockBuilderRequest>
  void StartAppBlockBuilderAsync(const StartAppBlockBuilderRequestT& request, const StartAppBlockBuilderResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::StartAppBlockBuilder, request, handler, context);
  }
 
  virtual Model::StartFleetOutcome StartFleet(const Model::StartFleetRequest& request) const;
 
  template <typename StartFleetRequestT = Model::StartFleetRequest>
  Model::StartFleetOutcomeCallable StartFleetCallable(const StartFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::StartFleet, request);
  }
 
  template <typename StartFleetRequestT = Model::StartFleetRequest>
  void StartFleetAsync(const StartFleetRequestT& request, const StartFleetResponseReceivedHandler& handler,
                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::StartFleet, request, handler, context);
  }
 
  virtual Model::StartImageBuilderOutcome StartImageBuilder(const Model::StartImageBuilderRequest& request) const;
 
  template <typename StartImageBuilderRequestT = Model::StartImageBuilderRequest>
  Model::StartImageBuilderOutcomeCallable StartImageBuilderCallable(const StartImageBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::StartImageBuilder, request);
  }
 
  template <typename StartImageBuilderRequestT = Model::StartImageBuilderRequest>
  void StartImageBuilderAsync(const StartImageBuilderRequestT& request, const StartImageBuilderResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::StartImageBuilder, request, handler, context);
  }
 
  virtual Model::StartSoftwareDeploymentToImageBuilderOutcome StartSoftwareDeploymentToImageBuilder(
      const Model::StartSoftwareDeploymentToImageBuilderRequest& request) const;
 
  template <typename StartSoftwareDeploymentToImageBuilderRequestT = Model::StartSoftwareDeploymentToImageBuilderRequest>
  Model::StartSoftwareDeploymentToImageBuilderOutcomeCallable StartSoftwareDeploymentToImageBuilderCallable(
      const StartSoftwareDeploymentToImageBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::StartSoftwareDeploymentToImageBuilder, request);
  }
 
  template <typename StartSoftwareDeploymentToImageBuilderRequestT = Model::StartSoftwareDeploymentToImageBuilderRequest>
  void StartSoftwareDeploymentToImageBuilderAsync(const StartSoftwareDeploymentToImageBuilderRequestT& request,
                                                  const StartSoftwareDeploymentToImageBuilderResponseReceivedHandler& handler,
                                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::StartSoftwareDeploymentToImageBuilder, request, handler, context);
  }
 
  virtual Model::StopAppBlockBuilderOutcome StopAppBlockBuilder(const Model::StopAppBlockBuilderRequest& request) const;
 
  template <typename StopAppBlockBuilderRequestT = Model::StopAppBlockBuilderRequest>
  Model::StopAppBlockBuilderOutcomeCallable StopAppBlockBuilderCallable(const StopAppBlockBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::StopAppBlockBuilder, request);
  }
 
  template <typename StopAppBlockBuilderRequestT = Model::StopAppBlockBuilderRequest>
  void StopAppBlockBuilderAsync(const StopAppBlockBuilderRequestT& request, const StopAppBlockBuilderResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::StopAppBlockBuilder, request, handler, context);
  }
 
  virtual Model::StopFleetOutcome StopFleet(const Model::StopFleetRequest& request) const;
 
  template <typename StopFleetRequestT = Model::StopFleetRequest>
  Model::StopFleetOutcomeCallable StopFleetCallable(const StopFleetRequestT& request) const {
    return SubmitCallable(&AppStreamClient::StopFleet, request);
  }
 
  template <typename StopFleetRequestT = Model::StopFleetRequest>
  void StopFleetAsync(const StopFleetRequestT& request, const StopFleetResponseReceivedHandler& handler,
                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::StopFleet, request, handler, context);
  }
 
  virtual Model::StopImageBuilderOutcome StopImageBuilder(const Model::StopImageBuilderRequest& request) const;
 
  template <typename StopImageBuilderRequestT = Model::StopImageBuilderRequest>
  Model::StopImageBuilderOutcomeCallable StopImageBuilderCallable(const StopImageBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::StopImageBuilder, request);
  }
 
  template <typename StopImageBuilderRequestT = Model::StopImageBuilderRequest>
  void StopImageBuilderAsync(const StopImageBuilderRequestT& request, const StopImageBuilderResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::StopImageBuilder, request, handler, context);
  }
 
  virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const;
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const {
    return SubmitCallable(&AppStreamClient::TagResource, request);
  }
 
  template <typename TagResourceRequestT = Model::TagResourceRequest>
  void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::TagResource, request, handler, context);
  }
 
  virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const;
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UntagResource, request);
  }
 
  template <typename UntagResourceRequestT = Model::UntagResourceRequest>
  void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateAppBlockBuilderOutcome UpdateAppBlockBuilder(const Model::UpdateAppBlockBuilderRequest& request) const;
 
  template <typename UpdateAppBlockBuilderRequestT = Model::UpdateAppBlockBuilderRequest>
  Model::UpdateAppBlockBuilderOutcomeCallable UpdateAppBlockBuilderCallable(const UpdateAppBlockBuilderRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UpdateAppBlockBuilder, request);
  }
 
  template <typename UpdateAppBlockBuilderRequestT = Model::UpdateAppBlockBuilderRequest>
  void UpdateAppBlockBuilderAsync(const UpdateAppBlockBuilderRequestT& request, const UpdateAppBlockBuilderResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UpdateAppBlockBuilder, request, handler, context);
  }
 
  virtual Model::UpdateApplicationOutcome UpdateApplication(const Model::UpdateApplicationRequest& request) const;
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  Model::UpdateApplicationOutcomeCallable UpdateApplicationCallable(const UpdateApplicationRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UpdateApplication, request);
  }
 
  template <typename UpdateApplicationRequestT = Model::UpdateApplicationRequest>
  void UpdateApplicationAsync(const UpdateApplicationRequestT& request, const UpdateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UpdateApplication, request, handler, context);
  }
 
  virtual Model::UpdateDirectoryConfigOutcome UpdateDirectoryConfig(const Model::UpdateDirectoryConfigRequest& request) const;
 
  template <typename UpdateDirectoryConfigRequestT = Model::UpdateDirectoryConfigRequest>
  Model::UpdateDirectoryConfigOutcomeCallable UpdateDirectoryConfigCallable(const UpdateDirectoryConfigRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UpdateDirectoryConfig, request);
  }
 
  template <typename UpdateDirectoryConfigRequestT = Model::UpdateDirectoryConfigRequest>
  void UpdateDirectoryConfigAsync(const UpdateDirectoryConfigRequestT& request, const UpdateDirectoryConfigResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UpdateDirectoryConfig, request, handler, context);
  }
 
  virtual Model::UpdateEntitlementOutcome UpdateEntitlement(const Model::UpdateEntitlementRequest& request) const;
 
  template <typename UpdateEntitlementRequestT = Model::UpdateEntitlementRequest>
  Model::UpdateEntitlementOutcomeCallable UpdateEntitlementCallable(const UpdateEntitlementRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UpdateEntitlement, request);
  }
 
  template <typename UpdateEntitlementRequestT = Model::UpdateEntitlementRequest>
  void UpdateEntitlementAsync(const UpdateEntitlementRequestT& request, const UpdateEntitlementResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UpdateEntitlement, request, handler, context);
  }
 
  virtual Model::UpdateFleetOutcome UpdateFleet(const Model::UpdateFleetRequest& request = {}) const;
 
  template <typename UpdateFleetRequestT = Model::UpdateFleetRequest>
  Model::UpdateFleetOutcomeCallable UpdateFleetCallable(const UpdateFleetRequestT& request = {}) const {
    return SubmitCallable(&AppStreamClient::UpdateFleet, request);
  }
 
  template <typename UpdateFleetRequestT = Model::UpdateFleetRequest>
  void UpdateFleetAsync(const UpdateFleetResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                        const UpdateFleetRequestT& request = {}) const {
    return SubmitAsync(&AppStreamClient::UpdateFleet, request, handler, context);
  }
 
  virtual Model::UpdateImagePermissionsOutcome UpdateImagePermissions(const Model::UpdateImagePermissionsRequest& request) const;
 
  template <typename UpdateImagePermissionsRequestT = Model::UpdateImagePermissionsRequest>
  Model::UpdateImagePermissionsOutcomeCallable UpdateImagePermissionsCallable(const UpdateImagePermissionsRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UpdateImagePermissions, request);
  }
 
  template <typename UpdateImagePermissionsRequestT = Model::UpdateImagePermissionsRequest>
  void UpdateImagePermissionsAsync(const UpdateImagePermissionsRequestT& request,
                                   const UpdateImagePermissionsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UpdateImagePermissions, request, handler, context);
  }
 
  virtual Model::UpdateStackOutcome UpdateStack(const Model::UpdateStackRequest& request) const;
 
  template <typename UpdateStackRequestT = Model::UpdateStackRequest>
  Model::UpdateStackOutcomeCallable UpdateStackCallable(const UpdateStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UpdateStack, request);
  }
 
  template <typename UpdateStackRequestT = Model::UpdateStackRequest>
  void UpdateStackAsync(const UpdateStackRequestT& request, const UpdateStackResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UpdateStack, request, handler, context);
  }
 
  virtual Model::UpdateThemeForStackOutcome UpdateThemeForStack(const Model::UpdateThemeForStackRequest& request) const;
 
  template <typename UpdateThemeForStackRequestT = Model::UpdateThemeForStackRequest>
  Model::UpdateThemeForStackOutcomeCallable UpdateThemeForStackCallable(const UpdateThemeForStackRequestT& request) const {
    return SubmitCallable(&AppStreamClient::UpdateThemeForStack, request);
  }
 
  template <typename UpdateThemeForStackRequestT = Model::UpdateThemeForStackRequest>
  void UpdateThemeForStackAsync(const UpdateThemeForStackRequestT& request, const UpdateThemeForStackResponseReceivedHandler& handler,
                                const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AppStreamClient::UpdateThemeForStack, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<AppStreamEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AppStreamClient>;
  void init(const AppStreamClientConfiguration& clientConfiguration);
 
  AppStreamClientConfiguration m_clientConfiguration;
  std::shared_ptr<AppStreamEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AppStream
}  // namespace Aws