TemplateVersionDefinition.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/quicksight/QuickSight_EXPORTS.h>
#include <aws/quicksight/model/AnalysisDefaults.h>
#include <aws/quicksight/model/AssetOptions.h>
#include <aws/quicksight/model/CalculatedField.h>
#include <aws/quicksight/model/ColumnConfiguration.h>
#include <aws/quicksight/model/DataSetConfiguration.h>
#include <aws/quicksight/model/FilterGroup.h>
#include <aws/quicksight/model/ParameterDeclaration.h>
#include <aws/quicksight/model/QueryExecutionOptions.h>
#include <aws/quicksight/model/SheetDefinition.h>
#include <aws/quicksight/model/StaticFile.h>
#include <aws/quicksight/model/TooltipSheetDefinition.h>
#include <aws/quicksight/model/TopicConfiguration.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace QuickSight {
namespace Model {
 
class TemplateVersionDefinition {
 public:
  AWS_QUICKSIGHT_API TemplateVersionDefinition() = default;
  AWS_QUICKSIGHT_API TemplateVersionDefinition(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API TemplateVersionDefinition& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_QUICKSIGHT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<DataSetConfiguration>& GetDataSetConfigurations() const { return m_dataSetConfigurations; }
  inline bool DataSetConfigurationsHasBeenSet() const { return m_dataSetConfigurationsHasBeenSet; }
  template <typename DataSetConfigurationsT = Aws::Vector<DataSetConfiguration>>
  void SetDataSetConfigurations(DataSetConfigurationsT&& value) {
    m_dataSetConfigurationsHasBeenSet = true;
    m_dataSetConfigurations = std::forward<DataSetConfigurationsT>(value);
  }
  template <typename DataSetConfigurationsT = Aws::Vector<DataSetConfiguration>>
  TemplateVersionDefinition& WithDataSetConfigurations(DataSetConfigurationsT&& value) {
    SetDataSetConfigurations(std::forward<DataSetConfigurationsT>(value));
    return *this;
  }
  template <typename DataSetConfigurationsT = DataSetConfiguration>
  TemplateVersionDefinition& AddDataSetConfigurations(DataSetConfigurationsT&& value) {
    m_dataSetConfigurationsHasBeenSet = true;
    m_dataSetConfigurations.emplace_back(std::forward<DataSetConfigurationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<TopicConfiguration>& GetTopicConfigurations() const { return m_topicConfigurations; }
  inline bool TopicConfigurationsHasBeenSet() const { return m_topicConfigurationsHasBeenSet; }
  template <typename TopicConfigurationsT = Aws::Vector<TopicConfiguration>>
  void SetTopicConfigurations(TopicConfigurationsT&& value) {
    m_topicConfigurationsHasBeenSet = true;
    m_topicConfigurations = std::forward<TopicConfigurationsT>(value);
  }
  template <typename TopicConfigurationsT = Aws::Vector<TopicConfiguration>>
  TemplateVersionDefinition& WithTopicConfigurations(TopicConfigurationsT&& value) {
    SetTopicConfigurations(std::forward<TopicConfigurationsT>(value));
    return *this;
  }
  template <typename TopicConfigurationsT = TopicConfiguration>
  TemplateVersionDefinition& AddTopicConfigurations(TopicConfigurationsT&& value) {
    m_topicConfigurationsHasBeenSet = true;
    m_topicConfigurations.emplace_back(std::forward<TopicConfigurationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<SheetDefinition>& GetSheets() const { return m_sheets; }
  inline bool SheetsHasBeenSet() const { return m_sheetsHasBeenSet; }
  template <typename SheetsT = Aws::Vector<SheetDefinition>>
  void SetSheets(SheetsT&& value) {
    m_sheetsHasBeenSet = true;
    m_sheets = std::forward<SheetsT>(value);
  }
  template <typename SheetsT = Aws::Vector<SheetDefinition>>
  TemplateVersionDefinition& WithSheets(SheetsT&& value) {
    SetSheets(std::forward<SheetsT>(value));
    return *this;
  }
  template <typename SheetsT = SheetDefinition>
  TemplateVersionDefinition& AddSheets(SheetsT&& value) {
    m_sheetsHasBeenSet = true;
    m_sheets.emplace_back(std::forward<SheetsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<TooltipSheetDefinition>& GetTooltipSheets() const { return m_tooltipSheets; }
  inline bool TooltipSheetsHasBeenSet() const { return m_tooltipSheetsHasBeenSet; }
  template <typename TooltipSheetsT = Aws::Vector<TooltipSheetDefinition>>
  void SetTooltipSheets(TooltipSheetsT&& value) {
    m_tooltipSheetsHasBeenSet = true;
    m_tooltipSheets = std::forward<TooltipSheetsT>(value);
  }
  template <typename TooltipSheetsT = Aws::Vector<TooltipSheetDefinition>>
  TemplateVersionDefinition& WithTooltipSheets(TooltipSheetsT&& value) {
    SetTooltipSheets(std::forward<TooltipSheetsT>(value));
    return *this;
  }
  template <typename TooltipSheetsT = TooltipSheetDefinition>
  TemplateVersionDefinition& AddTooltipSheets(TooltipSheetsT&& value) {
    m_tooltipSheetsHasBeenSet = true;
    m_tooltipSheets.emplace_back(std::forward<TooltipSheetsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CalculatedField>& GetCalculatedFields() const { return m_calculatedFields; }
  inline bool CalculatedFieldsHasBeenSet() const { return m_calculatedFieldsHasBeenSet; }
  template <typename CalculatedFieldsT = Aws::Vector<CalculatedField>>
  void SetCalculatedFields(CalculatedFieldsT&& value) {
    m_calculatedFieldsHasBeenSet = true;
    m_calculatedFields = std::forward<CalculatedFieldsT>(value);
  }
  template <typename CalculatedFieldsT = Aws::Vector<CalculatedField>>
  TemplateVersionDefinition& WithCalculatedFields(CalculatedFieldsT&& value) {
    SetCalculatedFields(std::forward<CalculatedFieldsT>(value));
    return *this;
  }
  template <typename CalculatedFieldsT = CalculatedField>
  TemplateVersionDefinition& AddCalculatedFields(CalculatedFieldsT&& value) {
    m_calculatedFieldsHasBeenSet = true;
    m_calculatedFields.emplace_back(std::forward<CalculatedFieldsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ParameterDeclaration>& GetParameterDeclarations() const { return m_parameterDeclarations; }
  inline bool ParameterDeclarationsHasBeenSet() const { return m_parameterDeclarationsHasBeenSet; }
  template <typename ParameterDeclarationsT = Aws::Vector<ParameterDeclaration>>
  void SetParameterDeclarations(ParameterDeclarationsT&& value) {
    m_parameterDeclarationsHasBeenSet = true;
    m_parameterDeclarations = std::forward<ParameterDeclarationsT>(value);
  }
  template <typename ParameterDeclarationsT = Aws::Vector<ParameterDeclaration>>
  TemplateVersionDefinition& WithParameterDeclarations(ParameterDeclarationsT&& value) {
    SetParameterDeclarations(std::forward<ParameterDeclarationsT>(value));
    return *this;
  }
  template <typename ParameterDeclarationsT = ParameterDeclaration>
  TemplateVersionDefinition& AddParameterDeclarations(ParameterDeclarationsT&& value) {
    m_parameterDeclarationsHasBeenSet = true;
    m_parameterDeclarations.emplace_back(std::forward<ParameterDeclarationsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<FilterGroup>& GetFilterGroups() const { return m_filterGroups; }
  inline bool FilterGroupsHasBeenSet() const { return m_filterGroupsHasBeenSet; }
  template <typename FilterGroupsT = Aws::Vector<FilterGroup>>
  void SetFilterGroups(FilterGroupsT&& value) {
    m_filterGroupsHasBeenSet = true;
    m_filterGroups = std::forward<FilterGroupsT>(value);
  }
  template <typename FilterGroupsT = Aws::Vector<FilterGroup>>
  TemplateVersionDefinition& WithFilterGroups(FilterGroupsT&& value) {
    SetFilterGroups(std::forward<FilterGroupsT>(value));
    return *this;
  }
  template <typename FilterGroupsT = FilterGroup>
  TemplateVersionDefinition& AddFilterGroups(FilterGroupsT&& value) {
    m_filterGroupsHasBeenSet = true;
    m_filterGroups.emplace_back(std::forward<FilterGroupsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ColumnConfiguration>& GetColumnConfigurations() const { return m_columnConfigurations; }
  inline bool ColumnConfigurationsHasBeenSet() const { return m_columnConfigurationsHasBeenSet; }
  template <typename ColumnConfigurationsT = Aws::Vector<ColumnConfiguration>>
  void SetColumnConfigurations(ColumnConfigurationsT&& value) {
    m_columnConfigurationsHasBeenSet = true;
    m_columnConfigurations = std::forward<ColumnConfigurationsT>(value);
  }
  template <typename ColumnConfigurationsT = Aws::Vector<ColumnConfiguration>>
  TemplateVersionDefinition& WithColumnConfigurations(ColumnConfigurationsT&& value) {
    SetColumnConfigurations(std::forward<ColumnConfigurationsT>(value));
    return *this;
  }
  template <typename ColumnConfigurationsT = ColumnConfiguration>
  TemplateVersionDefinition& AddColumnConfigurations(ColumnConfigurationsT&& value) {
    m_columnConfigurationsHasBeenSet = true;
    m_columnConfigurations.emplace_back(std::forward<ColumnConfigurationsT>(value));
    return *this;
  }
 
 
  inline const AnalysisDefaults& GetAnalysisDefaults() const { return m_analysisDefaults; }
  inline bool AnalysisDefaultsHasBeenSet() const { return m_analysisDefaultsHasBeenSet; }
  template <typename AnalysisDefaultsT = AnalysisDefaults>
  void SetAnalysisDefaults(AnalysisDefaultsT&& value) {
    m_analysisDefaultsHasBeenSet = true;
    m_analysisDefaults = std::forward<AnalysisDefaultsT>(value);
  }
  template <typename AnalysisDefaultsT = AnalysisDefaults>
  TemplateVersionDefinition& WithAnalysisDefaults(AnalysisDefaultsT&& value) {
    SetAnalysisDefaults(std::forward<AnalysisDefaultsT>(value));
    return *this;
  }
 
 
  inline const AssetOptions& GetOptions() const { return m_options; }
  inline bool OptionsHasBeenSet() const { return m_optionsHasBeenSet; }
  template <typename OptionsT = AssetOptions>
  void SetOptions(OptionsT&& value) {
    m_optionsHasBeenSet = true;
    m_options = std::forward<OptionsT>(value);
  }
  template <typename OptionsT = AssetOptions>
  TemplateVersionDefinition& WithOptions(OptionsT&& value) {
    SetOptions(std::forward<OptionsT>(value));
    return *this;
  }
 
 
  inline const QueryExecutionOptions& GetQueryExecutionOptions() const { return m_queryExecutionOptions; }
  inline bool QueryExecutionOptionsHasBeenSet() const { return m_queryExecutionOptionsHasBeenSet; }
  template <typename QueryExecutionOptionsT = QueryExecutionOptions>
  void SetQueryExecutionOptions(QueryExecutionOptionsT&& value) {
    m_queryExecutionOptionsHasBeenSet = true;
    m_queryExecutionOptions = std::forward<QueryExecutionOptionsT>(value);
  }
  template <typename QueryExecutionOptionsT = QueryExecutionOptions>
  TemplateVersionDefinition& WithQueryExecutionOptions(QueryExecutionOptionsT&& value) {
    SetQueryExecutionOptions(std::forward<QueryExecutionOptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<StaticFile>& GetStaticFiles() const { return m_staticFiles; }
  inline bool StaticFilesHasBeenSet() const { return m_staticFilesHasBeenSet; }
  template <typename StaticFilesT = Aws::Vector<StaticFile>>
  void SetStaticFiles(StaticFilesT&& value) {
    m_staticFilesHasBeenSet = true;
    m_staticFiles = std::forward<StaticFilesT>(value);
  }
  template <typename StaticFilesT = Aws::Vector<StaticFile>>
  TemplateVersionDefinition& WithStaticFiles(StaticFilesT&& value) {
    SetStaticFiles(std::forward<StaticFilesT>(value));
    return *this;
  }
  template <typename StaticFilesT = StaticFile>
  TemplateVersionDefinition& AddStaticFiles(StaticFilesT&& value) {
    m_staticFilesHasBeenSet = true;
    m_staticFiles.emplace_back(std::forward<StaticFilesT>(value));
    return *this;
  }
 private:
  Aws::Vector<DataSetConfiguration> m_dataSetConfigurations;
 
  Aws::Vector<TopicConfiguration> m_topicConfigurations;
 
  Aws::Vector<SheetDefinition> m_sheets;
 
  Aws::Vector<TooltipSheetDefinition> m_tooltipSheets;
 
  Aws::Vector<CalculatedField> m_calculatedFields;
 
  Aws::Vector<ParameterDeclaration> m_parameterDeclarations;
 
  Aws::Vector<FilterGroup> m_filterGroups;
 
  Aws::Vector<ColumnConfiguration> m_columnConfigurations;
 
  AnalysisDefaults m_analysisDefaults;
 
  AssetOptions m_options;
 
  QueryExecutionOptions m_queryExecutionOptions;
 
  Aws::Vector<StaticFile> m_staticFiles;
  bool m_dataSetConfigurationsHasBeenSet = false;
  bool m_topicConfigurationsHasBeenSet = false;
  bool m_sheetsHasBeenSet = false;
  bool m_tooltipSheetsHasBeenSet = false;
  bool m_calculatedFieldsHasBeenSet = false;
  bool m_parameterDeclarationsHasBeenSet = false;
  bool m_filterGroupsHasBeenSet = false;
  bool m_columnConfigurationsHasBeenSet = false;
  bool m_analysisDefaultsHasBeenSet = false;
  bool m_optionsHasBeenSet = false;
  bool m_queryExecutionOptionsHasBeenSet = false;
  bool m_staticFilesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace QuickSight
}  // namespace Aws