TextractClient.h

 
#pragma once
#include <aws/textract/Textract_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/textract/TextractServiceClientModel.h>
 
namespace Aws
{
namespace Textract
{
  class AWS_TEXTRACT_API TextractClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<TextractClient>
  {
    public:
      typedef Aws::Client::AWSJsonClient BASECLASS;
      static const char* GetServiceName();
      static const char* GetAllocationTag();
 
      typedef TextractClientConfiguration ClientConfigurationType;
      typedef TextractEndpointProvider EndpointProviderType;
 
        TextractClient(const Aws::Textract::TextractClientConfiguration& clientConfiguration = Aws::Textract::TextractClientConfiguration(),
                       std::shared_ptr<TextractEndpointProviderBase> endpointProvider = nullptr);
 
        TextractClient(const Aws::Auth::AWSCredentials& credentials,
                       std::shared_ptr<TextractEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Textract::TextractClientConfiguration& clientConfiguration = Aws::Textract::TextractClientConfiguration());
 
        TextractClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       std::shared_ptr<TextractEndpointProviderBase> endpointProvider = nullptr,
                       const Aws::Textract::TextractClientConfiguration& clientConfiguration = Aws::Textract::TextractClientConfiguration());
 
 
        /* Legacy constructors due deprecation */
        TextractClient(const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TextractClient(const Aws::Auth::AWSCredentials& credentials,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        TextractClient(const std::shared_ptr<Aws::Auth::AWSCredentialsProvider>& credentialsProvider,
                       const Aws::Client::ClientConfiguration& clientConfiguration);
 
        /* End of legacy constructors due deprecation */
        virtual ~TextractClient();
 
        virtual Model::AnalyzeDocumentOutcome AnalyzeDocument(const Model::AnalyzeDocumentRequest& request) const;
 
        template<typename AnalyzeDocumentRequestT = Model::AnalyzeDocumentRequest>
        Model::AnalyzeDocumentOutcomeCallable AnalyzeDocumentCallable(const AnalyzeDocumentRequestT& request) const
        {
            return SubmitCallable(&TextractClient::AnalyzeDocument, request);
        }
 
        template<typename AnalyzeDocumentRequestT = Model::AnalyzeDocumentRequest>
        void AnalyzeDocumentAsync(const AnalyzeDocumentRequestT& request, const AnalyzeDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::AnalyzeDocument, request, handler, context);
        }
 
        virtual Model::AnalyzeExpenseOutcome AnalyzeExpense(const Model::AnalyzeExpenseRequest& request) const;
 
        template<typename AnalyzeExpenseRequestT = Model::AnalyzeExpenseRequest>
        Model::AnalyzeExpenseOutcomeCallable AnalyzeExpenseCallable(const AnalyzeExpenseRequestT& request) const
        {
            return SubmitCallable(&TextractClient::AnalyzeExpense, request);
        }
 
        template<typename AnalyzeExpenseRequestT = Model::AnalyzeExpenseRequest>
        void AnalyzeExpenseAsync(const AnalyzeExpenseRequestT& request, const AnalyzeExpenseResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::AnalyzeExpense, request, handler, context);
        }
 
        virtual Model::AnalyzeIDOutcome AnalyzeID(const Model::AnalyzeIDRequest& request) const;
 
        template<typename AnalyzeIDRequestT = Model::AnalyzeIDRequest>
        Model::AnalyzeIDOutcomeCallable AnalyzeIDCallable(const AnalyzeIDRequestT& request) const
        {
            return SubmitCallable(&TextractClient::AnalyzeID, request);
        }
 
        template<typename AnalyzeIDRequestT = Model::AnalyzeIDRequest>
        void AnalyzeIDAsync(const AnalyzeIDRequestT& request, const AnalyzeIDResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::AnalyzeID, request, handler, context);
        }
 
        virtual Model::CreateAdapterOutcome CreateAdapter(const Model::CreateAdapterRequest& request) const;
 
        template<typename CreateAdapterRequestT = Model::CreateAdapterRequest>
        Model::CreateAdapterOutcomeCallable CreateAdapterCallable(const CreateAdapterRequestT& request) const
        {
            return SubmitCallable(&TextractClient::CreateAdapter, request);
        }
 
