CloudControlApiClient.h

 
#pragma once
#include <aws/cloudcontrol/CloudControlApiServiceClientModel.h>
#include <aws/cloudcontrol/CloudControlApi_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 CloudControlApi {
class AWS_CLOUDCONTROLAPI_API CloudControlApiClient : public Aws::Client::AWSJsonClient,
                                                      public Aws::Client::ClientWithAsyncTemplateMethods<CloudControlApiClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef CloudControlApiClientConfiguration ClientConfigurationType;
  typedef CloudControlApiEndpointProvider EndpointProviderType;
 
  CloudControlApiClient(const Aws::CloudControlApi::CloudControlApiClientConfiguration& clientConfiguration =
                            Aws::CloudControlApi::CloudControlApiClientConfiguration(),
                        std::shared_ptr<CloudControlApiEndpointProviderBase> endpointProvider = nullptr);
 
  CloudControlApiClient(const Aws::Auth::AWSCredentials& credentials,
                        std::shared_ptr<CloudControlApiEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::CloudControlApi::CloudControlApiClientConfiguration& clientConfiguration =
                            Aws::CloudControlApi::CloudControlApiClientConfiguration());
 
  CloudControlApiClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        std::shared_ptr<CloudControlApiEndpointProviderBase> endpointProvider = nullptr,
                        const Aws::CloudControlApi::CloudControlApiClientConfiguration& clientConfiguration =
                            Aws::CloudControlApi::CloudControlApiClientConfiguration());
 
  /* Legacy constructors due deprecation */
  CloudControlApiClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudControlApiClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  CloudControlApiClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                        const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~CloudControlApiClient();
 
  virtual Model::CancelResourceRequestOutcome CancelResourceRequest(const Model::CancelResourceRequestRequest& request) const;
 
  template <typename CancelResourceRequestRequestT = Model::CancelResourceRequestRequest>
  Model::CancelResourceRequestOutcomeCallable CancelResourceRequestCallable(const CancelResourceRequestRequestT& request) const {
    return SubmitCallable(&CloudControlApiClient::CancelResourceRequest, request);
  }
 
  template <typename CancelResourceRequestRequestT = Model::CancelResourceRequestRequest>
  void CancelResourceRequestAsync(const CancelResourceRequestRequestT& request, const CancelResourceRequestResponseReceivedHandler& handler,
                                  const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudControlApiClient::CancelResourceRequest, request, handler, context);
  }
 
  virtual Model::CreateResourceOutcome CreateResource(const Model::CreateResourceRequest& request) const;
 
  template <typename CreateResourceRequestT = Model::CreateResourceRequest>
  Model::CreateResourceOutcomeCallable CreateResourceCallable(const CreateResourceRequestT& request) const {
    return SubmitCallable(&CloudControlApiClient::CreateResource, request);
  }
 
  template <typename CreateResourceRequestT = Model::CreateResourceRequest>
  void CreateResourceAsync(const CreateResourceRequestT& request, const CreateResourceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudControlApiClient::CreateResource, request, handler, context);
  }
 
  virtual Model::DeleteResourceOutcome DeleteResource(const Model::DeleteResourceRequest& request) const;
 
  template <typename DeleteResourceRequestT = Model::DeleteResourceRequest>
  Model::DeleteResourceOutcomeCallable DeleteResourceCallable(const DeleteResourceRequestT& request) const {
    return SubmitCallable(&CloudControlApiClient::DeleteResource, request);
  }
 
  template <typename DeleteResourceRequestT = Model::DeleteResourceRequest>
  void DeleteResourceAsync(const DeleteResourceRequestT& request, const DeleteResourceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudControlApiClient::DeleteResource, request, handler, context);
  }
 
  virtual Model::GetResourceOutcome GetResource(const Model::GetResourceRequest& request) const;
 
  template <typename GetResourceRequestT = Model::GetResourceRequest>
  Model::GetResourceOutcomeCallable GetResourceCallable(const GetResourceRequestT& request) const {
    return SubmitCallable(&CloudControlApiClient::GetResource, request);
  }
 
  template <typename GetResourceRequestT = Model::GetResourceRequest>
  void GetResourceAsync(const GetResourceRequestT& request, const GetResourceResponseReceivedHandler& handler,
                        const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudControlApiClient::GetResource, request, handler, context);
  }
 
  virtual Model::GetResourceRequestStatusOutcome GetResourceRequestStatus(const Model::GetResourceRequestStatusRequest& request) const;
 
  template <typename GetResourceRequestStatusRequestT = Model::GetResourceRequestStatusRequest>
  Model::GetResourceRequestStatusOutcomeCallable GetResourceRequestStatusCallable(const GetResourceRequestStatusRequestT& request) const {
    return SubmitCallable(&CloudControlApiClient::GetResourceRequestStatus, request);
  }
 
  template <typename GetResourceRequestStatusRequestT = Model::GetResourceRequestStatusRequest>
  void GetResourceRequestStatusAsync(const GetResourceRequestStatusRequestT& request,
                                     const GetResourceRequestStatusResponseReceivedHandler& handler,
                                     const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudControlApiClient::GetResourceRequestStatus, request, handler, context);
  }
 
  virtual Model::ListResourceRequestsOutcome ListResourceRequests(const Model::ListResourceRequestsRequest& request = {}) const;
 
  template <typename ListResourceRequestsRequestT = Model::ListResourceRequestsRequest>
  Model::ListResourceRequestsOutcomeCallable ListResourceRequestsCallable(const ListResourceRequestsRequestT& request = {}) const {
    return SubmitCallable(&CloudControlApiClient::ListResourceRequests, request);
  }
 
  template <typename ListResourceRequestsRequestT = Model::ListResourceRequestsRequest>
  void ListResourceRequestsAsync(const ListResourceRequestsResponseReceivedHandler& handler,
                                 const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                 const ListResourceRequestsRequestT& request = {}) const {
    return SubmitAsync(&CloudControlApiClient::ListResourceRequests, request, handler, context);
  }
 
  virtual Model::ListResourcesOutcome ListResources(const Model::ListResourcesRequest& request) const;
 
  template <typename ListResourcesRequestT = Model::ListResourcesRequest>
  Model::ListResourcesOutcomeCallable ListResourcesCallable(const ListResourcesRequestT& request) const {
    return SubmitCallable(&CloudControlApiClient::ListResources, request);
  }
 
  template <typename ListResourcesRequestT = Model::ListResourcesRequest>
  void ListResourcesAsync(const ListResourcesRequestT& request, const ListResourcesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudControlApiClient::ListResources, request, handler, context);
  }
 
  virtual Model::UpdateResourceOutcome UpdateResource(const Model::UpdateResourceRequest& request) const;
 
  template <typename UpdateResourceRequestT = Model::UpdateResourceRequest>
  Model::UpdateResourceOutcomeCallable UpdateResourceCallable(const UpdateResourceRequestT& request) const {
    return SubmitCallable(&CloudControlApiClient::UpdateResource, request);
  }
 
  template <typename UpdateResourceRequestT = Model::UpdateResourceRequest>
  void UpdateResourceAsync(const UpdateResourceRequestT& request, const UpdateResourceResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&CloudControlApiClient::UpdateResource, request, handler, context);
  }
 
  void OverrideEndpoint(const Aws::String& endpoint);
  std::shared_ptr<CloudControlApiEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<CloudControlApiClient>;
  void init(const CloudControlApiClientConfiguration& clientConfiguration);
 
  CloudControlApiClientConfiguration m_clientConfiguration;
  std::shared_ptr<CloudControlApiEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace CloudControlApi
}  // namespace Aws