LicenseManagerClient.h

 
#pragma once
#include <aws/license-manager/LicenseManager_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/license-manager/LicenseManagerServiceClientModel.h>
 
namespace Aws
{
namespace LicenseManager
{
  class AWS_LICENSEMANAGER_API LicenseManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<LicenseManagerClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef LicenseManagerClientConfiguration ClientConfigurationType;
      typedef LicenseManagerEndpointProvider EndpointProviderType;
 
        LicenseManagerClient(const Aws::LicenseManager::LicenseManagerClientConfiguration& clientConfiguration = Aws::LicenseManager::LicenseManagerClientConfiguration(),
                             std::shared_ptr<LicenseManagerEndpointProviderBase> endpointProvider = nullptr);
 
        LicenseManagerClient(const Aws::Auth::AWSCredentials& credentials,
                             std::shared_ptr<LicenseManagerEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::LicenseManager::LicenseManagerClientConfiguration& clientConfiguration = Aws::LicenseManager::LicenseManagerClientConfiguration());
 
        LicenseManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             std::shared_ptr<LicenseManagerEndpointProviderBase> endpointProvider = nullptr,
                             const Aws::LicenseManager::LicenseManagerClientConfiguration& clientConfiguration = Aws::LicenseManager::LicenseManagerClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        LicenseManagerClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LicenseManagerClient(const Aws::Auth::AWSCredentials& credentials,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LicenseManagerClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                             const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~LicenseManagerClient();
 
        virtual Model::AcceptGrantOutcome AcceptGrant(const Model::AcceptGrantRequest& request) const;
 
        template<typename AcceptGrantRequestT = Model::AcceptGrantRequest>
        Model::AcceptGrantOutcomeCallable AcceptGrantCallable(const AcceptGrantRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::AcceptGrant, request);
        }
 
        template<typename AcceptGrantRequestT = Model::AcceptGrantRequest>
        void AcceptGrantAsync(const AcceptGrantRequestT& request, const AcceptGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::AcceptGrant, request, handler, context);
        }
 
        virtual Model::CheckInLicenseOutcome CheckInLicense(const Model::CheckInLicenseRequest& request) const;
 
