FreeTierClient.h

 
#pragma once
#include <aws/freetier/FreeTier_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/freetier/FreeTierServiceClientModel.h>
 
namespace Aws
{
namespace FreeTier
{
  class AWS_FREETIER_API FreeTierClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<FreeTierClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef FreeTierClientConfiguration ClientConfigurationType;
      typedef FreeTierEndpointProvider EndpointProviderType;
 
        FreeTierClient(const Aws::FreeTier::FreeTierClientConfiguration& clientConfiguration = Aws::FreeTier::FreeTierClientConfiguration(),
                       std::shared_ptr<FreeTierEndpointProviderBase> endpointProvider = nullptr);
 
        FreeTierClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<FreeTierEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::FreeTier::FreeTierClientConfiguration& clientConfiguration = Aws::FreeTier::FreeTierClientConfiguration());
 
        FreeTierClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<FreeTierEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::FreeTier::FreeTierClientConfiguration& clientConfiguration = Aws::FreeTier::FreeTierClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        FreeTierClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FreeTierClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        FreeTierClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~FreeTierClient();
 
        virtual Model::GetAccountActivityOutcome GetAccountActivity(const Model::GetAccountActivityRequest& request) const;
 
        template<typename GetAccountActivityRequestT = Model::GetAccountActivityRequest>
        Model::GetAccountActivityOutcomeCallable GetAccountActivityCallable(const GetAccountActivityRequestT& request) const
        {
            return SubmitCallable(&FreeTierClient::GetAccountActivity, request);
        }
 
        template<typename GetAccountActivityRequestT = Model::GetAccountActivityRequest>
        void GetAccountActivityAsync(const GetAccountActivityRequestT& request, const GetAccountActivityResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FreeTierClient::GetAccountActivity, request, handler, context);
        }
 
        virtual Model::GetAccountPlanStateOutcome GetAccountPlanState(const Model::GetAccountPlanStateRequest& request = {}) const;
 
        template<typename GetAccountPlanStateRequestT = Model::GetAccountPlanStateRequest>
        Model::GetAccountPlanStateOutcomeCallable GetAccountPlanStateCallable(const GetAccountPlanStateRequestT& request = {}) const
        {
            return SubmitCallable(&FreeTierClient::GetAccountPlanState, request);
        }
 
        template<typename GetAccountPlanStateRequestT = Model::GetAccountPlanStateRequest>
        void GetAccountPlanStateAsync(const GetAccountPlanStateResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetAccountPlanStateRequestT& request = {}) const
        {
            return SubmitAsync(&FreeTierClient::GetAccountPlanState, request, handler, context);
        }
 
        virtual Model::GetFreeTierUsageOutcome GetFreeTierUsage(const Model::GetFreeTierUsageRequest& request = {}) const;
 
        template<typename GetFreeTierUsageRequestT = Model::GetFreeTierUsageRequest>
        Model::GetFreeTierUsageOutcomeCallable GetFreeTierUsageCallable(const GetFreeTierUsageRequestT& request = {}) const
        {
            return SubmitCallable(&FreeTierClient::GetFreeTierUsage, request);
        }
 
        template<typename GetFreeTierUsageRequestT = Model::GetFreeTierUsageRequest>
        void GetFreeTierUsageAsync(const GetFreeTierUsageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const GetFreeTierUsageRequestT& request = {}) const
        {
            return SubmitAsync(&FreeTierClient::GetFreeTierUsage, request, handler, context);
        }
 
        virtual Model::ListAccountActivitiesOutcome ListAccountActivities(const Model::ListAccountActivitiesRequest& request = {}) const;
 
        template<typename ListAccountActivitiesRequestT = Model::ListAccountActivitiesRequest>
        Model::ListAccountActivitiesOutcomeCallable ListAccountActivitiesCallable(const ListAccountActivitiesRequestT& request = {}) const
        {
            return SubmitCallable(&FreeTierClient::ListAccountActivities, request);
        }
 
        template<typename ListAccountActivitiesRequestT = Model::ListAccountActivitiesRequest>
        void ListAccountActivitiesAsync(const ListAccountActivitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAccountActivitiesRequestT& request = {}) const
        {
            return SubmitAsync(&FreeTierClient::ListAccountActivities, request, handler, context);
        }
 
        virtual Model::UpgradeAccountPlanOutcome UpgradeAccountPlan(const Model::UpgradeAccountPlanRequest& request) const;
 
        template<typename UpgradeAccountPlanRequestT = Model::UpgradeAccountPlanRequest>
        Model::UpgradeAccountPlanOutcomeCallable UpgradeAccountPlanCallable(const UpgradeAccountPlanRequestT& request) const
        {
            return SubmitCallable(&FreeTierClient::UpgradeAccountPlan, request);
        }
 
        template<typename UpgradeAccountPlanRequestT = Model::UpgradeAccountPlanRequest>
        void UpgradeAccountPlanAsync(const UpgradeAccountPlanRequestT& request, const UpgradeAccountPlanResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&FreeTierClient::UpgradeAccountPlan, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<FreeTierEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<FreeTierClient>;
      void init(const FreeTierClientConfiguration& clientConfiguration);
 
      FreeTierClientConfiguration m_clientConfiguration;
      std::shared_ptr<FreeTierEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace FreeTier
} // namespace Aws