TranslateClient.h

 
#pragma once
#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>
#include <aws/translate/TranslatePaginationBase.h>
#include <aws/translate/TranslateServiceClientModel.h>
#include <aws/translate/TranslateWaiter.h>
#include <aws/translate/Translate_EXPORTS.h>
 
namespace Aws {
namespace Translate {
class AWS_TRANSLATE_API TranslateClient : public Aws::Client::AWSJsonClient,
                                          public Aws::Client::ClientWithAsyncTemplateMethods<TranslateClient>,
                                          public TranslatePaginationBase<TranslateClient>,
                                          public TranslateWaiter<TranslateClient> {
 public:
  typedef Aws::Client::AWSJsonClient BASECLASS;
  static const char* GetServiceName();
  static const char* GetAllocationTag();
 
  typedef TranslateClientConfiguration ClientConfigurationType;
  typedef TranslateEndpointProvider EndpointProviderType;
 
  TranslateClient(const Aws::Translate::TranslateClientConfiguration& clientConfiguration = Aws::Translate::TranslateClientConfiguration(),
                  std::shared_ptr<TranslateEndpointProviderBase> endpointProvider = nullptr);
 
  TranslateClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr<TranslateEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Translate::TranslateClientConfiguration& clientConfiguration = Aws::Translate::TranslateClientConfiguration());
 
  TranslateClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  std::shared_ptr<TranslateEndpointProviderBase> endpointProvider = nullptr,
                  const Aws::Translate::TranslateClientConfiguration& clientConfiguration = Aws::Translate::TranslateClientConfiguration());
 
