LicenseManagerClient.h

 
#pragma once
#include <aws/core/client/AWSClient.h>
#include <aws/core/client/AWSClientAsyncCRTP.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/license-manager/LicenseManagerPaginationBase.h>
#include <aws/license-manager/LicenseManagerServiceClientModel.h>
#include <aws/license-manager/LicenseManager_EXPORTS.h>
 
namespace Aws {
namespace LicenseManager {
class AWS_LICENSEMANAGER_API LicenseManagerClient : public Aws::Client::AWSJsonClient,
                                                    public Aws::Client::ClientWithAsyncTemplateMethods<LicenseManagerClient>,
                                                    public LicenseManagerPaginationBase<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::CreateLicenseAssetGroupOutcome CreateLicenseAssetGroup(const Model::CreateLicenseAssetGroupRequest& request) const;
 
  template <typename CreateLicenseAssetGroupRequestT = Model::CreateLicenseAssetGroupRequest>
  Model::CreateLicenseAssetGroupOutcomeCallable CreateLicenseAssetGroupCallable(const CreateLicenseAssetGroupRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::CreateLicenseAssetGroup, request);
  }
 
  template <typename CreateLicenseAssetGroupRequestT = Model::CreateLicenseAssetGroupRequest>
  void CreateLicenseAssetGroupAsync(const CreateLicenseAssetGroupRequestT& request,
                                    const CreateLicenseAssetGroupResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::CreateLicenseAssetGroup, request, handler, context);
  }
 
  virtual Model::CreateLicenseAssetRulesetOutcome CreateLicenseAssetRuleset(const Model::CreateLicenseAssetRulesetRequest& request) const;
 
  template <typename CreateLicenseAssetRulesetRequestT = Model::CreateLicenseAssetRulesetRequest>
  Model::CreateLicenseAssetRulesetOutcomeCallable CreateLicenseAssetRulesetCallable(
      const CreateLicenseAssetRulesetRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::CreateLicenseAssetRuleset, request);
  }
 
  template <typename CreateLicenseAssetRulesetRequestT = Model::CreateLicenseAssetRulesetRequest>
  void CreateLicenseAssetRulesetAsync(const CreateLicenseAssetRulesetRequestT& request,
                                      const CreateLicenseAssetRulesetResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::CreateLicenseAssetRuleset, 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::DeleteLicenseAssetGroupOutcome DeleteLicenseAssetGroup(const Model::DeleteLicenseAssetGroupRequest& request) const;
 
  template <typename DeleteLicenseAssetGroupRequestT = Model::DeleteLicenseAssetGroupRequest>
  Model::DeleteLicenseAssetGroupOutcomeCallable DeleteLicenseAssetGroupCallable(const DeleteLicenseAssetGroupRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::DeleteLicenseAssetGroup, request);
  }
 
  template <typename DeleteLicenseAssetGroupRequestT = Model::DeleteLicenseAssetGroupRequest>
  void DeleteLicenseAssetGroupAsync(const DeleteLicenseAssetGroupRequestT& request,
                                    const DeleteLicenseAssetGroupResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::DeleteLicenseAssetGroup, request, handler, context);
  }
 
  virtual Model::DeleteLicenseAssetRulesetOutcome DeleteLicenseAssetRuleset(const Model::DeleteLicenseAssetRulesetRequest& request) const;
 
  template <typename DeleteLicenseAssetRulesetRequestT = Model::DeleteLicenseAssetRulesetRequest>
  Model::DeleteLicenseAssetRulesetOutcomeCallable DeleteLicenseAssetRulesetCallable(
      const DeleteLicenseAssetRulesetRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::DeleteLicenseAssetRuleset, request);
  }
 
  template <typename DeleteLicenseAssetRulesetRequestT = Model::DeleteLicenseAssetRulesetRequest>
  void DeleteLicenseAssetRulesetAsync(const DeleteLicenseAssetRulesetRequestT& request,
                                      const DeleteLicenseAssetRulesetResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::DeleteLicenseAssetRuleset, 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::GetLicenseAssetGroupOutcome GetLicenseAssetGroup(const Model::GetLicenseAssetGroupRequest& request) const;
 
  template <typename GetLicenseAssetGroupRequestT = Model::GetLicenseAssetGroupRequest>
  Model::GetLicenseAssetGroupOutcomeCallable GetLicenseAssetGroupCallable(const GetLicenseAssetGroupRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::GetLicenseAssetGroup, request);
  }
 
  template <typename GetLicenseAssetGroupRequestT = Model::GetLicenseAssetGroupRequest>
  void GetLicenseAssetGroupAsync(const GetLicenseAssetGroupRequestT& request, const GetLicenseAssetGroupResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::GetLicenseAssetGroup, request, handler, context);
  }
 
  virtual Model::GetLicenseAssetRulesetOutcome GetLicenseAssetRuleset(const Model::GetLicenseAssetRulesetRequest& request) const;
 
  template <typename GetLicenseAssetRulesetRequestT = Model::GetLicenseAssetRulesetRequest>
  Model::GetLicenseAssetRulesetOutcomeCallable GetLicenseAssetRulesetCallable(const GetLicenseAssetRulesetRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::GetLicenseAssetRuleset, request);
  }
 
  template <typename GetLicenseAssetRulesetRequestT = Model::GetLicenseAssetRulesetRequest>
  void GetLicenseAssetRulesetAsync(const GetLicenseAssetRulesetRequestT& request,
                                   const GetLicenseAssetRulesetResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::GetLicenseAssetRuleset, 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::ListAssetsForLicenseAssetGroupOutcome ListAssetsForLicenseAssetGroup(
      const Model::ListAssetsForLicenseAssetGroupRequest& request) const;
 
  template <typename ListAssetsForLicenseAssetGroupRequestT = Model::ListAssetsForLicenseAssetGroupRequest>
  Model::ListAssetsForLicenseAssetGroupOutcomeCallable ListAssetsForLicenseAssetGroupCallable(
      const ListAssetsForLicenseAssetGroupRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::ListAssetsForLicenseAssetGroup, request);
  }
 
  template <typename ListAssetsForLicenseAssetGroupRequestT = Model::ListAssetsForLicenseAssetGroupRequest>
  void ListAssetsForLicenseAssetGroupAsync(const ListAssetsForLicenseAssetGroupRequestT& request,
                                           const ListAssetsForLicenseAssetGroupResponseReceivedHandler& handler,
                                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::ListAssetsForLicenseAssetGroup, 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::ListLicenseAssetGroupsOutcome ListLicenseAssetGroups(const Model::ListLicenseAssetGroupsRequest& request = {}) const;
 
  template <typename ListLicenseAssetGroupsRequestT = Model::ListLicenseAssetGroupsRequest>
  Model::ListLicenseAssetGroupsOutcomeCallable ListLicenseAssetGroupsCallable(const ListLicenseAssetGroupsRequestT& request = {}) const {
    return SubmitCallable(&LicenseManagerClient::ListLicenseAssetGroups, request);
  }
 
  template <typename ListLicenseAssetGroupsRequestT = Model::ListLicenseAssetGroupsRequest>
  void ListLicenseAssetGroupsAsync(const ListLicenseAssetGroupsResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                   const ListLicenseAssetGroupsRequestT& request = {}) const {
    return SubmitAsync(&LicenseManagerClient::ListLicenseAssetGroups, request, handler, context);
  }
 
  virtual Model::ListLicenseAssetRulesetsOutcome ListLicenseAssetRulesets(const Model::ListLicenseAssetRulesetsRequest& request = {}) const;
 
  template <typename ListLicenseAssetRulesetsRequestT = Model::ListLicenseAssetRulesetsRequest>
  Model::ListLicenseAssetRulesetsOutcomeCallable ListLicenseAssetRulesetsCallable(
      const ListLicenseAssetRulesetsRequestT& request = {}) const {
    return SubmitCallable(&LicenseManagerClient::ListLicenseAssetRulesets, request);
  }
 
  template <typename ListLicenseAssetRulesetsRequestT = Model::ListLicenseAssetRulesetsRequest>
  void ListLicenseAssetRulesetsAsync(const ListLicenseAssetRulesetsResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                     const ListLicenseAssetRulesetsRequestT& request = {}) const {
    return SubmitAsync(&LicenseManagerClient::ListLicenseAssetRulesets, 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::ListLicenseConfigurationsForOrganizationOutcome ListLicenseConfigurationsForOrganization(
      const Model::ListLicenseConfigurationsForOrganizationRequest& request = {}) const;
 
  template <typename ListLicenseConfigurationsForOrganizationRequestT = Model::ListLicenseConfigurationsForOrganizationRequest>
  Model::ListLicenseConfigurationsForOrganizationOutcomeCallable ListLicenseConfigurationsForOrganizationCallable(
      const ListLicenseConfigurationsForOrganizationRequestT& request = {}) const {
    return SubmitCallable(&LicenseManagerClient::ListLicenseConfigurationsForOrganization, request);
  }
 
  template <typename ListLicenseConfigurationsForOrganizationRequestT = Model::ListLicenseConfigurationsForOrganizationRequest>
  void ListLicenseConfigurationsForOrganizationAsync(const ListLicenseConfigurationsForOrganizationResponseReceivedHandler& handler,
                                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                                     const ListLicenseConfigurationsForOrganizationRequestT& request = {}) const {
    return SubmitAsync(&LicenseManagerClient::ListLicenseConfigurationsForOrganization, 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::UpdateLicenseAssetGroupOutcome UpdateLicenseAssetGroup(const Model::UpdateLicenseAssetGroupRequest& request) const;
 
  template <typename UpdateLicenseAssetGroupRequestT = Model::UpdateLicenseAssetGroupRequest>
  Model::UpdateLicenseAssetGroupOutcomeCallable UpdateLicenseAssetGroupCallable(const UpdateLicenseAssetGroupRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::UpdateLicenseAssetGroup, request);
  }
 
  template <typename UpdateLicenseAssetGroupRequestT = Model::UpdateLicenseAssetGroupRequest>
  void UpdateLicenseAssetGroupAsync(const UpdateLicenseAssetGroupRequestT& request,
                                    const UpdateLicenseAssetGroupResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::UpdateLicenseAssetGroup, request, handler, context);
  }
 
  virtual Model::UpdateLicenseAssetRulesetOutcome UpdateLicenseAssetRuleset(const Model::UpdateLicenseAssetRulesetRequest& request) const;
 
  template <typename UpdateLicenseAssetRulesetRequestT = Model::UpdateLicenseAssetRulesetRequest>
  Model::UpdateLicenseAssetRulesetOutcomeCallable UpdateLicenseAssetRulesetCallable(
      const UpdateLicenseAssetRulesetRequestT& request) const {
    return SubmitCallable(&LicenseManagerClient::UpdateLicenseAssetRuleset, request);
  }
 
  template <typename UpdateLicenseAssetRulesetRequestT = Model::UpdateLicenseAssetRulesetRequest>
  void UpdateLicenseAssetRulesetAsync(const UpdateLicenseAssetRulesetRequestT& request,
                                      const UpdateLicenseAssetRulesetResponseReceivedHandler& handler,
                                      const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&LicenseManagerClient::UpdateLicenseAssetRuleset, 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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual 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