ServiceQuotasClient.h

 
#pragma once
#include <aws/service-quotas/ServiceQuotas_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/service-quotas/ServiceQuotasServiceClientModel.h>
 
namespace Aws
{
namespace ServiceQuotas
{
  class AWS_SERVICEQUOTAS_API ServiceQuotasClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<ServiceQuotasClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef ServiceQuotasClientConfiguration ClientConfigurationType;
      typedef ServiceQuotasEndpointProvider EndpointProviderType;
 
        ServiceQuotasClient(const Aws::ServiceQuotas::ServiceQuotasClientConfiguration& clientConfiguration = Aws::ServiceQuotas::ServiceQuotasClientConfiguration(),
                            std::shared_ptr<ServiceQuotasEndpointProviderBase> endpointProvider = nullptr);
 
        ServiceQuotasClient(const Aws::Auth::AWSCredentials& credentials,
                            std::shared_ptr<ServiceQuotasEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::ServiceQuotas::ServiceQuotasClientConfiguration& clientConfiguration = Aws::ServiceQuotas::ServiceQuotasClientConfiguration());
 
        ServiceQuotasClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            std::shared_ptr<ServiceQuotasEndpointProviderBase> endpointProvider = nullptr,
                            const Aws::ServiceQuotas::ServiceQuotasClientConfiguration& clientConfiguration = Aws::ServiceQuotas::ServiceQuotasClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        ServiceQuotasClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ServiceQuotasClient(const Aws::Auth::AWSCredentials& credentials,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        ServiceQuotasClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                            const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~ServiceQuotasClient();
 
        virtual Model::AssociateServiceQuotaTemplateOutcome AssociateServiceQuotaTemplate(const Model::AssociateServiceQuotaTemplateRequest& request = {}) const;
 
        template<typename AssociateServiceQuotaTemplateRequestT = Model::AssociateServiceQuotaTemplateRequest>
        Model::AssociateServiceQuotaTemplateOutcomeCallable AssociateServiceQuotaTemplateCallable(const AssociateServiceQuotaTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceQuotasClient::AssociateServiceQuotaTemplate, request);
        }
 
        template<typename AssociateServiceQuotaTemplateRequestT = Model::AssociateServiceQuotaTemplateRequest>
        void AssociateServiceQuotaTemplateAsync(const AssociateServiceQuotaTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const AssociateServiceQuotaTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceQuotasClient::AssociateServiceQuotaTemplate, request, handler, context);
        }
 
        virtual Model::DeleteServiceQuotaIncreaseRequestFromTemplateOutcome DeleteServiceQuotaIncreaseRequestFromTemplate(const Model::DeleteServiceQuotaIncreaseRequestFromTemplateRequest& request) const;
 