  /* Legacy constructors due deprecation */
  TranslateClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TranslateClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration);
 
  TranslateClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                  const Aws::Client::ClientConfiguration& clientConfiguration);
 
  /* End of legacy constructors due deprecation */
  virtual ~TranslateClient();
 
  virtual Model::CreateParallelDataOutcome CreateParallelData(const Model::CreateParallelDataRequest& request) const;
 
  template <typename CreateParallelDataRequestT = Model::CreateParallelDataRequest>
  Model::CreateParallelDataOutcomeCallable CreateParallelDataCallable(const CreateParallelDataRequestT& request) const {
    return SubmitCallable(&TranslateClient::CreateParallelData, request);
  }
 
  template <typename CreateParallelDataRequestT = Model::CreateParallelDataRequest>
  void CreateParallelDataAsync(const CreateParallelDataRequestT& request, const CreateParallelDataResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::CreateParallelData, request, handler, context);
  }
 
  virtual Model::DeleteParallelDataOutcome DeleteParallelData(const Model::DeleteParallelDataRequest& request) const;
 
  template <typename DeleteParallelDataRequestT = Model::DeleteParallelDataRequest>
  Model::DeleteParallelDataOutcomeCallable DeleteParallelDataCallable(const DeleteParallelDataRequestT& request) const {
    return SubmitCallable(&TranslateClient::DeleteParallelData, request);
  }
 
  template <typename DeleteParallelDataRequestT = Model::DeleteParallelDataRequest>
  void DeleteParallelDataAsync(const DeleteParallelDataRequestT& request, const DeleteParallelDataResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::DeleteParallelData, request, handler, context);
  }
 
  virtual Model::DeleteTerminologyOutcome DeleteTerminology(const Model::DeleteTerminologyRequest& request) const;
 
  template <typename DeleteTerminologyRequestT = Model::DeleteTerminologyRequest>
  Model::DeleteTerminologyOutcomeCallable DeleteTerminologyCallable(const DeleteTerminologyRequestT& request) const {
    return SubmitCallable(&TranslateClient::DeleteTerminology, request);
  }
 
  template <typename DeleteTerminologyRequestT = Model::DeleteTerminologyRequest>
  void DeleteTerminologyAsync(const DeleteTerminologyRequestT& request, const DeleteTerminologyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::DeleteTerminology, request, handler, context);
  }
 
  virtual Model::DescribeTextTranslationJobOutcome DescribeTextTranslationJob(
      const Model::DescribeTextTranslationJobRequest& request) const;
 
  template <typename DescribeTextTranslationJobRequestT = Model::DescribeTextTranslationJobRequest>
  Model::DescribeTextTranslationJobOutcomeCallable DescribeTextTranslationJobCallable(
      const DescribeTextTranslationJobRequestT& request) const {
    return SubmitCallable(&TranslateClient::DescribeTextTranslationJob, request);
  }
 
  template <typename DescribeTextTranslationJobRequestT = Model::DescribeTextTranslationJobRequest>
  void DescribeTextTranslationJobAsync(const DescribeTextTranslationJobRequestT& request,
                                       const DescribeTextTranslationJobResponseReceivedHandler& handler,
                                       const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::DescribeTextTranslationJob, request, handler, context);
  }
 
  virtual Model::GetParallelDataOutcome GetParallelData(const Model::GetParallelDataRequest& request) const;
 
  template <typename GetParallelDataRequestT = Model::GetParallelDataRequest>
  Model::GetParallelDataOutcomeCallable GetParallelDataCallable(const GetParallelDataRequestT& request) const {
    return SubmitCallable(&TranslateClient::GetParallelData, request);
  }
 
  template <typename GetParallelDataRequestT = Model::GetParallelDataRequest>
  void GetParallelDataAsync(const GetParallelDataRequestT& request, const GetParallelDataResponseReceivedHandler& handler,
                            const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::GetParallelData, request, handler, context);
  }
 
  virtual Model::GetTerminologyOutcome GetTerminology(const Model::GetTerminologyRequest& request) const;
 
  template <typename GetTerminologyRequestT = Model::GetTerminologyRequest>
  Model::GetTerminologyOutcomeCallable GetTerminologyCallable(const GetTerminologyRequestT& request) const {
    return SubmitCallable(&TranslateClient::GetTerminology, request);
  }
 
  template <typename GetTerminologyRequestT = Model::GetTerminologyRequest>
  void GetTerminologyAsync(const GetTerminologyRequestT& request, const GetTerminologyResponseReceivedHandler& handler,
                           const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::GetTerminology, request, handler, context);
  }
 
  virtual Model::ImportTerminologyOutcome ImportTerminology(const Model::ImportTerminologyRequest& request) const;
 
  template <typename ImportTerminologyRequestT = Model::ImportTerminologyRequest>
  Model::ImportTerminologyOutcomeCallable ImportTerminologyCallable(const ImportTerminologyRequestT& request) const {
    return SubmitCallable(&TranslateClient::ImportTerminology, request);
  }
 
  template <typename ImportTerminologyRequestT = Model::ImportTerminologyRequest>
  void ImportTerminologyAsync(const ImportTerminologyRequestT& request, const ImportTerminologyResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::ImportTerminology, request, handler, context);
  }
 
  virtual Model::ListLanguagesOutcome ListLanguages(const Model::ListLanguagesRequest& request = {}) const;
 
  template <typename ListLanguagesRequestT = Model::ListLanguagesRequest>
  Model::ListLanguagesOutcomeCallable ListLanguagesCallable(const ListLanguagesRequestT& request = {}) const {
    return SubmitCallable(&TranslateClient::ListLanguages, request);
  }
 
  template <typename ListLanguagesRequestT = Model::ListLanguagesRequest>
  void ListLanguagesAsync(const ListLanguagesResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                          const ListLanguagesRequestT& request = {}) const {
    return SubmitAsync(&TranslateClient::ListLanguages, request, handler, context);
  }
 
  virtual Model::ListParallelDataOutcome ListParallelData(const Model::ListParallelDataRequest& request = {}) const;
 
  template <typename ListParallelDataRequestT = Model::ListParallelDataRequest>
  Model::ListParallelDataOutcomeCallable ListParallelDataCallable(const ListParallelDataRequestT& request = {}) const {
    return SubmitCallable(&TranslateClient::ListParallelData, request);
  }
 
  template <typename ListParallelDataRequestT = Model::ListParallelDataRequest>
  void ListParallelDataAsync(const ListParallelDataResponseReceivedHandler& handler,
                             const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                             const ListParallelDataRequestT& request = {}) const {
    return SubmitAsync(&TranslateClient::ListParallelData, 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(&TranslateClient::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(&TranslateClient::ListTagsForResource, request, handler, context);
  }
 
  virtual Model::ListTerminologiesOutcome ListTerminologies(const Model::ListTerminologiesRequest& request = {}) const;
 
  template <typename ListTerminologiesRequestT = Model::ListTerminologiesRequest>
  Model::ListTerminologiesOutcomeCallable ListTerminologiesCallable(const ListTerminologiesRequestT& request = {}) const {
    return SubmitCallable(&TranslateClient::ListTerminologies, request);
  }
 
  template <typename ListTerminologiesRequestT = Model::ListTerminologiesRequest>
  void ListTerminologiesAsync(const ListTerminologiesResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                              const ListTerminologiesRequestT& request = {}) const {
    return SubmitAsync(&TranslateClient::ListTerminologies, request, handler, context);
  }
 
  virtual Model::ListTextTranslationJobsOutcome ListTextTranslationJobs(const Model::ListTextTranslationJobsRequest& request = {}) const;
 
  template <typename ListTextTranslationJobsRequestT = Model::ListTextTranslationJobsRequest>
  Model::ListTextTranslationJobsOutcomeCallable ListTextTranslationJobsCallable(const ListTextTranslationJobsRequestT& request = {}) const {
    return SubmitCallable(&TranslateClient::ListTextTranslationJobs, request);
  }
 
  template <typename ListTextTranslationJobsRequestT = Model::ListTextTranslationJobsRequest>
  void ListTextTranslationJobsAsync(const ListTextTranslationJobsResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr,
                                    const ListTextTranslationJobsRequestT& request = {}) const {
    return SubmitAsync(&TranslateClient::ListTextTranslationJobs, request, handler, context);
  }
 
  virtual Model::StartTextTranslationJobOutcome StartTextTranslationJob(const Model::StartTextTranslationJobRequest& request) const;
 
  template <typename StartTextTranslationJobRequestT = Model::StartTextTranslationJobRequest>
  Model::StartTextTranslationJobOutcomeCallable StartTextTranslationJobCallable(const StartTextTranslationJobRequestT& request) const {
    return SubmitCallable(&TranslateClient::StartTextTranslationJob, request);
  }
 
  template <typename StartTextTranslationJobRequestT = Model::StartTextTranslationJobRequest>
  void StartTextTranslationJobAsync(const StartTextTranslationJobRequestT& request,
                                    const StartTextTranslationJobResponseReceivedHandler& handler,
                                    const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::StartTextTranslationJob, request, handler, context);
  }
 
  virtual Model::StopTextTranslationJobOutcome StopTextTranslationJob(const Model::StopTextTranslationJobRequest& request) const;
 
  template <typename StopTextTranslationJobRequestT = Model::StopTextTranslationJobRequest>
  Model::StopTextTranslationJobOutcomeCallable StopTextTranslationJobCallable(const StopTextTranslationJobRequestT& request) const {
    return SubmitCallable(&TranslateClient::StopTextTranslationJob, request);
  }
 
  template <typename StopTextTranslationJobRequestT = Model::StopTextTranslationJobRequest>
  void StopTextTranslationJobAsync(const StopTextTranslationJobRequestT& request,
                                   const StopTextTranslationJobResponseReceivedHandler& handler,
                                   const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::StopTextTranslationJob, 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(&TranslateClient::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(&TranslateClient::TagResource, request, handler, context);
  }
 
  virtual Model::TranslateDocumentOutcome TranslateDocument(const Model::TranslateDocumentRequest& request) const;
 
  template <typename TranslateDocumentRequestT = Model::TranslateDocumentRequest>
  Model::TranslateDocumentOutcomeCallable TranslateDocumentCallable(const TranslateDocumentRequestT& request) const {
    return SubmitCallable(&TranslateClient::TranslateDocument, request);
  }
 
  template <typename TranslateDocumentRequestT = Model::TranslateDocumentRequest>
  void TranslateDocumentAsync(const TranslateDocumentRequestT& request, const TranslateDocumentResponseReceivedHandler& handler,
                              const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::TranslateDocument, request, handler, context);
  }
 
  virtual Model::TranslateTextOutcome TranslateText(const Model::TranslateTextRequest& request) const;
 
  template <typename TranslateTextRequestT = Model::TranslateTextRequest>
  Model::TranslateTextOutcomeCallable TranslateTextCallable(const TranslateTextRequestT& request) const {
    return SubmitCallable(&TranslateClient::TranslateText, request);
  }
 
  template <typename TranslateTextRequestT = Model::TranslateTextRequest>
  void TranslateTextAsync(const TranslateTextRequestT& request, const TranslateTextResponseReceivedHandler& handler,
                          const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::TranslateText, 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(&TranslateClient::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(&TranslateClient::UntagResource, request, handler, context);
  }
 
  virtual Model::UpdateParallelDataOutcome UpdateParallelData(const Model::UpdateParallelDataRequest& request) const;
 
  template <typename UpdateParallelDataRequestT = Model::UpdateParallelDataRequest>
  Model::UpdateParallelDataOutcomeCallable UpdateParallelDataCallable(const UpdateParallelDataRequestT& request) const {
    return SubmitCallable(&TranslateClient::UpdateParallelData, request);
  }
 
  template <typename UpdateParallelDataRequestT = Model::UpdateParallelDataRequest>
  void UpdateParallelDataAsync(const UpdateParallelDataRequestT& request, const UpdateParallelDataResponseReceivedHandler& handler,
                               const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const {
    return SubmitAsync(&TranslateClient::UpdateParallelData, request, handler, context);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<TranslateEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TranslateClient>;
  void init(const TranslateClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, TranslateError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  TranslateClientConfiguration m_clientConfiguration;
  std::shared_ptr<TranslateEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Translate
}  // namespace Aws