InputTemplate.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/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AdvancedInputFilter.h>
#include <aws/mediaconvert/model/AdvancedInputFilterSettings.h>
#include <aws/mediaconvert/model/AudioSelector.h>
#include <aws/mediaconvert/model/AudioSelectorGroup.h>
#include <aws/mediaconvert/model/CaptionSelector.h>
#include <aws/mediaconvert/model/DynamicAudioSelector.h>
#include <aws/mediaconvert/model/ImageInserter.h>
#include <aws/mediaconvert/model/InputClipping.h>
#include <aws/mediaconvert/model/InputDeblockFilter.h>
#include <aws/mediaconvert/model/InputDenoiseFilter.h>
#include <aws/mediaconvert/model/InputFilterEnable.h>
#include <aws/mediaconvert/model/InputPsiControl.h>
#include <aws/mediaconvert/model/InputScanType.h>
#include <aws/mediaconvert/model/InputTimecodeSource.h>
#include <aws/mediaconvert/model/Rectangle.h>
#include <aws/mediaconvert/model/VideoOverlay.h>
#include <aws/mediaconvert/model/VideoSelector.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class InputTemplate {
 public:
  AWS_MEDIACONVERT_API InputTemplate() = default;
  AWS_MEDIACONVERT_API InputTemplate(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API InputTemplate& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline AdvancedInputFilter GetAdvancedInputFilter() const { return m_advancedInputFilter; }
  inline bool AdvancedInputFilterHasBeenSet() const { return m_advancedInputFilterHasBeenSet; }
  inline void SetAdvancedInputFilter(AdvancedInputFilter value) {
    m_advancedInputFilterHasBeenSet = true;
    m_advancedInputFilter = value;
  }
  inline InputTemplate& WithAdvancedInputFilter(AdvancedInputFilter value) {
    SetAdvancedInputFilter(value);
    return *this;
  }
 
 
  inline const AdvancedInputFilterSettings& GetAdvancedInputFilterSettings() const { return m_advancedInputFilterSettings; }
  inline bool AdvancedInputFilterSettingsHasBeenSet() const { return m_advancedInputFilterSettingsHasBeenSet; }
  template <typename AdvancedInputFilterSettingsT = AdvancedInputFilterSettings>
  void SetAdvancedInputFilterSettings(AdvancedInputFilterSettingsT&& value) {
    m_advancedInputFilterSettingsHasBeenSet = true;
    m_advancedInputFilterSettings = std::forward<AdvancedInputFilterSettingsT>(value);
  }
  template <typename AdvancedInputFilterSettingsT = AdvancedInputFilterSettings>
  InputTemplate& WithAdvancedInputFilterSettings(AdvancedInputFilterSettingsT&& value) {
    SetAdvancedInputFilterSettings(std::forward<AdvancedInputFilterSettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, AudioSelectorGroup>& GetAudioSelectorGroups() const { return m_audioSelectorGroups; }
  inline bool AudioSelectorGroupsHasBeenSet() const { return m_audioSelectorGroupsHasBeenSet; }
  template <typename AudioSelectorGroupsT = Aws::Map<Aws::String, AudioSelectorGroup>>
  void SetAudioSelectorGroups(AudioSelectorGroupsT&& value) {
    m_audioSelectorGroupsHasBeenSet = true;
    m_audioSelectorGroups = std::forward<AudioSelectorGroupsT>(value);
  }
  template <typename AudioSelectorGroupsT = Aws::Map<Aws::String, AudioSelectorGroup>>
  InputTemplate& WithAudioSelectorGroups(AudioSelectorGroupsT&& value) {
    SetAudioSelectorGroups(std::forward<AudioSelectorGroupsT>(value));
    return *this;
  }
  template <typename AudioSelectorGroupsKeyT = Aws::String, typename AudioSelectorGroupsValueT = AudioSelectorGroup>
  InputTemplate& AddAudioSelectorGroups(AudioSelectorGroupsKeyT&& key, AudioSelectorGroupsValueT&& value) {
    m_audioSelectorGroupsHasBeenSet = true;
    m_audioSelectorGroups.emplace(std::forward<AudioSelectorGroupsKeyT>(key), std::forward<AudioSelectorGroupsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, AudioSelector>& GetAudioSelectors() const { return m_audioSelectors; }
  inline bool AudioSelectorsHasBeenSet() const { return m_audioSelectorsHasBeenSet; }
  template <typename AudioSelectorsT = Aws::Map<Aws::String, AudioSelector>>
  void SetAudioSelectors(AudioSelectorsT&& value) {
    m_audioSelectorsHasBeenSet = true;
    m_audioSelectors = std::forward<AudioSelectorsT>(value);
  }
  template <typename AudioSelectorsT = Aws::Map<Aws::String, AudioSelector>>
  InputTemplate& WithAudioSelectors(AudioSelectorsT&& value) {
    SetAudioSelectors(std::forward<AudioSelectorsT>(value));
    return *this;
  }
  template <typename AudioSelectorsKeyT = Aws::String, typename AudioSelectorsValueT = AudioSelector>
  InputTemplate& AddAudioSelectors(AudioSelectorsKeyT&& key, AudioSelectorsValueT&& value) {
    m_audioSelectorsHasBeenSet = true;
    m_audioSelectors.emplace(std::forward<AudioSelectorsKeyT>(key), std::forward<AudioSelectorsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, CaptionSelector>& GetCaptionSelectors() const { return m_captionSelectors; }
  inline bool CaptionSelectorsHasBeenSet() const { return m_captionSelectorsHasBeenSet; }
  template <typename CaptionSelectorsT = Aws::Map<Aws::String, CaptionSelector>>
  void SetCaptionSelectors(CaptionSelectorsT&& value) {
    m_captionSelectorsHasBeenSet = true;
    m_captionSelectors = std::forward<CaptionSelectorsT>(value);
  }
  template <typename CaptionSelectorsT = Aws::Map<Aws::String, CaptionSelector>>
  InputTemplate& WithCaptionSelectors(CaptionSelectorsT&& value) {
    SetCaptionSelectors(std::forward<CaptionSelectorsT>(value));
    return *this;
  }
  template <typename CaptionSelectorsKeyT = Aws::String, typename CaptionSelectorsValueT = CaptionSelector>
  InputTemplate& AddCaptionSelectors(CaptionSelectorsKeyT&& key, CaptionSelectorsValueT&& value) {
    m_captionSelectorsHasBeenSet = true;
    m_captionSelectors.emplace(std::forward<CaptionSelectorsKeyT>(key), std::forward<CaptionSelectorsValueT>(value));
    return *this;
  }
 
 
  inline const Rectangle& GetCrop() const { return m_crop; }
  inline bool CropHasBeenSet() const { return m_cropHasBeenSet; }
  template <typename CropT = Rectangle>
  void SetCrop(CropT&& value) {
    m_cropHasBeenSet = true;
    m_crop = std::forward<CropT>(value);
  }
  template <typename CropT = Rectangle>
  InputTemplate& WithCrop(CropT&& value) {
    SetCrop(std::forward<CropT>(value));
    return *this;
  }
 
 
  inline InputDeblockFilter GetDeblockFilter() const { return m_deblockFilter; }
  inline bool DeblockFilterHasBeenSet() const { return m_deblockFilterHasBeenSet; }
  inline void SetDeblockFilter(InputDeblockFilter value) {
    m_deblockFilterHasBeenSet = true;
    m_deblockFilter = value;
  }
  inline InputTemplate& WithDeblockFilter(InputDeblockFilter value) {
    SetDeblockFilter(value);
    return *this;
  }
 
 
  inline InputDenoiseFilter GetDenoiseFilter() const { return m_denoiseFilter; }
  inline bool DenoiseFilterHasBeenSet() const { return m_denoiseFilterHasBeenSet; }
  inline void SetDenoiseFilter(InputDenoiseFilter value) {
    m_denoiseFilterHasBeenSet = true;
    m_denoiseFilter = value;
  }
  inline InputTemplate& WithDenoiseFilter(InputDenoiseFilter value) {
    SetDenoiseFilter(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDolbyVisionMetadataXml() const { return m_dolbyVisionMetadataXml; }
  inline bool DolbyVisionMetadataXmlHasBeenSet() const { return m_dolbyVisionMetadataXmlHasBeenSet; }
  template <typename DolbyVisionMetadataXmlT = Aws::String>
  void SetDolbyVisionMetadataXml(DolbyVisionMetadataXmlT&& value) {
    m_dolbyVisionMetadataXmlHasBeenSet = true;
    m_dolbyVisionMetadataXml = std::forward<DolbyVisionMetadataXmlT>(value);
  }
  template <typename DolbyVisionMetadataXmlT = Aws::String>
  InputTemplate& WithDolbyVisionMetadataXml(DolbyVisionMetadataXmlT&& value) {
    SetDolbyVisionMetadataXml(std::forward<DolbyVisionMetadataXmlT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, DynamicAudioSelector>& GetDynamicAudioSelectors() const { return m_dynamicAudioSelectors; }
  inline bool DynamicAudioSelectorsHasBeenSet() const { return m_dynamicAudioSelectorsHasBeenSet; }
  template <typename DynamicAudioSelectorsT = Aws::Map<Aws::String, DynamicAudioSelector>>
  void SetDynamicAudioSelectors(DynamicAudioSelectorsT&& value) {
    m_dynamicAudioSelectorsHasBeenSet = true;
    m_dynamicAudioSelectors = std::forward<DynamicAudioSelectorsT>(value);
  }
  template <typename DynamicAudioSelectorsT = Aws::Map<Aws::String, DynamicAudioSelector>>
  InputTemplate& WithDynamicAudioSelectors(DynamicAudioSelectorsT&& value) {
    SetDynamicAudioSelectors(std::forward<DynamicAudioSelectorsT>(value));
    return *this;
  }
  template <typename DynamicAudioSelectorsKeyT = Aws::String, typename DynamicAudioSelectorsValueT = DynamicAudioSelector>
  InputTemplate& AddDynamicAudioSelectors(DynamicAudioSelectorsKeyT&& key, DynamicAudioSelectorsValueT&& value) {
    m_dynamicAudioSelectorsHasBeenSet = true;
    m_dynamicAudioSelectors.emplace(std::forward<DynamicAudioSelectorsKeyT>(key), std::forward<DynamicAudioSelectorsValueT>(value));
    return *this;
  }
 
 
  inline InputFilterEnable GetFilterEnable() const { return m_filterEnable; }
  inline bool FilterEnableHasBeenSet() const { return m_filterEnableHasBeenSet; }
  inline void SetFilterEnable(InputFilterEnable value) {
    m_filterEnableHasBeenSet = true;
    m_filterEnable = value;
  }
  inline InputTemplate& WithFilterEnable(InputFilterEnable value) {
    SetFilterEnable(value);
    return *this;
  }
 
 
  inline int GetFilterStrength() const { return m_filterStrength; }
  inline bool FilterStrengthHasBeenSet() const { return m_filterStrengthHasBeenSet; }
  inline void SetFilterStrength(int value) {
    m_filterStrengthHasBeenSet = true;
    m_filterStrength = value;
  }
  inline InputTemplate& WithFilterStrength(int value) {
    SetFilterStrength(value);
    return *this;
  }
 
 
  inline const ImageInserter& GetImageInserter() const { return m_imageInserter; }
  inline bool ImageInserterHasBeenSet() const { return m_imageInserterHasBeenSet; }
  template <typename ImageInserterT = ImageInserter>
  void SetImageInserter(ImageInserterT&& value) {
    m_imageInserterHasBeenSet = true;
    m_imageInserter = std::forward<ImageInserterT>(value);
  }
  template <typename ImageInserterT = ImageInserter>
  InputTemplate& WithImageInserter(ImageInserterT&& value) {
    SetImageInserter(std::forward<ImageInserterT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<InputClipping>& GetInputClippings() const { return m_inputClippings; }
  inline bool InputClippingsHasBeenSet() const { return m_inputClippingsHasBeenSet; }
  template <typename InputClippingsT = Aws::Vector<InputClipping>>
  void SetInputClippings(InputClippingsT&& value) {
    m_inputClippingsHasBeenSet = true;
    m_inputClippings = std::forward<InputClippingsT>(value);
  }
  template <typename InputClippingsT = Aws::Vector<InputClipping>>
  InputTemplate& WithInputClippings(InputClippingsT&& value) {
    SetInputClippings(std::forward<InputClippingsT>(value));
    return *this;
  }
  template <typename InputClippingsT = InputClipping>
  InputTemplate& AddInputClippings(InputClippingsT&& value) {
    m_inputClippingsHasBeenSet = true;
    m_inputClippings.emplace_back(std::forward<InputClippingsT>(value));
    return *this;
  }
 
 
  inline InputScanType GetInputScanType() const { return m_inputScanType; }
  inline bool InputScanTypeHasBeenSet() const { return m_inputScanTypeHasBeenSet; }
  inline void SetInputScanType(InputScanType value) {
    m_inputScanTypeHasBeenSet = true;
    m_inputScanType = value;
  }
  inline InputTemplate& WithInputScanType(InputScanType value) {
    SetInputScanType(value);
    return *this;
  }
 
 
  inline const Rectangle& GetPosition() const { return m_position; }
  inline bool PositionHasBeenSet() const { return m_positionHasBeenSet; }
  template <typename PositionT = Rectangle>
  void SetPosition(PositionT&& value) {
    m_positionHasBeenSet = true;
    m_position = std::forward<PositionT>(value);
  }
  template <typename PositionT = Rectangle>
  InputTemplate& WithPosition(PositionT&& value) {
    SetPosition(std::forward<PositionT>(value));
    return *this;
  }
 
 
  inline int GetProgramNumber() const { return m_programNumber; }
  inline bool ProgramNumberHasBeenSet() const { return m_programNumberHasBeenSet; }
  inline void SetProgramNumber(int value) {
    m_programNumberHasBeenSet = true;
    m_programNumber = value;
  }
  inline InputTemplate& WithProgramNumber(int value) {
    SetProgramNumber(value);
    return *this;
  }
 
 
  inline InputPsiControl GetPsiControl() const { return m_psiControl; }
  inline bool PsiControlHasBeenSet() const { return m_psiControlHasBeenSet; }
  inline void SetPsiControl(InputPsiControl value) {
    m_psiControlHasBeenSet = true;
    m_psiControl = value;
  }
  inline InputTemplate& WithPsiControl(InputPsiControl value) {
    SetPsiControl(value);
    return *this;
  }
 
 
  inline InputTimecodeSource GetTimecodeSource() const { return m_timecodeSource; }
  inline bool TimecodeSourceHasBeenSet() const { return m_timecodeSourceHasBeenSet; }
  inline void SetTimecodeSource(InputTimecodeSource value) {
    m_timecodeSourceHasBeenSet = true;
    m_timecodeSource = value;
  }
  inline InputTemplate& WithTimecodeSource(InputTimecodeSource value) {
    SetTimecodeSource(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTimecodeStart() const { return m_timecodeStart; }
  inline bool TimecodeStartHasBeenSet() const { return m_timecodeStartHasBeenSet; }
  template <typename TimecodeStartT = Aws::String>
  void SetTimecodeStart(TimecodeStartT&& value) {
    m_timecodeStartHasBeenSet = true;
    m_timecodeStart = std::forward<TimecodeStartT>(value);
  }
  template <typename TimecodeStartT = Aws::String>
  InputTemplate& WithTimecodeStart(TimecodeStartT&& value) {
    SetTimecodeStart(std::forward<TimecodeStartT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<VideoOverlay>& GetVideoOverlays() const { return m_videoOverlays; }
  inline bool VideoOverlaysHasBeenSet() const { return m_videoOverlaysHasBeenSet; }
  template <typename VideoOverlaysT = Aws::Vector<VideoOverlay>>
  void SetVideoOverlays(VideoOverlaysT&& value) {
    m_videoOverlaysHasBeenSet = true;
    m_videoOverlays = std::forward<VideoOverlaysT>(value);
  }
  template <typename VideoOverlaysT = Aws::Vector<VideoOverlay>>
  InputTemplate& WithVideoOverlays(VideoOverlaysT&& value) {
    SetVideoOverlays(std::forward<VideoOverlaysT>(value));
    return *this;
  }
  template <typename VideoOverlaysT = VideoOverlay>
  InputTemplate& AddVideoOverlays(VideoOverlaysT&& value) {
    m_videoOverlaysHasBeenSet = true;
    m_videoOverlays.emplace_back(std::forward<VideoOverlaysT>(value));
    return *this;
  }
 
 
  inline const VideoSelector& GetVideoSelector() const { return m_videoSelector; }
  inline bool VideoSelectorHasBeenSet() const { return m_videoSelectorHasBeenSet; }
  template <typename VideoSelectorT = VideoSelector>
  void SetVideoSelector(VideoSelectorT&& value) {
    m_videoSelectorHasBeenSet = true;
    m_videoSelector = std::forward<VideoSelectorT>(value);
  }
  template <typename VideoSelectorT = VideoSelector>
  InputTemplate& WithVideoSelector(VideoSelectorT&& value) {
    SetVideoSelector(std::forward<VideoSelectorT>(value));
    return *this;
  }
 private:
  AdvancedInputFilter m_advancedInputFilter{AdvancedInputFilter::NOT_SET};
 
  AdvancedInputFilterSettings m_advancedInputFilterSettings;
 
  Aws::Map<Aws::String, AudioSelectorGroup> m_audioSelectorGroups;
 
  Aws::Map<Aws::String, AudioSelector> m_audioSelectors;
 
  Aws::Map<Aws::String, CaptionSelector> m_captionSelectors;
 
  Rectangle m_crop;
 
  InputDeblockFilter m_deblockFilter{InputDeblockFilter::NOT_SET};
 
  InputDenoiseFilter m_denoiseFilter{InputDenoiseFilter::NOT_SET};
 
  Aws::String m_dolbyVisionMetadataXml;
 
  Aws::Map<Aws::String, DynamicAudioSelector> m_dynamicAudioSelectors;
 
  InputFilterEnable m_filterEnable{InputFilterEnable::NOT_SET};
 
  int m_filterStrength{0};
 
  ImageInserter m_imageInserter;
 
  Aws::Vector<InputClipping> m_inputClippings;
 
  InputScanType m_inputScanType{InputScanType::NOT_SET};
 
  Rectangle m_position;
 
  int m_programNumber{0};
 
  InputPsiControl m_psiControl{InputPsiControl::NOT_SET};
 
  InputTimecodeSource m_timecodeSource{InputTimecodeSource::NOT_SET};
 
  Aws::String m_timecodeStart;
 
  Aws::Vector<VideoOverlay> m_videoOverlays;
 
  VideoSelector m_videoSelector;
  bool m_advancedInputFilterHasBeenSet = false;
  bool m_advancedInputFilterSettingsHasBeenSet = false;
  bool m_audioSelectorGroupsHasBeenSet = false;
  bool m_audioSelectorsHasBeenSet = false;
  bool m_captionSelectorsHasBeenSet = false;
  bool m_cropHasBeenSet = false;
  bool m_deblockFilterHasBeenSet = false;
  bool m_denoiseFilterHasBeenSet = false;
  bool m_dolbyVisionMetadataXmlHasBeenSet = false;
  bool m_dynamicAudioSelectorsHasBeenSet = false;
  bool m_filterEnableHasBeenSet = false;
  bool m_filterStrengthHasBeenSet = false;
  bool m_imageInserterHasBeenSet = false;
  bool m_inputClippingsHasBeenSet = false;
  bool m_inputScanTypeHasBeenSet = false;
  bool m_positionHasBeenSet = false;
  bool m_programNumberHasBeenSet = false;
  bool m_psiControlHasBeenSet = false;
  bool m_timecodeSourceHasBeenSet = false;
  bool m_timecodeStartHasBeenSet = false;
  bool m_videoOverlaysHasBeenSet = false;
  bool m_videoSelectorHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws