Input.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/InputDecryptionSettings.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/InputTamsSettings.h>
#include <aws/mediaconvert/model/InputTimecodeSource.h>
#include <aws/mediaconvert/model/InputVideoGenerator.h>
#include <aws/mediaconvert/model/MultiViewSettings.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 Input {
 public:
  AWS_MEDIACONVERT_API Input() = default;
  AWS_MEDIACONVERT_API Input(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Input& 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 Input& 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>
  Input& 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>>
  Input& WithAudioSelectorGroups(AudioSelectorGroupsT&& value) {
    SetAudioSelectorGroups(std::forward<AudioSelectorGroupsT>(value));
    return *this;
  }
  template <typename AudioSelectorGroupsKeyT = Aws::String, typename AudioSelectorGroupsValueT = AudioSelectorGroup>
  Input& 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>>
  Input& WithAudioSelectors(AudioSelectorsT&& value) {
    SetAudioSelectors(std::forward<AudioSelectorsT>(value));
    return *this;
  }
  template <typename AudioSelectorsKeyT = Aws::String, typename AudioSelectorsValueT = AudioSelector>
  Input& 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>>
  Input& WithCaptionSelectors(CaptionSelectorsT&& value) {
    SetCaptionSelectors(std::forward<CaptionSelectorsT>(value));
    return *this;
  }
  template <typename CaptionSelectorsKeyT = Aws::String, typename CaptionSelectorsValueT = CaptionSelector>
  Input& 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>
  Input& 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 Input& WithDeblockFilter(InputDeblockFilter value) {
    SetDeblockFilter(value);
    return *this;
  }
 
 
  inline const InputDecryptionSettings& GetDecryptionSettings() const { return m_decryptionSettings; }
  inline bool DecryptionSettingsHasBeenSet() const { return m_decryptionSettingsHasBeenSet; }
  template <typename DecryptionSettingsT = InputDecryptionSettings>
  void SetDecryptionSettings(DecryptionSettingsT&& value) {
    m_decryptionSettingsHasBeenSet = true;
    m_decryptionSettings = std::forward<DecryptionSettingsT>(value);
  }
  template <typename DecryptionSettingsT = InputDecryptionSettings>
  Input& WithDecryptionSettings(DecryptionSettingsT&& value) {
    SetDecryptionSettings(std::forward<DecryptionSettingsT>(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 Input& 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>
  Input& 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>>
  Input& WithDynamicAudioSelectors(DynamicAudioSelectorsT&& value) {
    SetDynamicAudioSelectors(std::forward<DynamicAudioSelectorsT>(value));
    return *this;
  }
  template <typename DynamicAudioSelectorsKeyT = Aws::String, typename DynamicAudioSelectorsValueT = DynamicAudioSelector>
  Input& AddDynamicAudioSelectors(DynamicAudioSelectorsKeyT&& key, DynamicAudioSelectorsValueT&& value) {
    m_dynamicAudioSelectorsHasBeenSet = true;
    m_dynamicAudioSelectors.emplace(std::forward<DynamicAudioSelectorsKeyT>(key), std::forward<DynamicAudioSelectorsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFileInput() const { return m_fileInput; }
  inline bool FileInputHasBeenSet() const { return m_fileInputHasBeenSet; }
  template <typename FileInputT = Aws::String>
  void SetFileInput(FileInputT&& value) {
    m_fileInputHasBeenSet = true;
    m_fileInput = std::forward<FileInputT>(value);
  }
  template <typename FileInputT = Aws::String>
  Input& WithFileInput(FileInputT&& value) {
    SetFileInput(std::forward<FileInputT>(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 Input& 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 Input& 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>
  Input& 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>>
  Input& WithInputClippings(InputClippingsT&& value) {
    SetInputClippings(std::forward<InputClippingsT>(value));
    return *this;
  }
  template <typename InputClippingsT = InputClipping>
  Input& 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 Input& WithInputScanType(InputScanType value) {
    SetInputScanType(value);
    return *this;
  }
 
 
  inline const Aws::Vector<MultiViewSettings>& GetMultiViewSettings() const { return m_multiViewSettings; }
  inline bool MultiViewSettingsHasBeenSet() const { return m_multiViewSettingsHasBeenSet; }
  template <typename MultiViewSettingsT = Aws::Vector<MultiViewSettings>>
  void SetMultiViewSettings(MultiViewSettingsT&& value) {
    m_multiViewSettingsHasBeenSet = true;
    m_multiViewSettings = std::forward<MultiViewSettingsT>(value);
  }
  template <typename MultiViewSettingsT = Aws::Vector<MultiViewSettings>>
  Input& WithMultiViewSettings(MultiViewSettingsT&& value) {
    SetMultiViewSettings(std::forward<MultiViewSettingsT>(value));
    return *this;
  }
  template <typename MultiViewSettingsT = MultiViewSettings>
  Input& AddMultiViewSettings(MultiViewSettingsT&& value) {
    m_multiViewSettingsHasBeenSet = true;
    m_multiViewSettings.emplace_back(std::forward<MultiViewSettingsT>(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>
  Input& 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 Input& 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 Input& WithPsiControl(InputPsiControl value) {
    SetPsiControl(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSupplementalImps() const { return m_supplementalImps; }
  inline bool SupplementalImpsHasBeenSet() const { return m_supplementalImpsHasBeenSet; }
  template <typename SupplementalImpsT = Aws::Vector<Aws::String>>
  void SetSupplementalImps(SupplementalImpsT&& value) {
    m_supplementalImpsHasBeenSet = true;
    m_supplementalImps = std::forward<SupplementalImpsT>(value);
  }
  template <typename SupplementalImpsT = Aws::Vector<Aws::String>>
  Input& WithSupplementalImps(SupplementalImpsT&& value) {
    SetSupplementalImps(std::forward<SupplementalImpsT>(value));
    return *this;
  }
  template <typename SupplementalImpsT = Aws::String>
  Input& AddSupplementalImps(SupplementalImpsT&& value) {
    m_supplementalImpsHasBeenSet = true;
    m_supplementalImps.emplace_back(std::forward<SupplementalImpsT>(value));
    return *this;
  }
 
 
  inline const InputTamsSettings& GetTamsSettings() const { return m_tamsSettings; }
  inline bool TamsSettingsHasBeenSet() const { return m_tamsSettingsHasBeenSet; }
  template <typename TamsSettingsT = InputTamsSettings>
  void SetTamsSettings(TamsSettingsT&& value) {
    m_tamsSettingsHasBeenSet = true;
    m_tamsSettings = std::forward<TamsSettingsT>(value);
  }
  template <typename TamsSettingsT = InputTamsSettings>
  Input& WithTamsSettings(TamsSettingsT&& value) {
    SetTamsSettings(std::forward<TamsSettingsT>(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 Input& 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>
  Input& WithTimecodeStart(TimecodeStartT&& value) {
    SetTimecodeStart(std::forward<TimecodeStartT>(value));
    return *this;
  }
 
 
  inline const InputVideoGenerator& GetVideoGenerator() const { return m_videoGenerator; }
  inline bool VideoGeneratorHasBeenSet() const { return m_videoGeneratorHasBeenSet; }
  template <typename VideoGeneratorT = InputVideoGenerator>
  void SetVideoGenerator(VideoGeneratorT&& value) {
    m_videoGeneratorHasBeenSet = true;
    m_videoGenerator = std::forward<VideoGeneratorT>(value);
  }
  template <typename VideoGeneratorT = InputVideoGenerator>
  Input& WithVideoGenerator(VideoGeneratorT&& value) {
    SetVideoGenerator(std::forward<VideoGeneratorT>(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>>
  Input& WithVideoOverlays(VideoOverlaysT&& value) {
    SetVideoOverlays(std::forward<VideoOverlaysT>(value));
    return *this;
  }
  template <typename VideoOverlaysT = VideoOverlay>
  Input& 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>
  Input& 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};
 
  InputDecryptionSettings m_decryptionSettings;
 
  InputDenoiseFilter m_denoiseFilter{InputDenoiseFilter::NOT_SET};
 
  Aws::String m_dolbyVisionMetadataXml;
 
  Aws::Map<Aws::String, DynamicAudioSelector> m_dynamicAudioSelectors;
 
  Aws::String m_fileInput;
 
  InputFilterEnable m_filterEnable{InputFilterEnable::NOT_SET};
 
  int m_filterStrength{0};
 
  ImageInserter m_imageInserter;
 
  Aws::Vector<InputClipping> m_inputClippings;
 
  InputScanType m_inputScanType{InputScanType::NOT_SET};
 
  Aws::Vector<MultiViewSettings> m_multiViewSettings;
 
  Rectangle m_position;
 
  int m_programNumber{0};
 
  InputPsiControl m_psiControl{InputPsiControl::NOT_SET};
 
  Aws::Vector<Aws::String> m_supplementalImps;
 
  InputTamsSettings m_tamsSettings;
 
  InputTimecodeSource m_timecodeSource{InputTimecodeSource::NOT_SET};
 
  Aws::String m_timecodeStart;
 
  InputVideoGenerator m_videoGenerator;
 
  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_decryptionSettingsHasBeenSet = false;
  bool m_denoiseFilterHasBeenSet = false;
  bool m_dolbyVisionMetadataXmlHasBeenSet = false;
  bool m_dynamicAudioSelectorsHasBeenSet = false;
  bool m_fileInputHasBeenSet = false;
  bool m_filterEnableHasBeenSet = false;
  bool m_filterStrengthHasBeenSet = false;
  bool m_imageInserterHasBeenSet = false;
  bool m_inputClippingsHasBeenSet = false;
  bool m_inputScanTypeHasBeenSet = false;
  bool m_multiViewSettingsHasBeenSet = false;
  bool m_positionHasBeenSet = false;
  bool m_programNumberHasBeenSet = false;
  bool m_psiControlHasBeenSet = false;
  bool m_supplementalImpsHasBeenSet = false;
  bool m_tamsSettingsHasBeenSet = false;
  bool m_timecodeSourceHasBeenSet = false;
  bool m_timecodeStartHasBeenSet = false;
  bool m_videoGeneratorHasBeenSet = false;
  bool m_videoOverlaysHasBeenSet = false;
  bool m_videoSelectorHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws