LicenseManagerUserSubscriptionsClient.h

 
#pragma once
#include <aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptions_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-user-subscriptions/LicenseManagerUserSubscriptionsServiceClientModel.h>
 
namespace Aws
{
namespace LicenseManagerUserSubscriptions
{
  class AWS_LICENSEMANAGERUSERSUBSCRIPTIONS_API LicenseManagerUserSubscriptionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<LicenseManagerUserSubscriptionsClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef LicenseManagerUserSubscriptionsClientConfiguration ClientConfigurationType;
      typedef LicenseManagerUserSubscriptionsEndpointProvider EndpointProviderType;
 
        LicenseManagerUserSubscriptionsClient(const Aws::LicenseManagerUserSubscriptions::LicenseManagerUserSubscriptionsClientConfiguration& clientConfiguration = Aws::LicenseManagerUserSubscriptions::LicenseManagerUserSubscriptionsClientConfiguration(),
                                              std::shared_ptr<LicenseManagerUserSubscriptionsEndpointProviderBase> endpointProvider = nullptr);
 
        LicenseManagerUserSubscriptionsClient(const Aws::Auth::AWSCredentials& credentials,
                                              std::shared_ptr<LicenseManagerUserSubscriptionsEndpointProviderBase> endpointProvider = nullptr,
                                              const Aws::LicenseManagerUserSubscriptions::LicenseManagerUserSubscriptionsClientConfiguration& clientConfiguration = Aws::LicenseManagerUserSubscriptions::LicenseManagerUserSubscriptionsClientConfiguration());
 
        LicenseManagerUserSubscriptionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                              std::shared_ptr<LicenseManagerUserSubscriptionsEndpointProviderBase> endpointProvider = nullptr,
                                              const Aws::LicenseManagerUserSubscriptions::LicenseManagerUserSubscriptionsClientConfiguration& clientConfiguration = Aws::LicenseManagerUserSubscriptions::LicenseManagerUserSubscriptionsClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        LicenseManagerUserSubscriptionsClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LicenseManagerUserSubscriptionsClient(const Aws::Auth::AWSCredentials& credentials,
                                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        LicenseManagerUserSubscriptionsClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                                              const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~LicenseManagerUserSubscriptionsClient();
 
        virtual Model::AssociateUserOutcome AssociateUser(const Model::AssociateUserRequest& request) const;
 
        template<typename AssociateUserRequestT = Model::AssociateUserRequest>
        Model::AssociateUserOutcomeCallable AssociateUserCallable(const AssociateUserRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::AssociateUser, request);
        }
 
        template<typename AssociateUserRequestT = Model::AssociateUserRequest>
        void AssociateUserAsync(const AssociateUserRequestT& request, const AssociateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::AssociateUser, request, handler, context);
        }
 
        virtual Model::CreateLicenseServerEndpointOutcome CreateLicenseServerEndpoint(const Model::CreateLicenseServerEndpointRequest& request) const;
 
        template<typename CreateLicenseServerEndpointRequestT = Model::CreateLicenseServerEndpointRequest>
        Model::CreateLicenseServerEndpointOutcomeCallable CreateLicenseServerEndpointCallable(const CreateLicenseServerEndpointRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::CreateLicenseServerEndpoint, request);
        }
 
        template<typename CreateLicenseServerEndpointRequestT = Model::CreateLicenseServerEndpointRequest>
        void CreateLicenseServerEndpointAsync(const CreateLicenseServerEndpointRequestT& request, const CreateLicenseServerEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::CreateLicenseServerEndpoint, request, handler, context);
        }
 
        virtual Model::DeleteLicenseServerEndpointOutcome DeleteLicenseServerEndpoint(const Model::DeleteLicenseServerEndpointRequest& request) const;
 
        template<typename DeleteLicenseServerEndpointRequestT = Model::DeleteLicenseServerEndpointRequest>
        Model::DeleteLicenseServerEndpointOutcomeCallable DeleteLicenseServerEndpointCallable(const DeleteLicenseServerEndpointRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::DeleteLicenseServerEndpoint, request);
        }
 
        template<typename DeleteLicenseServerEndpointRequestT = Model::DeleteLicenseServerEndpointRequest>
        void DeleteLicenseServerEndpointAsync(const DeleteLicenseServerEndpointRequestT& request, const DeleteLicenseServerEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::DeleteLicenseServerEndpoint, request, handler, context);
        }
 
        virtual Model::DeregisterIdentityProviderOutcome DeregisterIdentityProvider(const Model::DeregisterIdentityProviderRequest& request = {}) const;
 
        template<typename DeregisterIdentityProviderRequestT = Model::DeregisterIdentityProviderRequest>
        Model::DeregisterIdentityProviderOutcomeCallable DeregisterIdentityProviderCallable(const DeregisterIdentityProviderRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::DeregisterIdentityProvider, request);
        }
 
        template<typename DeregisterIdentityProviderRequestT = Model::DeregisterIdentityProviderRequest>
        void DeregisterIdentityProviderAsync(const DeregisterIdentityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DeregisterIdentityProviderRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::DeregisterIdentityProvider, request, handler, context);
        }
 
        virtual Model::DisassociateUserOutcome DisassociateUser(const Model::DisassociateUserRequest& request = {}) const;
 
        template<typename DisassociateUserRequestT = Model::DisassociateUserRequest>
        Model::DisassociateUserOutcomeCallable DisassociateUserCallable(const DisassociateUserRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::DisassociateUser, request);
        }
 
        template<typename DisassociateUserRequestT = Model::DisassociateUserRequest>
        void DisassociateUserAsync(const DisassociateUserResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisassociateUserRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::DisassociateUser, request, handler, context);
        }
 
        virtual Model::ListIdentityProvidersOutcome ListIdentityProviders(const Model::ListIdentityProvidersRequest& request = {}) const;
 
        template<typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
        Model::ListIdentityProvidersOutcomeCallable ListIdentityProvidersCallable(const ListIdentityProvidersRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::ListIdentityProviders, request);
        }
 
        template<typename ListIdentityProvidersRequestT = Model::ListIdentityProvidersRequest>
        void ListIdentityProvidersAsync(const ListIdentityProvidersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListIdentityProvidersRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::ListIdentityProviders, request, handler, context);
        }
 
        virtual Model::ListInstancesOutcome ListInstances(const Model::ListInstancesRequest& request = {}) const;
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        Model::ListInstancesOutcomeCallable ListInstancesCallable(const ListInstancesRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::ListInstances, request);
        }
 
        template<typename ListInstancesRequestT = Model::ListInstancesRequest>
        void ListInstancesAsync(const ListInstancesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListInstancesRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::ListInstances, request, handler, context);
        }
 
        virtual Model::ListLicenseServerEndpointsOutcome ListLicenseServerEndpoints(const Model::ListLicenseServerEndpointsRequest& request = {}) const;
 
        template<typename ListLicenseServerEndpointsRequestT = Model::ListLicenseServerEndpointsRequest>
        Model::ListLicenseServerEndpointsOutcomeCallable ListLicenseServerEndpointsCallable(const ListLicenseServerEndpointsRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::ListLicenseServerEndpoints, request);
        }
 
        template<typename ListLicenseServerEndpointsRequestT = Model::ListLicenseServerEndpointsRequest>
        void ListLicenseServerEndpointsAsync(const ListLicenseServerEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListLicenseServerEndpointsRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::ListLicenseServerEndpoints, request, handler, context);
        }
 
        virtual Model::ListProductSubscriptionsOutcome ListProductSubscriptions(const Model::ListProductSubscriptionsRequest& request) const;
 
        template<typename ListProductSubscriptionsRequestT = Model::ListProductSubscriptionsRequest>
        Model::ListProductSubscriptionsOutcomeCallable ListProductSubscriptionsCallable(const ListProductSubscriptionsRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::ListProductSubscriptions, request);
        }
 
        template<typename ListProductSubscriptionsRequestT = Model::ListProductSubscriptionsRequest>
        void ListProductSubscriptionsAsync(const ListProductSubscriptionsRequestT& request, const ListProductSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::ListProductSubscriptions, 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(&LicenseManagerUserSubscriptionsClient::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(&LicenseManagerUserSubscriptionsClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::ListUserAssociationsOutcome ListUserAssociations(const Model::ListUserAssociationsRequest& request) const;
 
        template<typename ListUserAssociationsRequestT = Model::ListUserAssociationsRequest>
        Model::ListUserAssociationsOutcomeCallable ListUserAssociationsCallable(const ListUserAssociationsRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::ListUserAssociations, request);
        }
 
        template<typename ListUserAssociationsRequestT = Model::ListUserAssociationsRequest>
        void ListUserAssociationsAsync(const ListUserAssociationsRequestT& request, const ListUserAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::ListUserAssociations, request, handler, context);
        }
 
        virtual Model::RegisterIdentityProviderOutcome RegisterIdentityProvider(const Model::RegisterIdentityProviderRequest& request) const;
 
        template<typename RegisterIdentityProviderRequestT = Model::RegisterIdentityProviderRequest>
        Model::RegisterIdentityProviderOutcomeCallable RegisterIdentityProviderCallable(const RegisterIdentityProviderRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::RegisterIdentityProvider, request);
        }
 
        template<typename RegisterIdentityProviderRequestT = Model::RegisterIdentityProviderRequest>
        void RegisterIdentityProviderAsync(const RegisterIdentityProviderRequestT& request, const RegisterIdentityProviderResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::RegisterIdentityProvider, request, handler, context);
        }
 
        virtual Model::StartProductSubscriptionOutcome StartProductSubscription(const Model::StartProductSubscriptionRequest& request) const;
 
        template<typename StartProductSubscriptionRequestT = Model::StartProductSubscriptionRequest>
        Model::StartProductSubscriptionOutcomeCallable StartProductSubscriptionCallable(const StartProductSubscriptionRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::StartProductSubscription, request);
        }
 
        template<typename StartProductSubscriptionRequestT = Model::StartProductSubscriptionRequest>
        void StartProductSubscriptionAsync(const StartProductSubscriptionRequestT& request, const StartProductSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::StartProductSubscription, request, handler, context);
        }
 
        virtual Model::StopProductSubscriptionOutcome StopProductSubscription(const Model::StopProductSubscriptionRequest& request = {}) const;
 
        template<typename StopProductSubscriptionRequestT = Model::StopProductSubscriptionRequest>
        Model::StopProductSubscriptionOutcomeCallable StopProductSubscriptionCallable(const StopProductSubscriptionRequestT& request = {}) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::StopProductSubscription, request);
        }
 
        template<typename StopProductSubscriptionRequestT = Model::StopProductSubscriptionRequest>
        void StopProductSubscriptionAsync(const StopProductSubscriptionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const StopProductSubscriptionRequestT& request = {}) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::StopProductSubscription, 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(&LicenseManagerUserSubscriptionsClient::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(&LicenseManagerUserSubscriptionsClient::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(&LicenseManagerUserSubscriptionsClient::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(&LicenseManagerUserSubscriptionsClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateIdentityProviderSettingsOutcome UpdateIdentityProviderSettings(const Model::UpdateIdentityProviderSettingsRequest& request) const;
 
        template<typename UpdateIdentityProviderSettingsRequestT = Model::UpdateIdentityProviderSettingsRequest>
        Model::UpdateIdentityProviderSettingsOutcomeCallable UpdateIdentityProviderSettingsCallable(const UpdateIdentityProviderSettingsRequestT& request) const
        {
            return SubmitCallable(&LicenseManagerUserSubscriptionsClient::UpdateIdentityProviderSettings, request);
        }
 
        template<typename UpdateIdentityProviderSettingsRequestT = Model::UpdateIdentityProviderSettingsRequest>
        void UpdateIdentityProviderSettingsAsync(const UpdateIdentityProviderSettingsRequestT& request, const UpdateIdentityProviderSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&LicenseManagerUserSubscriptionsClient::UpdateIdentityProviderSettings, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<LicenseManagerUserSubscriptionsEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<LicenseManagerUserSubscriptionsClient>;
      void init(const LicenseManagerUserSubscriptionsClientConfiguration& clientConfiguration);
 
      LicenseManagerUserSubscriptionsClientConfiguration m_clientConfiguration;
      std::shared_ptr<LicenseManagerUserSubscriptionsEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace LicenseManagerUserSubscriptions
} // namespace Aws