TextractClient.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/textract/TextractPaginationBase.h>
#include <aws/textract/TextractServiceClientModel.h>
#include <aws/textract/TextractWaiter.h>
#include <aws/textract/Textract_EXPORTS.h>
 
namespace Aws {
namespace Textract {
class AWS_TEXTRACT_API TextractClient : public Aws::Client::AWSJsonClient,
                                        public Aws::Client::ClientWithAsyncTemplateMethods<TextractClient>,
                                        public TextractPaginationBase<TextractClient>,
                                        public TextractWaiter<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);
  }
 
  virtual void OverrideEndpoint(const Aws::String& endpoint);
  virtual std::shared_ptr<TextractEndpointProviderBase>& accessEndpointProvider();
 
 private:
  friend class Aws::Client::ClientWithAsyncTemplateMethods<TextractClient>;
  void init(const TextractClientConfiguration& clientConfiguration);
 
  typedef Aws::Utils::Outcome<Aws::AmazonWebServiceResult<RESPONSE>, TextractError> InvokeOperationOutcome;
 
  InvokeOperationOutcome InvokeServiceOperation(const AmazonWebServiceRequest& request, Aws::Http::HttpMethod httpMethod) const;
 
  TextractClientConfiguration m_clientConfiguration;
  std::shared_ptr<TextractEndpointProviderBase> m_endpointProvider;
};
 
}  // namespace Textract
}  // namespace Aws