        template<typename DeleteServiceQuotaIncreaseRequestFromTemplateRequestT = Model::DeleteServiceQuotaIncreaseRequestFromTemplateRequest>
        Model::DeleteServiceQuotaIncreaseRequestFromTemplateOutcomeCallable DeleteServiceQuotaIncreaseRequestFromTemplateCallable(const DeleteServiceQuotaIncreaseRequestFromTemplateRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::DeleteServiceQuotaIncreaseRequestFromTemplate, request);
        }
 
        template<typename DeleteServiceQuotaIncreaseRequestFromTemplateRequestT = Model::DeleteServiceQuotaIncreaseRequestFromTemplateRequest>
        void DeleteServiceQuotaIncreaseRequestFromTemplateAsync(const DeleteServiceQuotaIncreaseRequestFromTemplateRequestT& request, const DeleteServiceQuotaIncreaseRequestFromTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::DeleteServiceQuotaIncreaseRequestFromTemplate, request, handler, context);
        }
 
        virtual Model::DisassociateServiceQuotaTemplateOutcome DisassociateServiceQuotaTemplate(const Model::DisassociateServiceQuotaTemplateRequest& request = {}) const;
 
        template<typename DisassociateServiceQuotaTemplateRequestT = Model::DisassociateServiceQuotaTemplateRequest>
        Model::DisassociateServiceQuotaTemplateOutcomeCallable DisassociateServiceQuotaTemplateCallable(const DisassociateServiceQuotaTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceQuotasClient::DisassociateServiceQuotaTemplate, request);
        }
 
        template<typename DisassociateServiceQuotaTemplateRequestT = Model::DisassociateServiceQuotaTemplateRequest>
        void DisassociateServiceQuotaTemplateAsync(const DisassociateServiceQuotaTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const DisassociateServiceQuotaTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceQuotasClient::DisassociateServiceQuotaTemplate, request, handler, context);
        }
 
        virtual Model::GetAWSDefaultServiceQuotaOutcome GetAWSDefaultServiceQuota(const Model::GetAWSDefaultServiceQuotaRequest& request) const;
 
        template<typename GetAWSDefaultServiceQuotaRequestT = Model::GetAWSDefaultServiceQuotaRequest>
        Model::GetAWSDefaultServiceQuotaOutcomeCallable GetAWSDefaultServiceQuotaCallable(const GetAWSDefaultServiceQuotaRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::GetAWSDefaultServiceQuota, request);
        }
 
        template<typename GetAWSDefaultServiceQuotaRequestT = Model::GetAWSDefaultServiceQuotaRequest>
        void GetAWSDefaultServiceQuotaAsync(const GetAWSDefaultServiceQuotaRequestT& request, const GetAWSDefaultServiceQuotaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::GetAWSDefaultServiceQuota, request, handler, context);
        }
 
        virtual Model::GetAssociationForServiceQuotaTemplateOutcome GetAssociationForServiceQuotaTemplate(const Model::GetAssociationForServiceQuotaTemplateRequest& request = {}) const;
 
        template<typename GetAssociationForServiceQuotaTemplateRequestT = Model::GetAssociationForServiceQuotaTemplateRequest>
        Model::GetAssociationForServiceQuotaTemplateOutcomeCallable GetAssociationForServiceQuotaTemplateCallable(const GetAssociationForServiceQuotaTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceQuotasClient::GetAssociationForServiceQuotaTemplate, request);
        }
 
        template<typename GetAssociationForServiceQuotaTemplateRequestT = Model::GetAssociationForServiceQuotaTemplateRequest>
        void GetAssociationForServiceQuotaTemplateAsync(const GetAssociationForServiceQuotaTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAssociationForServiceQuotaTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceQuotasClient::GetAssociationForServiceQuotaTemplate, request, handler, context);
        }
 
        virtual Model::GetRequestedServiceQuotaChangeOutcome GetRequestedServiceQuotaChange(const Model::GetRequestedServiceQuotaChangeRequest& request) const;
 
        template<typename GetRequestedServiceQuotaChangeRequestT = Model::GetRequestedServiceQuotaChangeRequest>
        Model::GetRequestedServiceQuotaChangeOutcomeCallable GetRequestedServiceQuotaChangeCallable(const GetRequestedServiceQuotaChangeRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::GetRequestedServiceQuotaChange, request);
        }
 
        template<typename GetRequestedServiceQuotaChangeRequestT = Model::GetRequestedServiceQuotaChangeRequest>
        void GetRequestedServiceQuotaChangeAsync(const GetRequestedServiceQuotaChangeRequestT& request, const GetRequestedServiceQuotaChangeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::GetRequestedServiceQuotaChange, request, handler, context);
        }
 
        virtual Model::GetServiceQuotaOutcome GetServiceQuota(const Model::GetServiceQuotaRequest& request) const;
 
        template<typename GetServiceQuotaRequestT = Model::GetServiceQuotaRequest>
        Model::GetServiceQuotaOutcomeCallable GetServiceQuotaCallable(const GetServiceQuotaRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::GetServiceQuota, request);
        }
 
        template<typename GetServiceQuotaRequestT = Model::GetServiceQuotaRequest>
        void GetServiceQuotaAsync(const GetServiceQuotaRequestT& request, const GetServiceQuotaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::GetServiceQuota, request, handler, context);
        }
 
        virtual Model::GetServiceQuotaIncreaseRequestFromTemplateOutcome GetServiceQuotaIncreaseRequestFromTemplate(const Model::GetServiceQuotaIncreaseRequestFromTemplateRequest& request) const;
 
        template<typename GetServiceQuotaIncreaseRequestFromTemplateRequestT = Model::GetServiceQuotaIncreaseRequestFromTemplateRequest>
        Model::GetServiceQuotaIncreaseRequestFromTemplateOutcomeCallable GetServiceQuotaIncreaseRequestFromTemplateCallable(const GetServiceQuotaIncreaseRequestFromTemplateRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::GetServiceQuotaIncreaseRequestFromTemplate, request);
        }
 
        template<typename GetServiceQuotaIncreaseRequestFromTemplateRequestT = Model::GetServiceQuotaIncreaseRequestFromTemplateRequest>
        void GetServiceQuotaIncreaseRequestFromTemplateAsync(const GetServiceQuotaIncreaseRequestFromTemplateRequestT& request, const GetServiceQuotaIncreaseRequestFromTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::GetServiceQuotaIncreaseRequestFromTemplate, request, handler, context);
        }
 
        virtual Model::ListAWSDefaultServiceQuotasOutcome ListAWSDefaultServiceQuotas(const Model::ListAWSDefaultServiceQuotasRequest& request) const;
 
        template<typename ListAWSDefaultServiceQuotasRequestT = Model::ListAWSDefaultServiceQuotasRequest>
        Model::ListAWSDefaultServiceQuotasOutcomeCallable ListAWSDefaultServiceQuotasCallable(const ListAWSDefaultServiceQuotasRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::ListAWSDefaultServiceQuotas, request);
        }
 
        template<typename ListAWSDefaultServiceQuotasRequestT = Model::ListAWSDefaultServiceQuotasRequest>
        void ListAWSDefaultServiceQuotasAsync(const ListAWSDefaultServiceQuotasRequestT& request, const ListAWSDefaultServiceQuotasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::ListAWSDefaultServiceQuotas, request, handler, context);
        }
 
        virtual Model::ListRequestedServiceQuotaChangeHistoryOutcome ListRequestedServiceQuotaChangeHistory(const Model::ListRequestedServiceQuotaChangeHistoryRequest& request = {}) const;
 
        template<typename ListRequestedServiceQuotaChangeHistoryRequestT = Model::ListRequestedServiceQuotaChangeHistoryRequest>
        Model::ListRequestedServiceQuotaChangeHistoryOutcomeCallable ListRequestedServiceQuotaChangeHistoryCallable(const ListRequestedServiceQuotaChangeHistoryRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceQuotasClient::ListRequestedServiceQuotaChangeHistory, request);
        }
 
        template<typename ListRequestedServiceQuotaChangeHistoryRequestT = Model::ListRequestedServiceQuotaChangeHistoryRequest>
        void ListRequestedServiceQuotaChangeHistoryAsync(const ListRequestedServiceQuotaChangeHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListRequestedServiceQuotaChangeHistoryRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceQuotasClient::ListRequestedServiceQuotaChangeHistory, request, handler, context);
        }
 
        virtual Model::ListRequestedServiceQuotaChangeHistoryByQuotaOutcome ListRequestedServiceQuotaChangeHistoryByQuota(const Model::ListRequestedServiceQuotaChangeHistoryByQuotaRequest& request) const;
 
        template<typename ListRequestedServiceQuotaChangeHistoryByQuotaRequestT = Model::ListRequestedServiceQuotaChangeHistoryByQuotaRequest>
        Model::ListRequestedServiceQuotaChangeHistoryByQuotaOutcomeCallable ListRequestedServiceQuotaChangeHistoryByQuotaCallable(const ListRequestedServiceQuotaChangeHistoryByQuotaRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::ListRequestedServiceQuotaChangeHistoryByQuota, request);
        }
 
        template<typename ListRequestedServiceQuotaChangeHistoryByQuotaRequestT = Model::ListRequestedServiceQuotaChangeHistoryByQuotaRequest>
        void ListRequestedServiceQuotaChangeHistoryByQuotaAsync(const ListRequestedServiceQuotaChangeHistoryByQuotaRequestT& request, const ListRequestedServiceQuotaChangeHistoryByQuotaResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::ListRequestedServiceQuotaChangeHistoryByQuota, request, handler, context);
        }
 
        virtual Model::ListServiceQuotaIncreaseRequestsInTemplateOutcome ListServiceQuotaIncreaseRequestsInTemplate(const Model::ListServiceQuotaIncreaseRequestsInTemplateRequest& request = {}) const;
 
        template<typename ListServiceQuotaIncreaseRequestsInTemplateRequestT = Model::ListServiceQuotaIncreaseRequestsInTemplateRequest>
        Model::ListServiceQuotaIncreaseRequestsInTemplateOutcomeCallable ListServiceQuotaIncreaseRequestsInTemplateCallable(const ListServiceQuotaIncreaseRequestsInTemplateRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceQuotasClient::ListServiceQuotaIncreaseRequestsInTemplate, request);
        }
 
        template<typename ListServiceQuotaIncreaseRequestsInTemplateRequestT = Model::ListServiceQuotaIncreaseRequestsInTemplateRequest>
        void ListServiceQuotaIncreaseRequestsInTemplateAsync(const ListServiceQuotaIncreaseRequestsInTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServiceQuotaIncreaseRequestsInTemplateRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceQuotasClient::ListServiceQuotaIncreaseRequestsInTemplate, request, handler, context);
        }
 
        virtual Model::ListServiceQuotasOutcome ListServiceQuotas(const Model::ListServiceQuotasRequest& request) const;
 
        template<typename ListServiceQuotasRequestT = Model::ListServiceQuotasRequest>
        Model::ListServiceQuotasOutcomeCallable ListServiceQuotasCallable(const ListServiceQuotasRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::ListServiceQuotas, request);
        }
 
        template<typename ListServiceQuotasRequestT = Model::ListServiceQuotasRequest>
        void ListServiceQuotasAsync(const ListServiceQuotasRequestT& request, const ListServiceQuotasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::ListServiceQuotas, request, handler, context);
        }
 
        virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request = {}) const;
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request = {}) const
        {
            return SubmitCallable(&ServiceQuotasClient::ListServices, request);
        }
 
        template<typename ListServicesRequestT = Model::ListServicesRequest>
        void ListServicesAsync(const ListServicesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListServicesRequestT& request = {}) const
        {
            return SubmitAsync(&ServiceQuotasClient::ListServices, 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(&ServiceQuotasClient::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(&ServiceQuotasClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::PutServiceQuotaIncreaseRequestIntoTemplateOutcome PutServiceQuotaIncreaseRequestIntoTemplate(const Model::PutServiceQuotaIncreaseRequestIntoTemplateRequest& request) const;
 
        template<typename PutServiceQuotaIncreaseRequestIntoTemplateRequestT = Model::PutServiceQuotaIncreaseRequestIntoTemplateRequest>
        Model::PutServiceQuotaIncreaseRequestIntoTemplateOutcomeCallable PutServiceQuotaIncreaseRequestIntoTemplateCallable(const PutServiceQuotaIncreaseRequestIntoTemplateRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::PutServiceQuotaIncreaseRequestIntoTemplate, request);
        }
 
        template<typename PutServiceQuotaIncreaseRequestIntoTemplateRequestT = Model::PutServiceQuotaIncreaseRequestIntoTemplateRequest>
        void PutServiceQuotaIncreaseRequestIntoTemplateAsync(const PutServiceQuotaIncreaseRequestIntoTemplateRequestT& request, const PutServiceQuotaIncreaseRequestIntoTemplateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::PutServiceQuotaIncreaseRequestIntoTemplate, request, handler, context);
        }
 
        virtual Model::RequestServiceQuotaIncreaseOutcome RequestServiceQuotaIncrease(const Model::RequestServiceQuotaIncreaseRequest& request) const;
 
        template<typename RequestServiceQuotaIncreaseRequestT = Model::RequestServiceQuotaIncreaseRequest>
        Model::RequestServiceQuotaIncreaseOutcomeCallable RequestServiceQuotaIncreaseCallable(const RequestServiceQuotaIncreaseRequestT& request) const
        {
            return SubmitCallable(&ServiceQuotasClient::RequestServiceQuotaIncrease, request);
        }
 
        template<typename RequestServiceQuotaIncreaseRequestT = Model::RequestServiceQuotaIncreaseRequest>
        void RequestServiceQuotaIncreaseAsync(const RequestServiceQuotaIncreaseRequestT& request, const RequestServiceQuotaIncreaseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&ServiceQuotasClient::RequestServiceQuotaIncrease, 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(&ServiceQuotasClient::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(&ServiceQuotasClient::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(&ServiceQuotasClient::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(&ServiceQuotasClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<ServiceQuotasEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<ServiceQuotasClient>;
      void init(const ServiceQuotasClientConfiguration& clientConfiguration);
 
      ServiceQuotasClientConfiguration m_clientConfiguration;
      std::shared_ptr<ServiceQuotasEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace ServiceQuotas
} // namespace Aws