StartDocumentAnalysisRequest.h

 
#pragma once
#include <aws/textract/Textract_EXPORTS.h>
#include <aws/textract/TextractRequest.h>
#include <aws/textract/model/DocumentLocation.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/textract/model/NotificationChannel.h>
#include <aws/textract/model/OutputConfig.h>
#include <aws/textract/model/QueriesConfig.h>
#include <aws/textract/model/AdaptersConfig.h>
#include <aws/textract/model/FeatureType.h>
#include <utility>
 
namespace Aws
{
namespace Textract
{
namespace Model
{
 
  class StartDocumentAnalysisRequest : public TextractRequest
  {
  public:
    AWS_TEXTRACT_API StartDocumentAnalysisRequest() = default;
 
    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "StartDocumentAnalysis"; }
 
    AWS_TEXTRACT_API Aws::String SerializePayload() const override;
 
    AWS_TEXTRACT_API Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
 
 
 
    inline const DocumentLocation& GetDocumentLocation() const { return m_documentLocation; }
    inline bool DocumentLocationHasBeenSet() const { return m_documentLocationHasBeenSet; }
    template<typename DocumentLocationT = DocumentLocation>
    void SetDocumentLocation(DocumentLocationT&& value) { m_documentLocationHasBeenSet = true; m_documentLocation = std::forward<DocumentLocationT>(value); }
    template<typename DocumentLocationT = DocumentLocation>
    StartDocumentAnalysisRequest& WithDocumentLocation(DocumentLocationT&& value) { SetDocumentLocation(std::forward<DocumentLocationT>(value)); return *this;}
 
 
    inline const Aws::Vector<FeatureType>& GetFeatureTypes() const { return m_featureTypes; }
    inline bool FeatureTypesHasBeenSet() const { return m_featureTypesHasBeenSet; }
    template<typename FeatureTypesT = Aws::Vector<FeatureType>>
    void SetFeatureTypes(FeatureTypesT&& value) { m_featureTypesHasBeenSet = true; m_featureTypes = std::forward<FeatureTypesT>(value); }
    template<typename FeatureTypesT = Aws::Vector<FeatureType>>
    StartDocumentAnalysisRequest& WithFeatureTypes(FeatureTypesT&& value) { SetFeatureTypes(std::forward<FeatureTypesT>(value)); return *this;}
    inline StartDocumentAnalysisRequest& AddFeatureTypes(FeatureType value) { m_featureTypesHasBeenSet = true; m_featureTypes.push_back(value); return *this; }
 
 
    inline const Aws::String& GetClientRequestToken() const { return m_clientRequestToken; }
    inline bool ClientRequestTokenHasBeenSet() const { return m_clientRequestTokenHasBeenSet; }
    template<typename ClientRequestTokenT = Aws::String>
    void SetClientRequestToken(ClientRequestTokenT&& value) { m_clientRequestTokenHasBeenSet = true; m_clientRequestToken = std::forward<ClientRequestTokenT>(value); }
    template<typename ClientRequestTokenT = Aws::String>
    StartDocumentAnalysisRequest& WithClientRequestToken(ClientRequestTokenT&& value) { SetClientRequestToken(std::forward<ClientRequestTokenT>(value)); return *this;}
 
 
    inline const Aws::String& GetJobTag() const { return m_jobTag; }
    inline bool JobTagHasBeenSet() const { return m_jobTagHasBeenSet; }
    template<typename JobTagT = Aws::String>
    void SetJobTag(JobTagT&& value) { m_jobTagHasBeenSet = true; m_jobTag = std::forward<JobTagT>(value); }
    template<typename JobTagT = Aws::String>
    StartDocumentAnalysisRequest& WithJobTag(JobTagT&& value) { SetJobTag(std::forward<JobTagT>(value)); return *this;}
 
 
    inline const NotificationChannel& GetNotificationChannel() const { return m_notificationChannel; }
    inline bool NotificationChannelHasBeenSet() const { return m_notificationChannelHasBeenSet; }
    template<typename NotificationChannelT = NotificationChannel>
    void SetNotificationChannel(NotificationChannelT&& value) { m_notificationChannelHasBeenSet = true; m_notificationChannel = std::forward<NotificationChannelT>(value); }
    template<typename NotificationChannelT = NotificationChannel>
    StartDocumentAnalysisRequest& WithNotificationChannel(NotificationChannelT&& value) { SetNotificationChannel(std::forward<NotificationChannelT>(value)); return *this;}
 
 
    inline const OutputConfig& GetOutputConfig() const { return m_outputConfig; }
    inline bool OutputConfigHasBeenSet() const { return m_outputConfigHasBeenSet; }
    template<typename OutputConfigT = OutputConfig>
    void SetOutputConfig(OutputConfigT&& value) { m_outputConfigHasBeenSet = true; m_outputConfig = std::forward<OutputConfigT>(value); }
    template<typename OutputConfigT = OutputConfig>
    StartDocumentAnalysisRequest& WithOutputConfig(OutputConfigT&& value) { SetOutputConfig(std::forward<OutputConfigT>(value)); return *this;}
 
 
    inline const Aws::String& GetKMSKeyId() const { return m_kMSKeyId; }
    inline bool KMSKeyIdHasBeenSet() const { return m_kMSKeyIdHasBeenSet; }
    template<typename KMSKeyIdT = Aws::String>
    void SetKMSKeyId(KMSKeyIdT&& value) { m_kMSKeyIdHasBeenSet = true; m_kMSKeyId = std::forward<KMSKeyIdT>(value); }
    template<typename KMSKeyIdT = Aws::String>
    StartDocumentAnalysisRequest& WithKMSKeyId(KMSKeyIdT&& value) { SetKMSKeyId(std::forward<KMSKeyIdT>(value)); return *this;}
 
    
    inline const QueriesConfig& GetQueriesConfig() const { return m_queriesConfig; }
    inline bool QueriesConfigHasBeenSet() const { return m_queriesConfigHasBeenSet; }
    template<typename QueriesConfigT = QueriesConfig>
    void SetQueriesConfig(QueriesConfigT&& value) { m_queriesConfigHasBeenSet = true; m_queriesConfig = std::forward<QueriesConfigT>(value); }
    template<typename QueriesConfigT = QueriesConfig>
    StartDocumentAnalysisRequest& WithQueriesConfig(QueriesConfigT&& value) { SetQueriesConfig(std::forward<QueriesConfigT>(value)); return *this;}
 
 
    inline const AdaptersConfig& GetAdaptersConfig() const { return m_adaptersConfig; }
    inline bool AdaptersConfigHasBeenSet() const { return m_adaptersConfigHasBeenSet; }
    template<typename AdaptersConfigT = AdaptersConfig>
    void SetAdaptersConfig(AdaptersConfigT&& value) { m_adaptersConfigHasBeenSet = true; m_adaptersConfig = std::forward<AdaptersConfigT>(value); }
    template<typename AdaptersConfigT = AdaptersConfig>
    StartDocumentAnalysisRequest& WithAdaptersConfig(AdaptersConfigT&& value) { SetAdaptersConfig(std::forward<AdaptersConfigT>(value)); return *this;}
  private:
 
    DocumentLocation m_documentLocation;
    bool m_documentLocationHasBeenSet = false;
 
    Aws::Vector<FeatureType> m_featureTypes;
    bool m_featureTypesHasBeenSet = false;
 
    Aws::String m_clientRequestToken;
    bool m_clientRequestTokenHasBeenSet = false;
 
    Aws::String m_jobTag;
    bool m_jobTagHasBeenSet = false;
 
    NotificationChannel m_notificationChannel;
    bool m_notificationChannelHasBeenSet = false;
 
    OutputConfig m_outputConfig;
    bool m_outputConfigHasBeenSet = false;
 
    Aws::String m_kMSKeyId;
    bool m_kMSKeyIdHasBeenSet = false;
 
    QueriesConfig m_queriesConfig;
    bool m_queriesConfigHasBeenSet = false;
 
    AdaptersConfig m_adaptersConfig;
    bool m_adaptersConfigHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Textract
} // namespace Aws