TranslateClient.h

 
#pragma once
#include <aws/translate/Translate_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/translate/TranslateServiceClientModel.h>
 
namespace Aws
{
namespace Translate
{
  class AWS_TRANSLATE_API TranslateClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<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);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<TranslateEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<TranslateClient>;
      void init(const TranslateClientConfiguration& clientConfiguration);
 
      TranslateClientConfiguration m_clientConfiguration;
      std::shared_ptr<TranslateEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Translate
} // namespace Aws