        template<typename CheckInLicenseRequestT = Model::CheckInLicenseRequest>
        Model::CheckInLicenseOutcomeCallable CheckInLicenseCallable(const CheckInLicenseRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CheckInLicense, request);
        }
 
        template<typename CheckInLicenseRequestT = Model::CheckInLicenseRequest>
        void CheckInLicenseAsync(const CheckInLicenseRequestT& request, const CheckInLicenseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CheckInLicense, request, handler, context);
        }
 
        virtual Model::CheckoutBorrowLicenseOutcome CheckoutBorrowLicense(const Model::CheckoutBorrowLicenseRequest& request) const;
 
        template<typename CheckoutBorrowLicenseRequestT = Model::CheckoutBorrowLicenseRequest>
        Model::CheckoutBorrowLicenseOutcomeCallable CheckoutBorrowLicenseCallable(const CheckoutBorrowLicenseRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CheckoutBorrowLicense, request);
        }
 
        template<typename CheckoutBorrowLicenseRequestT = Model::CheckoutBorrowLicenseRequest>
        void CheckoutBorrowLicenseAsync(const CheckoutBorrowLicenseRequestT& request, const CheckoutBorrowLicenseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CheckoutBorrowLicense, request, handler, context);
        }
 
        virtual Model::CheckoutLicenseOutcome CheckoutLicense(const Model::CheckoutLicenseRequest& request) const;
 
        template<typename CheckoutLicenseRequestT = Model::CheckoutLicenseRequest>
        Model::CheckoutLicenseOutcomeCallable CheckoutLicenseCallable(const CheckoutLicenseRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CheckoutLicense, request);
        }
 
        template<typename CheckoutLicenseRequestT = Model::CheckoutLicenseRequest>
        void CheckoutLicenseAsync(const CheckoutLicenseRequestT& request, const CheckoutLicenseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CheckoutLicense, request, handler, context);
        }
 
        virtual Model::CreateGrantOutcome CreateGrant(const Model::CreateGrantRequest& request) const;
 
        template<typename CreateGrantRequestT = Model::CreateGrantRequest>
        Model::CreateGrantOutcomeCallable CreateGrantCallable(const CreateGrantRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateGrant, request);
        }
 
        template<typename CreateGrantRequestT = Model::CreateGrantRequest>
        void CreateGrantAsync(const CreateGrantRequestT& request, const CreateGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateGrant, request, handler, context);
        }
 
        virtual Model::CreateGrantVersionOutcome CreateGrantVersion(const Model::CreateGrantVersionRequest& request) const;
 
        template<typename CreateGrantVersionRequestT = Model::CreateGrantVersionRequest>
        Model::CreateGrantVersionOutcomeCallable CreateGrantVersionCallable(const CreateGrantVersionRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateGrantVersion, request);
        }
 
        template<typename CreateGrantVersionRequestT = Model::CreateGrantVersionRequest>
        void CreateGrantVersionAsync(const CreateGrantVersionRequestT& request, const CreateGrantVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateGrantVersion, request, handler, context);
        }
 
        virtual Model::CreateLicenseOutcome CreateLicense(const Model::CreateLicenseRequest& request) const;
 
        template<typename CreateLicenseRequestT = Model::CreateLicenseRequest>
        Model::CreateLicenseOutcomeCallable CreateLicenseCallable(const CreateLicenseRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateLicense, request);
        }
 
        template<typename CreateLicenseRequestT = Model::CreateLicenseRequest>
        void CreateLicenseAsync(const CreateLicenseRequestT& request, const CreateLicenseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateLicense, request, handler, context);
        }
 
        virtual Model::CreateLicenseConfigurationOutcome CreateLicenseConfiguration(const Model::CreateLicenseConfigurationRequest& request) const;
 
        template<typename CreateLicenseConfigurationRequestT = Model::CreateLicenseConfigurationRequest>
        Model::CreateLicenseConfigurationOutcomeCallable CreateLicenseConfigurationCallable(const CreateLicenseConfigurationRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateLicenseConfiguration, request);
        }
 
        template<typename CreateLicenseConfigurationRequestT = Model::CreateLicenseConfigurationRequest>
        void CreateLicenseConfigurationAsync(const CreateLicenseConfigurationRequestT& request, const CreateLicenseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateLicenseConfiguration, request, handler, context);
        }
 
        virtual Model::CreateLicenseConversionTaskForResourceOutcome CreateLicenseConversionTaskForResource(const Model::CreateLicenseConversionTaskForResourceRequest& request) const;
 
        template<typename CreateLicenseConversionTaskForResourceRequestT = Model::CreateLicenseConversionTaskForResourceRequest>
        Model::CreateLicenseConversionTaskForResourceOutcomeCallable CreateLicenseConversionTaskForResourceCallable(const CreateLicenseConversionTaskForResourceRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateLicenseConversionTaskForResource, request);
        }
 
        template<typename CreateLicenseConversionTaskForResourceRequestT = Model::CreateLicenseConversionTaskForResourceRequest>
        void CreateLicenseConversionTaskForResourceAsync(const CreateLicenseConversionTaskForResourceRequestT& request, const CreateLicenseConversionTaskForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateLicenseConversionTaskForResource, request, handler, context);
        }
 
        virtual Model::CreateLicenseManagerReportGeneratorOutcome CreateLicenseManagerReportGenerator(const Model::CreateLicenseManagerReportGeneratorRequest& request) const;
 
        template<typename CreateLicenseManagerReportGeneratorRequestT = Model::CreateLicenseManagerReportGeneratorRequest>
        Model::CreateLicenseManagerReportGeneratorOutcomeCallable CreateLicenseManagerReportGeneratorCallable(const CreateLicenseManagerReportGeneratorRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateLicenseManagerReportGenerator, request);
        }
 
        template<typename CreateLicenseManagerReportGeneratorRequestT = Model::CreateLicenseManagerReportGeneratorRequest>
        void CreateLicenseManagerReportGeneratorAsync(const CreateLicenseManagerReportGeneratorRequestT& request, const CreateLicenseManagerReportGeneratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateLicenseManagerReportGenerator, request, handler, context);
        }
 
        virtual Model::CreateLicenseVersionOutcome CreateLicenseVersion(const Model::CreateLicenseVersionRequest& request) const;
 
        template<typename CreateLicenseVersionRequestT = Model::CreateLicenseVersionRequest>
        Model::CreateLicenseVersionOutcomeCallable CreateLicenseVersionCallable(const CreateLicenseVersionRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateLicenseVersion, request);
        }
 
        template<typename CreateLicenseVersionRequestT = Model::CreateLicenseVersionRequest>
        void CreateLicenseVersionAsync(const CreateLicenseVersionRequestT& request, const CreateLicenseVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateLicenseVersion, request, handler, context);
        }
 
        virtual Model::CreateTokenOutcome CreateToken(const Model::CreateTokenRequest& request) const;
 
        template<typename CreateTokenRequestT = Model::CreateTokenRequest>
        Model::CreateTokenOutcomeCallable CreateTokenCallable(const CreateTokenRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::CreateToken, request);
        }
 
        template<typename CreateTokenRequestT = Model::CreateTokenRequest>
        void CreateTokenAsync(const CreateTokenRequestT& request, const CreateTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::CreateToken, request, handler, context);
        }
 
        virtual Model::DeleteGrantOutcome DeleteGrant(const Model::DeleteGrantRequest& request) const;
 
        template<typename DeleteGrantRequestT = Model::DeleteGrantRequest>
        Model::DeleteGrantOutcomeCallable DeleteGrantCallable(const DeleteGrantRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::DeleteGrant, request);
        }
 
        template<typename DeleteGrantRequestT = Model::DeleteGrantRequest>
        void DeleteGrantAsync(const DeleteGrantRequestT& request, const DeleteGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::DeleteGrant, request, handler, context);
        }
 
        virtual Model::DeleteLicenseOutcome DeleteLicense(const Model::DeleteLicenseRequest& request) const;
 
        template<typename DeleteLicenseRequestT = Model::DeleteLicenseRequest>
        Model::DeleteLicenseOutcomeCallable DeleteLicenseCallable(const DeleteLicenseRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::DeleteLicense, request);
        }
 
        template<typename DeleteLicenseRequestT = Model::DeleteLicenseRequest>
        void DeleteLicenseAsync(const DeleteLicenseRequestT& request, const DeleteLicenseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::DeleteLicense, request, handler, context);
        }
 
        virtual Model::DeleteLicenseConfigurationOutcome DeleteLicenseConfiguration(const Model::DeleteLicenseConfigurationRequest& request) const;
 
        template<typename DeleteLicenseConfigurationRequestT = Model::DeleteLicenseConfigurationRequest>
        Model::DeleteLicenseConfigurationOutcomeCallable DeleteLicenseConfigurationCallable(const DeleteLicenseConfigurationRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::DeleteLicenseConfiguration, request);
        }
 
        template<typename DeleteLicenseConfigurationRequestT = Model::DeleteLicenseConfigurationRequest>
        void DeleteLicenseConfigurationAsync(const DeleteLicenseConfigurationRequestT& request, const DeleteLicenseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::DeleteLicenseConfiguration, request, handler, context);
        }
 
        virtual Model::DeleteLicenseManagerReportGeneratorOutcome DeleteLicenseManagerReportGenerator(const Model::DeleteLicenseManagerReportGeneratorRequest& request) const;
 
        template<typename DeleteLicenseManagerReportGeneratorRequestT = Model::DeleteLicenseManagerReportGeneratorRequest>
        Model::DeleteLicenseManagerReportGeneratorOutcomeCallable DeleteLicenseManagerReportGeneratorCallable(const DeleteLicenseManagerReportGeneratorRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::DeleteLicenseManagerReportGenerator, request);
        }
 
        template<typename DeleteLicenseManagerReportGeneratorRequestT = Model::DeleteLicenseManagerReportGeneratorRequest>
        void DeleteLicenseManagerReportGeneratorAsync(const DeleteLicenseManagerReportGeneratorRequestT& request, const DeleteLicenseManagerReportGeneratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::DeleteLicenseManagerReportGenerator, request, handler, context);
        }
 
        virtual Model::DeleteTokenOutcome DeleteToken(const Model::DeleteTokenRequest& request) const;
 
        template<typename DeleteTokenRequestT = Model::DeleteTokenRequest>
        Model::DeleteTokenOutcomeCallable DeleteTokenCallable(const DeleteTokenRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::DeleteToken, request);
        }
 
        template<typename DeleteTokenRequestT = Model::DeleteTokenRequest>
        void DeleteTokenAsync(const DeleteTokenRequestT& request, const DeleteTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::DeleteToken, request, handler, context);
        }
 
        virtual Model::ExtendLicenseConsumptionOutcome ExtendLicenseConsumption(const Model::ExtendLicenseConsumptionRequest& request) const;
 
        template<typename ExtendLicenseConsumptionRequestT = Model::ExtendLicenseConsumptionRequest>
        Model::ExtendLicenseConsumptionOutcomeCallable ExtendLicenseConsumptionCallable(const ExtendLicenseConsumptionRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::ExtendLicenseConsumption, request);
        }
 
        template<typename ExtendLicenseConsumptionRequestT = Model::ExtendLicenseConsumptionRequest>
        void ExtendLicenseConsumptionAsync(const ExtendLicenseConsumptionRequestT& request, const ExtendLicenseConsumptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::ExtendLicenseConsumption, request, handler, context);
        }
 
        virtual Model::GetAccessTokenOutcome GetAccessToken(const Model::GetAccessTokenRequest& request) const;
 
        template<typename GetAccessTokenRequestT = Model::GetAccessTokenRequest>
        Model::GetAccessTokenOutcomeCallable GetAccessTokenCallable(const GetAccessTokenRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::GetAccessToken, request);
        }
 
        template<typename GetAccessTokenRequestT = Model::GetAccessTokenRequest>
        void GetAccessTokenAsync(const GetAccessTokenRequestT& request, const GetAccessTokenResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::GetAccessToken, request, handler, context);
        }
 
        virtual Model::GetGrantOutcome GetGrant(const Model::GetGrantRequest& request) const;
 
        template<typename GetGrantRequestT = Model::GetGrantRequest>
        Model::GetGrantOutcomeCallable GetGrantCallable(const GetGrantRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::GetGrant, request);
        }
 
        template<typename GetGrantRequestT = Model::GetGrantRequest>
        void GetGrantAsync(const GetGrantRequestT& request, const GetGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::GetGrant, request, handler, context);
        }
 
        virtual Model::GetLicenseOutcome GetLicense(const Model::GetLicenseRequest& request) const;
 
        template<typename GetLicenseRequestT = Model::GetLicenseRequest>
        Model::GetLicenseOutcomeCallable GetLicenseCallable(const GetLicenseRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::GetLicense, request);
        }
 
        template<typename GetLicenseRequestT = Model::GetLicenseRequest>
        void GetLicenseAsync(const GetLicenseRequestT& request, const GetLicenseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::GetLicense, request, handler, context);
        }
 
        virtual Model::GetLicenseConfigurationOutcome GetLicenseConfiguration(const Model::GetLicenseConfigurationRequest& request) const;
 
        template<typename GetLicenseConfigurationRequestT = Model::GetLicenseConfigurationRequest>
        Model::GetLicenseConfigurationOutcomeCallable GetLicenseConfigurationCallable(const GetLicenseConfigurationRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::GetLicenseConfiguration, request);
        }
 
        template<typename GetLicenseConfigurationRequestT = Model::GetLicenseConfigurationRequest>
        void GetLicenseConfigurationAsync(const GetLicenseConfigurationRequestT& request, const GetLicenseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::GetLicenseConfiguration, request, handler, context);
        }
 
        virtual Model::GetLicenseConversionTaskOutcome GetLicenseConversionTask(const Model::GetLicenseConversionTaskRequest& request) const;
 
        template<typename GetLicenseConversionTaskRequestT = Model::GetLicenseConversionTaskRequest>
        Model::GetLicenseConversionTaskOutcomeCallable GetLicenseConversionTaskCallable(const GetLicenseConversionTaskRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::GetLicenseConversionTask, request);
        }
 
        template<typename GetLicenseConversionTaskRequestT = Model::GetLicenseConversionTaskRequest>
        void GetLicenseConversionTaskAsync(const GetLicenseConversionTaskRequestT& request, const GetLicenseConversionTaskResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::GetLicenseConversionTask, request, handler, context);
        }
 
        virtual Model::GetLicenseManagerReportGeneratorOutcome GetLicenseManagerReportGenerator(const Model::GetLicenseManagerReportGeneratorRequest& request) const;
 
        template<typename GetLicenseManagerReportGeneratorRequestT = Model::GetLicenseManagerReportGeneratorRequest>
        Model::GetLicenseManagerReportGeneratorOutcomeCallable GetLicenseManagerReportGeneratorCallable(const GetLicenseManagerReportGeneratorRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::GetLicenseManagerReportGenerator, request);
        }
 
        template<typename GetLicenseManagerReportGeneratorRequestT = Model::GetLicenseManagerReportGeneratorRequest>
        void GetLicenseManagerReportGeneratorAsync(const GetLicenseManagerReportGeneratorRequestT& request, const GetLicenseManagerReportGeneratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::GetLicenseManagerReportGenerator, request, handler, context);
        }
 
        virtual Model::GetLicenseUsageOutcome GetLicenseUsage(const Model::GetLicenseUsageRequest& request) const;
 
        template<typename GetLicenseUsageRequestT = Model::GetLicenseUsageRequest>
        Model::GetLicenseUsageOutcomeCallable GetLicenseUsageCallable(const GetLicenseUsageRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::GetLicenseUsage, request);
        }
 
        template<typename GetLicenseUsageRequestT = Model::GetLicenseUsageRequest>
        void GetLicenseUsageAsync(const GetLicenseUsageRequestT& request, const GetLicenseUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::GetLicenseUsage, request, handler, context);
        }
 
        virtual Model::GetServiceSettingsOutcome GetServiceSettings(const Model::GetServiceSettingsRequest& request = {}) const;
 
        template<typename GetServiceSettingsRequestT = Model::GetServiceSettingsRequest>
        Model::GetServiceSettingsOutcomeCallable GetServiceSettingsCallable(const GetServiceSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::GetServiceSettings, request);
        }
 
        template<typename GetServiceSettingsRequestT = Model::GetServiceSettingsRequest>
        void GetServiceSettingsAsync(const GetServiceSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetServiceSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::GetServiceSettings, request, handler, context);
        }
 
        virtual Model::ListAssociationsForLicenseConfigurationOutcome ListAssociationsForLicenseConfiguration(const Model::ListAssociationsForLicenseConfigurationRequest& request) const;
 
        template<typename ListAssociationsForLicenseConfigurationRequestT = Model::ListAssociationsForLicenseConfigurationRequest>
        Model::ListAssociationsForLicenseConfigurationOutcomeCallable ListAssociationsForLicenseConfigurationCallable(const ListAssociationsForLicenseConfigurationRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::ListAssociationsForLicenseConfiguration, request);
        }
 
        template<typename ListAssociationsForLicenseConfigurationRequestT = Model::ListAssociationsForLicenseConfigurationRequest>
        void ListAssociationsForLicenseConfigurationAsync(const ListAssociationsForLicenseConfigurationRequestT& request, const ListAssociationsForLicenseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::ListAssociationsForLicenseConfiguration, request, handler, context);
        }
 
        virtual Model::ListDistributedGrantsOutcome ListDistributedGrants(const Model::ListDistributedGrantsRequest& request = {}) const;
 
        template<typename ListDistributedGrantsRequestT = Model::ListDistributedGrantsRequest>
        Model::ListDistributedGrantsOutcomeCallable ListDistributedGrantsCallable(const ListDistributedGrantsRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListDistributedGrants, request);
        }
 
        template<typename ListDistributedGrantsRequestT = Model::ListDistributedGrantsRequest>
        void ListDistributedGrantsAsync(const ListDistributedGrantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListDistributedGrantsRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListDistributedGrants, request, handler, context);
        }
 
        virtual Model::ListFailuresForLicenseConfigurationOperationsOutcome ListFailuresForLicenseConfigurationOperations(const Model::ListFailuresForLicenseConfigurationOperationsRequest& request) const;
 
        template<typename ListFailuresForLicenseConfigurationOperationsRequestT = Model::ListFailuresForLicenseConfigurationOperationsRequest>
        Model::ListFailuresForLicenseConfigurationOperationsOutcomeCallable ListFailuresForLicenseConfigurationOperationsCallable(const ListFailuresForLicenseConfigurationOperationsRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::ListFailuresForLicenseConfigurationOperations, request);
        }
 
        template<typename ListFailuresForLicenseConfigurationOperationsRequestT = Model::ListFailuresForLicenseConfigurationOperationsRequest>
        void ListFailuresForLicenseConfigurationOperationsAsync(const ListFailuresForLicenseConfigurationOperationsRequestT& request, const ListFailuresForLicenseConfigurationOperationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::ListFailuresForLicenseConfigurationOperations, request, handler, context);
        }
 
        virtual Model::ListLicenseConfigurationsOutcome ListLicenseConfigurations(const Model::ListLicenseConfigurationsRequest& request = {}) const;
 
        template<typename ListLicenseConfigurationsRequestT = Model::ListLicenseConfigurationsRequest>
        Model::ListLicenseConfigurationsOutcomeCallable ListLicenseConfigurationsCallable(const ListLicenseConfigurationsRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListLicenseConfigurations, request);
        }
 
        template<typename ListLicenseConfigurationsRequestT = Model::ListLicenseConfigurationsRequest>
        void ListLicenseConfigurationsAsync(const ListLicenseConfigurationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLicenseConfigurationsRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListLicenseConfigurations, request, handler, context);
        }
 
        virtual Model::ListLicenseConversionTasksOutcome ListLicenseConversionTasks(const Model::ListLicenseConversionTasksRequest& request = {}) const;
 
        template<typename ListLicenseConversionTasksRequestT = Model::ListLicenseConversionTasksRequest>
        Model::ListLicenseConversionTasksOutcomeCallable ListLicenseConversionTasksCallable(const ListLicenseConversionTasksRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListLicenseConversionTasks, request);
        }
 
        template<typename ListLicenseConversionTasksRequestT = Model::ListLicenseConversionTasksRequest>
        void ListLicenseConversionTasksAsync(const ListLicenseConversionTasksResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLicenseConversionTasksRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListLicenseConversionTasks, request, handler, context);
        }
 
        virtual Model::ListLicenseManagerReportGeneratorsOutcome ListLicenseManagerReportGenerators(const Model::ListLicenseManagerReportGeneratorsRequest& request = {}) const;
 
        template<typename ListLicenseManagerReportGeneratorsRequestT = Model::ListLicenseManagerReportGeneratorsRequest>
        Model::ListLicenseManagerReportGeneratorsOutcomeCallable ListLicenseManagerReportGeneratorsCallable(const ListLicenseManagerReportGeneratorsRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListLicenseManagerReportGenerators, request);
        }
 
        template<typename ListLicenseManagerReportGeneratorsRequestT = Model::ListLicenseManagerReportGeneratorsRequest>
        void ListLicenseManagerReportGeneratorsAsync(const ListLicenseManagerReportGeneratorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLicenseManagerReportGeneratorsRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListLicenseManagerReportGenerators, request, handler, context);
        }
 
        virtual Model::ListLicenseSpecificationsForResourceOutcome ListLicenseSpecificationsForResource(const Model::ListLicenseSpecificationsForResourceRequest& request) const;
 
        template<typename ListLicenseSpecificationsForResourceRequestT = Model::ListLicenseSpecificationsForResourceRequest>
        Model::ListLicenseSpecificationsForResourceOutcomeCallable ListLicenseSpecificationsForResourceCallable(const ListLicenseSpecificationsForResourceRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::ListLicenseSpecificationsForResource, request);
        }
 
        template<typename ListLicenseSpecificationsForResourceRequestT = Model::ListLicenseSpecificationsForResourceRequest>
        void ListLicenseSpecificationsForResourceAsync(const ListLicenseSpecificationsForResourceRequestT& request, const ListLicenseSpecificationsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::ListLicenseSpecificationsForResource, request, handler, context);
        }
 
        virtual Model::ListLicenseVersionsOutcome ListLicenseVersions(const Model::ListLicenseVersionsRequest& request) const;
 
        template<typename ListLicenseVersionsRequestT = Model::ListLicenseVersionsRequest>
        Model::ListLicenseVersionsOutcomeCallable ListLicenseVersionsCallable(const ListLicenseVersionsRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::ListLicenseVersions, request);
        }
 
        template<typename ListLicenseVersionsRequestT = Model::ListLicenseVersionsRequest>
        void ListLicenseVersionsAsync(const ListLicenseVersionsRequestT& request, const ListLicenseVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::ListLicenseVersions, request, handler, context);
        }
 
        virtual Model::ListLicensesOutcome ListLicenses(const Model::ListLicensesRequest& request = {}) const;
 
        template<typename ListLicensesRequestT = Model::ListLicensesRequest>
        Model::ListLicensesOutcomeCallable ListLicensesCallable(const ListLicensesRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListLicenses, request);
        }
 
        template<typename ListLicensesRequestT = Model::ListLicensesRequest>
        void ListLicensesAsync(const ListLicensesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLicensesRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListLicenses, request, handler, context);
        }
 
        virtual Model::ListReceivedGrantsOutcome ListReceivedGrants(const Model::ListReceivedGrantsRequest& request = {}) const;
 
        template<typename ListReceivedGrantsRequestT = Model::ListReceivedGrantsRequest>
        Model::ListReceivedGrantsOutcomeCallable ListReceivedGrantsCallable(const ListReceivedGrantsRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListReceivedGrants, request);
        }
 
        template<typename ListReceivedGrantsRequestT = Model::ListReceivedGrantsRequest>
        void ListReceivedGrantsAsync(const ListReceivedGrantsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReceivedGrantsRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListReceivedGrants, request, handler, context);
        }
 
        virtual Model::ListReceivedGrantsForOrganizationOutcome ListReceivedGrantsForOrganization(const Model::ListReceivedGrantsForOrganizationRequest& request) const;
 
        template<typename ListReceivedGrantsForOrganizationRequestT = Model::ListReceivedGrantsForOrganizationRequest>
        Model::ListReceivedGrantsForOrganizationOutcomeCallable ListReceivedGrantsForOrganizationCallable(const ListReceivedGrantsForOrganizationRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::ListReceivedGrantsForOrganization, request);
        }
 
        template<typename ListReceivedGrantsForOrganizationRequestT = Model::ListReceivedGrantsForOrganizationRequest>
        void ListReceivedGrantsForOrganizationAsync(const ListReceivedGrantsForOrganizationRequestT& request, const ListReceivedGrantsForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::ListReceivedGrantsForOrganization, request, handler, context);
        }
 
        virtual Model::ListReceivedLicensesOutcome ListReceivedLicenses(const Model::ListReceivedLicensesRequest& request = {}) const;
 
        template<typename ListReceivedLicensesRequestT = Model::ListReceivedLicensesRequest>
        Model::ListReceivedLicensesOutcomeCallable ListReceivedLicensesCallable(const ListReceivedLicensesRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListReceivedLicenses, request);
        }
 
        template<typename ListReceivedLicensesRequestT = Model::ListReceivedLicensesRequest>
        void ListReceivedLicensesAsync(const ListReceivedLicensesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReceivedLicensesRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListReceivedLicenses, request, handler, context);
        }
 
        virtual Model::ListReceivedLicensesForOrganizationOutcome ListReceivedLicensesForOrganization(const Model::ListReceivedLicensesForOrganizationRequest& request = {}) const;
 
        template<typename ListReceivedLicensesForOrganizationRequestT = Model::ListReceivedLicensesForOrganizationRequest>
        Model::ListReceivedLicensesForOrganizationOutcomeCallable ListReceivedLicensesForOrganizationCallable(const ListReceivedLicensesForOrganizationRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListReceivedLicensesForOrganization, request);
        }
 
        template<typename ListReceivedLicensesForOrganizationRequestT = Model::ListReceivedLicensesForOrganizationRequest>
        void ListReceivedLicensesForOrganizationAsync(const ListReceivedLicensesForOrganizationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListReceivedLicensesForOrganizationRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListReceivedLicensesForOrganization, request, handler, context);
        }
 
        virtual Model::ListResourceInventoryOutcome ListResourceInventory(const Model::ListResourceInventoryRequest& request = {}) const;
 
        template<typename ListResourceInventoryRequestT = Model::ListResourceInventoryRequest>
        Model::ListResourceInventoryOutcomeCallable ListResourceInventoryCallable(const ListResourceInventoryRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListResourceInventory, request);
        }
 
        template<typename ListResourceInventoryRequestT = Model::ListResourceInventoryRequest>
        void ListResourceInventoryAsync(const ListResourceInventoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListResourceInventoryRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListResourceInventory, 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(&LicenseManagerClient::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(&LicenseManagerClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListTokensOutcome ListTokens(const Model::ListTokensRequest& request = {}) const;
 
        template<typename ListTokensRequestT = Model::ListTokensRequest>
        Model::ListTokensOutcomeCallable ListTokensCallable(const ListTokensRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::ListTokens, request);
        }
 
        template<typename ListTokensRequestT = Model::ListTokensRequest>
        void ListTokensAsync(const ListTokensResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListTokensRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::ListTokens, request, handler, context);
        }
 
        virtual Model::ListUsageForLicenseConfigurationOutcome ListUsageForLicenseConfiguration(const Model::ListUsageForLicenseConfigurationRequest& request) const;
 
        template<typename ListUsageForLicenseConfigurationRequestT = Model::ListUsageForLicenseConfigurationRequest>
        Model::ListUsageForLicenseConfigurationOutcomeCallable ListUsageForLicenseConfigurationCallable(const ListUsageForLicenseConfigurationRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::ListUsageForLicenseConfiguration, request);
        }
 
        template<typename ListUsageForLicenseConfigurationRequestT = Model::ListUsageForLicenseConfigurationRequest>
        void ListUsageForLicenseConfigurationAsync(const ListUsageForLicenseConfigurationRequestT& request, const ListUsageForLicenseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::ListUsageForLicenseConfiguration, request, handler, context);
        }
 
        virtual Model::RejectGrantOutcome RejectGrant(const Model::RejectGrantRequest& request) const;
 
        template<typename RejectGrantRequestT = Model::RejectGrantRequest>
        Model::RejectGrantOutcomeCallable RejectGrantCallable(const RejectGrantRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::RejectGrant, request);
        }
 
        template<typename RejectGrantRequestT = Model::RejectGrantRequest>
        void RejectGrantAsync(const RejectGrantRequestT& request, const RejectGrantResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::RejectGrant, 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(&LicenseManagerClient::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(&LicenseManagerClient::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(&LicenseManagerClient::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(&LicenseManagerClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateLicenseConfigurationOutcome UpdateLicenseConfiguration(const Model::UpdateLicenseConfigurationRequest& request) const;
 
        template<typename UpdateLicenseConfigurationRequestT = Model::UpdateLicenseConfigurationRequest>
        Model::UpdateLicenseConfigurationOutcomeCallable UpdateLicenseConfigurationCallable(const UpdateLicenseConfigurationRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::UpdateLicenseConfiguration, request);
        }
 
        template<typename UpdateLicenseConfigurationRequestT = Model::UpdateLicenseConfigurationRequest>
        void UpdateLicenseConfigurationAsync(const UpdateLicenseConfigurationRequestT& request, const UpdateLicenseConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::UpdateLicenseConfiguration, request, handler, context);
        }
 
        virtual Model::UpdateLicenseManagerReportGeneratorOutcome UpdateLicenseManagerReportGenerator(const Model::UpdateLicenseManagerReportGeneratorRequest& request) const;
 
        template<typename UpdateLicenseManagerReportGeneratorRequestT = Model::UpdateLicenseManagerReportGeneratorRequest>
        Model::UpdateLicenseManagerReportGeneratorOutcomeCallable UpdateLicenseManagerReportGeneratorCallable(const UpdateLicenseManagerReportGeneratorRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::UpdateLicenseManagerReportGenerator, request);
        }
 
        template<typename UpdateLicenseManagerReportGeneratorRequestT = Model::UpdateLicenseManagerReportGeneratorRequest>
        void UpdateLicenseManagerReportGeneratorAsync(const UpdateLicenseManagerReportGeneratorRequestT& request, const UpdateLicenseManagerReportGeneratorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::UpdateLicenseManagerReportGenerator, request, handler, context);
        }
 
        virtual Model::UpdateLicenseSpecificationsForResourceOutcome UpdateLicenseSpecificationsForResource(const Model::UpdateLicenseSpecificationsForResourceRequest& request) const;
 
        template<typename UpdateLicenseSpecificationsForResourceRequestT = Model::UpdateLicenseSpecificationsForResourceRequest>
        Model::UpdateLicenseSpecificationsForResourceOutcomeCallable UpdateLicenseSpecificationsForResourceCallable(const UpdateLicenseSpecificationsForResourceRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerClient::UpdateLicenseSpecificationsForResource, request);
        }
 
        template<typename UpdateLicenseSpecificationsForResourceRequestT = Model::UpdateLicenseSpecificationsForResourceRequest>
        void UpdateLicenseSpecificationsForResourceAsync(const UpdateLicenseSpecificationsForResourceRequestT& request, const UpdateLicenseSpecificationsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerClient::UpdateLicenseSpecificationsForResource, request, handler, context);
        }
 
        virtual Model::UpdateServiceSettingsOutcome UpdateServiceSettings(const Model::UpdateServiceSettingsRequest& request = {}) const;
 
        template<typename UpdateServiceSettingsRequestT = Model::UpdateServiceSettingsRequest>
        Model::UpdateServiceSettingsOutcomeCallable UpdateServiceSettingsCallable(const UpdateServiceSettingsRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerClient::UpdateServiceSettings, request);
        }
 
        template<typename UpdateServiceSettingsRequestT = Model::UpdateServiceSettingsRequest>
        void UpdateServiceSettingsAsync(const UpdateServiceSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const UpdateServiceSettingsRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerClient::UpdateServiceSettings, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LicenseManagerEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LicenseManagerClient>;
      void init(const LicenseManagerClientConfiguration& clientConfiguration);
 
      LicenseManagerClientConfiguration m_clientConfiguration;
      std::shared_ptr<LicenseManagerEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace LicenseManager
} // namespace Aws