CloudControlApiClient.h

 
#pragma once
#include <aws/cloudcontrol/CloudControlApi_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/cloudcontrol/CloudControlApiServiceClientModel.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