BackupSearchClient.h

 
#pragma once
#include <aws/backupsearch/BackupSearch_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/backupsearch/BackupSearchServiceClientModel.h>
 
namespace Aws
{
namespace BackupSearch
{
  class AWS_BACKUPSEARCH_API BackupSearchClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<BackupSearchClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef BackupSearchClientConfiguration ClientConfigurationType;
      typedef BackupSearchEndpointProvider EndpointProviderType;
 
        BackupSearchClient(const Aws::BackupSearch::BackupSearchClientConfiguration& clientConfiguration = Aws::BackupSearch::BackupSearchClientConfiguration(),
                           std::shared_ptr<BackupSearchEndpointProviderBase> endpointProvider = nullptr);
 
        BackupSearchClient(const Aws::Auth::AWSCredentials& credentials,
                           std::shared_ptr<BackupSearchEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::BackupSearch::BackupSearchClientConfiguration& clientConfiguration = Aws::BackupSearch::BackupSearchClientConfiguration());
 
        BackupSearchClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           std::shared_ptr<BackupSearchEndpointProviderBase> endpointProvider = nullptr,
                           const Aws::BackupSearch::BackupSearchClientConfiguration& clientConfiguration = Aws::BackupSearch::BackupSearchClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        BackupSearchClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BackupSearchClient(const Aws::Auth::AWSCredentials& credentials,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        BackupSearchClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                           const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~BackupSearchClient();
 
        virtual Model::GetSearchJobOutcome GetSearchJob(const Model::GetSearchJobRequest& request) const;
 
        template<typename GetSearchJobRequestT = Model::GetSearchJobRequest>
        Model::GetSearchJobOutcomeCallable GetSearchJobCallable(const GetSearchJobRequestT& request) const
        {
            return SubmitCallable(&BackupSearchClient::GetSearchJob, request);
        }
 
        template<typename GetSearchJobRequestT = Model::GetSearchJobRequest>
        void GetSearchJobAsync(const GetSearchJobRequestT& request, const GetSearchJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupSearchClient::GetSearchJob, request, handler, context);
        }
 
        virtual Model::GetSearchResultExportJobOutcome GetSearchResultExportJob(const Model::GetSearchResultExportJobRequest& request) const;
 
        template<typename GetSearchResultExportJobRequestT = Model::GetSearchResultExportJobRequest>
        Model::GetSearchResultExportJobOutcomeCallable GetSearchResultExportJobCallable(const GetSearchResultExportJobRequestT& request) const
        {
            return SubmitCallable(&BackupSearchClient::GetSearchResultExportJob, request);
        }
 
        template<typename GetSearchResultExportJobRequestT = Model::GetSearchResultExportJobRequest>
        void GetSearchResultExportJobAsync(const GetSearchResultExportJobRequestT& request, const GetSearchResultExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupSearchClient::GetSearchResultExportJob, request, handler, context);
        }
 
        virtual Model::ListSearchJobBackupsOutcome ListSearchJobBackups(const Model::ListSearchJobBackupsRequest& request) const;
 
        template<typename ListSearchJobBackupsRequestT = Model::ListSearchJobBackupsRequest>
        Model::ListSearchJobBackupsOutcomeCallable ListSearchJobBackupsCallable(const ListSearchJobBackupsRequestT& request) const
        {
            return SubmitCallable(&BackupSearchClient::ListSearchJobBackups, request);
        }
 
        template<typename ListSearchJobBackupsRequestT = Model::ListSearchJobBackupsRequest>
        void ListSearchJobBackupsAsync(const ListSearchJobBackupsRequestT& request, const ListSearchJobBackupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupSearchClient::ListSearchJobBackups, request, handler, context);
        }
 
        virtual Model::ListSearchJobResultsOutcome ListSearchJobResults(const Model::ListSearchJobResultsRequest& request) const;
 
        template<typename ListSearchJobResultsRequestT = Model::ListSearchJobResultsRequest>
        Model::ListSearchJobResultsOutcomeCallable ListSearchJobResultsCallable(const ListSearchJobResultsRequestT& request) const
        {
            return SubmitCallable(&BackupSearchClient::ListSearchJobResults, request);
        }
 
        template<typename ListSearchJobResultsRequestT = Model::ListSearchJobResultsRequest>
        void ListSearchJobResultsAsync(const ListSearchJobResultsRequestT& request, const ListSearchJobResultsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupSearchClient::ListSearchJobResults, request, handler, context);
        }
 
        virtual Model::ListSearchJobsOutcome ListSearchJobs(const Model::ListSearchJobsRequest& request = {}) const;
 
        template<typename ListSearchJobsRequestT = Model::ListSearchJobsRequest>
        Model::ListSearchJobsOutcomeCallable ListSearchJobsCallable(const ListSearchJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupSearchClient::ListSearchJobs, request);
        }
 
        template<typename ListSearchJobsRequestT = Model::ListSearchJobsRequest>
        void ListSearchJobsAsync(const ListSearchJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSearchJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupSearchClient::ListSearchJobs, request, handler, context);
        }
 
        virtual Model::ListSearchResultExportJobsOutcome ListSearchResultExportJobs(const Model::ListSearchResultExportJobsRequest& request = {}) const;
 
        template<typename ListSearchResultExportJobsRequestT = Model::ListSearchResultExportJobsRequest>
        Model::ListSearchResultExportJobsOutcomeCallable ListSearchResultExportJobsCallable(const ListSearchResultExportJobsRequestT& request = {}) const
        {
            return SubmitCallable(&BackupSearchClient::ListSearchResultExportJobs, request);
        }
 
        template<typename ListSearchResultExportJobsRequestT = Model::ListSearchResultExportJobsRequest>
        void ListSearchResultExportJobsAsync(const ListSearchResultExportJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListSearchResultExportJobsRequestT& request = {}) const
        {
            return SubmitAsync(&BackupSearchClient::ListSearchResultExportJobs, 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(&BackupSearchClient::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(&BackupSearchClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartSearchJobOutcome StartSearchJob(const Model::StartSearchJobRequest& request) const;
 
        template<typename StartSearchJobRequestT = Model::StartSearchJobRequest>
        Model::StartSearchJobOutcomeCallable StartSearchJobCallable(const StartSearchJobRequestT& request) const
        {
            return SubmitCallable(&BackupSearchClient::StartSearchJob, request);
        }
 
        template<typename StartSearchJobRequestT = Model::StartSearchJobRequest>
        void StartSearchJobAsync(const StartSearchJobRequestT& request, const StartSearchJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupSearchClient::StartSearchJob, request, handler, context);
        }
 
        virtual Model::StartSearchResultExportJobOutcome StartSearchResultExportJob(const Model::StartSearchResultExportJobRequest& request) const;
 
        template<typename StartSearchResultExportJobRequestT = Model::StartSearchResultExportJobRequest>
        Model::StartSearchResultExportJobOutcomeCallable StartSearchResultExportJobCallable(const StartSearchResultExportJobRequestT& request) const
        {
            return SubmitCallable(&BackupSearchClient::StartSearchResultExportJob, request);
        }
 
        template<typename StartSearchResultExportJobRequestT = Model::StartSearchResultExportJobRequest>
        void StartSearchResultExportJobAsync(const StartSearchResultExportJobRequestT& request, const StartSearchResultExportJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupSearchClient::StartSearchResultExportJob, request, handler, context);
        }
 
        virtual Model::StopSearchJobOutcome StopSearchJob(const Model::StopSearchJobRequest& request) const;
 
        template<typename StopSearchJobRequestT = Model::StopSearchJobRequest>
        Model::StopSearchJobOutcomeCallable StopSearchJobCallable(const StopSearchJobRequestT& request) const
        {
            return SubmitCallable(&BackupSearchClient::StopSearchJob, request);
        }
 
        template<typename StopSearchJobRequestT = Model::StopSearchJobRequest>
        void StopSearchJobAsync(const StopSearchJobRequestT& request, const StopSearchJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&BackupSearchClient::StopSearchJob, 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(&BackupSearchClient::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(&BackupSearchClient::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(&BackupSearchClient::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(&BackupSearchClient::UntagResource, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<BackupSearchEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<BackupSearchClient>;
      void init(const BackupSearchClientConfiguration& clientConfiguration);
 
      BackupSearchClientConfiguration m_clientConfiguration;
      std::shared_ptr<BackupSearchEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace BackupSearch
} // namespace Aws