VideoOverlay.h

 
#pragma once
#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/VideoOverlayCrop.h>
#include <aws/mediaconvert/model/VideoOverlayInput.h>
#include <aws/mediaconvert/model/VideoOverlayPlayBackMode.h>
#include <aws/mediaconvert/model/VideoOverlayPosition.h>
#include <aws/mediaconvert/model/VideoOverlayTransition.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class VideoOverlay {
 public:
  AWS_MEDIACONVERT_API VideoOverlay() = default;
  AWS_MEDIACONVERT_API VideoOverlay(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API VideoOverlay& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const VideoOverlayCrop& GetCrop() const { return m_crop; }
  inline bool CropHasBeenSet() const { return m_cropHasBeenSet; }
  template <typename CropT = VideoOverlayCrop>
  void SetCrop(CropT&& value) {
    m_cropHasBeenSet = true;
    m_crop = std::forward<CropT>(value);
  }
  template <typename CropT = VideoOverlayCrop>
  VideoOverlay& WithCrop(CropT&& value) {
    SetCrop(std::forward<CropT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEndTimecode() const { return m_endTimecode; }
  inline bool EndTimecodeHasBeenSet() const { return m_endTimecodeHasBeenSet; }
  template <typename EndTimecodeT = Aws::String>
  void SetEndTimecode(EndTimecodeT&& value) {
    m_endTimecodeHasBeenSet = true;
    m_endTimecode = std::forward<EndTimecodeT>(value);
  }
  template <typename EndTimecodeT = Aws::String>
  VideoOverlay& WithEndTimecode(EndTimecodeT&& value) {
    SetEndTimecode(std::forward<EndTimecodeT>(value));
    return *this;
  }
 
 
  inline const VideoOverlayPosition& GetInitialPosition() const { return m_initialPosition; }
  inline bool InitialPositionHasBeenSet() const { return m_initialPositionHasBeenSet; }
  template <typename InitialPositionT = VideoOverlayPosition>
  void SetInitialPosition(InitialPositionT&& value) {
    m_initialPositionHasBeenSet = true;
    m_initialPosition = std::forward<InitialPositionT>(value);
  }
  template <typename InitialPositionT = VideoOverlayPosition>
  VideoOverlay& WithInitialPosition(InitialPositionT&& value) {
    SetInitialPosition(std::forward<InitialPositionT>(value));
    return *this;
  }
 
 
  inline const VideoOverlayInput& GetInput() const { return m_input; }
  inline bool InputHasBeenSet() const { return m_inputHasBeenSet; }
  template <typename InputT = VideoOverlayInput>
  void SetInput(InputT&& value) {
    m_inputHasBeenSet = true;
    m_input = std::forward<InputT>(value);
  }
  template <typename InputT = VideoOverlayInput>
  VideoOverlay& WithInput(InputT&& value) {
    SetInput(std::forward<InputT>(value));
    return *this;
  }
 
 
  inline VideoOverlayPlayBackMode GetPlayback() const { return m_playback; }
  inline bool PlaybackHasBeenSet() const { return m_playbackHasBeenSet; }
  inline void SetPlayback(VideoOverlayPlayBackMode value) {
    m_playbackHasBeenSet = true;
    m_playback = value;
  }
  inline VideoOverlay& WithPlayback(VideoOverlayPlayBackMode value) {
    SetPlayback(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStartTimecode() const { return m_startTimecode; }
  inline bool StartTimecodeHasBeenSet() const { return m_startTimecodeHasBeenSet; }
  template <typename StartTimecodeT = Aws::String>
  void SetStartTimecode(StartTimecodeT&& value) {
    m_startTimecodeHasBeenSet = true;
    m_startTimecode = std::forward<StartTimecodeT>(value);
  }
  template <typename StartTimecodeT = Aws::String>
  VideoOverlay& WithStartTimecode(StartTimecodeT&& value) {
    SetStartTimecode(std::forward<StartTimecodeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<VideoOverlayTransition>& GetTransitions() const { return m_transitions; }
  inline bool TransitionsHasBeenSet() const { return m_transitionsHasBeenSet; }
  template <typename TransitionsT = Aws::Vector<VideoOverlayTransition>>
  void SetTransitions(TransitionsT&& value) {
    m_transitionsHasBeenSet = true;
    m_transitions = std::forward<TransitionsT>(value);
  }
  template <typename TransitionsT = Aws::Vector<VideoOverlayTransition>>
  VideoOverlay& WithTransitions(TransitionsT&& value) {
    SetTransitions(std::forward<TransitionsT>(value));
    return *this;
  }
  template <typename TransitionsT = VideoOverlayTransition>
  VideoOverlay& AddTransitions(TransitionsT&& value) {
    m_transitionsHasBeenSet = true;
    m_transitions.emplace_back(std::forward<TransitionsT>(value));
    return *this;
  }
 private:
  VideoOverlayCrop m_crop;
 
  Aws::String m_endTimecode;
 
  VideoOverlayPosition m_initialPosition;
 
  VideoOverlayInput m_input;
 
  VideoOverlayPlayBackMode m_playback{VideoOverlayPlayBackMode::NOT_SET};
 
  Aws::String m_startTimecode;
 
  Aws::Vector<VideoOverlayTransition> m_transitions;
  bool m_cropHasBeenSet = false;
  bool m_endTimecodeHasBeenSet = false;
  bool m_initialPositionHasBeenSet = false;
  bool m_inputHasBeenSet = false;
  bool m_playbackHasBeenSet = false;
  bool m_startTimecodeHasBeenSet = false;
  bool m_transitionsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws