AudioDescription.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>
#include <aws/mediaconvert/model/AudioChannelTaggingSettings.h>
#include <aws/mediaconvert/model/AudioCodecSettings.h>
#include <aws/mediaconvert/model/AudioLanguageCodeControl.h>
#include <aws/mediaconvert/model/AudioNormalizationSettings.h>
#include <aws/mediaconvert/model/AudioPitchCorrectionSettings.h>
#include <aws/mediaconvert/model/AudioTypeControl.h>
#include <aws/mediaconvert/model/LanguageCode.h>
#include <aws/mediaconvert/model/RemixSettings.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class AudioDescription {
 public:
  AWS_MEDIACONVERT_API AudioDescription() = default;
  AWS_MEDIACONVERT_API AudioDescription(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API AudioDescription& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const AudioChannelTaggingSettings& GetAudioChannelTaggingSettings() const { return m_audioChannelTaggingSettings; }
  inline bool AudioChannelTaggingSettingsHasBeenSet() const { return m_audioChannelTaggingSettingsHasBeenSet; }
  template <typename AudioChannelTaggingSettingsT = AudioChannelTaggingSettings>
  void SetAudioChannelTaggingSettings(AudioChannelTaggingSettingsT&& value) {
    m_audioChannelTaggingSettingsHasBeenSet = true;
    m_audioChannelTaggingSettings = std::forward<AudioChannelTaggingSettingsT>(value);
  }
  template <typename AudioChannelTaggingSettingsT = AudioChannelTaggingSettings>
  AudioDescription& WithAudioChannelTaggingSettings(AudioChannelTaggingSettingsT&& value) {
    SetAudioChannelTaggingSettings(std::forward<AudioChannelTaggingSettingsT>(value));
    return *this;
  }
 
 
  inline const AudioNormalizationSettings& GetAudioNormalizationSettings() const { return m_audioNormalizationSettings; }
  inline bool AudioNormalizationSettingsHasBeenSet() const { return m_audioNormalizationSettingsHasBeenSet; }
  template <typename AudioNormalizationSettingsT = AudioNormalizationSettings>
  void SetAudioNormalizationSettings(AudioNormalizationSettingsT&& value) {
    m_audioNormalizationSettingsHasBeenSet = true;
    m_audioNormalizationSettings = std::forward<AudioNormalizationSettingsT>(value);
  }
  template <typename AudioNormalizationSettingsT = AudioNormalizationSettings>
  AudioDescription& WithAudioNormalizationSettings(AudioNormalizationSettingsT&& value) {
    SetAudioNormalizationSettings(std::forward<AudioNormalizationSettingsT>(value));
    return *this;
  }
 
 
  inline const AudioPitchCorrectionSettings& GetAudioPitchCorrectionSettings() const { return m_audioPitchCorrectionSettings; }
  inline bool AudioPitchCorrectionSettingsHasBeenSet() const { return m_audioPitchCorrectionSettingsHasBeenSet; }
  template <typename AudioPitchCorrectionSettingsT = AudioPitchCorrectionSettings>
  void SetAudioPitchCorrectionSettings(AudioPitchCorrectionSettingsT&& value) {
    m_audioPitchCorrectionSettingsHasBeenSet = true;
    m_audioPitchCorrectionSettings = std::forward<AudioPitchCorrectionSettingsT>(value);
  }
  template <typename AudioPitchCorrectionSettingsT = AudioPitchCorrectionSettings>
  AudioDescription& WithAudioPitchCorrectionSettings(AudioPitchCorrectionSettingsT&& value) {
    SetAudioPitchCorrectionSettings(std::forward<AudioPitchCorrectionSettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAudioSourceName() const { return m_audioSourceName; }
  inline bool AudioSourceNameHasBeenSet() const { return m_audioSourceNameHasBeenSet; }
  template <typename AudioSourceNameT = Aws::String>
  void SetAudioSourceName(AudioSourceNameT&& value) {
    m_audioSourceNameHasBeenSet = true;
    m_audioSourceName = std::forward<AudioSourceNameT>(value);
  }
  template <typename AudioSourceNameT = Aws::String>
  AudioDescription& WithAudioSourceName(AudioSourceNameT&& value) {
    SetAudioSourceName(std::forward<AudioSourceNameT>(value));
    return *this;
  }
 
 
  inline int GetAudioType() const { return m_audioType; }
  inline bool AudioTypeHasBeenSet() const { return m_audioTypeHasBeenSet; }
  inline void SetAudioType(int value) {
    m_audioTypeHasBeenSet = true;
    m_audioType = value;
  }
  inline AudioDescription& WithAudioType(int value) {
    SetAudioType(value);
    return *this;
  }
 
 
  inline AudioTypeControl GetAudioTypeControl() const { return m_audioTypeControl; }
  inline bool AudioTypeControlHasBeenSet() const { return m_audioTypeControlHasBeenSet; }
  inline void SetAudioTypeControl(AudioTypeControl value) {
    m_audioTypeControlHasBeenSet = true;
    m_audioTypeControl = value;
  }
  inline AudioDescription& WithAudioTypeControl(AudioTypeControl value) {
    SetAudioTypeControl(value);
    return *this;
  }
 
 
  inline const AudioCodecSettings& GetCodecSettings() const { return m_codecSettings; }
  inline bool CodecSettingsHasBeenSet() const { return m_codecSettingsHasBeenSet; }
  template <typename CodecSettingsT = AudioCodecSettings>
  void SetCodecSettings(CodecSettingsT&& value) {
    m_codecSettingsHasBeenSet = true;
    m_codecSettings = std::forward<CodecSettingsT>(value);
  }
  template <typename CodecSettingsT = AudioCodecSettings>
  AudioDescription& WithCodecSettings(CodecSettingsT&& value) {
    SetCodecSettings(std::forward<CodecSettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCustomLanguageCode() const { return m_customLanguageCode; }
  inline bool CustomLanguageCodeHasBeenSet() const { return m_customLanguageCodeHasBeenSet; }
  template <typename CustomLanguageCodeT = Aws::String>
  void SetCustomLanguageCode(CustomLanguageCodeT&& value) {
    m_customLanguageCodeHasBeenSet = true;
    m_customLanguageCode = std::forward<CustomLanguageCodeT>(value);
  }
  template <typename CustomLanguageCodeT = Aws::String>
  AudioDescription& WithCustomLanguageCode(CustomLanguageCodeT&& value) {
    SetCustomLanguageCode(std::forward<CustomLanguageCodeT>(value));
    return *this;
  }
 
 
  inline LanguageCode GetLanguageCode() const { return m_languageCode; }
  inline bool LanguageCodeHasBeenSet() const { return m_languageCodeHasBeenSet; }
  inline void SetLanguageCode(LanguageCode value) {
    m_languageCodeHasBeenSet = true;
    m_languageCode = value;
  }
  inline AudioDescription& WithLanguageCode(LanguageCode value) {
    SetLanguageCode(value);
    return *this;
  }
 
 
  inline AudioLanguageCodeControl GetLanguageCodeControl() const { return m_languageCodeControl; }
  inline bool LanguageCodeControlHasBeenSet() const { return m_languageCodeControlHasBeenSet; }
  inline void SetLanguageCodeControl(AudioLanguageCodeControl value) {
    m_languageCodeControlHasBeenSet = true;
    m_languageCodeControl = value;
  }
  inline AudioDescription& WithLanguageCodeControl(AudioLanguageCodeControl value) {
    SetLanguageCodeControl(value);
    return *this;
  }
 
 
  inline const RemixSettings& GetRemixSettings() const { return m_remixSettings; }
  inline bool RemixSettingsHasBeenSet() const { return m_remixSettingsHasBeenSet; }
  template <typename RemixSettingsT = RemixSettings>
  void SetRemixSettings(RemixSettingsT&& value) {
    m_remixSettingsHasBeenSet = true;
    m_remixSettings = std::forward<RemixSettingsT>(value);
  }
  template <typename RemixSettingsT = RemixSettings>
  AudioDescription& WithRemixSettings(RemixSettingsT&& value) {
    SetRemixSettings(std::forward<RemixSettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetStreamName() const { return m_streamName; }
  inline bool StreamNameHasBeenSet() const { return m_streamNameHasBeenSet; }
  template <typename StreamNameT = Aws::String>
  void SetStreamName(StreamNameT&& value) {
    m_streamNameHasBeenSet = true;
    m_streamName = std::forward<StreamNameT>(value);
  }
  template <typename StreamNameT = Aws::String>
  AudioDescription& WithStreamName(StreamNameT&& value) {
    SetStreamName(std::forward<StreamNameT>(value));
    return *this;
  }
 private:
  AudioChannelTaggingSettings m_audioChannelTaggingSettings;
 
  AudioNormalizationSettings m_audioNormalizationSettings;
 
  AudioPitchCorrectionSettings m_audioPitchCorrectionSettings;
 
  Aws::String m_audioSourceName;
 
  int m_audioType{0};
 
  AudioTypeControl m_audioTypeControl{AudioTypeControl::NOT_SET};
 
  AudioCodecSettings m_codecSettings;
 
  Aws::String m_customLanguageCode;
 
  LanguageCode m_languageCode{LanguageCode::NOT_SET};
 
  AudioLanguageCodeControl m_languageCodeControl{AudioLanguageCodeControl::NOT_SET};
 
  RemixSettings m_remixSettings;
 
  Aws::String m_streamName;
  bool m_audioChannelTaggingSettingsHasBeenSet = false;
  bool m_audioNormalizationSettingsHasBeenSet = false;
  bool m_audioPitchCorrectionSettingsHasBeenSet = false;
  bool m_audioSourceNameHasBeenSet = false;
  bool m_audioTypeHasBeenSet = false;
  bool m_audioTypeControlHasBeenSet = false;
  bool m_codecSettingsHasBeenSet = false;
  bool m_customLanguageCodeHasBeenSet = false;
  bool m_languageCodeHasBeenSet = false;
  bool m_languageCodeControlHasBeenSet = false;
  bool m_remixSettingsHasBeenSet = false;
  bool m_streamNameHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws