CreateDataSetRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/quicksight/QuickSightRequest.h>
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/quicksight/model/ColumnGroup.h>
#include <aws/quicksight/model/ColumnLevelPermissionRule.h>
#include <aws/quicksight/model/DataPrepConfiguration.h>
#include <aws/quicksight/model/DataSetImportMode.h>
#include <aws/quicksight/model/DataSetUsageConfiguration.h>
#include <aws/quicksight/model/DataSetUseAs.h>
#include <aws/quicksight/model/DatasetParameter.h>
#include <aws/quicksight/model/FieldFolder.h>
#include <aws/quicksight/model/PerformanceConfiguration.h>
#include <aws/quicksight/model/PhysicalTable.h>
#include <aws/quicksight/model/ResourcePermission.h>
#include <aws/quicksight/model/SemanticModelConfiguration.h>
#include <aws/quicksight/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace QuickSight {
namespace Model {
 
class CreateDataSetRequest : public QuickSightRequest {
 public:
  AWS_QUICKSIGHT_API CreateDataSetRequest() = 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 "CreateDataSet"; }
 
  AWS_QUICKSIGHT_API Aws::String SerializePayload() const override;
 
 
  inline const Aws::String& GetAwsAccountId() const { return m_awsAccountId; }
  inline bool AwsAccountIdHasBeenSet() const { return m_awsAccountIdHasBeenSet; }
  template <typename AwsAccountIdT = Aws::String>
  void SetAwsAccountId(AwsAccountIdT&& value) {
    m_awsAccountIdHasBeenSet = true;
    m_awsAccountId = std::forward<AwsAccountIdT>(value);
  }
  template <typename AwsAccountIdT = Aws::String>
  CreateDataSetRequest& WithAwsAccountId(AwsAccountIdT&& value) {
    SetAwsAccountId(std::forward<AwsAccountIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDataSetId() const { return m_dataSetId; }
  inline bool DataSetIdHasBeenSet() const { return m_dataSetIdHasBeenSet; }
  template <typename DataSetIdT = Aws::String>
  void SetDataSetId(DataSetIdT&& value) {
    m_dataSetIdHasBeenSet = true;
    m_dataSetId = std::forward<DataSetIdT>(value);
  }
  template <typename DataSetIdT = Aws::String>
  CreateDataSetRequest& WithDataSetId(DataSetIdT&& value) {
    SetDataSetId(std::forward<DataSetIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  CreateDataSetRequest& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, PhysicalTable>& GetPhysicalTableMap() const { return m_physicalTableMap; }
  inline bool PhysicalTableMapHasBeenSet() const { return m_physicalTableMapHasBeenSet; }
  template <typename PhysicalTableMapT = Aws::Map<Aws::String, PhysicalTable>>
  void SetPhysicalTableMap(PhysicalTableMapT&& value) {
    m_physicalTableMapHasBeenSet = true;
    m_physicalTableMap = std::forward<PhysicalTableMapT>(value);
  }
  template <typename PhysicalTableMapT = Aws::Map<Aws::String, PhysicalTable>>
  CreateDataSetRequest& WithPhysicalTableMap(PhysicalTableMapT&& value) {
    SetPhysicalTableMap(std::forward<PhysicalTableMapT>(value));
    return *this;
  }
  template <typename PhysicalTableMapKeyT = Aws::String, typename PhysicalTableMapValueT = PhysicalTable>
  CreateDataSetRequest& AddPhysicalTableMap(PhysicalTableMapKeyT&& key, PhysicalTableMapValueT&& value) {
    m_physicalTableMapHasBeenSet = true;
    m_physicalTableMap.emplace(std::forward<PhysicalTableMapKeyT>(key), std::forward<PhysicalTableMapValueT>(value));
    return *this;
  }
 
 
  inline DataSetImportMode GetImportMode() const { return m_importMode; }
  inline bool ImportModeHasBeenSet() const { return m_importModeHasBeenSet; }
  inline void SetImportMode(DataSetImportMode value) {
    m_importModeHasBeenSet = true;
    m_importMode = value;
  }
  inline CreateDataSetRequest& WithImportMode(DataSetImportMode value) {
    SetImportMode(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ColumnGroup>& GetColumnGroups() const { return m_columnGroups; }
  inline bool ColumnGroupsHasBeenSet() const { return m_columnGroupsHasBeenSet; }
  template <typename ColumnGroupsT = Aws::Vector<ColumnGroup>>
  void SetColumnGroups(ColumnGroupsT&& value) {
    m_columnGroupsHasBeenSet = true;
    m_columnGroups = std::forward<ColumnGroupsT>(value);
  }
  template <typename ColumnGroupsT = Aws::Vector<ColumnGroup>>
  CreateDataSetRequest& WithColumnGroups(ColumnGroupsT&& value) {
    SetColumnGroups(std::forward<ColumnGroupsT>(value));
    return *this;
  }
  template <typename ColumnGroupsT = ColumnGroup>
  CreateDataSetRequest& AddColumnGroups(ColumnGroupsT&& value) {
    m_columnGroupsHasBeenSet = true;
    m_columnGroups.emplace_back(std::forward<ColumnGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, FieldFolder>& GetFieldFolders() const { return m_fieldFolders; }
  inline bool FieldFoldersHasBeenSet() const { return m_fieldFoldersHasBeenSet; }
  template <typename FieldFoldersT = Aws::Map<Aws::String, FieldFolder>>
  void SetFieldFolders(FieldFoldersT&& value) {
    m_fieldFoldersHasBeenSet = true;
    m_fieldFolders = std::forward<FieldFoldersT>(value);
  }
  template <typename FieldFoldersT = Aws::Map<Aws::String, FieldFolder>>
  CreateDataSetRequest& WithFieldFolders(FieldFoldersT&& value) {
    SetFieldFolders(std::forward<FieldFoldersT>(value));
    return *this;
  }
  template <typename FieldFoldersKeyT = Aws::String, typename FieldFoldersValueT = FieldFolder>
  CreateDataSetRequest& AddFieldFolders(FieldFoldersKeyT&& key, FieldFoldersValueT&& value) {
    m_fieldFoldersHasBeenSet = true;
    m_fieldFolders.emplace(std::forward<FieldFoldersKeyT>(key), std::forward<FieldFoldersValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ResourcePermission>& GetPermissions() const { return m_permissions; }
  inline bool PermissionsHasBeenSet() const { return m_permissionsHasBeenSet; }
  template <typename PermissionsT = Aws::Vector<ResourcePermission>>
  void SetPermissions(PermissionsT&& value) {
    m_permissionsHasBeenSet = true;
    m_permissions = std::forward<PermissionsT>(value);
  }
  template <typename PermissionsT = Aws::Vector<ResourcePermission>>
  CreateDataSetRequest& WithPermissions(PermissionsT&& value) {
    SetPermissions(std::forward<PermissionsT>(value));
    return *this;
  }
  template <typename PermissionsT = ResourcePermission>
  CreateDataSetRequest& AddPermissions(PermissionsT&& value) {
    m_permissionsHasBeenSet = true;
    m_permissions.emplace_back(std::forward<PermissionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ColumnLevelPermissionRule>& GetColumnLevelPermissionRules() const { return m_columnLevelPermissionRules; }
  inline bool ColumnLevelPermissionRulesHasBeenSet() const { return m_columnLevelPermissionRulesHasBeenSet; }
  template <typename ColumnLevelPermissionRulesT = Aws::Vector<ColumnLevelPermissionRule>>
  void SetColumnLevelPermissionRules(ColumnLevelPermissionRulesT&& value) {
    m_columnLevelPermissionRulesHasBeenSet = true;
    m_columnLevelPermissionRules = std::forward<ColumnLevelPermissionRulesT>(value);
  }
  template <typename ColumnLevelPermissionRulesT = Aws::Vector<ColumnLevelPermissionRule>>
  CreateDataSetRequest& WithColumnLevelPermissionRules(ColumnLevelPermissionRulesT&& value) {
    SetColumnLevelPermissionRules(std::forward<ColumnLevelPermissionRulesT>(value));
    return *this;
  }
  template <typename ColumnLevelPermissionRulesT = ColumnLevelPermissionRule>
  CreateDataSetRequest& AddColumnLevelPermissionRules(ColumnLevelPermissionRulesT&& value) {
    m_columnLevelPermissionRulesHasBeenSet = true;
    m_columnLevelPermissionRules.emplace_back(std::forward<ColumnLevelPermissionRulesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  CreateDataSetRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateDataSetRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const DataSetUsageConfiguration& GetDataSetUsageConfiguration() const { return m_dataSetUsageConfiguration; }
  inline bool DataSetUsageConfigurationHasBeenSet() const { return m_dataSetUsageConfigurationHasBeenSet; }
  template <typename DataSetUsageConfigurationT = DataSetUsageConfiguration>
  void SetDataSetUsageConfiguration(DataSetUsageConfigurationT&& value) {
    m_dataSetUsageConfigurationHasBeenSet = true;
    m_dataSetUsageConfiguration = std::forward<DataSetUsageConfigurationT>(value);
  }
  template <typename DataSetUsageConfigurationT = DataSetUsageConfiguration>
  CreateDataSetRequest& WithDataSetUsageConfiguration(DataSetUsageConfigurationT&& value) {
    SetDataSetUsageConfiguration(std::forward<DataSetUsageConfigurationT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<DatasetParameter>& GetDatasetParameters() const { return m_datasetParameters; }
  inline bool DatasetParametersHasBeenSet() const { return m_datasetParametersHasBeenSet; }
  template <typename DatasetParametersT = Aws::Vector<DatasetParameter>>
  void SetDatasetParameters(DatasetParametersT&& value) {
    m_datasetParametersHasBeenSet = true;
    m_datasetParameters = std::forward<DatasetParametersT>(value);
  }
  template <typename DatasetParametersT = Aws::Vector<DatasetParameter>>
  CreateDataSetRequest& WithDatasetParameters(DatasetParametersT&& value) {
    SetDatasetParameters(std::forward<DatasetParametersT>(value));
    return *this;
  }
  template <typename DatasetParametersT = DatasetParameter>
  CreateDataSetRequest& AddDatasetParameters(DatasetParametersT&& value) {
    m_datasetParametersHasBeenSet = true;
    m_datasetParameters.emplace_back(std::forward<DatasetParametersT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetFolderArns() const { return m_folderArns; }
  inline bool FolderArnsHasBeenSet() const { return m_folderArnsHasBeenSet; }
  template <typename FolderArnsT = Aws::Vector<Aws::String>>
  void SetFolderArns(FolderArnsT&& value) {
    m_folderArnsHasBeenSet = true;
    m_folderArns = std::forward<FolderArnsT>(value);
  }
  template <typename FolderArnsT = Aws::Vector<Aws::String>>
  CreateDataSetRequest& WithFolderArns(FolderArnsT&& value) {
    SetFolderArns(std::forward<FolderArnsT>(value));
    return *this;
  }
  template <typename FolderArnsT = Aws::String>
  CreateDataSetRequest& AddFolderArns(FolderArnsT&& value) {
    m_folderArnsHasBeenSet = true;
    m_folderArns.emplace_back(std::forward<FolderArnsT>(value));
    return *this;
  }
 
 
  inline const PerformanceConfiguration& GetPerformanceConfiguration() const { return m_performanceConfiguration; }
  inline bool PerformanceConfigurationHasBeenSet() const { return m_performanceConfigurationHasBeenSet; }
  template <typename PerformanceConfigurationT = PerformanceConfiguration>
  void SetPerformanceConfiguration(PerformanceConfigurationT&& value) {
    m_performanceConfigurationHasBeenSet = true;
    m_performanceConfiguration = std::forward<PerformanceConfigurationT>(value);
  }
  template <typename PerformanceConfigurationT = PerformanceConfiguration>
  CreateDataSetRequest& WithPerformanceConfiguration(PerformanceConfigurationT&& value) {
    SetPerformanceConfiguration(std::forward<PerformanceConfigurationT>(value));
    return *this;
  }
 
 
  inline DataSetUseAs GetUseAs() const { return m_useAs; }
  inline bool UseAsHasBeenSet() const { return m_useAsHasBeenSet; }
  inline void SetUseAs(DataSetUseAs value) {
    m_useAsHasBeenSet = true;
    m_useAs = value;
  }
  inline CreateDataSetRequest& WithUseAs(DataSetUseAs value) {
    SetUseAs(value);
    return *this;
  }
 
 
  inline const DataPrepConfiguration& GetDataPrepConfiguration() const { return m_dataPrepConfiguration; }
  inline bool DataPrepConfigurationHasBeenSet() const { return m_dataPrepConfigurationHasBeenSet; }
  template <typename DataPrepConfigurationT = DataPrepConfiguration>
  void SetDataPrepConfiguration(DataPrepConfigurationT&& value) {
    m_dataPrepConfigurationHasBeenSet = true;
    m_dataPrepConfiguration = std::forward<DataPrepConfigurationT>(value);
  }
  template <typename DataPrepConfigurationT = DataPrepConfiguration>
  CreateDataSetRequest& WithDataPrepConfiguration(DataPrepConfigurationT&& value) {
    SetDataPrepConfiguration(std::forward<DataPrepConfigurationT>(value));
    return *this;
  }
 
 
  inline const SemanticModelConfiguration& GetSemanticModelConfiguration() const { return m_semanticModelConfiguration; }
  inline bool SemanticModelConfigurationHasBeenSet() const { return m_semanticModelConfigurationHasBeenSet; }
  template <typename SemanticModelConfigurationT = SemanticModelConfiguration>
  void SetSemanticModelConfiguration(SemanticModelConfigurationT&& value) {
    m_semanticModelConfigurationHasBeenSet = true;
    m_semanticModelConfiguration = std::forward<SemanticModelConfigurationT>(value);
  }
  template <typename SemanticModelConfigurationT = SemanticModelConfiguration>
  CreateDataSetRequest& WithSemanticModelConfiguration(SemanticModelConfigurationT&& value) {
    SetSemanticModelConfiguration(std::forward<SemanticModelConfigurationT>(value));
    return *this;
  }
 private:
  Aws::String m_awsAccountId;
 
  Aws::String m_dataSetId;
 
  Aws::String m_name;
 
  Aws::Map<Aws::String, PhysicalTable> m_physicalTableMap;
 
  DataSetImportMode m_importMode{DataSetImportMode::NOT_SET};
 
  Aws::Vector<ColumnGroup> m_columnGroups;
 
  Aws::Map<Aws::String, FieldFolder> m_fieldFolders;
 
  Aws::Vector<ResourcePermission> m_permissions;
 
  Aws::Vector<ColumnLevelPermissionRule> m_columnLevelPermissionRules;
 
  Aws::Vector<Tag> m_tags;
 
  DataSetUsageConfiguration m_dataSetUsageConfiguration;
 
  Aws::Vector<DatasetParameter> m_datasetParameters;
 
  Aws::Vector<Aws::String> m_folderArns;
 
  PerformanceConfiguration m_performanceConfiguration;
 
  DataSetUseAs m_useAs{DataSetUseAs::NOT_SET};
 
  DataPrepConfiguration m_dataPrepConfiguration;
 
  SemanticModelConfiguration m_semanticModelConfiguration;
  bool m_awsAccountIdHasBeenSet = false;
  bool m_dataSetIdHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_physicalTableMapHasBeenSet = false;
  bool m_importModeHasBeenSet = false;
  bool m_columnGroupsHasBeenSet = false;
  bool m_fieldFoldersHasBeenSet = false;
  bool m_permissionsHasBeenSet = false;
  bool m_columnLevelPermissionRulesHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_dataSetUsageConfigurationHasBeenSet = false;
  bool m_datasetParametersHasBeenSet = false;
  bool m_folderArnsHasBeenSet = false;
  bool m_performanceConfigurationHasBeenSet = false;
  bool m_useAsHasBeenSet = false;
  bool m_dataPrepConfigurationHasBeenSet = false;
  bool m_semanticModelConfigurationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws