AppStreamClient.h

 
#pragma once
#include <aws/appstream/AppStream_EXPORTS.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/appstream/AppStreamServiceClientModel.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::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::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::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::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::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::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::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::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::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