        template<typename CreateAdapterRequestT = Model::CreateAdapterRequest>
        void CreateAdapterAsync(const CreateAdapterRequestT& request, const CreateAdapterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::CreateAdapter, request, handler, context);
        }
 
        virtual Model::CreateAdapterVersionOutcome CreateAdapterVersion(const Model::CreateAdapterVersionRequest& request) const;
 
        template<typename CreateAdapterVersionRequestT = Model::CreateAdapterVersionRequest>
        Model::CreateAdapterVersionOutcomeCallable CreateAdapterVersionCallable(const CreateAdapterVersionRequestT& request) const
        {
            return SubmitCallable(&TextractClient::CreateAdapterVersion, request);
        }
 
        template<typename CreateAdapterVersionRequestT = Model::CreateAdapterVersionRequest>
        void CreateAdapterVersionAsync(const CreateAdapterVersionRequestT& request, const CreateAdapterVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::CreateAdapterVersion, request, handler, context);
        }
 
        virtual Model::DeleteAdapterOutcome DeleteAdapter(const Model::DeleteAdapterRequest& request) const;
 
        template<typename DeleteAdapterRequestT = Model::DeleteAdapterRequest>
        Model::DeleteAdapterOutcomeCallable DeleteAdapterCallable(const DeleteAdapterRequestT& request) const
        {
            return SubmitCallable(&TextractClient::DeleteAdapter, request);
        }
 
        template<typename DeleteAdapterRequestT = Model::DeleteAdapterRequest>
        void DeleteAdapterAsync(const DeleteAdapterRequestT& request, const DeleteAdapterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::DeleteAdapter, request, handler, context);
        }
 
        virtual Model::DeleteAdapterVersionOutcome DeleteAdapterVersion(const Model::DeleteAdapterVersionRequest& request) const;
 
        template<typename DeleteAdapterVersionRequestT = Model::DeleteAdapterVersionRequest>
        Model::DeleteAdapterVersionOutcomeCallable DeleteAdapterVersionCallable(const DeleteAdapterVersionRequestT& request) const
        {
            return SubmitCallable(&TextractClient::DeleteAdapterVersion, request);
        }
 
        template<typename DeleteAdapterVersionRequestT = Model::DeleteAdapterVersionRequest>
        void DeleteAdapterVersionAsync(const DeleteAdapterVersionRequestT& request, const DeleteAdapterVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::DeleteAdapterVersion, request, handler, context);
        }
 
        virtual Model::DetectDocumentTextOutcome DetectDocumentText(const Model::DetectDocumentTextRequest& request) const;
 
        template<typename DetectDocumentTextRequestT = Model::DetectDocumentTextRequest>
        Model::DetectDocumentTextOutcomeCallable DetectDocumentTextCallable(const DetectDocumentTextRequestT& request) const
        {
            return SubmitCallable(&TextractClient::DetectDocumentText, request);
        }
 
        template<typename DetectDocumentTextRequestT = Model::DetectDocumentTextRequest>
        void DetectDocumentTextAsync(const DetectDocumentTextRequestT& request, const DetectDocumentTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::DetectDocumentText, request, handler, context);
        }
 
        virtual Model::GetAdapterOutcome GetAdapter(const Model::GetAdapterRequest& request) const;
 
        template<typename GetAdapterRequestT = Model::GetAdapterRequest>
        Model::GetAdapterOutcomeCallable GetAdapterCallable(const GetAdapterRequestT& request) const
        {
            return SubmitCallable(&TextractClient::GetAdapter, request);
        }
 
        template<typename GetAdapterRequestT = Model::GetAdapterRequest>
        void GetAdapterAsync(const GetAdapterRequestT& request, const GetAdapterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::GetAdapter, request, handler, context);
        }
 
        virtual Model::GetAdapterVersionOutcome GetAdapterVersion(const Model::GetAdapterVersionRequest& request) const;
 
        template<typename GetAdapterVersionRequestT = Model::GetAdapterVersionRequest>
        Model::GetAdapterVersionOutcomeCallable GetAdapterVersionCallable(const GetAdapterVersionRequestT& request) const
        {
            return SubmitCallable(&TextractClient::GetAdapterVersion, request);
        }
 
        template<typename GetAdapterVersionRequestT = Model::GetAdapterVersionRequest>
        void GetAdapterVersionAsync(const GetAdapterVersionRequestT& request, const GetAdapterVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::GetAdapterVersion, request, handler, context);
        }
 
        virtual Model::GetDocumentAnalysisOutcome GetDocumentAnalysis(const Model::GetDocumentAnalysisRequest& request) const;
 
        template<typename GetDocumentAnalysisRequestT = Model::GetDocumentAnalysisRequest>
        Model::GetDocumentAnalysisOutcomeCallable GetDocumentAnalysisCallable(const GetDocumentAnalysisRequestT& request) const
        {
            return SubmitCallable(&TextractClient::GetDocumentAnalysis, request);
        }
 
        template<typename GetDocumentAnalysisRequestT = Model::GetDocumentAnalysisRequest>
        void GetDocumentAnalysisAsync(const GetDocumentAnalysisRequestT& request, const GetDocumentAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::GetDocumentAnalysis, request, handler, context);
        }
 
        virtual Model::GetDocumentTextDetectionOutcome GetDocumentTextDetection(const Model::GetDocumentTextDetectionRequest& request) const;
 
        template<typename GetDocumentTextDetectionRequestT = Model::GetDocumentTextDetectionRequest>
        Model::GetDocumentTextDetectionOutcomeCallable GetDocumentTextDetectionCallable(const GetDocumentTextDetectionRequestT& request) const
        {
            return SubmitCallable(&TextractClient::GetDocumentTextDetection, request);
        }
 
        template<typename GetDocumentTextDetectionRequestT = Model::GetDocumentTextDetectionRequest>
        void GetDocumentTextDetectionAsync(const GetDocumentTextDetectionRequestT& request, const GetDocumentTextDetectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::GetDocumentTextDetection, request, handler, context);
        }
 
        virtual Model::GetExpenseAnalysisOutcome GetExpenseAnalysis(const Model::GetExpenseAnalysisRequest& request) const;
 
        template<typename GetExpenseAnalysisRequestT = Model::GetExpenseAnalysisRequest>
        Model::GetExpenseAnalysisOutcomeCallable GetExpenseAnalysisCallable(const GetExpenseAnalysisRequestT& request) const
        {
            return SubmitCallable(&TextractClient::GetExpenseAnalysis, request);
        }
 
        template<typename GetExpenseAnalysisRequestT = Model::GetExpenseAnalysisRequest>
        void GetExpenseAnalysisAsync(const GetExpenseAnalysisRequestT& request, const GetExpenseAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::GetExpenseAnalysis, request, handler, context);
        }
 
        virtual Model::GetLendingAnalysisOutcome GetLendingAnalysis(const Model::GetLendingAnalysisRequest& request) const;
 
        template<typename GetLendingAnalysisRequestT = Model::GetLendingAnalysisRequest>
        Model::GetLendingAnalysisOutcomeCallable GetLendingAnalysisCallable(const GetLendingAnalysisRequestT& request) const
        {
            return SubmitCallable(&TextractClient::GetLendingAnalysis, request);
        }
 
        template<typename GetLendingAnalysisRequestT = Model::GetLendingAnalysisRequest>
        void GetLendingAnalysisAsync(const GetLendingAnalysisRequestT& request, const GetLendingAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::GetLendingAnalysis, request, handler, context);
        }
 
        virtual Model::GetLendingAnalysisSummaryOutcome GetLendingAnalysisSummary(const Model::GetLendingAnalysisSummaryRequest& request) const;
 
        template<typename GetLendingAnalysisSummaryRequestT = Model::GetLendingAnalysisSummaryRequest>
        Model::GetLendingAnalysisSummaryOutcomeCallable GetLendingAnalysisSummaryCallable(const GetLendingAnalysisSummaryRequestT& request) const
        {
            return SubmitCallable(&TextractClient::GetLendingAnalysisSummary, request);
        }
 
        template<typename GetLendingAnalysisSummaryRequestT = Model::GetLendingAnalysisSummaryRequest>
        void GetLendingAnalysisSummaryAsync(const GetLendingAnalysisSummaryRequestT& request, const GetLendingAnalysisSummaryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::GetLendingAnalysisSummary, request, handler, context);
        }
 
        virtual Model::ListAdapterVersionsOutcome ListAdapterVersions(const Model::ListAdapterVersionsRequest& request = {}) const;
 
        template<typename ListAdapterVersionsRequestT = Model::ListAdapterVersionsRequest>
        Model::ListAdapterVersionsOutcomeCallable ListAdapterVersionsCallable(const ListAdapterVersionsRequestT& request = {}) const
        {
            return SubmitCallable(&TextractClient::ListAdapterVersions, request);
        }
 
        template<typename ListAdapterVersionsRequestT = Model::ListAdapterVersionsRequest>
        void ListAdapterVersionsAsync(const ListAdapterVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAdapterVersionsRequestT& request = {}) const
        {
            return SubmitAsync(&TextractClient::ListAdapterVersions, request, handler, context);
        }
 
        virtual Model::ListAdaptersOutcome ListAdapters(const Model::ListAdaptersRequest& request = {}) const;
 
        template<typename ListAdaptersRequestT = Model::ListAdaptersRequest>
        Model::ListAdaptersOutcomeCallable ListAdaptersCallable(const ListAdaptersRequestT& request = {}) const
        {
            return SubmitCallable(&TextractClient::ListAdapters, request);
        }
 
        template<typename ListAdaptersRequestT = Model::ListAdaptersRequest>
        void ListAdaptersAsync(const ListAdaptersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr, const ListAdaptersRequestT& request = {}) const
        {
            return SubmitAsync(&TextractClient::ListAdapters, 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(&TextractClient::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(&TextractClient::ListTagsForResource, request, handler, context);
        }
 
        virtual Model::StartDocumentAnalysisOutcome StartDocumentAnalysis(const Model::StartDocumentAnalysisRequest& request) const;
 
        template<typename StartDocumentAnalysisRequestT = Model::StartDocumentAnalysisRequest>
        Model::StartDocumentAnalysisOutcomeCallable StartDocumentAnalysisCallable(const StartDocumentAnalysisRequestT& request) const
        {
            return SubmitCallable(&TextractClient::StartDocumentAnalysis, request);
        }
 
        template<typename StartDocumentAnalysisRequestT = Model::StartDocumentAnalysisRequest>
        void StartDocumentAnalysisAsync(const StartDocumentAnalysisRequestT& request, const StartDocumentAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::StartDocumentAnalysis, request, handler, context);
        }
 
        virtual Model::StartDocumentTextDetectionOutcome StartDocumentTextDetection(const Model::StartDocumentTextDetectionRequest& request) const;
 
        template<typename StartDocumentTextDetectionRequestT = Model::StartDocumentTextDetectionRequest>
        Model::StartDocumentTextDetectionOutcomeCallable StartDocumentTextDetectionCallable(const StartDocumentTextDetectionRequestT& request) const
        {
            return SubmitCallable(&TextractClient::StartDocumentTextDetection, request);
        }
 
        template<typename StartDocumentTextDetectionRequestT = Model::StartDocumentTextDetectionRequest>
        void StartDocumentTextDetectionAsync(const StartDocumentTextDetectionRequestT& request, const StartDocumentTextDetectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::StartDocumentTextDetection, request, handler, context);
        }
 
        virtual Model::StartExpenseAnalysisOutcome StartExpenseAnalysis(const Model::StartExpenseAnalysisRequest& request) const;
 
        template<typename StartExpenseAnalysisRequestT = Model::StartExpenseAnalysisRequest>
        Model::StartExpenseAnalysisOutcomeCallable StartExpenseAnalysisCallable(const StartExpenseAnalysisRequestT& request) const
        {
            return SubmitCallable(&TextractClient::StartExpenseAnalysis, request);
        }
 
        template<typename StartExpenseAnalysisRequestT = Model::StartExpenseAnalysisRequest>
        void StartExpenseAnalysisAsync(const StartExpenseAnalysisRequestT& request, const StartExpenseAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::StartExpenseAnalysis, request, handler, context);
        }
 
        virtual Model::StartLendingAnalysisOutcome StartLendingAnalysis(const Model::StartLendingAnalysisRequest& request) const;
 
        template<typename StartLendingAnalysisRequestT = Model::StartLendingAnalysisRequest>
        Model::StartLendingAnalysisOutcomeCallable StartLendingAnalysisCallable(const StartLendingAnalysisRequestT& request) const
        {
            return SubmitCallable(&TextractClient::StartLendingAnalysis, request);
        }
 
        template<typename StartLendingAnalysisRequestT = Model::StartLendingAnalysisRequest>
        void StartLendingAnalysisAsync(const StartLendingAnalysisRequestT& request, const StartLendingAnalysisResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::StartLendingAnalysis, 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(&TextractClient::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(&TextractClient::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(&TextractClient::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(&TextractClient::UntagResource, request, handler, context);
        }
 
        virtual Model::UpdateAdapterOutcome UpdateAdapter(const Model::UpdateAdapterRequest& request) const;
 
        template<typename UpdateAdapterRequestT = Model::UpdateAdapterRequest>
        Model::UpdateAdapterOutcomeCallable UpdateAdapterCallable(const UpdateAdapterRequestT& request) const
        {
            return SubmitCallable(&TextractClient::UpdateAdapter, request);
        }
 
        template<typename UpdateAdapterRequestT = Model::UpdateAdapterRequest>
        void UpdateAdapterAsync(const UpdateAdapterRequestT& request, const UpdateAdapterResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context = nullptr) const
        {
            return SubmitAsync(&TextractClient::UpdateAdapter, request, handler, context);
        }
 
 
      void OverrideEndpoint(const Aws::String& endpoint);
      std::shared_ptr<TextractEndpointProviderBase>& accessEndpointProvider();
    private:
      friend class Aws::Client::ClientWithAsyncTemplateMethods<TextractClient>;
      void init(const TextractClientConfiguration& clientConfiguration);
 
      TextractClientConfiguration m_clientConfiguration;
      std::shared_ptr<TextractEndpointProviderBase> m_endpointProvider;
  };
 
} // namespace Textract
} // namespace Aws