CmafGroupSettings.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/CmafAdditionalManifest.h>
#include <aws/mediaconvert/model/CmafClientCache.h>
#include <aws/mediaconvert/model/CmafCodecSpecification.h>
#include <aws/mediaconvert/model/CmafEncryptionSettings.h>
#include <aws/mediaconvert/model/CmafImageBasedTrickPlay.h>
#include <aws/mediaconvert/model/CmafImageBasedTrickPlaySettings.h>
#include <aws/mediaconvert/model/CmafImageBasedTrickPlayVariant.h>
#include <aws/mediaconvert/model/CmafManifestCompression.h>
#include <aws/mediaconvert/model/CmafManifestDurationFormat.h>
#include <aws/mediaconvert/model/CmafMpdManifestBandwidthType.h>
#include <aws/mediaconvert/model/CmafMpdProfile.h>
#include <aws/mediaconvert/model/CmafPtsOffsetHandlingForBFrames.h>
#include <aws/mediaconvert/model/CmafSegmentControl.h>
#include <aws/mediaconvert/model/CmafSegmentLengthControl.h>
#include <aws/mediaconvert/model/CmafStreamInfResolution.h>
#include <aws/mediaconvert/model/CmafTargetDurationCompatibilityMode.h>
#include <aws/mediaconvert/model/CmafVideoCompositionOffsets.h>
#include <aws/mediaconvert/model/CmafWriteDASHManifest.h>
#include <aws/mediaconvert/model/CmafWriteHLSManifest.h>
#include <aws/mediaconvert/model/CmafWriteSegmentTimelineInRepresentation.h>
#include <aws/mediaconvert/model/DashManifestStyle.h>
#include <aws/mediaconvert/model/DestinationSettings.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaConvert {
namespace Model {
 
class CmafGroupSettings {
 public:
  AWS_MEDIACONVERT_API CmafGroupSettings() = default;
  AWS_MEDIACONVERT_API CmafGroupSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API CmafGroupSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<CmafAdditionalManifest>& GetAdditionalManifests() const { return m_additionalManifests; }
  inline bool AdditionalManifestsHasBeenSet() const { return m_additionalManifestsHasBeenSet; }
  template <typename AdditionalManifestsT = Aws::Vector<CmafAdditionalManifest>>
  void SetAdditionalManifests(AdditionalManifestsT&& value) {
    m_additionalManifestsHasBeenSet = true;
    m_additionalManifests = std::forward<AdditionalManifestsT>(value);
  }
  template <typename AdditionalManifestsT = Aws::Vector<CmafAdditionalManifest>>
  CmafGroupSettings& WithAdditionalManifests(AdditionalManifestsT&& value) {
    SetAdditionalManifests(std::forward<AdditionalManifestsT>(value));
    return *this;
  }
  template <typename AdditionalManifestsT = CmafAdditionalManifest>
  CmafGroupSettings& AddAdditionalManifests(AdditionalManifestsT&& value) {
    m_additionalManifestsHasBeenSet = true;
    m_additionalManifests.emplace_back(std::forward<AdditionalManifestsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetBaseUrl() const { return m_baseUrl; }
  inline bool BaseUrlHasBeenSet() const { return m_baseUrlHasBeenSet; }
  template <typename BaseUrlT = Aws::String>
  void SetBaseUrl(BaseUrlT&& value) {
    m_baseUrlHasBeenSet = true;
    m_baseUrl = std::forward<BaseUrlT>(value);
  }
  template <typename BaseUrlT = Aws::String>
  CmafGroupSettings& WithBaseUrl(BaseUrlT&& value) {
    SetBaseUrl(std::forward<BaseUrlT>(value));
    return *this;
  }
 
 
  inline CmafClientCache GetClientCache() const { return m_clientCache; }
  inline bool ClientCacheHasBeenSet() const { return m_clientCacheHasBeenSet; }
  inline void SetClientCache(CmafClientCache value) {
    m_clientCacheHasBeenSet = true;
    m_clientCache = value;
  }
  inline CmafGroupSettings& WithClientCache(CmafClientCache value) {
    SetClientCache(value);
    return *this;
  }
 
 
  inline CmafCodecSpecification GetCodecSpecification() const { return m_codecSpecification; }
  inline bool CodecSpecificationHasBeenSet() const { return m_codecSpecificationHasBeenSet; }
  inline void SetCodecSpecification(CmafCodecSpecification value) {
    m_codecSpecificationHasBeenSet = true;
    m_codecSpecification = value;
  }
  inline CmafGroupSettings& WithCodecSpecification(CmafCodecSpecification value) {
    SetCodecSpecification(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDashIFrameTrickPlayNameModifier() const { return m_dashIFrameTrickPlayNameModifier; }
  inline bool DashIFrameTrickPlayNameModifierHasBeenSet() const { return m_dashIFrameTrickPlayNameModifierHasBeenSet; }
  template <typename DashIFrameTrickPlayNameModifierT = Aws::String>
  void SetDashIFrameTrickPlayNameModifier(DashIFrameTrickPlayNameModifierT&& value) {
    m_dashIFrameTrickPlayNameModifierHasBeenSet = true;
    m_dashIFrameTrickPlayNameModifier = std::forward<DashIFrameTrickPlayNameModifierT>(value);
  }
  template <typename DashIFrameTrickPlayNameModifierT = Aws::String>
  CmafGroupSettings& WithDashIFrameTrickPlayNameModifier(DashIFrameTrickPlayNameModifierT&& value) {
    SetDashIFrameTrickPlayNameModifier(std::forward<DashIFrameTrickPlayNameModifierT>(value));
    return *this;
  }
 
 
  inline DashManifestStyle GetDashManifestStyle() const { return m_dashManifestStyle; }
  inline bool DashManifestStyleHasBeenSet() const { return m_dashManifestStyleHasBeenSet; }
  inline void SetDashManifestStyle(DashManifestStyle value) {
    m_dashManifestStyleHasBeenSet = true;
    m_dashManifestStyle = value;
  }
  inline CmafGroupSettings& WithDashManifestStyle(DashManifestStyle value) {
    SetDashManifestStyle(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDestination() const { return m_destination; }
  inline bool DestinationHasBeenSet() const { return m_destinationHasBeenSet; }
  template <typename DestinationT = Aws::String>
  void SetDestination(DestinationT&& value) {
    m_destinationHasBeenSet = true;
    m_destination = std::forward<DestinationT>(value);
  }
  template <typename DestinationT = Aws::String>
  CmafGroupSettings& WithDestination(DestinationT&& value) {
    SetDestination(std::forward<DestinationT>(value));
    return *this;
  }
 
 
  inline const DestinationSettings& GetDestinationSettings() const { return m_destinationSettings; }
  inline bool DestinationSettingsHasBeenSet() const { return m_destinationSettingsHasBeenSet; }
  template <typename DestinationSettingsT = DestinationSettings>
  void SetDestinationSettings(DestinationSettingsT&& value) {
    m_destinationSettingsHasBeenSet = true;
    m_destinationSettings = std::forward<DestinationSettingsT>(value);
  }
  template <typename DestinationSettingsT = DestinationSettings>
  CmafGroupSettings& WithDestinationSettings(DestinationSettingsT&& value) {
    SetDestinationSettings(std::forward<DestinationSettingsT>(value));
    return *this;
  }
 
 
  inline const CmafEncryptionSettings& GetEncryption() const { return m_encryption; }
  inline bool EncryptionHasBeenSet() const { return m_encryptionHasBeenSet; }
  template <typename EncryptionT = CmafEncryptionSettings>
  void SetEncryption(EncryptionT&& value) {
    m_encryptionHasBeenSet = true;
    m_encryption = std::forward<EncryptionT>(value);
  }
  template <typename EncryptionT = CmafEncryptionSettings>
  CmafGroupSettings& WithEncryption(EncryptionT&& value) {
    SetEncryption(std::forward<EncryptionT>(value));
    return *this;
  }
 
 
  inline int GetFragmentLength() const { return m_fragmentLength; }
  inline bool FragmentLengthHasBeenSet() const { return m_fragmentLengthHasBeenSet; }
  inline void SetFragmentLength(int value) {
    m_fragmentLengthHasBeenSet = true;
    m_fragmentLength = value;
  }
  inline CmafGroupSettings& WithFragmentLength(int value) {
    SetFragmentLength(value);
    return *this;
  }
 
 
  inline CmafImageBasedTrickPlay GetImageBasedTrickPlay() const { return m_imageBasedTrickPlay; }
  inline bool ImageBasedTrickPlayHasBeenSet() const { return m_imageBasedTrickPlayHasBeenSet; }
  inline void SetImageBasedTrickPlay(CmafImageBasedTrickPlay value) {
    m_imageBasedTrickPlayHasBeenSet = true;
    m_imageBasedTrickPlay = value;
  }
  inline CmafGroupSettings& WithImageBasedTrickPlay(CmafImageBasedTrickPlay value) {
    SetImageBasedTrickPlay(value);
    return *this;
  }
 
 
  inline const CmafImageBasedTrickPlaySettings& GetImageBasedTrickPlaySettings() const { return m_imageBasedTrickPlaySettings; }
  inline bool ImageBasedTrickPlaySettingsHasBeenSet() const { return m_imageBasedTrickPlaySettingsHasBeenSet; }
  template <typename ImageBasedTrickPlaySettingsT = CmafImageBasedTrickPlaySettings>
  void SetImageBasedTrickPlaySettings(ImageBasedTrickPlaySettingsT&& value) {
    m_imageBasedTrickPlaySettingsHasBeenSet = true;
    m_imageBasedTrickPlaySettings = std::forward<ImageBasedTrickPlaySettingsT>(value);
  }
  template <typename ImageBasedTrickPlaySettingsT = CmafImageBasedTrickPlaySettings>
  CmafGroupSettings& WithImageBasedTrickPlaySettings(ImageBasedTrickPlaySettingsT&& value) {
    SetImageBasedTrickPlaySettings(std::forward<ImageBasedTrickPlaySettingsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<CmafImageBasedTrickPlayVariant>& GetImageBasedTrickPlayVariants() const { return m_imageBasedTrickPlayVariants; }
  inline bool ImageBasedTrickPlayVariantsHasBeenSet() const { return m_imageBasedTrickPlayVariantsHasBeenSet; }
  template <typename ImageBasedTrickPlayVariantsT = Aws::Vector<CmafImageBasedTrickPlayVariant>>
  void SetImageBasedTrickPlayVariants(ImageBasedTrickPlayVariantsT&& value) {
    m_imageBasedTrickPlayVariantsHasBeenSet = true;
    m_imageBasedTrickPlayVariants = std::forward<ImageBasedTrickPlayVariantsT>(value);
  }
  template <typename ImageBasedTrickPlayVariantsT = Aws::Vector<CmafImageBasedTrickPlayVariant>>
  CmafGroupSettings& WithImageBasedTrickPlayVariants(ImageBasedTrickPlayVariantsT&& value) {
    SetImageBasedTrickPlayVariants(std::forward<ImageBasedTrickPlayVariantsT>(value));
    return *this;
  }
  template <typename ImageBasedTrickPlayVariantsT = CmafImageBasedTrickPlayVariant>
  CmafGroupSettings& AddImageBasedTrickPlayVariants(ImageBasedTrickPlayVariantsT&& value) {
    m_imageBasedTrickPlayVariantsHasBeenSet = true;
    m_imageBasedTrickPlayVariants.emplace_back(std::forward<ImageBasedTrickPlayVariantsT>(value));
    return *this;
  }
 
 
  inline CmafManifestCompression GetManifestCompression() const { return m_manifestCompression; }
  inline bool ManifestCompressionHasBeenSet() const { return m_manifestCompressionHasBeenSet; }
  inline void SetManifestCompression(CmafManifestCompression value) {
    m_manifestCompressionHasBeenSet = true;
    m_manifestCompression = value;
  }
  inline CmafGroupSettings& WithManifestCompression(CmafManifestCompression value) {
    SetManifestCompression(value);
    return *this;
  }
 
 
  inline CmafManifestDurationFormat GetManifestDurationFormat() const { return m_manifestDurationFormat; }
  inline bool ManifestDurationFormatHasBeenSet() const { return m_manifestDurationFormatHasBeenSet; }
  inline void SetManifestDurationFormat(CmafManifestDurationFormat value) {
    m_manifestDurationFormatHasBeenSet = true;
    m_manifestDurationFormat = value;
  }
  inline CmafGroupSettings& WithManifestDurationFormat(CmafManifestDurationFormat value) {
    SetManifestDurationFormat(value);
    return *this;
  }
 
 
  inline int GetMinBufferTime() const { return m_minBufferTime; }
  inline bool MinBufferTimeHasBeenSet() const { return m_minBufferTimeHasBeenSet; }
  inline void SetMinBufferTime(int value) {
    m_minBufferTimeHasBeenSet = true;
    m_minBufferTime = value;
  }
  inline CmafGroupSettings& WithMinBufferTime(int value) {
    SetMinBufferTime(value);
    return *this;
  }
 
 
  inline double GetMinFinalSegmentLength() const { return m_minFinalSegmentLength; }
  inline bool MinFinalSegmentLengthHasBeenSet() const { return m_minFinalSegmentLengthHasBeenSet; }
  inline void SetMinFinalSegmentLength(double value) {
    m_minFinalSegmentLengthHasBeenSet = true;
    m_minFinalSegmentLength = value;
  }
  inline CmafGroupSettings& WithMinFinalSegmentLength(double value) {
    SetMinFinalSegmentLength(value);
    return *this;
  }
 
 
  inline CmafMpdManifestBandwidthType GetMpdManifestBandwidthType() const { return m_mpdManifestBandwidthType; }
  inline bool MpdManifestBandwidthTypeHasBeenSet() const { return m_mpdManifestBandwidthTypeHasBeenSet; }
  inline void SetMpdManifestBandwidthType(CmafMpdManifestBandwidthType value) {
    m_mpdManifestBandwidthTypeHasBeenSet = true;
    m_mpdManifestBandwidthType = value;
  }
  inline CmafGroupSettings& WithMpdManifestBandwidthType(CmafMpdManifestBandwidthType value) {
    SetMpdManifestBandwidthType(value);
    return *this;
  }
 
 
  inline CmafMpdProfile GetMpdProfile() const { return m_mpdProfile; }
  inline bool MpdProfileHasBeenSet() const { return m_mpdProfileHasBeenSet; }
  inline void SetMpdProfile(CmafMpdProfile value) {
    m_mpdProfileHasBeenSet = true;
    m_mpdProfile = value;
  }
  inline CmafGroupSettings& WithMpdProfile(CmafMpdProfile value) {
    SetMpdProfile(value);
    return *this;
  }
 
 
  inline CmafPtsOffsetHandlingForBFrames GetPtsOffsetHandlingForBFrames() const { return m_ptsOffsetHandlingForBFrames; }
  inline bool PtsOffsetHandlingForBFramesHasBeenSet() const { return m_ptsOffsetHandlingForBFramesHasBeenSet; }
  inline void SetPtsOffsetHandlingForBFrames(CmafPtsOffsetHandlingForBFrames value) {
    m_ptsOffsetHandlingForBFramesHasBeenSet = true;
    m_ptsOffsetHandlingForBFrames = value;
  }
  inline CmafGroupSettings& WithPtsOffsetHandlingForBFrames(CmafPtsOffsetHandlingForBFrames value) {
    SetPtsOffsetHandlingForBFrames(value);
    return *this;
  }
 
 
  inline CmafSegmentControl GetSegmentControl() const { return m_segmentControl; }
  inline bool SegmentControlHasBeenSet() const { return m_segmentControlHasBeenSet; }
  inline void SetSegmentControl(CmafSegmentControl value) {
    m_segmentControlHasBeenSet = true;
    m_segmentControl = value;
  }
  inline CmafGroupSettings& WithSegmentControl(CmafSegmentControl value) {
    SetSegmentControl(value);
    return *this;
  }
 
 
  inline int GetSegmentLength() const { return m_segmentLength; }
  inline bool SegmentLengthHasBeenSet() const { return m_segmentLengthHasBeenSet; }
  inline void SetSegmentLength(int value) {
    m_segmentLengthHasBeenSet = true;
    m_segmentLength = value;
  }
  inline CmafGroupSettings& WithSegmentLength(int value) {
    SetSegmentLength(value);
    return *this;
  }
 
 
  inline CmafSegmentLengthControl GetSegmentLengthControl() const { return m_segmentLengthControl; }
  inline bool SegmentLengthControlHasBeenSet() const { return m_segmentLengthControlHasBeenSet; }
  inline void SetSegmentLengthControl(CmafSegmentLengthControl value) {
    m_segmentLengthControlHasBeenSet = true;
    m_segmentLengthControl = value;
  }
  inline CmafGroupSettings& WithSegmentLengthControl(CmafSegmentLengthControl value) {
    SetSegmentLengthControl(value);
    return *this;
  }
 
 
  inline CmafStreamInfResolution GetStreamInfResolution() const { return m_streamInfResolution; }
  inline bool StreamInfResolutionHasBeenSet() const { return m_streamInfResolutionHasBeenSet; }
  inline void SetStreamInfResolution(CmafStreamInfResolution value) {
    m_streamInfResolutionHasBeenSet = true;
    m_streamInfResolution = value;
  }
  inline CmafGroupSettings& WithStreamInfResolution(CmafStreamInfResolution value) {
    SetStreamInfResolution(value);
    return *this;
  }
 
 
  inline CmafTargetDurationCompatibilityMode GetTargetDurationCompatibilityMode() const { return m_targetDurationCompatibilityMode; }
  inline bool TargetDurationCompatibilityModeHasBeenSet() const { return m_targetDurationCompatibilityModeHasBeenSet; }
  inline void SetTargetDurationCompatibilityMode(CmafTargetDurationCompatibilityMode value) {
    m_targetDurationCompatibilityModeHasBeenSet = true;
    m_targetDurationCompatibilityMode = value;
  }
  inline CmafGroupSettings& WithTargetDurationCompatibilityMode(CmafTargetDurationCompatibilityMode value) {
    SetTargetDurationCompatibilityMode(value);
    return *this;
  }
 
 
  inline CmafVideoCompositionOffsets GetVideoCompositionOffsets() const { return m_videoCompositionOffsets; }
  inline bool VideoCompositionOffsetsHasBeenSet() const { return m_videoCompositionOffsetsHasBeenSet; }
  inline void SetVideoCompositionOffsets(CmafVideoCompositionOffsets value) {
    m_videoCompositionOffsetsHasBeenSet = true;
    m_videoCompositionOffsets = value;
  }
  inline CmafGroupSettings& WithVideoCompositionOffsets(CmafVideoCompositionOffsets value) {
    SetVideoCompositionOffsets(value);
    return *this;
  }
 
 
  inline CmafWriteDASHManifest GetWriteDashManifest() const { return m_writeDashManifest; }
  inline bool WriteDashManifestHasBeenSet() const { return m_writeDashManifestHasBeenSet; }
  inline void SetWriteDashManifest(CmafWriteDASHManifest value) {
    m_writeDashManifestHasBeenSet = true;
    m_writeDashManifest = value;
  }
  inline CmafGroupSettings& WithWriteDashManifest(CmafWriteDASHManifest value) {
    SetWriteDashManifest(value);
    return *this;
  }
 
 
  inline CmafWriteHLSManifest GetWriteHlsManifest() const { return m_writeHlsManifest; }
  inline bool WriteHlsManifestHasBeenSet() const { return m_writeHlsManifestHasBeenSet; }
  inline void SetWriteHlsManifest(CmafWriteHLSManifest value) {
    m_writeHlsManifestHasBeenSet = true;
    m_writeHlsManifest = value;
  }
  inline CmafGroupSettings& WithWriteHlsManifest(CmafWriteHLSManifest value) {
    SetWriteHlsManifest(value);
    return *this;
  }
 
 
  inline CmafWriteSegmentTimelineInRepresentation GetWriteSegmentTimelineInRepresentation() const {
    return m_writeSegmentTimelineInRepresentation;
  }
  inline bool WriteSegmentTimelineInRepresentationHasBeenSet() const { return m_writeSegmentTimelineInRepresentationHasBeenSet; }
  inline void SetWriteSegmentTimelineInRepresentation(CmafWriteSegmentTimelineInRepresentation value) {
    m_writeSegmentTimelineInRepresentationHasBeenSet = true;
    m_writeSegmentTimelineInRepresentation = value;
  }
  inline CmafGroupSettings& WithWriteSegmentTimelineInRepresentation(CmafWriteSegmentTimelineInRepresentation value) {
    SetWriteSegmentTimelineInRepresentation(value);
    return *this;
  }
 private:
  Aws::Vector<CmafAdditionalManifest> m_additionalManifests;
 
  Aws::String m_baseUrl;
 
  CmafClientCache m_clientCache{CmafClientCache::NOT_SET};
 
  CmafCodecSpecification m_codecSpecification{CmafCodecSpecification::NOT_SET};
 
  Aws::String m_dashIFrameTrickPlayNameModifier;
 
  DashManifestStyle m_dashManifestStyle{DashManifestStyle::NOT_SET};
 
  Aws::String m_destination;
 
  DestinationSettings m_destinationSettings;
 
  CmafEncryptionSettings m_encryption;
 
  int m_fragmentLength{0};
 
  CmafImageBasedTrickPlay m_imageBasedTrickPlay{CmafImageBasedTrickPlay::NOT_SET};
 
  CmafImageBasedTrickPlaySettings m_imageBasedTrickPlaySettings;
 
  Aws::Vector<CmafImageBasedTrickPlayVariant> m_imageBasedTrickPlayVariants;
 
  CmafManifestCompression m_manifestCompression{CmafManifestCompression::NOT_SET};
 
  CmafManifestDurationFormat m_manifestDurationFormat{CmafManifestDurationFormat::NOT_SET};
 
  int m_minBufferTime{0};
 
  double m_minFinalSegmentLength{0.0};
 
  CmafMpdManifestBandwidthType m_mpdManifestBandwidthType{CmafMpdManifestBandwidthType::NOT_SET};
 
  CmafMpdProfile m_mpdProfile{CmafMpdProfile::NOT_SET};
 
  CmafPtsOffsetHandlingForBFrames m_ptsOffsetHandlingForBFrames{CmafPtsOffsetHandlingForBFrames::NOT_SET};
 
  CmafSegmentControl m_segmentControl{CmafSegmentControl::NOT_SET};
 
  int m_segmentLength{0};
 
  CmafSegmentLengthControl m_segmentLengthControl{CmafSegmentLengthControl::NOT_SET};
 
  CmafStreamInfResolution m_streamInfResolution{CmafStreamInfResolution::NOT_SET};
 
  CmafTargetDurationCompatibilityMode m_targetDurationCompatibilityMode{CmafTargetDurationCompatibilityMode::NOT_SET};
 
  CmafVideoCompositionOffsets m_videoCompositionOffsets{CmafVideoCompositionOffsets::NOT_SET};
 
  CmafWriteDASHManifest m_writeDashManifest{CmafWriteDASHManifest::NOT_SET};
 
  CmafWriteHLSManifest m_writeHlsManifest{CmafWriteHLSManifest::NOT_SET};
 
  CmafWriteSegmentTimelineInRepresentation m_writeSegmentTimelineInRepresentation{CmafWriteSegmentTimelineInRepresentation::NOT_SET};
  bool m_additionalManifestsHasBeenSet = false;
  bool m_baseUrlHasBeenSet = false;
  bool m_clientCacheHasBeenSet = false;
  bool m_codecSpecificationHasBeenSet = false;
  bool m_dashIFrameTrickPlayNameModifierHasBeenSet = false;
  bool m_dashManifestStyleHasBeenSet = false;
  bool m_destinationHasBeenSet = false;
  bool m_destinationSettingsHasBeenSet = false;
  bool m_encryptionHasBeenSet = false;
  bool m_fragmentLengthHasBeenSet = false;
  bool m_imageBasedTrickPlayHasBeenSet = false;
  bool m_imageBasedTrickPlaySettingsHasBeenSet = false;
  bool m_imageBasedTrickPlayVariantsHasBeenSet = false;
  bool m_manifestCompressionHasBeenSet = false;
  bool m_manifestDurationFormatHasBeenSet = false;
  bool m_minBufferTimeHasBeenSet = false;
  bool m_minFinalSegmentLengthHasBeenSet = false;
  bool m_mpdManifestBandwidthTypeHasBeenSet = false;
  bool m_mpdProfileHasBeenSet = false;
  bool m_ptsOffsetHandlingForBFramesHasBeenSet = false;
  bool m_segmentControlHasBeenSet = false;
  bool m_segmentLengthHasBeenSet = false;
  bool m_segmentLengthControlHasBeenSet = false;
  bool m_streamInfResolutionHasBeenSet = false;
  bool m_targetDurationCompatibilityModeHasBeenSet = false;
  bool m_videoCompositionOffsetsHasBeenSet = false;
  bool m_writeDashManifestHasBeenSet = false;
  bool m_writeHlsManifestHasBeenSet = false;
  bool m_writeSegmentTimelineInRepresentationHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaConvert
}  // namespace Aws