AccountAccessClient.h

 
#pragma once
#include <aws/account-access/AccountAccessPaginationBase.h>
#include <aws/account-access/AccountAccessServiceClientModel.h>
#include <aws/account-access/AccountAccessWaiter.h>
#include <aws/account-access/AccountAccess_EXPORTS.h>
#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>
 
namespace Aws {
namespace AccountAccess {
class AWS_ACCOUNTACCESS_API AccountAccessClient : public Aws::Client::AWSJsonClient,
                                                  public Aws::Client::ClientWithAsyncTemplateMethods<AccountAccessClient>,
                                                  public AccountAccessPaginationBase<AccountAccessClient>,
                                                  public AccountAccessWaiter<AccountAccessClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef AccountAccessClientConfiguration ClientConfigurationType;
  typedef AccountAccessEndpointProvider EndpointProviderType;
 
  AccountAccessClient(const Aws::AccountAccess::AccountAccessClientConfiguration& clientConfiguration =
                          Aws::AccountAccess::AccountAccessClientConfiguration(),
                      std::shared_ptr<AccountAccessEndpointProviderBase> endpointProvider = nullptr);
 
  AccountAccessClient(const Aws::Auth::AWSCredentials& credentials,
                      std::shared_ptr<AccountAccessEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::AccountAccess::AccountAccessClientConfiguration& clientConfiguration =
                          Aws::AccountAccess::AccountAccessClientConfiguration());
 
  AccountAccessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      std::shared_ptr<AccountAccessEndpointProviderBase> endpointProvider = nullptr,
                      const Aws::AccountAccess::AccountAccessClientConfiguration& clientConfiguration =
                          Aws::AccountAccess::AccountAccessClientConfiguration());
 
  /* Legacy constructors due deprecation */
  AccountAccessClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AccountAccessClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  AccountAccessClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                      const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~AccountAccessClient();
 
  virtual Model::CreateApplicationOutcome CreateApplication(const Model::CreateApplicationRequest& request) const;
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  Model::CreateApplicationOutcomeCallable CreateApplicationCallable(const CreateApplicationRequestT& request) const {
    return SubmitCallable(&AccountAccessClient::CreateApplication, request);
  }
 
  template <typename CreateApplicationRequestT = Model::CreateApplicationRequest>
  void CreateApplicationAsync(const CreateApplicationRequestT& request, const CreateApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccountAccessClient::CreateApplication, request, handler, context);
  }
 
  virtual Model::CreateEntitlementOutcome CreateEntitlement(const Model::CreateEntitlementRequest& request) const;
 
  template <typename CreateEntitlementRequestT = Model::CreateEntitlementRequest>
  Model::CreateEntitlementOutcomeCallable CreateEntitlementCallable(const CreateEntitlementRequestT& request) const {
    return SubmitCallable(&AccountAccessClient::CreateEntitlement, request);
  }
 
  template <typename CreateEntitlementRequestT = Model::CreateEntitlementRequest>
  void CreateEntitlementAsync(const CreateEntitlementRequestT& request, const CreateEntitlementResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccountAccessClient::CreateEntitlement, request, handler, context);
  }
 
  virtual Model::DeleteApplicationOutcome DeleteApplication(const Model::DeleteApplicationRequest& request) const;
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  Model::DeleteApplicationOutcomeCallable DeleteApplicationCallable(const DeleteApplicationRequestT& request) const {
    return SubmitCallable(&AccountAccessClient::DeleteApplication, request);
  }
 
  template <typename DeleteApplicationRequestT = Model::DeleteApplicationRequest>
  void DeleteApplicationAsync(const DeleteApplicationRequestT& request, const DeleteApplicationResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccountAccessClient::DeleteApplication, request, handler, context);
  }
 
  virtual Model::DeleteEntitlementOutcome DeleteEntitlement(const Model::DeleteEntitlementRequest& request) const;
 
  template <typename DeleteEntitlementRequestT = Model::DeleteEntitlementRequest>
  Model::DeleteEntitlementOutcomeCallable DeleteEntitlementCallable(const DeleteEntitlementRequestT& request) const {
    return SubmitCallable(&AccountAccessClient::DeleteEntitlement, request);
  }
 
  template <typename DeleteEntitlementRequestT = Model::DeleteEntitlementRequest>
  void DeleteEntitlementAsync(const DeleteEntitlementRequestT& request, const DeleteEntitlementResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccountAccessClient::DeleteEntitlement, request, handler, context);
  }
 
  virtual Model::GetApplicationOutcome GetApplication(const Model::GetApplicationRequest& request) const;
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  Model::GetApplicationOutcomeCallable GetApplicationCallable(const GetApplicationRequestT& request) const {
    return SubmitCallable(&AccountAccessClient::GetApplication, request);
  }
 
  template <typename GetApplicationRequestT = Model::GetApplicationRequest>
  void GetApplicationAsync(const GetApplicationRequestT& request, const GetApplicationResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccountAccessClient::GetApplication, request, handler, context);
  }
 
  virtual Model::GetEntitlementOutcome GetEntitlement(const Model::GetEntitlementRequest& request) const;
 
  template <typename GetEntitlementRequestT = Model::GetEntitlementRequest>
  Model::GetEntitlementOutcomeCallable GetEntitlementCallable(const GetEntitlementRequestT& request) const {
    return SubmitCallable(&AccountAccessClient::GetEntitlement, request);
  }
 
  template <typename GetEntitlementRequestT = Model::GetEntitlementRequest>
  void GetEntitlementAsync(const GetEntitlementRequestT& request, const GetEntitlementResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccountAccessClient::GetEntitlement, request, handler, context);
  }
 
  virtual Model::ListApplicationsOutcome ListApplications(const Model::ListApplicationsRequest& request = {}) const;
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  Model::ListApplicationsOutcomeCallable ListApplicationsCallable(const ListApplicationsRequestT& request = {}) const {
    return SubmitCallable(&AccountAccessClient::ListApplications, request);
  }
 
  template <typename ListApplicationsRequestT = Model::ListApplicationsRequest>
  void ListApplicationsAsync(const ListApplicationsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListApplicationsRequestT& request = {}) const {
    return SubmitAsync(&AccountAccessClient::ListApplications, request, handler, context);
  }
 
  virtual Model::ListEntitlementsOutcome ListEntitlements(const Model::ListEntitlementsRequest& request) const;
 
  template <typename ListEntitlementsRequestT = Model::ListEntitlementsRequest>
  Model::ListEntitlementsOutcomeCallable ListEntitlementsCallable(const ListEntitlementsRequestT& request) const {
    return SubmitCallable(&AccountAccessClient::ListEntitlements, request);
  }
 
  template <typename ListEntitlementsRequestT = Model::ListEntitlementsRequest>
  void ListEntitlementsAsync(const ListEntitlementsRequestT& request, const ListEntitlementsResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&AccountAccessClient::ListEntitlements, 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(&AccountAccessClient::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(&AccountAccessClient::ListTagsForResource, 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(&AccountAccessClient::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(&AccountAccessClient::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(&AccountAccessClient::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(&AccountAccessClient::UntagResource, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<AccountAccessEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<AccountAccessClient>;
  void init(const AccountAccessClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, AccountAccessError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request,
                                                const std::function<void(Aws::Endpoint::ResolveEndpointOutcome&)>& resolveUri,
                                                Aws::Http::HttpMethod httpMethod) const;
 
  AccountAccessClientConfiguration m_clientConfiguration;
  std::shared_ptr<AccountAccessEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace AccountAccess
}  // namespace Aws